metal-orm 1.0.14 → 1.0.16

package/src/core/ddl/dialects/base-schema-dialect.ts

@@ -1,7 +1,8 @@
-import { SchemaDialect, DialectName, formatLiteral, quoteQualified } from '../schema-generator.js';
+import { SchemaDialect, DialectName } from '../schema-dialect.js';
+import { formatLiteral, quoteQualified, createLiteralFormatter, LiteralFormatter } from '../sql-writing.js';
 import { ColumnDef, ForeignKeyReference } from '../../../schema/column.js';
 import { IndexDef, TableDef } from '../../../schema/table.js';
-import { DatabaseTable } from '../schema-types.js';
+import { DatabaseTable, DatabaseColumn, ColumnDiff } from '../schema-types.js';
 
 type TableLike = { name: string; schema?: string };
 
@@ -10,7 +11,7 @@ type TableLike = { name: string; schema?: string };
  * Concrete dialects only override the small surface area instead of reimplementing everything.
  */
 export abstract class BaseSchemaDialect implements SchemaDialect {
-  abstract name: DialectName;
+  abstract readonly name: DialectName;
   abstract quoteIdentifier(id: string): string;
   abstract renderColumnType(column: ColumnDef): string;
   abstract renderAutoIncrement(column: ColumnDef, table: TableDef): string | undefined;
@@ -24,8 +25,11 @@ export abstract class BaseSchemaDialect implements SchemaDialect {
     }
     return this.quoteIdentifier(table.name);
   }
