@vibeorm/migrate 1.3.1 → 2.0.0-alpha.2

package/src/introspector.ts

@@ -1,684 +0,0 @@
-/**
- * Introspector — PostgreSQL → Schema IR
- *
- * Queries the live database (information_schema + pg_catalog) and
- * produces a Schema IR. The reverse of ddl-builder.ts.
- */
-
-import type {
-  Schema,
-  Model,
-  Field,
-  ScalarField,
-  EnumField,
-  RelationField,
-  PrimaryKey,
-  UniqueConstraint,
-  IndexDefinition,
-  Enum,
-  EnumValue,
-  PrismaScalarType,
-  PostgresType,
-  DefaultValue,
-  CascadeAction,
-} from "@vibeorm/parser";
-import { PRISMA_TO_TS, PRISMA_TO_PG } from "@vibeorm/parser";
-import type { SqlExecutor } from "./types.ts";
-import { PG_CHAR_TO_CASCADE_ACTION } from "./cascade-actions.ts";
-
-// ─── Reverse Type Mapping ─────────────────────────────────────────
-
-const PG_TO_PRISMA: Record<string, PrismaScalarType> = {
-  text: "String",
-  varchar: "String",
-  "character varying": "String",
-  char: "String",
-  character: "String",
-  uuid: "String",
-  boolean: "Boolean",
-  bool: "Boolean",
-  integer: "Int",
-  int4: "Int",
-  serial: "Int",
-  smallint: "Int",
-  int2: "Int",
-  bigint: "BigInt",
-  int8: "BigInt",
-  bigserial: "BigInt",
-  "double precision": "Float",
-  float8: "Float",
-  real: "Float",
-  float4: "Float",
-  decimal: "Decimal",
-  numeric: "Decimal",
-  timestamp: "DateTime",
-  "timestamp without time zone": "DateTime",
-  timestamptz: "DateTime",
-  "timestamp with time zone": "DateTime",
-  jsonb: "Json",
-  json: "Json",
-  bytea: "Bytes",
-};
-
-// ─── Internal Types ───────────────────────────────────────────────
-
-type ColumnInfo = {
-  tableName: string;
-  columnName: string;
-  dataType: string;
-  udtName: string;
-  isNullable: boolean;
-  columnDefault: string | null;
-  ordinalPosition: number;
-};
-
-type ConstraintInfo = {
-  constraintName: string;
-  constraintType: string; // PRIMARY KEY, UNIQUE, FOREIGN KEY
-  tableName: string;
-  columnName: string;
-};
-
-type ForeignKeyInfo = {
-  constraintName: string;
-  tableName: string;
-  columnName: string;
-  foreignTableName: string;
-  foreignColumnName: string;
-  /** ON DELETE action from `pg_constraint.confdeltype` (mapped to CascadeAction). */
-  onDelete: CascadeAction;
-  /** ON UPDATE action from `pg_constraint.confupdtype` (mapped to CascadeAction). */
-  onUpdate: CascadeAction;
-};
-
-type EnumInfo = {
-  typeName: string;
-  enumValue: string;
-  sortOrder: number;
-};
-
-type IndexInfo = {
-  tableName: string;
-  indexName: string;
-  indexDef: string;
-  isUnique: boolean;
-};
-
-// ─── SQL Queries ──────────────────────────────────────────────────
-
-const TABLES_QUERY = `
-  SELECT table_name
-  FROM information_schema.tables
-  WHERE table_schema = 'public'
-    AND table_type = 'BASE TABLE'
-    AND table_name NOT LIKE '_vibeorm_%'
-  ORDER BY table_name;
-`;
-
-const COLUMNS_QUERY = `
-  SELECT
-    table_name,
-    column_name,
-    data_type,
-    udt_name,
-    is_nullable,
-    column_default,
-    ordinal_position
-  FROM information_schema.columns
-  WHERE table_schema = 'public'
-  ORDER BY table_name, ordinal_position;
-`;
-
-const CONSTRAINTS_QUERY = `
-  SELECT
-    tc.constraint_name,
-    tc.constraint_type,
-    tc.table_name,
-    kcu.column_name
-  FROM information_schema.table_constraints tc
-  JOIN information_schema.key_column_usage kcu
-    ON tc.constraint_name = kcu.constraint_name
-    AND tc.table_schema = kcu.table_schema
-  WHERE tc.table_schema = 'public'
-    AND tc.constraint_type IN ('PRIMARY KEY', 'UNIQUE')
-  ORDER BY tc.table_name, tc.constraint_name, kcu.ordinal_position;
-`;
-
-/**
- * Foreign keys via pg_catalog rather than information_schema, because
- * information_schema's `referential_constraints.delete_rule` exposes the rule
- * but doesn't preserve the column ordering of composite FKs reliably across
- * server versions. The pg_catalog path with `unnest(...) WITH ORDINALITY`
- * pairs up `conkey` / `confkey` in declaration order and also surfaces
- * `confdeltype` / `confupdtype` directly.
- */
-const FOREIGN_KEYS_QUERY = `
-  SELECT
-    c.conname  AS constraint_name,
-    cl.relname AS table_name,
-    att.attname AS column_name,
-    fcl.relname AS foreign_table_name,
-    fatt.attname AS foreign_column_name,
-    c.confdeltype AS on_delete_char,
-    c.confupdtype AS on_update_char
-  FROM pg_catalog.pg_constraint c
-  JOIN pg_catalog.pg_class cl       ON cl.oid = c.conrelid
-  JOIN pg_catalog.pg_namespace n    ON n.oid = cl.relnamespace
-  JOIN pg_catalog.pg_class fcl      ON fcl.oid = c.confrelid
-  JOIN pg_catalog.pg_namespace fn   ON fn.oid = fcl.relnamespace
-  JOIN unnest(c.conkey)  WITH ORDINALITY AS lk(attnum, ord) ON true
-  JOIN unnest(c.confkey) WITH ORDINALITY AS rk(attnum, ord) ON lk.ord = rk.ord
-  JOIN pg_catalog.pg_attribute att  ON att.attrelid = c.conrelid  AND att.attnum = lk.attnum
-  JOIN pg_catalog.pg_attribute fatt ON fatt.attrelid = c.confrelid AND fatt.attnum = rk.attnum
-  WHERE c.contype = 'f'
-    AND n.nspname = 'public'
-    AND fn.nspname = 'public'
-  ORDER BY cl.relname, c.conname, lk.ord;
-`;
-
-const ENUMS_QUERY = `
-  SELECT
-    t.typname AS type_name,
-    e.enumlabel AS enum_value,
-    e.enumsortorder AS sort_order
-  FROM pg_type t
-  JOIN pg_enum e ON t.oid = e.enumtypid
-  JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
-  WHERE n.nspname = 'public'
-  ORDER BY t.typname, e.enumsortorder;
-`;
-
-const INDEXES_QUERY = `
-  SELECT
-    tablename AS table_name,
-    indexname AS index_name,
-    indexdef AS index_def
-  FROM pg_indexes
-  WHERE schemaname = 'public'
-  ORDER BY tablename, indexname;
-`;
-
-// ─── Default Value Parsing ────────────────────────────────────────
-
-function parseDefault(params: { columnDefault: string | null; dataType: string }): DefaultValue | undefined {
-  const { columnDefault, dataType } = params;
-  if (!columnDefault) return undefined;
-
-  const val = columnDefault;
-
-  // Autoincrement: nextval('table_column_seq'::regclass)
-  if (val.includes("nextval(")) {
-    return { kind: "autoincrement" };
-  }
-
-  // now() / CURRENT_TIMESTAMP
-  if (val === "CURRENT_TIMESTAMP" || val === "now()" || val.startsWith("CURRENT_TIMESTAMP")) {
-    return { kind: "now" };
-  }
-
-  // uuid: gen_random_uuid()
-  if (val.includes("gen_random_uuid()")) {
-    return { kind: "uuid" };
-  }
-
-  // Boolean literals
-  if (val === "true" || val === "false") {
-    return { kind: "literal", value: val === "true" };
-  }
-
-  // Numeric literals
-  if (/^-?\d+(\.\d+)?$/.test(val)) {
-    return { kind: "literal", value: Number(val) };
-  }
-
-  // String literals: 'value'::type or 'value'
-  const stringMatch = val.match(/^'(.+?)'::/);
-  if (stringMatch) {
-    return { kind: "literal", value: stringMatch[1]! };
-  }
-
-  // Plain string
-  const plainStringMatch = val.match(/^'(.+?)'$/);
-  if (plainStringMatch) {
-    return { kind: "literal", value: plainStringMatch[1]! };
-  }
-
-  // dbgenerated for anything else
-  return { kind: "dbgenerated", value: val };
-}
-
-// ─── Implicit M:N Detection ──────────────────────────────────────
-
-function isImplicitJoinTable(params: {
-  tableName: string;
-  columns: ColumnInfo[];
-  foreignKeys: ForeignKeyInfo[];
-}): { modelA: string; modelB: string } | null {
-  const { tableName, columns, foreignKeys } = params;
-
-  // Pattern: _ModelAToModelB
-  const match = tableName.match(/^_(\w+)To(\w+)$/);
-  if (!match) return null;
-
-  const tableColumns = columns.filter((c) => c.tableName === tableName);
-  const tableFKs = foreignKeys.filter((fk) => fk.tableName === tableName);
-
-  // Must have exactly columns A and B
-  const colNames = tableColumns.map((c) => c.columnName).sort();
-  if (colNames.length !== 2 || colNames[0] !== "A" || colNames[1] !== "B") return null;
-
-  // Must have exactly 2 FKs
-  if (tableFKs.length !== 2) return null;
-
-  return { modelA: match[1]!, modelB: match[2]! };
-}
-
-// ─── Main Introspect Function ─────────────────────────────────────
-
-export async function introspect(params: { executor: SqlExecutor }): Promise<Schema> {
-  const { executor } = params;
-
-  // Run all queries in parallel
-  const [tablesRaw, columnsRaw, constraintsRaw, foreignKeysRaw, enumsRaw, indexesRaw] = await Promise.all([
-    executor({ text: TABLES_QUERY }),
-    executor({ text: COLUMNS_QUERY }),
-    executor({ text: CONSTRAINTS_QUERY }),
-    executor({ text: FOREIGN_KEYS_QUERY }),
-    executor({ text: ENUMS_QUERY }),
-    executor({ text: INDEXES_QUERY }),
-  ]);
-
-  // Parse raw results
-  const tables = tablesRaw.map((r) => r.table_name as string);
-
-  const columns: ColumnInfo[] = columnsRaw.map((r) => ({
-    tableName: r.table_name as string,
-    columnName: r.column_name as string,
-    dataType: r.data_type as string,
-    udtName: r.udt_name as string,
-    isNullable: (r.is_nullable as string) === "YES",
-    columnDefault: r.column_default as string | null,
-    ordinalPosition: r.ordinal_position as number,
-  }));
-
-  const constraints: ConstraintInfo[] = constraintsRaw.map((r) => ({
-    constraintName: r.constraint_name as string,
-    constraintType: r.constraint_type as string,
-    tableName: r.table_name as string,
-    columnName: r.column_name as string,
-  }));
-
-  const foreignKeys: ForeignKeyInfo[] = foreignKeysRaw.map((r) => {
-    // Postgres uses single-char codes: a=NoAction, r=Restrict, c=Cascade,
-    // n=SetNull, d=SetDefault. Fall back to NoAction (the Postgres default)
-    // if we ever see an unrecognised char from a future PG version.
-    const onDeleteChar = (r.on_delete_char as string) ?? "a";
-    const onUpdateChar = (r.on_update_char as string) ?? "a";
-    return {
-      constraintName: r.constraint_name as string,
-      tableName: r.table_name as string,
-      columnName: r.column_name as string,
-      foreignTableName: r.foreign_table_name as string,
-      foreignColumnName: r.foreign_column_name as string,
-      onDelete: PG_CHAR_TO_CASCADE_ACTION[onDeleteChar] ?? "NoAction",
-      onUpdate: PG_CHAR_TO_CASCADE_ACTION[onUpdateChar] ?? "NoAction",
-    };
-  });
-
-  const enumInfos: EnumInfo[] = enumsRaw.map((r) => ({
-    typeName: r.type_name as string,
-    enumValue: r.enum_value as string,
-    sortOrder: r.sort_order as number,
-  }));
-
-  const indexInfos: IndexInfo[] = indexesRaw.map((r) => ({
-    tableName: r.table_name as string,
-    indexName: r.index_name as string,
-    indexDef: r.index_def as string,
-    isUnique: (r.index_def as string).includes("UNIQUE"),
-  }));
-
-  // ─── Build Enums ────────────────────────────────────────────────
-
-  const enumMap = new Map<string, EnumValue[]>();
-  for (const ei of enumInfos) {
-    if (!enumMap.has(ei.typeName)) {
-      enumMap.set(ei.typeName, []);
-    }
-    enumMap.get(ei.typeName)!.push({ name: ei.enumValue, dbName: undefined });
-  }
-
-  const enums: Enum[] = [];
-  for (const [name, values] of enumMap) {
-    enums.push({ name, dbName: undefined, values });
-  }
-
-  const enumNames = new Set(enumMap.keys());
-
-  // ─── Detect join tables ─────────────────────────────────────────
-
-  const joinTables = new Map<string, { modelA: string; modelB: string }>();
-  for (const tableName of tables) {
-    const result = isImplicitJoinTable({ tableName, columns, foreignKeys });
-    if (result) {
-      joinTables.set(tableName, result);
-    }
-  }
-
-  // ─── Build constraints maps ─────────────────────────────────────
-
-  // Primary keys: tableName → column names
-  const primaryKeys = new Map<string, string[]>();
-  for (const c of constraints) {
-    if (c.constraintType !== "PRIMARY KEY") continue;
-    if (!primaryKeys.has(c.tableName)) primaryKeys.set(c.tableName, []);
-    primaryKeys.get(c.tableName)!.push(c.columnName);
-  }
-
-  // Unique constraints: tableName → array of { constraintName, columns }
-  const uniqueConstraints = new Map<string, Map<string, string[]>>();
-  for (const c of constraints) {
-    if (c.constraintType !== "UNIQUE") continue;
-    if (!uniqueConstraints.has(c.tableName)) uniqueConstraints.set(c.tableName, new Map());
-    const tableUniques = uniqueConstraints.get(c.tableName)!;
-    if (!tableUniques.has(c.constraintName)) tableUniques.set(c.constraintName, []);
-    tableUniques.get(c.constraintName)!.push(c.columnName);
-  }
-
-  // FK columns with unique constraints (for 1:1 detection)
-  const uniqueColumns = new Set<string>();
-  for (const [tableName, tableUniques] of uniqueConstraints) {
-    for (const [, cols] of tableUniques) {
-      if (cols.length === 1) {
-        uniqueColumns.add(`${tableName}.${cols[0]}`);
-      }
-    }
-  }
-
-  // Group foreign keys by constraint name
-  const fkByConstraint = new Map<string, ForeignKeyInfo[]>();
-  for (const fk of foreignKeys) {
-    if (!fkByConstraint.has(fk.constraintName)) fkByConstraint.set(fk.constraintName, []);
-    fkByConstraint.get(fk.constraintName)!.push(fk);
-  }
-
-  // ─── Build Models ───────────────────────────────────────────────
-
-  const models: Model[] = [];
-
-  for (const tableName of tables) {
-    // Skip join tables
-    if (joinTables.has(tableName)) continue;
-
-    const tableColumns = columns.filter((c) => c.tableName === tableName);
-    const tablePK = primaryKeys.get(tableName) ?? [];
-    const tableUniques = uniqueConstraints.get(tableName) ?? new Map<string, string[]>();
-    const tableFKs = foreignKeys.filter((fk) => fk.tableName === tableName);
-
-    // Group FKs by constraint for multi-column FK support. Cascade actions are
-    // a property of the constraint as a whole, so we carry them once per group.
-    const fkGroups = new Map<string, {
-      localCols: string[];
-      foreignTable: string;
-      foreignCols: string[];
-      onDelete: CascadeAction;
-      onUpdate: CascadeAction;
-    }>();
-    for (const fk of tableFKs) {
-      if (!fkGroups.has(fk.constraintName)) {
-        fkGroups.set(fk.constraintName, {
-          localCols: [],
-          foreignTable: fk.foreignTableName,
-          foreignCols: [],
-          onDelete: fk.onDelete,
-          onUpdate: fk.onUpdate,
-        });
-      }
-      const group = fkGroups.get(fk.constraintName)!;
-      group.localCols.push(fk.columnName);
-      group.foreignCols.push(fk.foreignColumnName);
-    }
-
-    const fields: Field[] = [];
-
-    // Scalar/Enum fields
-    for (const col of tableColumns) {
-      const isId = tablePK.includes(col.columnName);
-      const isUnique = uniqueColumns.has(`${tableName}.${col.columnName}`);
-      const parsedDefault = parseDefault({ columnDefault: col.columnDefault, dataType: col.dataType });
-
-      // Branch 1: scalar enum column (data_type=USER-DEFINED, udt_name=EnumName).
-      if (col.dataType === "USER-DEFINED" && enumNames.has(col.udtName)) {
-        const enumField: EnumField = {
-          kind: "enum",
-          name: col.columnName,
-          dbName: col.columnName,
-          enumName: col.udtName,
-          isRequired: !col.isNullable,
-          isList: false,
-          isId,
-          isUnique,
-          default: parsedDefault,
-          documentation: undefined,
-        };
-        fields.push(enumField);
-      }
-      // Branch 2: enum-array column. Postgres reports the underlying array type
-      // as `_EnumName` (the leading underscore is the array-type naming convention),
-      // and `data_type` is `ARRAY`. Without this branch the field would be parsed
-      // as `String[]` and the round-trip drift differ would always want to ALTER it.
-      // Bug 2 — see .ai/bug-report-2026-05-24.md.
-      else if (
-        col.dataType === "ARRAY" &&
-        col.udtName.startsWith("_") &&
-        enumNames.has(col.udtName.slice(1))
-      ) {
-        const enumField: EnumField = {
-          kind: "enum",
-          name: col.columnName,
-          dbName: col.columnName,
-          enumName: col.udtName.slice(1),
-          isRequired: !col.isNullable,
-          isList: true,
-          isId,
-          isUnique,
-          default: parsedDefault,
-          documentation: undefined,
-        };
-        fields.push(enumField);
-      }
-      // Branch 3: scalar / scalar-array fallback.
-      else {
-        const pgType = col.dataType === "ARRAY" ? col.udtName.replace(/^_/, "") : col.udtName;
-        const prismaType = PG_TO_PRISMA[pgType] ?? PG_TO_PRISMA[col.dataType] ?? "String";
-        const isArray = col.dataType === "ARRAY";
-
-        const scalarField: ScalarField = {
-          kind: "scalar",
-          name: col.columnName,
-          dbName: col.columnName,
-          prismaType,
-          tsType: PRISMA_TO_TS[prismaType],
-          pgType: PRISMA_TO_PG[prismaType],
-          isRequired: !col.isNullable,
-          isList: isArray,
-          isId,
-          isUnique,
-          isUpdatedAt: false, // Can't detect @updatedAt from DB
-          default: parsedDefault,
-          nativeType: undefined,
-          documentation: undefined,
-        };
-        fields.push(scalarField);
-      }
-    }
-
-    // Relation fields (FK side — this model owns the FK)
-    for (const [constraintName, group] of fkGroups) {
-      // Determine relation type: if FK column is unique → oneToOne, else manyToOne
-      const isOneToOne = group.localCols.length === 1 &&
-        uniqueColumns.has(`${tableName}.${group.localCols[0]}`);
-
-      const relationField: RelationField = {
-        kind: "relation",
-        name: group.foreignTable.charAt(0).toLowerCase() + group.foreignTable.slice(1),
-        relatedModel: group.foreignTable,
-        isList: false,
-        isRequired: group.localCols.every((col) => {
-          const colInfo = tableColumns.find((c) => c.columnName === col);
-          return colInfo ? !colInfo.isNullable : true;
-        }),
-        relation: {
-          name: undefined,
-          fields: group.localCols,
-          references: group.foreignCols,
-          relatedModel: group.foreignTable,
-          type: isOneToOne ? "oneToOne" : "manyToOne",
-          isForeignKey: true,
-          onDelete: group.onDelete,
-          onUpdate: group.onUpdate,
-        },
-      };
-      fields.push(relationField);
-    }
-
-    // Build unique constraints (multi-column only, single-column is on the field)
-    const modelUniques: UniqueConstraint[] = [];
-    for (const [name, cols] of tableUniques) {
-      if (cols.length > 1) {
-        modelUniques.push({ fields: cols, name });
-      }
-    }
-
-    // Build indexes (exclude PKs and unique constraints that are already tracked)
-    const constraintNames = new Set(constraints.filter((c) => c.tableName === tableName).map((c) => c.constraintName));
-    const tableIndexes = indexInfos.filter(
-      (idx) => idx.tableName === tableName && !constraintNames.has(idx.indexName)
-    );
-    const modelIndexes: IndexDefinition[] = [];
-    for (const idx of tableIndexes) {
-      // Parse columns from index definition: CREATE [UNIQUE] INDEX name ON table (col1, col2)
-      const colMatch = idx.indexDef.match(/\(([^)]+)\)/);
-      if (colMatch) {
-        const cols = colMatch[1]!.split(",").map((c) => c.trim().replace(/"/g, ""));
-        if (idx.isUnique) {
-          // Unique indexes → treat as unique constraints (multi-column only;
-          // single-column uniqueness is already captured via information_schema)
-          if (cols.length > 1) {
-            modelUniques.push({ fields: cols, name: idx.indexName });
-          }
-        } else {
-          modelIndexes.push({ fields: cols, name: idx.indexName });
-        }
-      }
-    }
-
-    const model: Model = {
-      name: tableName,
-      dbName: tableName,
-      fields,
-      primaryKey: {
-        fields: tablePK,
-        isComposite: tablePK.length > 1,
-      },
-      uniqueConstraints: modelUniques,
-      indexes: modelIndexes,
-    };
-
-    models.push(model);
-  }
-
-  // ─── Add back-reference relation fields ─────────────────────────
-
-  // For each FK-owning relation, add the inverse relation to the referenced model
-  for (const model of models) {
-    for (const field of model.fields) {
-      if (field.kind !== "relation") continue;
-      if (!field.relation.isForeignKey) continue;
-
-      const relatedModel = models.find((m) => m.name === field.relatedModel);
-      if (!relatedModel) continue;
-
-      // Check if the related model already has a back-reference
-      const hasBackRef = relatedModel.fields.some(
-        (f) => f.kind === "relation" && f.relatedModel === model.name
-      );
-      if (hasBackRef) continue;
-
-      const isOneToOne = field.relation.type === "oneToOne";
-
-      const backRef: RelationField = {
-        kind: "relation",
-        name: isOneToOne
-          ? model.name.charAt(0).toLowerCase() + model.name.slice(1)
-          : model.name.charAt(0).toLowerCase() + model.name.slice(1),
-        relatedModel: model.name,
-        isList: !isOneToOne,
-        isRequired: false,
-        relation: {
-          name: undefined,
-          fields: [],
-          references: [],
-          relatedModel: model.name,
-          type: isOneToOne ? "oneToOne" : "oneToMany",
-          isForeignKey: false,
-        },
-      };
-      relatedModel.fields.push(backRef);
-    }
-  }
-
-  // ─── Add implicit M:N relation fields ───────────────────────────
-
-  for (const [joinTableName, { modelA, modelB }] of joinTables) {
-    const modelADef = models.find((m) => m.name === modelA);
-    const modelBDef = models.find((m) => m.name === modelB);
-    if (!modelADef || !modelBDef) continue;
-
-    // Add relation field to model A → model B[]
-    const hasRelA = modelADef.fields.some(
-      (f) => f.kind === "relation" && f.relatedModel === modelB && f.isList
-    );
-    if (!hasRelA) {
-      modelADef.fields.push({
-        kind: "relation",
-        name: modelB.charAt(0).toLowerCase() + modelB.slice(1),
-        relatedModel: modelB,
-        isList: true,
-        isRequired: false,
-        relation: {
-          name: undefined,
-          fields: [],
-          references: [],
-          relatedModel: modelB,
-          type: "oneToMany", // M:N represented as two oneToMany from each side
-          isForeignKey: false,
-        },
-      });
-    }
-
-    // Add relation field to model B → model A[]
-    const hasRelB = modelBDef.fields.some(
-      (f) => f.kind === "relation" && f.relatedModel === modelA && f.isList
-    );
-    if (!hasRelB) {
-      modelBDef.fields.push({
-        kind: "relation",
-        name: modelA.charAt(0).toLowerCase() + modelA.slice(1),
-        relatedModel: modelA,
-        isList: true,
-        isRequired: false,
-        relation: {
-          name: undefined,
-          fields: [],
-          references: [],
-          relatedModel: modelA,
-          type: "oneToMany",
-          isForeignKey: false,
-        },
-      });
-    }
-  }
-
-  return { models, enums };
-}