metal-orm 1.0.13 → 1.0.15

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

@@ -1,179 +1,211 @@
-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;
-};
+import { TableDef } from '../../schema/table.js';
+import { ColumnDef } from '../../schema/column.js';
+import type { DbExecutor } from '../execution/db-executor.js';
+import { SchemaDialect } from './schema-dialect.js';
+import { deriveIndexName } from './naming-strategy.js';
+import { generateCreateTableSql, renderColumnDefinition } from './schema-generator.js';
+import { ColumnDiff, DatabaseColumn, 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};`;
+};
+
+const normalizeType = (value: string | undefined): string => (value || '').toLowerCase().replace(/\s+/g, ' ').trim();
+const normalizeDefault = (value: unknown): string | undefined => {
+  if (value === undefined || value === null) return undefined;
+  return String(value).trim();
+};
+
+const diffColumn = (expected: ColumnDef, actual: DatabaseColumn, dialect: SchemaDialect): ColumnDiff => {
+  const expectedType = normalizeType(dialect.renderColumnType(expected));
+  const actualType = normalizeType(actual.type);
+  const expectedDefault =
+    expected.default !== undefined ? normalizeDefault(dialect.renderDefault(expected.default, expected)) : undefined;
+  const actualDefault = normalizeDefault(actual.default);
+  return {
+    typeChanged: expectedType !== actualType,
+    nullabilityChanged: !!expected.notNull !== !!actual.notNull,
+    defaultChanged: expectedDefault !== actualDefault,
+    autoIncrementChanged: !!expected.autoIncrement !== !!actual.autoIncrement
+  };
+};
+
+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
+        });
+      } else {
+        const expectedCol = table.columns[colName];
+        const actualCol = actualCols.get(colName)!;
+        const colDiff = diffColumn(expectedCol, actualCol, dialect);
+        const shouldAlter =
+          colDiff.typeChanged || colDiff.nullabilityChanged || colDiff.defaultChanged || colDiff.autoIncrementChanged;
+        if (shouldAlter) {
+          const statements = dialect.alterColumnSql?.(table, expectedCol, actualCol, colDiff) ?? [];
+          if (statements.length > 0) {
+            plan.changes.push({
+              kind: 'alterColumn',
+              table: key,
+              description: `Alter column ${colName} on ${key}`,
+              statements,
+              safe: true
+            });
+          }
+          const warning = dialect.warnAlterColumn?.(table, expectedCol, actualCol, colDiff);
+          if (warning) plan.warnings.push(warning);
+        }
+      }
+    }
+    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) {
+    const { executeSchemaPlan } = await import('./schema-plan-executor.js');
+    await executeSchemaPlan(plan, executor, options);
+  }
+  return plan;
+};

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

@@ -1,98 +1,21 @@
-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;
-}
+import type { TableDef, IndexDef, IndexColumn } from '../../schema/table.js';
+import type { ColumnDef, ForeignKeyReference } from '../../schema/column.js';
+import type { SchemaDialect, DialectName } from './schema-dialect.js';
+import { deriveIndexName } from './naming-strategy.js';
+import {
+  formatLiteral,
+  renderIndexColumns,
+  quoteQualified,
+  resolvePrimaryKey,
+  Quoter
+} from './sql-writing.js';
+import { DatabaseTable, DatabaseColumn, ColumnDiff } from './schema-types.js';
 
 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;
 }
@@ -136,7 +59,7 @@ export const generateCreateTableSql = (
   const inlinePkColumns = new Set<string>();
 
   const columnLines = Object.values(table.columns).map(col => {
-    const includePk = dialect.preferInlinePkAutoincrement?.(col, table, pk) && pk.includes(col.name);
+    const includePk = (dialect as any).preferInlinePkAutoincrement?.(col, table, pk) && pk.includes(col.name);
     if (includePk) {
       inlinePkColumns.add(col.name);
     }
@@ -227,3 +150,6 @@ const orderTablesByDependencies = (tables: TableDef[]): TableDef[] => {
   tables.forEach(t => visit(t.name, new Set()));
   return ordered;
 };
+
+// Re-export DialectName for backward compatibility
+export { DialectName };

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

@@ -1,32 +1,25 @@
-import { DialectName } from './schema-generator.js';
-import { DatabaseSchema } from './schema-types.js';
-import { DbExecutor } from '../../orm/db-executor.js';
-import type { IntrospectOptions, SchemaIntrospector } from './introspect/types.js';
-import { postgresIntrospector } from './introspect/postgres.js';
-import { mysqlIntrospector } from './introspect/mysql.js';
-import { sqliteIntrospector } from './introspect/sqlite.js';
-import { mssqlIntrospector } from './introspect/mssql.js';
-
-const INTROSPECTORS: Record<DialectName, SchemaIntrospector> = {
-  postgres: postgresIntrospector,
-  mysql: mysqlIntrospector,
-  sqlite: sqliteIntrospector,
-  mssql: mssqlIntrospector
-};
-
-/**
- * Introspects an existing database schema using the dialect-specific strategy.
- */
-export const introspectSchema = async (
-  executor: DbExecutor,
-  dialect: DialectName,
-  options: IntrospectOptions = {}
-): Promise<DatabaseSchema> => {
-  const handler = INTROSPECTORS[dialect];
-  if (!handler) {
-    throw new Error(`Unsupported dialect for introspection: ${dialect}`);
-  }
-  return handler.introspect(executor, options);
-};
-
-export type { IntrospectOptions, SchemaIntrospector };
+import { DialectName } from './schema-generator.js';
+import { DatabaseSchema } from './schema-types.js';
+import { DbExecutor } from '../execution/db-executor.js';
+import type { IntrospectOptions, SchemaIntrospector, IntrospectContext } from './introspect/types.js';
+import { getSchemaIntrospector } from './introspect/registry.js';
+import { DialectFactory } from '../dialect/dialect-factory.js';
+
+/**
+ * Introspects an existing database schema using the dialect-specific strategy.
+ */
+export const introspectSchema = async (
+  executor: DbExecutor,
+  dialect: DialectName,
+  options: IntrospectOptions = {}
+): Promise<DatabaseSchema> => {
+  const handler = getSchemaIntrospector(dialect);
+  if (!handler) {
+    throw new Error(`Unsupported dialect for introspection: ${dialect}`);
+  }
+  const dialectInstance = DialectFactory.create(dialect);
+  const ctx: IntrospectContext = { executor, dialect: dialectInstance };
+  return handler.introspect(ctx, options);
+};
+
+export type { IntrospectOptions, SchemaIntrospector };

package/src/core/ddl/schema-plan-executor.ts

@@ -0,0 +1,17 @@
+import { DbExecutor } from '../execution/db-executor.js';
+import type { SchemaPlan, SynchronizeOptions } from './schema-diff.js';
+
+export const executeSchemaPlan = async (
+  plan: SchemaPlan,
+  executor: DbExecutor,
+  options: SynchronizeOptions = {}
+): Promise<void> => {
+  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);
+    }
+  }
+};