metal-orm 1.0.11 → 1.0.13

package/src/core/ddl/introspect/postgres.ts

@@ -0,0 +1,154 @@
+import { SchemaIntrospector, IntrospectOptions } from './types.js';
+import { queryRows, shouldIncludeTable } from './utils.js';
+import { DatabaseSchema, DatabaseTable, DatabaseIndex, DatabaseColumn } from '../schema-types.js';
+import { DbExecutor } from '../../orm/db-executor.js';
+
+export const postgresIntrospector: SchemaIntrospector = {
+  async introspect(executor: DbExecutor, options: IntrospectOptions): Promise<DatabaseSchema> {
+    const schema = options.schema || 'public';
+    const tables: DatabaseTable[] = [];
+
+    const columnRows = await queryRows(
+      executor,
+      `
+      SELECT table_schema, table_name, column_name, data_type, is_nullable, column_default
+      FROM information_schema.columns
+      WHERE table_schema = $1
+      ORDER BY table_name, ordinal_position
+      `,
+      [schema]
+    );
+
+    const pkRows = await queryRows(
+      executor,
+      `
+      SELECT
+        ns.nspname AS table_schema,
+        tbl.relname AS table_name,
+        array_agg(att.attname ORDER BY arr.idx) AS pk_columns
+      FROM pg_index i
+      JOIN pg_class tbl ON tbl.oid = i.indrelid
+      JOIN pg_namespace ns ON ns.oid = tbl.relnamespace
+      JOIN LATERAL unnest(i.indkey) WITH ORDINALITY AS arr(attnum, idx) ON TRUE
+      LEFT JOIN pg_attribute att ON att.attrelid = tbl.oid AND att.attnum = arr.attnum
+      WHERE i.indisprimary AND ns.nspname = $1
+      GROUP BY ns.nspname, tbl.relname
+      `,
+      [schema]
+    );
+
+    const pkMap = new Map<string, string[]>();
+    pkRows.forEach(r => {
+      pkMap.set(`${r.table_schema}.${r.table_name}`, r.pk_columns || []);
+    });
+
+    const fkRows = await queryRows(
+      executor,
+      `
+      SELECT
+        tc.table_schema,
+        tc.table_name,
+        kcu.column_name,
+        ccu.table_schema AS foreign_table_schema,
+        ccu.table_name AS foreign_table_name,
+        ccu.column_name AS foreign_column_name,
+        rc.update_rule AS on_update,
+        rc.delete_rule AS on_delete
+      FROM information_schema.table_constraints AS tc
+      JOIN information_schema.key_column_usage AS kcu
+        ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema
+      JOIN information_schema.constraint_column_usage AS ccu
+        ON ccu.constraint_name = tc.constraint_name AND ccu.table_schema = tc.table_schema
+      JOIN information_schema.referential_constraints rc
+        ON rc.constraint_name = tc.constraint_name AND rc.constraint_schema = tc.table_schema
+      WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_schema = $1
+      `,
+      [schema]
+    );
+
+    const fkMap = new Map<string, any[]>();
+    fkRows.forEach(r => {
+      const key = `${r.table_schema}.${r.table_name}.${r.column_name}`;
+      fkMap.set(key, [{
+        table: `${r.foreign_table_schema}.${r.foreign_table_name}`,
+        column: r.foreign_column_name,
+        onDelete: r.on_delete?.toUpperCase(),
+        onUpdate: r.on_update?.toUpperCase()
+      }]);
+    });
+
+    const indexRows = await queryRows(
+      executor,
+      `
+      SELECT
+        ns.nspname AS table_schema,
+        tbl.relname AS table_name,
+        idx.relname AS index_name,
+        i.indisunique AS is_unique,
+        pg_get_expr(i.indpred, i.indrelid) AS predicate,
+        array_agg(att.attname ORDER BY arr.idx) AS column_names
+      FROM pg_index i
+      JOIN pg_class tbl ON tbl.oid = i.indrelid
+      JOIN pg_namespace ns ON ns.oid = tbl.relnamespace
+      JOIN pg_class idx ON idx.oid = i.indexrelid
+      JOIN LATERAL unnest(i.indkey) WITH ORDINALITY AS arr(attnum, idx) ON TRUE
+      LEFT JOIN pg_attribute att ON att.attrelid = tbl.oid AND att.attnum = arr.attnum
+      WHERE ns.nspname = $1 AND NOT i.indisprimary
+      GROUP BY ns.nspname, tbl.relname, idx.relname, i.indisunique, i.indpred
+      `,
+      [schema]
+    );
+
+    const tablesByKey = new Map<string, DatabaseTable>();
+
+    columnRows.forEach(r => {
+      const key = `${r.table_schema}.${r.table_name}`;
+      if (!shouldIncludeTable(r.table_name, options)) {
+        return;
+      }
+      if (!tablesByKey.has(key)) {
+        tablesByKey.set(key, {
+          name: r.table_name,
+          schema: r.table_schema,
+          columns: [],
+          primaryKey: pkMap.get(key) || [],
+          indexes: []
+        });
+      }
+      const cols = tablesByKey.get(key)!;
+      const fk = fkMap.get(`${r.table_schema}.${r.table_name}.${r.column_name}`)?.[0];
+      const column: DatabaseColumn = {
+        name: r.column_name,
+        type: r.data_type,
+        notNull: r.is_nullable === 'NO',
+        default: r.column_default ?? undefined,
+        references: fk
+          ? {
+              table: fk.table,
+              column: fk.column,
+              onDelete: fk.onDelete,
+              onUpdate: fk.onUpdate
+            }
+          : undefined
+      };
+      cols.columns.push(column);
+    });
+
+    indexRows.forEach(r => {
+      const key = `${r.table_schema}.${r.table_name}`;
+      const table = tablesByKey.get(key);
+      if (!table) return;
+      const idx: DatabaseIndex = {
+        name: r.index_name,
+        columns: (r.column_names || []).map((c: string) => ({ column: c })),
+        unique: !!r.is_unique,
+        where: r.predicate || undefined
+      };
+      table.indexes = table.indexes || [];
+      table.indexes.push(idx);
+    });
+
+    tables.push(...tablesByKey.values());
+    return { tables };
+  }
+};

