metal-orm 1.1.26 → 1.1.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metal-orm",
-  "version": "1.1.26",
+  "version": "1.1.27",
   "type": "module",
   "repository": {
     "type": "git",

package/src/core/ddl/dialects/index.ts

@@ -1,6 +1,5 @@
-/** Re-exports for schema dialects. */
-export { BaseSchemaDialect } from './base-schema-dialect.js';
-export { PostgresSchemaDialect } from './postgres-schema-dialect.js';
-export { MySqlSchemaDialect } from './mysql-schema-dialect.js';
-export { SQLiteSchemaDialect } from './sqlite-schema-dialect.js';
-export { MSSqlSchemaDialect } from './mssql-schema-dialect.js';
+/** Re-exports for composed schema dialects. */
+export { PostgresSchemaDialect, createPostgresSchemaDialect } from './postgres-schema-dialect.js';
+export { MySqlSchemaDialect, createMySqlSchemaDialect } from './mysql-schema-dialect.js';
+export { SQLiteSchemaDialect, createSqliteSchemaDialect } from './sqlite-schema-dialect.js';
+export { MSSqlSchemaDialect, createMssqlSchemaDialect } from './mssql-schema-dialect.js';

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

@@ -1,140 +1,143 @@
-import { BaseSchemaDialect } from './base-schema-dialect.js';
 import { deriveIndexName } from '../naming-strategy.js';
-import { renderIndexColumns, createLiteralFormatter } from '../sql-writing.js';
-import { ColumnDef, normalizeColumnType, renderTypeWithArgs } from '../../../schema/column-types.js';
-import { IndexDef, TableDef } from '../../../schema/table.js';
-import { ColumnDiff, DatabaseColumn, DatabaseTable } from '../schema-types.js';
-import { DialectName } from '../schema-dialect.js';
+import {
+  createLiteralFormatter,
+  renderIndexColumns
+} from '../sql-writing.js';
+import {
+  composeSchemaDialect,
+  createStandardDropColumnCapability,
+  createStandardDropTableCapability,
+  type SchemaDialectServices
+} from '../schema-dialect-composer.js';
+import type { SchemaDialect } from '../schema-dialect.js';
+import {
+  normalizeColumnType,
+  renderTypeWithArgs,
+  type ColumnDef
+} from '../../../schema/column-types.js';
+import type { IndexDef, TableDef } from '../../../schema/table.js';
+import type { DatabaseTable } from '../schema-types.js';
 
-/** MSSQL schema dialect implementation. */
-export class MSSqlSchemaDialect extends BaseSchemaDialect {
-  name: DialectName = 'mssql';
+const quoteIdentifier = (id: string): string => `[${id.replace(/]/g, ']]')}]`;
+const literalFormatter = createLiteralFormatter({ booleanTrue: '1', booleanFalse: '0' });
 
-  private _literalFormatter = createLiteralFormatter({
-    booleanTrue: '1',
-    booleanFalse: '0',
-  });
-
-  get literalFormatter() {
-    return this._literalFormatter;
-  }
-
-  quoteIdentifier(id: string): string {
-    return `[${id.replace(/]/g, ']]')}]`;
-  }
+const renderMssqlColumnType = (
+  column: ColumnDef,
+  services: SchemaDialectServices
+): string => {
+  const override = column.dialectTypes?.[services.name] ?? column.dialectTypes?.default;
+  if (override) return renderTypeWithArgs(override, column.args);
 
-  renderColumnType(column: ColumnDef): string {
-    const override = column.dialectTypes?.[this.name] ?? column.dialectTypes?.default;
-    if (override) {
-      return renderTypeWithArgs(override, column.args);
+  const type = normalizeColumnType(column.type);
+  switch (type) {
+    case 'int':
+    case 'integer': return 'INT';
+    case 'bigint': return 'BIGINT';
+    case 'uuid': return 'UNIQUEIDENTIFIER';
+    case 'boolean': return 'BIT';
+    case 'json': return 'NVARCHAR(MAX)';
+    case 'decimal':
+      return column.args?.length ? `DECIMAL(${column.args[0]},${column.args[1] ?? 0})` : 'DECIMAL(18,0)';
+    case 'float':
+    case 'double': return 'FLOAT';
+    case 'timestamptz':
+    case 'timestamp':
+    case 'datetime': return 'DATETIME2';
+    case 'date': return 'DATE';
+    case 'varchar': return column.args?.length ? `NVARCHAR(${column.args[0]})` : 'NVARCHAR(255)';
+    case 'text': return 'NVARCHAR(MAX)';
+    case 'binary': {
+      const length = column.args?.[0];
+      return length !== undefined ? `BINARY(${length})` : 'BINARY(255)';
     }
-
-    const type = normalizeColumnType(column.type);
-    switch (type) {
-      case 'int':
-      case 'integer':
-        return 'INT';
-      case 'bigint':
-        return 'BIGINT';
-      case 'uuid':
-        return 'UNIQUEIDENTIFIER';
-      case 'boolean':
-        return 'BIT';
-      case 'json':
-        return 'NVARCHAR(MAX)';
-      case 'decimal':
-        return column.args?.length ? `DECIMAL(${column.args[0]},${column.args[1] ?? 0})` : 'DECIMAL(18,0)';
-      case 'float':
-      case 'double':
-        return 'FLOAT';
-      case 'timestamptz':
-      case 'timestamp':
-      case 'datetime':
-        return 'DATETIME2';
-      case 'date':
-        return 'DATE';
-      case 'varchar':
-        return column.args?.length ? `NVARCHAR(${column.args[0]})` : 'NVARCHAR(255)';
-      case 'text':
-        return 'NVARCHAR(MAX)';
-      case 'binary': {
-        const length = column.args?.[0];
-        return length !== undefined ? `BINARY(${length})` : 'BINARY(255)';
-      }
-      case 'varbinary': {
-        const length = column.args?.[0];
-        if (typeof length === 'string' && length.toLowerCase() === 'max') {
-          return 'VARBINARY(MAX)';
-        }
-        return length !== undefined ? `VARBINARY(${length})` : 'VARBINARY(255)';
-      }
-      case 'blob':
-      case 'bytea':
-        return 'VARBINARY(MAX)';
-      case 'enum':
-        return 'NVARCHAR(255)';
-      case 'vector': {
-        const dim = column.vectorOptions?.dimensions ?? column.args?.[0] ?? 3;
-        const elemType = column.vectorOptions?.elementType;
-        return elemType ? `VECTOR(${dim}, ${elemType})` : `VECTOR(${dim})`;
-      }
-      case 'halfvec': {
-        const dim = column.vectorOptions?.dimensions ?? column.args?.[0] ?? 3;
-        return `VECTOR(${dim}, float16)`;
-      }
-      default:
-        return renderTypeWithArgs(String(type).toUpperCase(), column.args);
+    case 'varbinary': {
+      const length = column.args?.[0];
+      if (typeof length === 'string' && length.toLowerCase() === 'max') return 'VARBINARY(MAX)';
+      return length !== undefined ? `VARBINARY(${length})` : 'VARBINARY(255)';
     }
+    case 'blob':
+    case 'bytea': return 'VARBINARY(MAX)';
+    case 'enum': return 'NVARCHAR(255)';
+    case 'vector': {
+      const dimensions = column.vectorOptions?.dimensions ?? column.args?.[0] ?? 3;
+      const elementType = column.vectorOptions?.elementType;
+      return elementType ? `VECTOR(${dimensions}, ${elementType})` : `VECTOR(${dimensions})`;
+    }
+    case 'halfvec': {
+      const dimensions = column.vectorOptions?.dimensions ?? column.args?.[0] ?? 3;
+      return `VECTOR(${dimensions}, float16)`;
+    }
+    default: return renderTypeWithArgs(String(type).toUpperCase(), column.args);
   }
+};
 
-  renderDefault(value: unknown): string {
-    return this.literalFormatter.formatLiteral(value);
-  }
-
-  renderAutoIncrement(column: ColumnDef): string | undefined {
-    return column.autoIncrement ? 'IDENTITY(1,1)' : undefined;
-  }
-
-  renderIndex(table: TableDef, index: IndexDef): string {
-    const name = index.name || deriveIndexName(table, index);
-    const cols = renderIndexColumns(this, index.columns);
-    const unique = index.unique ? 'UNIQUE ' : '';
-    const where = index.where ? ` WHERE ${index.where}` : '';
-    return `CREATE ${unique}INDEX ${this.quoteIdentifier(name)} ON ${this.formatTableName(table)} (${cols})${where};`;
-  }
-
-  supportsPartialIndexes(): boolean {
-    return true;
-  }
+export const createMssqlSchemaDialect = (): SchemaDialect =>
+  composeSchemaDialect({
+    name: 'mssql',
+    quoteIdentifier,
+    literalFormatter,
+    renderColumnType: renderMssqlColumnType,
+    renderAutoIncrement: column => column.autoIncrement ? 'IDENTITY(1,1)' : undefined,
+    renderIndex(table, index, services) {
+      const name = index.name || deriveIndexName(table, index);
+      const columns = renderIndexColumns(services, index.columns);
+      const unique = index.unique ? 'UNIQUE ' : '';
+      const where = index.where ? ` WHERE ${index.where}` : '';
+      return `CREATE ${unique}INDEX ${services.quoteIdentifier(name)} ON ${services.formatTableName(table)} (${columns})${where};`;
+    },
+    supportsPartialIndexes: true,
+    mutations: services => ({
+      dropTable: createStandardDropTableCapability(services),
+      dropColumn: createStandardDropColumnCapability(services),
+      dropIndex: {
+        compile: (table, index) => [
+          `DROP INDEX ${services.quoteIdentifier(index)} ON ${services.formatTableName(table)};`
+        ]
+      },
+      alterColumn: {
+        compile(table, column, actualColumn, diff) {
+          void actualColumn;
+          const statements: string[] = [];
+          if (diff.typeChanged || diff.nullabilityChanged) {
+            const nullability = column.notNull ? 'NOT NULL' : 'NULL';
+            statements.push(
+              `ALTER TABLE ${services.formatTableName(table)} ALTER COLUMN ${services.quoteIdentifier(column.name)} ${renderMssqlColumnType(column, services)} ${nullability};`
+            );
+          }
+          return statements;
+        },
+        warning(table, column, actualColumn, diff) {
+          void table;
+          void column;
+          void actualColumn;
+          return diff.defaultChanged || diff.autoIncrementChanged
+            ? 'Altering defaults or identity on MSSQL is not automated (requires dropping/adding default or identity constraints manually).'
+            : undefined;
+        }
+      }
+    })
+  });
 
-  dropColumnSql(table: DatabaseTable, column: string): string[] {
-    return [`ALTER TABLE ${this.formatTableName(table)} DROP COLUMN ${this.quoteIdentifier(column)};`];
-  }
+/** Ergonomic facade; DDL rendering itself is pure composition. */
+export class MSSqlSchemaDialect implements SchemaDialect {
+  private readonly delegate = createMssqlSchemaDialect();
+  readonly name = this.delegate.name;
+  readonly mutations = this.delegate.mutations;
 
-  dropIndexSql(table: DatabaseTable, index: string): string[] {
-    return [`DROP INDEX ${this.quoteIdentifier(index)} ON ${this.formatTableName(table)};`];
+  quoteIdentifier(id: string): string { return this.delegate.quoteIdentifier(id); }
+  formatTableName(table: TableDef | DatabaseTable): string { return this.delegate.formatTableName(table); }
+  renderColumnType(column: ColumnDef): string { return this.delegate.renderColumnType(column); }
+  renderDefault(value: unknown, column: ColumnDef): string { return this.delegate.renderDefault(value, column); }
+  renderAutoIncrement(column: ColumnDef, table: TableDef): string | undefined {
+    return this.delegate.renderAutoIncrement(column, table);
   }
-
-  alterColumnSql(table: TableDef, column: ColumnDef, _actual: DatabaseColumn, diff: ColumnDiff): string[] {
-    void _actual;
-    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;
+  renderReference(ref: Parameters<SchemaDialect['renderReference']>[0], table: TableDef): string {
+    return this.delegate.renderReference(ref, table);
   }
-
-  warnAlterColumn(_table: TableDef, _column: ColumnDef, _actual: DatabaseColumn, diff: ColumnDiff): string | undefined {
-    void _table;
-    void _column;
-    void _actual;
-    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;
+  renderIndex(table: TableDef, index: IndexDef): string { return this.delegate.renderIndex(table, index); }
+  renderTableOptions(table: TableDef): string | undefined { return this.delegate.renderTableOptions(table); }
+  supportsPartialIndexes(): boolean { return this.delegate.supportsPartialIndexes(); }
+  preferInlinePkAutoincrement(column: ColumnDef, table: TableDef, pk: string[]): boolean {
+    return this.delegate.preferInlinePkAutoincrement(column, table, pk);
   }
 }
-

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

@@ -1,125 +1,133 @@
-import { BaseSchemaDialect } from './base-schema-dialect.js';
 import { deriveIndexName } from '../naming-strategy.js';
-import { renderIndexColumns, escapeSqlString, createLiteralFormatter } from '../sql-writing.js';
-import { ColumnDef, normalizeColumnType, renderTypeWithArgs } from '../../../schema/column-types.js';
-import { IndexDef, TableDef } from '../../../schema/table.js';
-import { ColumnDiff, DatabaseColumn, DatabaseTable } from '../schema-types.js';
+import {
+  createLiteralFormatter,
+  escapeSqlString,
+  renderIndexColumns
+} from '../sql-writing.js';
+import {
+  composeSchemaDialect,
+  createStandardDropColumnCapability,
+  createStandardDropTableCapability,
+  type SchemaDialectServices
+} from '../schema-dialect-composer.js';
+import type { SchemaDialect } from '../schema-dialect.js';
 import { renderColumnDefinition } from '../schema-generator.js';
-import { DialectName } from '../schema-dialect.js';
+import {
+  normalizeColumnType,
+  renderTypeWithArgs,
+  type ColumnDef
+} from '../../../schema/column-types.js';
+import type { IndexDef, TableDef } from '../../../schema/table.js';
+import type { DatabaseTable } from '../schema-types.js';
 
-/** MySQL schema dialect implementation. */
-export class MySqlSchemaDialect extends BaseSchemaDialect {
-  name: DialectName = 'mysql';
+const quoteIdentifier = (id: string): string => `\`${id}\``;
+const literalFormatter = createLiteralFormatter({ booleanTrue: '1', booleanFalse: '0' });
 
-  private _literalFormatter = createLiteralFormatter({
-    booleanTrue: '1',
-    booleanFalse: '0',
-  });
-
-  get literalFormatter() {
-    return this._literalFormatter;
-  }
-
-  quoteIdentifier(id: string): string {
-    return `\`${id}\``;
-  }
+const renderMySqlColumnType = (
+  column: ColumnDef,
+  services: SchemaDialectServices
+): string => {
+  const override = column.dialectTypes?.[services.name] ?? column.dialectTypes?.default;
+  if (override) return renderTypeWithArgs(override, column.args);
 
-  renderColumnType(column: ColumnDef): string {
-    const override = column.dialectTypes?.[this.name] ?? column.dialectTypes?.default;
-    if (override) {
-      return renderTypeWithArgs(override, column.args);
+  const type = normalizeColumnType(column.type);
+  switch (type) {
+    case 'int':
+    case 'integer': return 'INT';
+    case 'bigint': return 'BIGINT';
+    case 'uuid': return 'CHAR(36)';
+    case 'boolean': return 'TINYINT(1)';
+    case 'json': return 'JSON';
+    case 'decimal':
+      return column.args?.length ? `DECIMAL(${column.args[0]},${column.args[1] ?? 0})` : 'DECIMAL';
+    case 'float': return column.args?.length ? `FLOAT(${column.args[0]})` : 'FLOAT';
+    case 'double': return 'DOUBLE';
+    case 'timestamptz':
+    case 'timestamp': return 'TIMESTAMP';
+    case 'datetime': return 'DATETIME';
+    case 'date': return 'DATE';
+    case 'varchar': return column.args?.length ? `VARCHAR(${column.args[0]})` : 'VARCHAR(255)';
+    case 'text': return 'TEXT';
+    case 'binary': return column.args?.length ? `BINARY(${column.args[0]})` : 'BINARY(255)';
+    case 'varbinary': return column.args?.length ? `VARBINARY(${column.args[0]})` : 'VARBINARY(255)';
+    case 'blob':
+    case 'bytea': return 'BLOB';
+    case 'enum':
+      return column.args?.length
+        ? `ENUM(${column.args.map(value => `'${escapeSqlString(String(value))}'`).join(',')})`
+        : 'ENUM';
+    case 'vector':
+    case 'halfvec': {
+      const dimensions = column.vectorOptions?.dimensions ?? column.args?.[0] ?? 3;
+      return `VECTOR(${dimensions})`;
     }
-
-    const type = normalizeColumnType(column.type);
-    switch (type) {
-      case 'int':
-      case 'integer':
-        return 'INT';
-      case 'bigint':
-        return 'BIGINT';
-      case 'uuid':
-        return 'CHAR(36)';
-      case 'boolean':
-        return 'TINYINT(1)';
-      case 'json':
-        return 'JSON';
-      case 'decimal':
-        return column.args?.length ? `DECIMAL(${column.args[0]},${column.args[1] ?? 0})` : 'DECIMAL';
-      case 'float':
-        return column.args?.length ? `FLOAT(${column.args[0]})` : 'FLOAT';
-      case 'double':
-        return 'DOUBLE';
-      case 'timestamptz':
-      case 'timestamp':
-        return 'TIMESTAMP';
-      case 'datetime':
-        return 'DATETIME';
-      case 'date':
-        return 'DATE';
-      case 'varchar':
-        return column.args?.length ? `VARCHAR(${column.args[0]})` : 'VARCHAR(255)';
-      case 'text':
-        return 'TEXT';
-      case 'binary':
-        return column.args?.length ? `BINARY(${column.args[0]})` : 'BINARY(255)';
-      case 'varbinary':
-        return column.args?.length ? `VARBINARY(${column.args[0]})` : 'VARBINARY(255)';
-      case 'blob':
-      case 'bytea':
-        return 'BLOB';
-      case 'enum':
-        return column.args && Array.isArray(column.args) && column.args.length
-          ? `ENUM(${column.args.map((v: string) => `'${escapeSqlString(v)}'`).join(',')})`
-          : 'ENUM';
-      case 'vector':
-      case 'halfvec': {
-        const dim = column.vectorOptions?.dimensions ?? column.args?.[0] ?? 3;
-        return `VECTOR(${dim})`;
-      }
-      default:
-        return renderTypeWithArgs(String(type).toUpperCase(), column.args);
-    }
-  }
-
-  renderDefault(value: unknown): string {
-    return this.literalFormatter.formatLiteral(value);
+    default: return renderTypeWithArgs(String(type).toUpperCase(), column.args);
   }
+};
 
-  renderAutoIncrement(column: ColumnDef): string | undefined {
-    return column.autoIncrement ? 'AUTO_INCREMENT' : undefined;
-  }
-
-  renderIndex(table: TableDef, index: IndexDef): string {
-    if (index.where) {
-      throw new Error('MySQL does not support partial/filtered indexes');
-    }
-    const name = index.name || deriveIndexName(table, index);
-    const cols = renderIndexColumns(this, index.columns);
-    const unique = index.unique ? 'UNIQUE ' : '';
-    return `CREATE ${unique}INDEX ${this.quoteIdentifier(name)} ON ${this.formatTableName(table)} (${cols});`;
-  }
+export const createMySqlSchemaDialect = (): SchemaDialect => {
+  let dialect!: SchemaDialect;
+  dialect = composeSchemaDialect({
+    name: 'mysql',
+    quoteIdentifier,
+    literalFormatter,
+    renderColumnType: renderMySqlColumnType,
+    renderAutoIncrement: column => column.autoIncrement ? 'AUTO_INCREMENT' : undefined,
+    renderIndex(table, index, services) {
+      if (index.where) throw new Error('MySQL does not support partial/filtered indexes');
+      const name = index.name || deriveIndexName(table, index);
+      const columns = renderIndexColumns(services, index.columns);
+      const unique = index.unique ? 'UNIQUE ' : '';
+      return `CREATE ${unique}INDEX ${services.quoteIdentifier(name)} ON ${services.formatTableName(table)} (${columns});`;
+    },
+    renderTableOptions(table) {
+      const parts: string[] = [];
+      if (table.engine) parts.push(`ENGINE=${table.engine}`);
+      if (table.charset) parts.push(`DEFAULT CHARSET=${table.charset}`);
+      if (table.collation) parts.push(`COLLATE=${table.collation}`);
+      return parts.length ? parts.join(' ') : undefined;
+    },
+    mutations: services => ({
+      dropTable: createStandardDropTableCapability(services),
+      dropColumn: createStandardDropColumnCapability(services),
+      dropIndex: {
+        compile: (table, index) => [
+          `DROP INDEX ${services.quoteIdentifier(index)} ON ${services.formatTableName(table)};`
+        ]
+      },
+      alterColumn: {
+        compile(table, column, actualColumn, diff) {
+          void actualColumn;
+          void diff;
+          const rendered = renderColumnDefinition(table, column, dialect);
+          return [`ALTER TABLE ${services.formatTableName(table)} MODIFY COLUMN ${rendered.sql};`];
+        }
+      }
+    })
+  });
+  return dialect;
+};
 
-  renderTableOptions(table: TableDef): string | undefined {
-    const parts: string[] = [];
-    if (table.engine) parts.push(`ENGINE=${table.engine}`);
-    if (table.charset) parts.push(`DEFAULT CHARSET=${table.charset}`);
-    if (table.collation) parts.push(`COLLATE=${table.collation}`);
-    return parts.length ? parts.join(' ') : undefined;
-  }
+/** Ergonomic facade; DDL rendering itself is pure composition. */
+export class MySqlSchemaDialect implements SchemaDialect {
+  private readonly delegate = createMySqlSchemaDialect();
+  readonly name = this.delegate.name;
+  readonly mutations = this.delegate.mutations;
 
-  dropColumnSql(table: DatabaseTable, column: string): string[] {
-    return [`ALTER TABLE ${this.formatTableName(table)} DROP COLUMN ${this.quoteIdentifier(column)};`];
+  quoteIdentifier(id: string): string { return this.delegate.quoteIdentifier(id); }
+  formatTableName(table: TableDef | DatabaseTable): string { return this.delegate.formatTableName(table); }
+  renderColumnType(column: ColumnDef): string { return this.delegate.renderColumnType(column); }
+  renderDefault(value: unknown, column: ColumnDef): string { return this.delegate.renderDefault(value, column); }
+  renderAutoIncrement(column: ColumnDef, table: TableDef): string | undefined {
+    return this.delegate.renderAutoIncrement(column, table);
   }
-
-  dropIndexSql(table: DatabaseTable, index: string): string[] {
-    return [`DROP INDEX ${this.quoteIdentifier(index)} ON ${this.formatTableName(table)};`];
+  renderReference(ref: Parameters<SchemaDialect['renderReference']>[0], table: TableDef): string {
+    return this.delegate.renderReference(ref, table);
   }
-
-  alterColumnSql(table: TableDef, column: ColumnDef, _actual: DatabaseColumn, _diff: ColumnDiff): string[] {
-    void _actual;
-    void _diff;
-    const rendered = renderColumnDefinition(table, column, this);
-    return [`ALTER TABLE ${this.formatTableName(table)} MODIFY COLUMN ${rendered.sql};`];
+  renderIndex(table: TableDef, index: IndexDef): string { return this.delegate.renderIndex(table, index); }
+  renderTableOptions(table: TableDef): string | undefined { return this.delegate.renderTableOptions(table); }
+  supportsPartialIndexes(): boolean { return this.delegate.supportsPartialIndexes(); }
+  preferInlinePkAutoincrement(column: ColumnDef, table: TableDef, pk: string[]): boolean {
+    return this.delegate.preferInlinePkAutoincrement(column, table, pk);
   }
 }
-