frontend/src/lib/api.ts - master - pv_hum/schemaforge

frontend/src/lib/api.ts
99 строк4 KB
pv_hum
Initial commit
21 май 2026, 22:25
21 май 2026, 22:250de9fa8
import {
  ActiveView,
  ChangedFlags,
  DbConnectionParams,
  DbStatus,
  GenerateRequest,
  ProductMode,
  ReviseRequest,
  SchemaModel,
  SchemaResponse,
  SqlDialect,
  ValidationResult,
  ChangeSummary,
  WorkflowFailure,
} from '../types/schema';

const API = import.meta.env.VITE_API_BASE_URL ?? 'http://localhost:8080/api';

async function req<T>(path: string, init: RequestInit): Promise<T> {
  const res = await fetch(`${API}${path}`, {
    credentials: 'include',
    headers: { 'Content-Type': 'application/json' },
    ...init,
  });
  const text = await res.text();
  if (!res.ok) {
    let message = text || `HTTP ${res.status}`;
    try {
      const parsed = JSON.parse(text) as Record<string, unknown>;
      if (typeof parsed.message === 'string') {
        message = parsed.stopReason ? `${parsed.stopReason}: ${parsed.message}` : parsed.message;
      } else if (typeof parsed.error === 'string') {
        message = parsed.error;
      } else if (typeof parsed.detail === 'string') {
        message = parsed.detail;
      }
    } catch {
      /* keep raw text */
    }
    throw new Error(message);
  }
  return text ? JSON.parse(text) : ({} as T);
}

function isWorkflowFailure(data: unknown): data is WorkflowFailure {
  return typeof data === 'object' && data !== null && (data as WorkflowFailure).success === false;
}

export const api = {
  health: () => req<{ status: string; agentStatus: string }>('/health', { method: 'GET' }),

  dbTestConnection: (params: DbConnectionParams) =>
    req<{ success: boolean; message: string }>('/db/test-connection', { method: 'POST', body: JSON.stringify(params) }),

  dbIntrospect: (params: DbConnectionParams) =>
    req<{ success: boolean; message: string; summary: string; tableCount: number }>('/db/introspect', {
      method: 'POST',
      body: JSON.stringify(params),
    }),

  dbStatus: () => req<DbStatus>('/db/status', { method: 'GET' }),

  dbDisconnect: () => req<{ success: boolean }>('/db/disconnect', { method: 'POST', body: '{}' }),

  generate: (body: GenerateRequest) =>
    req<SchemaResponse | WorkflowFailure>('/schema/generate', { method: 'POST', body: JSON.stringify(body) }).then((data) => {
      if (isWorkflowFailure(data)) throw new Error(`${data.stopReason}: ${data.message}`);
      return data as SchemaResponse;
    }),

  revise: (body: ReviseRequest) =>
    req<SchemaResponse | WorkflowFailure>('/schema/revise', { method: 'POST', body: JSON.stringify(body) }).then((data) => {
      if (isWorkflowFailure(data)) throw new Error(`${data.stopReason}: ${data.message}`);
      return data as SchemaResponse;
    }),

  parseSql: (sql: string, dialect: SqlDialect) =>
    req<SchemaResponse>('/schema/parse-sql', { method: 'POST', body: JSON.stringify({ sql, dialect }) }),

  fromEr: (erSchema: SchemaModel, dialect: SqlDialect) =>
    req<SchemaResponse>('/schema/from-er', { method: 'POST', body: JSON.stringify({ erSchema, dialect }) }),

  sql: (schema: SchemaModel, dialect: SqlDialect) =>
    req<{ sql: string }>('/schema/sql', { method: 'POST', body: JSON.stringify({ schema, dialect }) }),

  validate: (schema: SchemaModel) =>
    req<ValidationResult>('/schema/validate', { method: 'POST', body: JSON.stringify({ schema }) }),

  explainChanges: (oldSchema: SchemaModel, newSchema: SchemaModel) =>
    req<ChangeSummary>('/schema/explain-changes', { method: 'POST', body: JSON.stringify({ oldSchema, newSchema }) }),
};

export function buildChangedFlags(store: {
  dirty: ChangedFlags;
}): ChangedFlags {
  return { ...store.dirty };
}

export type { ProductMode, ActiveView, ChangedFlags };