package/src/core/ddl/introspect/sqlite.ts

@@ -0,0 +1,66 @@
+import { SchemaIntrospector, IntrospectOptions } from './types.js';
+import { queryRows, shouldIncludeTable } from './utils.js';
+import { DatabaseSchema, DatabaseTable, DatabaseIndex } from '../schema-types.js';
+import { DbExecutor } from '../../orm/db-executor.js';
+
+const escapeSingleQuotes = (name: string) => name.replace(/'/g, "''");
+
+export const sqliteIntrospector: SchemaIntrospector = {
+  async introspect(executor: DbExecutor, options: IntrospectOptions): Promise<DatabaseSchema> {
+    const tables: DatabaseTable[] = [];
+    const tableRows = await queryRows(
+      executor,
+      `SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%';`
+    );
+
+    for (const row of tableRows) {
+      const name = row.name as string;
+      if (!shouldIncludeTable(name, options)) continue;
+      const table: DatabaseTable = { name, columns: [], primaryKey: [], indexes: [] };
+
+      const cols = await queryRows(executor, `PRAGMA table_info('${escapeSingleQuotes(name)}');`);
+      cols.forEach(c => {
+        table.columns.push({
+          name: c.name,
+          type: c.type,
+          notNull: c.notnull === 1,
+          default: c.dflt_value ?? undefined,
+          autoIncrement: false
+        });
+        if (c.pk && c.pk > 0) {
+          table.primaryKey = table.primaryKey || [];
+          table.primaryKey.push(c.name);
+        }
+      });
+
+      const fkRows = await queryRows(executor, `PRAGMA foreign_key_list('${escapeSingleQuotes(name)}');`);
+      fkRows.forEach(fk => {
+        const col = table.columns.find(c => c.name === fk.from);
+        if (col) {
+          col.references = {
+            table: fk.table,
+            column: fk.to,
+            onDelete: fk.on_delete?.toUpperCase(),
+            onUpdate: fk.on_update?.toUpperCase()
+          };
+        }
+      });
+
+      const idxList = await queryRows(executor, `PRAGMA index_list('${escapeSingleQuotes(name)}');`);
+      for (const idx of idxList) {
+        const idxName = idx.name as string;
+        const columnsInfo = await queryRows(executor, `PRAGMA index_info('${escapeSingleQuotes(idxName)}');`);
+        const idxEntry: DatabaseIndex = {
+          name: idxName,
+          columns: columnsInfo.map(ci => ({ column: ci.name as string })),
+          unique: idx.unique === 1
+        };
+        table.indexes!.push(idxEntry);
+      }
+
+      tables.push(table);
+    }
+
+    return { tables };
+  }
+};

package/src/core/ddl/introspect/types.ts

@@ -0,0 +1,19 @@
+import type { DbExecutor } from '../../../orm/db-executor.js';
+import { DatabaseSchema } from '../schema-types.js';
+
+/**
+ * Dialect-agnostic options for schema introspection.
+ */
+export interface IntrospectOptions {
+  /** Dialect-specific schema/catalog. Postgres: schema; MySQL: database; MSSQL: schema. */
+  schema?: string;
+  includeTables?: string[];
+  excludeTables?: string[];
+}
+
+/**
+ * Strategy interface implemented per dialect to introspect an existing database schema.
+ */
+export interface SchemaIntrospector {
+  introspect(executor: DbExecutor, options: IntrospectOptions): Promise<DatabaseSchema>;
+}

package/src/core/ddl/introspect/utils.ts

@@ -0,0 +1,27 @@
+import { DbExecutor, QueryResult } from '../../orm/db-executor.js';
+import { IntrospectOptions } from './types.js';
+
+export const toRows = (result: QueryResult | undefined): Record<string, any>[] => {
+  if (!result) return [];
+  return result.values.map(row =>
+    result.columns.reduce<Record<string, any>>((acc, col, idx) => {
+      acc[col] = row[idx];
+      return acc;
+    }, {})
+  );
+};
+
+export const queryRows = async (
+  executor: DbExecutor,
+  sql: string,
+  params: unknown[] = []
+): Promise<Record<string, any>[]> => {
+  const [first] = await executor.executeSql(sql, params);
+  return toRows(first);
+};
+
+export const shouldIncludeTable = (name: string, options: IntrospectOptions): boolean => {
+  if (options.includeTables && !options.includeTables.includes(name)) return false;
+  if (options.excludeTables && options.excludeTables.includes(name)) return false;
+  return true;
+};

package/src/core/ddl/schema-diff.ts

@@ -0,0 +1,179 @@
+import { TableDef } from '../../schema/table.js';
+import { DbExecutor } from '../../orm/db-executor.js';
+import {
+  SchemaDialect,
+  deriveIndexName,
+  generateCreateTableSql,
+  renderColumnDefinition
+} from './schema-generator.js';
+import { DatabaseSchema, DatabaseTable } from './schema-types.js';
+
+export type SchemaChangeKind =
+  | 'createTable'
+  | 'dropTable'
+  | 'addColumn'
+  | 'dropColumn'
+  | 'alterColumn'
+  | 'addIndex'
+  | 'dropIndex';
+
+export interface SchemaChange {
+  kind: SchemaChangeKind;
+  table: string;
+  description: string;
+  statements: string[];
+  safe: boolean;
+}
+
+export interface SchemaPlan {
+  changes: SchemaChange[];
+  warnings: string[];
+}
+
+export interface SchemaDiffOptions {
+  /** Allow destructive operations (drops) */
+  allowDestructive?: boolean;
+}
+
+const tableKey = (name: string, schema?: string) => (schema ? `${schema}.${name}` : name);
+
+const mapTables = (schema: DatabaseSchema) => {
+  const map = new Map<string, DatabaseTable>();
+  for (const table of schema.tables) {
+    map.set(tableKey(table.name, table.schema), table);
+  }
+  return map;
+};
+
+const buildAddColumnSql = (table: TableDef, colName: string, dialect: SchemaDialect): string => {
+  const column = table.columns[colName];
+  const rendered = renderColumnDefinition(table, column, dialect);
+  return `ALTER TABLE ${dialect.formatTableName(table)} ADD ${rendered.sql};`;
+};
+
+export const diffSchema = (
+  expectedTables: TableDef[],
+  actualSchema: DatabaseSchema,
+  dialect: SchemaDialect,
+  options: SchemaDiffOptions = {}
+): SchemaPlan => {
+  const allowDestructive = options.allowDestructive ?? false;
+  const plan: SchemaPlan = { changes: [], warnings: [] };
+
+  const actualMap = mapTables(actualSchema);
+
+  // Create missing tables and indexes
+  for (const table of expectedTables) {
+    const key = tableKey(table.name, table.schema);
+    const actual = actualMap.get(key);
+    if (!actual) {
+      const { tableSql, indexSql } = generateCreateTableSql(table, dialect);
+      plan.changes.push({
+        kind: 'createTable',
+        table: key,
+        description: `Create table ${key}`,
+        statements: [tableSql, ...indexSql],
+        safe: true
+      });
+      continue;
+    }
+
+    // Columns
+    const actualCols = new Map(actual.columns.map(c => [c.name, c]));
+    for (const colName of Object.keys(table.columns)) {
+      if (!actualCols.has(colName)) {
+        plan.changes.push({
+          kind: 'addColumn',
+          table: key,
+          description: `Add column ${colName} to ${key}`,
+          statements: [buildAddColumnSql(table, colName, dialect)],
+          safe: true
+        });
+      }
+    }
+    for (const colName of actualCols.keys()) {
+      if (!table.columns[colName]) {
+        plan.changes.push({
+          kind: 'dropColumn',
+          table: key,
+          description: `Drop column ${colName} from ${key}`,
+          statements: allowDestructive ? dialect.dropColumnSql(actual, colName) : [],
+          safe: false
+        });
+        const warning = dialect.warnDropColumn?.(actual, colName);
+        if (warning) plan.warnings.push(warning);
+      }
+    }
+
+    // Indexes (naive: based on name or derived name)
+    const expectedIndexes = table.indexes ?? [];
+    const actualIndexes = actual.indexes ?? [];
+    const actualIndexMap = new Map(actualIndexes.map(idx => [idx.name, idx]));
+
+    for (const idx of expectedIndexes) {
+      const name = idx.name || deriveIndexName(table, idx);
+      if (!actualIndexMap.has(name)) {
+        plan.changes.push({
+          kind: 'addIndex',
+          table: key,
+          description: `Create index ${name} on ${key}`,
+          statements: [dialect.renderIndex(table, { ...idx, name })],
+          safe: true
+        });
+      }
+    }
+
+    for (const idx of actualIndexes) {
+      if (idx.name && !expectedIndexes.find(expected => (expected.name || deriveIndexName(table, expected)) === idx.name)) {
+        plan.changes.push({
+          kind: 'dropIndex',
+          table: key,
+          description: `Drop index ${idx.name} on ${key}`,
+          statements: allowDestructive ? dialect.dropIndexSql(actual, idx.name) : [],
+          safe: false
+        });
+      }
+    }
+  }
+
+  // Extra tables
+  for (const actual of actualSchema.tables) {
+    const key = tableKey(actual.name, actual.schema);
+    if (!expectedTables.find(t => tableKey(t.name, t.schema) === key)) {
+      plan.changes.push({
+        kind: 'dropTable',
+        table: key,
+        description: `Drop table ${key}`,
+        statements: allowDestructive ? dialect.dropTableSql(actual) : [],
+        safe: false
+      });
+    }
+  }
+
+  return plan;
+};
+
+export interface SynchronizeOptions extends SchemaDiffOptions {
+  dryRun?: boolean;
+}
+
+export const synchronizeSchema = async (
+  expectedTables: TableDef[],
+  actualSchema: DatabaseSchema,
+  dialect: SchemaDialect,
+  executor: DbExecutor,
+  options: SynchronizeOptions = {}
+): Promise<SchemaPlan> => {
+  const plan = diffSchema(expectedTables, actualSchema, dialect, options);
+  if (options.dryRun) return plan;
+
+  for (const change of plan.changes) {
+    if (!change.statements.length) continue;
+    if (!change.safe && !options.allowDestructive) continue;
+    for (const stmt of change.statements) {
+      if (!stmt.trim()) continue;
+      await executor.executeSql(stmt);
+    }
+  }
+  return plan;
+};

package/src/core/ddl/schema-generator.ts

@@ -0,0 +1,229 @@
+import { ColumnDef, ForeignKeyReference, RawDefaultValue } from '../../schema/column.js';
+import { IndexDef, IndexColumn, TableDef } from '../../schema/table.js';
+import { DatabaseTable } from './schema-types.js';
+export { BaseSchemaDialect } from './dialects/base-schema-dialect.js';
+export {
+  PostgresSchemaDialect,
+  MySqlSchemaDialect,
+  SQLiteSchemaDialect,
+  MSSqlSchemaDialect
+} from './dialects/index.js';
+
+export type DialectName = 'postgres' | 'mysql' | 'sqlite' | 'mssql';
+
+export interface SchemaDialect {
+  name: DialectName;
+  quoteIdentifier(id: string): string;
+  formatTableName(table: TableDef | DatabaseTable): string;
+  renderColumnType(column: ColumnDef): string;
+  renderDefault(value: unknown, column: ColumnDef): string;
+  renderAutoIncrement(column: ColumnDef, table: TableDef): string | undefined;
+  renderReference(ref: ForeignKeyReference, table: TableDef): string;
+  renderIndex(table: TableDef, index: IndexDef): string;
+  renderTableOptions(table: TableDef): string | undefined;
+  supportsPartialIndexes(): boolean;
+  preferInlinePkAutoincrement?(column: ColumnDef, table: TableDef, pk: string[]): boolean;
+  dropColumnSql(table: DatabaseTable, column: string): string[];
+  dropIndexSql(table: DatabaseTable, index: string): string[];
+  dropTableSql(table: DatabaseTable): string[];
+  warnDropColumn?(table: DatabaseTable, column: string): string | undefined;
+}
+
+export interface SchemaGenerateResult {
+  tableSql: string;
+  indexSql: string[];
+}
+
+export const escapeLiteral = (value: string): string => value.replace(/'/g, "''");
+
+const isRawDefault = (value: unknown): value is RawDefaultValue => {
+  return !!value && typeof value === 'object' && 'raw' in (value as any) && typeof (value as any).raw === 'string';
+};
+
+export const formatLiteral = (value: unknown, dialect: DialectName): string => {
+  if (isRawDefault(value)) return value.raw;
+  if (value === null) return 'NULL';
+  if (typeof value === 'number') return Number.isFinite(value) ? String(value) : 'NULL';
+  if (typeof value === 'boolean') {
+    if (dialect === 'mysql' || dialect === 'sqlite' || dialect === 'mssql') {
+      return value ? '1' : '0';
+    }
+    return value ? 'TRUE' : 'FALSE';
+  }
+  if (value instanceof Date) return `'${escapeLiteral(value.toISOString())}'`;
+  if (typeof value === 'string') return `'${escapeLiteral(value)}'`;
+  return `'${escapeLiteral(JSON.stringify(value))}'`;
+};
+
+export const resolvePrimaryKey = (table: TableDef): string[] => {
+  if (table.primaryKey && table.primaryKey.length > 0) {
+    return table.primaryKey;
+  }
+  const cols = Object.values(table.columns);
+  return cols.filter(c => c.primary).map(c => c.name);
+};
+
+export const quoteQualified = (dialect: SchemaDialect, identifier: string): string => {
+  if (identifier.includes('.')) {
+    return identifier
+      .split('.')
+      .map(part => dialect.quoteIdentifier(part))
+      .join('.');
+  }
+  return dialect.quoteIdentifier(identifier);
+};
+
+export const renderIndexColumns = (dialect: SchemaDialect, columns: (string | IndexColumn)[]) => {
+  return columns
+    .map(col => {
+      if (typeof col === 'string') return dialect.quoteIdentifier(col);
+      const parts = [dialect.quoteIdentifier(col.column)];
+      if (col.order) parts.push(col.order);
+      if (col.nulls) parts.push(`NULLS ${col.nulls}`);
+      return parts.join(' ');
+    })
+    .join(', ');
+};
+
+export const deriveIndexName = (table: TableDef, index: IndexDef): string => {
+  const base = (index.columns || [])
+    .map(col => (typeof col === 'string' ? col : col.column))
+    .join('_');
+  const suffix = index.unique ? 'uniq' : 'idx';
+  return `${table.name}_${base}_${suffix}`;
+};
+
+export interface RenderColumnOptions {
+  includePrimary?: boolean;
+}
+
+export const renderColumnDefinition = (
+  table: TableDef,
+  col: ColumnDef,
+  dialect: SchemaDialect,
+  options: RenderColumnOptions = {}
+): { sql: string; inlinePrimary: boolean } => {
+  const parts: string[] = [];
+  parts.push(dialect.quoteIdentifier(col.name));
+  parts.push(dialect.renderColumnType(col));
+
+  const autoInc = dialect.renderAutoIncrement(col, table);
+  if (autoInc) parts.push(autoInc);
+
+  if (col.notNull) parts.push('NOT NULL');
+  if (col.unique) parts.push('UNIQUE');
+  if (col.default !== undefined) {
+    parts.push(`DEFAULT ${dialect.renderDefault(col.default, col)}`);
+  }
+  if (options.includePrimary && col.primary) {
+    parts.push('PRIMARY KEY');
+  }
+  if (col.check) {
+    parts.push(`CHECK (${col.check})`);
+  }
+  if (col.references) {
+    parts.push(dialect.renderReference(col.references, table));
+  }
+
+  return { sql: parts.join(' '), inlinePrimary: !!(options.includePrimary && col.primary) };
+};
+
+export const generateCreateTableSql = (
+  table: TableDef,
+  dialect: SchemaDialect
+): SchemaGenerateResult => {
+  const pk = resolvePrimaryKey(table);
+  const inlinePkColumns = new Set<string>();
+
+  const columnLines = Object.values(table.columns).map(col => {
+    const includePk = dialect.preferInlinePkAutoincrement?.(col, table, pk) && pk.includes(col.name);
+    if (includePk) {
+      inlinePkColumns.add(col.name);
+    }
+    return renderColumnDefinition(table, col, dialect, { includePrimary: includePk }).sql;
+  });
+
+  const constraintLines: string[] = [];
+
+  if (pk.length > 0 && !(pk.length === 1 && inlinePkColumns.has(pk[0]))) {
+    const cols = pk.map(c => dialect.quoteIdentifier(c)).join(', ');
+    constraintLines.push(`PRIMARY KEY (${cols})`);
+  }
+
+  if (table.checks) {
+    table.checks.forEach(check => {
+      const name = check.name ? `${dialect.quoteIdentifier(check.name)} ` : '';
+      constraintLines.push(`CONSTRAINT ${name}CHECK (${check.expression})`);
+    });
+  }
+
+  const allLines = [...columnLines, ...constraintLines];
+  const body = allLines.map(line => `  ${line}`).join(',\n');
+  const tableOptions = dialect.renderTableOptions(table);
+  const tableSql = `CREATE TABLE ${dialect.formatTableName(table)} (\n${body}\n)${tableOptions ? ' ' + tableOptions : ''};`;
+
+  const indexSql: string[] = [];
+  if (table.indexes && table.indexes.length > 0) {
+    for (const idx of table.indexes) {
+      if (idx.where && !dialect.supportsPartialIndexes()) {
+        throw new Error(`Dialect ${dialect.name} does not support partial/filtered indexes (${idx.name || idx.columns.join('_')}).`);
+      }
+      indexSql.push(dialect.renderIndex(table, idx));
+    }
+  }
+
+  return { tableSql, indexSql };
+};
+
+export const generateSchemaSql = (
+  tables: TableDef[],
+  dialect: SchemaDialect
+): string[] => {
+  const ordered = orderTablesByDependencies(tables);
+  const statements: string[] = [];
+  ordered.forEach(table => {
+    const { tableSql, indexSql } = generateCreateTableSql(table, dialect);
+    statements.push(tableSql, ...indexSql);
+  });
+  return statements;
+};
+
+const orderTablesByDependencies = (tables: TableDef[]): TableDef[] => {
+  const map = new Map<string, TableDef>();
+  tables.forEach(t => map.set(t.name, t));
+
+  const deps = new Map<string, Set<string>>();
+  for (const table of tables) {
+    const refTables = new Set<string>();
+    Object.values(table.columns).forEach(col => {
+      if (col.references?.table) {
+        refTables.add(col.references.table);
+      }
+    });
+    deps.set(table.name, refTables);
+  }
+
+  const visited = new Set<string>();
+  const ordered: TableDef[] = [];
+
+  const visit = (name: string, stack: Set<string>) => {
+    if (visited.has(name)) return;
+    const table = map.get(name);
+    if (!table) return;
+    if (stack.has(name)) {
+      ordered.push(table);
+      visited.add(name);
+      return;
+    }
+    stack.add(name);
+    for (const dep of deps.get(name) || []) {
+      visit(dep, stack);
+    }
+    stack.delete(name);
+    visited.add(name);
+    ordered.push(table);
+  };
+
+  tables.forEach(t => visit(t.name, new Set()));
+  return ordered;
+};