+  // Each dialect should provide its own formatter
+  abstract get literalFormatter(): LiteralFormatter;
+
   renderDefault(value: unknown, _column: ColumnDef): string {
-    return formatLiteral(value, this.name);
+    return formatLiteral(this.literalFormatter, value);
   }
   renderReference(ref: ForeignKeyReference, _table: TableDef): string {
     const parts = ['REFERENCES', quoteQualified(this, ref.table), `(${this.quoteIdentifier(ref.column)})`];
@@ -40,9 +44,19 @@ export abstract class BaseSchemaDialect implements SchemaDialect {
   dropTableSql(table: DatabaseTable): string[] {
     return [`DROP TABLE IF EXISTS ${this.formatTableName(table)};`];
   }
-  abstract dropColumnSql(table: DatabaseTable, column: string): string[];
-  abstract dropIndexSql(table: DatabaseTable, index: string): string[];
+  dropColumnSql(table: DatabaseTable, column: string): string[] {
+    return [`ALTER TABLE ${this.formatTableName(table)} DROP COLUMN ${this.quoteIdentifier(column)};`];
+  }
+  dropIndexSql(table: DatabaseTable, index: string): string[] {
+    return [`DROP INDEX ${this.quoteIdentifier(index)};`];
+  }
   warnDropColumn(_table: DatabaseTable, _column: string): string | undefined {
     return undefined;
   }
+  alterColumnSql?(table: TableDef, column: ColumnDef, actualColumn: DatabaseColumn, diff: ColumnDiff): string[] {
+    return [];
+  }
+  warnAlterColumn?(_table: TableDef, _column: ColumnDef, _actual: DatabaseColumn, _diff: ColumnDiff): string | undefined {
+    return undefined;
+  }
 }

package/src/core/ddl/dialects/mssql-schema-dialect.ts

@@ -1,17 +1,23 @@
 import { BaseSchemaDialect } from './base-schema-dialect.js';
-import {
-  deriveIndexName,
-  renderIndexColumns,
-  DialectName,
-  formatLiteral
-} from '../schema-generator.js';
+import { deriveIndexName } from '../naming-strategy.js';
+import { renderIndexColumns, createLiteralFormatter } from '../sql-writing.js';
 import { ColumnDef } from '../../../schema/column.js';
 import { IndexDef, TableDef } from '../../../schema/table.js';
-import { DatabaseTable } from '../schema-types.js';
+import { ColumnDiff, DatabaseColumn, DatabaseTable } from '../schema-types.js';
+import { DialectName } from '../schema-dialect.js';
 
 export class MSSqlSchemaDialect extends BaseSchemaDialect {
   name: DialectName = 'mssql';
 
+  private _literalFormatter = createLiteralFormatter({
+    booleanTrue: '1',
+    booleanFalse: '0',
+  });
+
+  get literalFormatter() {
+    return this._literalFormatter;
+  }
+
   quoteIdentifier(id: string): string {
     return `[${id.replace(/]/g, ']]')}]`;
   }
@@ -68,7 +74,7 @@ export class MSSqlSchemaDialect extends BaseSchemaDialect {
   }
 
   renderDefault(value: unknown): string {
-    return formatLiteral(value, this.name);
+    return this.literalFormatter.formatLiteral(value);
   }
 
   renderAutoIncrement(column: ColumnDef): string | undefined {
@@ -94,4 +100,22 @@ export class MSSqlSchemaDialect extends BaseSchemaDialect {
   dropIndexSql(table: DatabaseTable, index: string): string[] {
     return [`DROP INDEX ${this.quoteIdentifier(index)} ON ${this.formatTableName(table)};`];
   }
+
+  alterColumnSql(table: TableDef, column: ColumnDef, _actual: DatabaseColumn, diff: ColumnDiff): string[] {
+    const stmts: string[] = [];
+    if (diff.typeChanged || diff.nullabilityChanged) {
+      const nullability = column.notNull ? 'NOT NULL' : 'NULL';
+      stmts.push(
+        `ALTER TABLE ${this.formatTableName(table)} ALTER COLUMN ${this.quoteIdentifier(column.name)} ${this.renderColumnType(column)} ${nullability};`
+      );
+    }
+    return stmts;
+  }
+
+  warnAlterColumn(_table: TableDef, _column: ColumnDef, _actual: DatabaseColumn, diff: ColumnDiff): string | undefined {
+    if (diff.defaultChanged || diff.autoIncrementChanged) {
+      return 'Altering defaults or identity on MSSQL is not automated (requires dropping/adding default or identity constraints manually).';
+    }
+    return undefined;
+  }
 }

package/src/core/ddl/dialects/mysql-schema-dialect.ts

@@ -1,18 +1,24 @@
 import { BaseSchemaDialect } from './base-schema-dialect.js';
-import {
-  deriveIndexName,
-  renderIndexColumns,
-  DialectName,
-  formatLiteral,
-  escapeLiteral
-} from '../schema-generator.js';
+import { deriveIndexName } from '../naming-strategy.js';
+import { renderIndexColumns, escapeSqlString, createLiteralFormatter } from '../sql-writing.js';
 import { ColumnDef } from '../../../schema/column.js';
 import { IndexDef, TableDef } from '../../../schema/table.js';
-import { DatabaseTable } from '../schema-types.js';
+import { ColumnDiff, DatabaseColumn, DatabaseTable } from '../schema-types.js';
+import { renderColumnDefinition } from '../schema-generator.js';
+import { DialectName } from '../schema-dialect.js';
 
 export class MySqlSchemaDialect extends BaseSchemaDialect {
   name: DialectName = 'mysql';
 
+  private _literalFormatter = createLiteralFormatter({
+    booleanTrue: '1',
+    booleanFalse: '0',
+  });
+
+  get literalFormatter() {
+    return this._literalFormatter;
+  }
+
   quoteIdentifier(id: string): string {
     return `\`${id}\``;
   }
@@ -66,7 +72,7 @@ export class MySqlSchemaDialect extends BaseSchemaDialect {
       case 'ENUM':
       case 'enum':
         return column.args && Array.isArray(column.args) && column.args.length
-          ? `ENUM(${column.args.map((v: string) => `'${escapeLiteral(v)}'`).join(',')})`
+          ? `ENUM(${column.args.map((v: string) => `'${escapeSqlString(v)}'`).join(',')})`
           : 'ENUM';
       default:
         return String(column.type).toUpperCase();
@@ -74,7 +80,7 @@ export class MySqlSchemaDialect extends BaseSchemaDialect {
   }
 
   renderDefault(value: unknown): string {
-    return formatLiteral(value, this.name);
+    return this.literalFormatter.formatLiteral(value);
   }
 
   renderAutoIncrement(column: ColumnDef): string | undefined {
@@ -106,4 +112,9 @@ export class MySqlSchemaDialect extends BaseSchemaDialect {
   dropIndexSql(table: DatabaseTable, index: string): string[] {
     return [`DROP INDEX ${this.quoteIdentifier(index)} ON ${this.formatTableName(table)};`];
   }
+
+  alterColumnSql(table: TableDef, column: ColumnDef, _actual: DatabaseColumn, _diff: ColumnDiff): string[] {
+    const rendered = renderColumnDefinition(table, column, this);
+    return [`ALTER TABLE ${this.formatTableName(table)} MODIFY COLUMN ${rendered.sql};`];
+  }
 }

package/src/core/ddl/dialects/postgres-schema-dialect.ts

@@ -1,15 +1,22 @@
 import { BaseSchemaDialect } from './base-schema-dialect.js';
-import {
-  deriveIndexName,
-  renderIndexColumns,
-  DialectName
-} from '../schema-generator.js';
+import { deriveIndexName } from '../naming-strategy.js';
+import { renderIndexColumns, createLiteralFormatter } from '../sql-writing.js';
 import { ColumnDef } from '../../../schema/column.js';
 import { IndexDef, TableDef } from '../../../schema/table.js';
-import { DatabaseTable } from '../schema-types.js';
+import { ColumnDiff, DatabaseColumn, DatabaseTable } from '../schema-types.js';
+import { DialectName } from '../schema-dialect.js';
 
 export class PostgresSchemaDialect extends BaseSchemaDialect {
-  name: DialectName = 'postgres';
+  readonly name: DialectName = 'postgres';
+
+  private _literalFormatter = createLiteralFormatter({
+    booleanTrue: 'TRUE',
+    booleanFalse: 'FALSE',
+  });
+
+  get literalFormatter() {
+    return this._literalFormatter;
+  }
 
   quoteIdentifier(id: string): string {
     return `"${id}"`;
@@ -96,4 +103,42 @@ export class PostgresSchemaDialect extends BaseSchemaDialect {
       : this.quoteIdentifier(index);
     return [`DROP INDEX IF EXISTS ${qualified};`];
   }
+
+  alterColumnSql(table: TableDef, column: ColumnDef, actualColumn: DatabaseColumn, diff: ColumnDiff): string[] {
+    const stmts: string[] = [];
+    const tableName = this.formatTableName(table);
+    const colName = this.quoteIdentifier(column.name);
+
+    if (diff.typeChanged) {
+      stmts.push(`ALTER TABLE ${tableName} ALTER COLUMN ${colName} TYPE ${this.renderColumnType(column)};`);
+    }
+    if (diff.defaultChanged) {
+      if (column.default === undefined) {
+        stmts.push(`ALTER TABLE ${tableName} ALTER COLUMN ${colName} DROP DEFAULT;`);
+      } else {
+        stmts.push(
+          `ALTER TABLE ${tableName} ALTER COLUMN ${colName} SET DEFAULT ${this.renderDefault(column.default, column)};`
+        );
+      }
+    }
+    if (diff.nullabilityChanged) {
+      stmts.push(`ALTER TABLE ${tableName} ALTER COLUMN ${colName} ${column.notNull ? 'SET' : 'DROP'} NOT NULL;`);
+    }
+    if (diff.autoIncrementChanged) {
+      if (column.autoIncrement) {
+        const strategy = column.generated === 'always' ? 'ALWAYS' : 'BY DEFAULT';
+        stmts.push(`ALTER TABLE ${tableName} ALTER COLUMN ${colName} ADD GENERATED ${strategy} AS IDENTITY;`);
+      } else {
+        stmts.push(`ALTER TABLE ${tableName} ALTER COLUMN ${colName} DROP IDENTITY IF EXISTS;`);
+      }
+    }
+    return stmts;
+  }
+
+  warnAlterColumn(_table: TableDef, _column: ColumnDef, _actual: DatabaseColumn, diff: ColumnDiff): string | undefined {
+    if (diff.autoIncrementChanged) {
+      return 'Altering identity properties may fail if an existing sequence is attached; verify generated column state.';
+    }
+    return undefined;
+  }
 }

package/src/core/ddl/dialects/sqlite-schema-dialect.ts

@@ -1,18 +1,23 @@
 import { BaseSchemaDialect } from './base-schema-dialect.js';
-import {
-  deriveIndexName,
-  renderIndexColumns,
-  DialectName,
-  formatLiteral,
-  resolvePrimaryKey
-} from '../schema-generator.js';
+import { deriveIndexName } from '../naming-strategy.js';
+import { renderIndexColumns, resolvePrimaryKey, createLiteralFormatter } from '../sql-writing.js';
 import { ColumnDef } from '../../../schema/column.js';
 import { IndexDef, TableDef } from '../../../schema/table.js';
-import { DatabaseTable } from '../schema-types.js';
+import { ColumnDiff, DatabaseColumn, DatabaseTable } from '../schema-types.js';
+import { DialectName } from '../schema-dialect.js';
 
 export class SQLiteSchemaDialect extends BaseSchemaDialect {
   name: DialectName = 'sqlite';
 
+  private _literalFormatter = createLiteralFormatter({
+    booleanTrue: '1',
+    booleanFalse: '0',
+  });
+
+  get literalFormatter() {
+    return this._literalFormatter;
+  }
+
   quoteIdentifier(id: string): string {
     return `"${id}"`;
   }
@@ -75,7 +80,7 @@ export class SQLiteSchemaDialect extends BaseSchemaDialect {
   }
 
   renderDefault(value: unknown): string {
-    return formatLiteral(value, this.name);
+    return this.literalFormatter.formatLiteral(value);
   }
 
   renderIndex(table: TableDef, index: IndexDef): string {
@@ -100,4 +105,13 @@ export class SQLiteSchemaDialect extends BaseSchemaDialect {
     const key = table.schema ? `${table.schema}.${table.name}` : table.name;
     return `Dropping columns on SQLite requires table rebuild (column ${column} on ${key}).`;
   }
+
+  alterColumnSql(_table: TableDef, _column: ColumnDef, _actual: DatabaseColumn, _diff: ColumnDiff): string[] {
+    return [];
+  }
+
+  warnAlterColumn(table: TableDef, column: ColumnDef, _actual: DatabaseColumn, _diff: ColumnDiff): string | undefined {
+    const key = table.schema ? `${table.schema}.${table.name}` : table.name;
+    return `SQLite ALTER COLUMN is not supported; rebuild table ${key} to change column ${column.name}.`;
+  }
 }

package/src/core/ddl/introspect/catalogs/index.ts

@@ -0,0 +1 @@
+export * from './postgres.js';

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

@@ -0,0 +1,143 @@
+import { defineTable } from '../../../../schema/table.js';
+import { col } from '../../../../schema/column.js';
+
+export const PgInformationSchemaColumns = defineTable(
+  'columns',
+  {
+    table_schema: col.varchar(255),
+    table_name: col.varchar(255),
+    column_name: col.varchar(255),
+    data_type: col.varchar(255),
+    is_nullable: col.varchar(3),
+    column_default: col.varchar(1024),
+    ordinal_position: col.int()
+  },
+  {},
+  undefined,
+  { schema: 'information_schema' }
+);
+
+export const PgClass = defineTable(
+  'pg_class',
+  {
+    oid: col.int(),
+    relname: col.varchar(255),
+    relnamespace: col.int(),
+    relkind: col.varchar(1)
+  },
+  {},
+  undefined,
+  { schema: 'pg_catalog' }
+);
+
+export const PgNamespace = defineTable(
+  'pg_namespace',
+  {
+    oid: col.int(),
+    nspname: col.varchar(255)
+  },
+  {},
+  undefined,
+  { schema: 'pg_catalog' }
+);
+
+export const PgIndex = defineTable(
+  'pg_index',
+  {
+    indrelid: col.int(),
+    indexrelid: col.int(),
+    indisprimary: col.boolean(),
+    indkey: col.varchar(255),
+    indpred: col.varchar(1024)
+  },
+  {},
+  undefined,
+  { schema: 'pg_catalog' }
+);
+
+export const PgAttribute = defineTable(
+  'pg_attribute',
+  {
+    attrelid: col.int(),
+    attname: col.varchar(255),
+    attnum: col.int()
+  },
+  {},
+  undefined,
+  { schema: 'pg_catalog' }
+);
+
+export const PgTableConstraints = defineTable(
+  'table_constraints',
+  {
+    constraint_catalog: col.varchar(255),
+    constraint_schema: col.varchar(255),
+    constraint_name: col.varchar(255),
+    table_catalog: col.varchar(255),
+    table_schema: col.varchar(255),
+    table_name: col.varchar(255),
+    constraint_type: col.varchar(255)
+  },
+  {},
+  undefined,
+  { schema: 'information_schema' }
+);
+
+export const PgKeyColumnUsage = defineTable(
+  'key_column_usage',
+  {
+    constraint_catalog: col.varchar(255),
+    constraint_schema: col.varchar(255),
+    constraint_name: col.varchar(255),
+    table_catalog: col.varchar(255),
+    table_schema: col.varchar(255),
+    table_name: col.varchar(255),
+    column_name: col.varchar(255),
+    ordinal_position: col.int()
+  },
+  {},
+  undefined,
+  { schema: 'information_schema' }
+);
+
+export const PgConstraintColumnUsage = defineTable(
+  'constraint_column_usage',
+  {
+    constraint_catalog: col.varchar(255),
+    constraint_schema: col.varchar(255),
+    constraint_name: col.varchar(255),
+    table_catalog: col.varchar(255),
+    table_schema: col.varchar(255),
+    table_name: col.varchar(255),
+    column_name: col.varchar(255)
+  },
+  {},
+  undefined,
+  { schema: 'information_schema' }
+);
+
+export const PgReferentialConstraints = defineTable(
+  'referential_constraints',
+  {
+    constraint_catalog: col.varchar(255),
+    constraint_schema: col.varchar(255),
+    constraint_name: col.varchar(255),
+    unique_constraint_catalog: col.varchar(255),
+    unique_constraint_schema: col.varchar(255),
+    unique_constraint_name: col.varchar(255),
+    match_option: col.varchar(64),
+    update_rule: col.varchar(64),
+    delete_rule: col.varchar(64)
+  },
+  {},
+  undefined,
+  { schema: 'information_schema' }
+);
+
+export default {
+  PgInformationSchemaColumns,
+  PgClass,
+  PgNamespace,
+  PgIndex,
+  PgAttribute
+};

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

@@ -0,0 +1,9 @@
+import type { Dialect } from '../../dialect/abstract.js';
+import type { DbExecutor } from '../../execution/db-executor.js';
+
+export interface IntrospectContext {
+  dialect: Dialect;
+  executor: DbExecutor;
+}
+
+export default IntrospectContext;

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

@@ -0,0 +1,26 @@
+// Small helpers to build Postgres-specific function calls as AST FunctionNodes
+import { columnOperand, valueToOperand } from '../../../ast/expression-builders.js';
+import type { OperandNode, FunctionNode } from '../../../ast/expression.js';
+
+type OperandInput = OperandNode | string | number | boolean | null;
+
+const toOperand = (v: OperandInput) => {
+  if (v === null) return valueToOperand(null);
+  if (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean') return valueToOperand(v);
+  return v as OperandNode;
+};
+
+const fn = (name: string, args: OperandInput[]): FunctionNode => ({
+  type: 'Function',
+  name,
+  fn: name,
+  args: args.map(toOperand)
+});
+
+export const pgGetExpr = (expr: OperandInput, relid: OperandInput): FunctionNode =>
+  fn('pg_get_expr', [expr, relid]);
+
+export const formatType = (typeOid: OperandInput, typmod: OperandInput): FunctionNode =>
+  fn('format_type', [typeOid, typmod]);
+
+export default { pgGetExpr, formatType };