@vibeorm/migrate 1.0.0

package/src/introspector.ts

@@ -0,0 +1,618 @@
+/**
+ * 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,
+} from "@vibeorm/parser";
+import { PRISMA_TO_TS, PRISMA_TO_PG } from "@vibeorm/parser";
+import type { SqlExecutor } from "./types.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;
+};
+
+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;
+`;
+
+const FOREIGN_KEYS_QUERY = `
+  SELECT
+    tc.constraint_name,
+    tc.table_name,
+    kcu.column_name,
+    ccu.table_name AS foreign_table_name,
+    ccu.column_name AS foreign_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
+  JOIN information_schema.constraint_column_usage ccu
+    ON tc.constraint_name = ccu.constraint_name
+    AND tc.table_schema = ccu.table_schema
+  WHERE tc.table_schema = 'public'
+    AND tc.constraint_type = 'FOREIGN KEY'
+  ORDER BY tc.table_name, tc.constraint_name;
+`;
+
+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) => ({
+    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,
+  }));
+
+  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
+    const fkGroups = new Map<string, { localCols: string[]; foreignTable: string; foreignCols: string[] }>();
+    for (const fk of tableFKs) {
+      if (!fkGroups.has(fk.constraintName)) {
+        fkGroups.set(fk.constraintName, {
+          localCols: [],
+          foreignTable: fk.foreignTableName,
+          foreignCols: [],
+        });
+      }
+      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 });
+
+      // Check if this is an enum column
+      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,
+        };
+        fields.push(enumField);
+      } else {
+        // Map PG type to Prisma type
+        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,
+        };
+        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,
+        },
+      };
+      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) + "s",
+        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) + "s",
+        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) + "s",
+        relatedModel: modelA,
+        isList: true,
+        isRequired: false,
+        relation: {
+          name: undefined,
+          fields: [],
+          references: [],
+          relatedModel: modelA,
+          type: "oneToMany",
+          isForeignKey: false,
+        },
+      });
+    }
+  }
+
+  return { models, enums };
+}