metal-orm 1.1.25 → 1.1.27

package/src/core/dialect/postgres/index.ts

@@ -1,68 +1,96 @@
 import type { ProcedureCallNode } from '../../ast/procedure.js';
 import type { BitwiseExpressionNode, ColumnNode, JsonPathNode } from '../../ast/expression.js';
-import type { TableNode } from '../../ast/query.js';
+import type {
+  DeleteQueryNode,
+  InsertQueryNode,
+  SelectQueryNode,
+  TableNode,
+  UpdateQueryNode
+} from '../../ast/query.js';
+import type { CompiledQuery, Dialect } from '../abstract.js';
 import type { CompiledProcedureCall, ProcedureCompiler } from '../capabilities/procedure-compiler.js';
-import { SqlDialectBase } from '../base/sql-dialect.js';
+import { composeSqlDialect } from '../base/sql-dialect-composer.js';
 import { PostgresFunctionStrategy } from './functions.js';
 import { PostgresTableFunctionStrategy } from './table-functions.js';
 import { PostgresProcedureCompiler } from './procedure-compiler.js';
 import { PostgresReturningStrategy } from './returning.js';
 import { PostgresUpsertStrategy } from './upsert.js';
 
-/** PostgreSQL dialect assembled from reusable compiler components. */
-export class PostgresDialect extends SqlDialectBase implements ProcedureCompiler {
-  protected readonly dialect = 'postgres';
-  private readonly procedureCompiler: PostgresProcedureCompiler;
+const quoteIdentifier = (id: string): string => `"${id}"`;
 
-  public constructor() {
-    super({
-      functionStrategy: new PostgresFunctionStrategy(),
-      tableFunctionStrategy: new PostgresTableFunctionStrategy(),
-      returningStrategy: new PostgresReturningStrategy(),
-      upsertStrategy: new PostgresUpsertStrategy(),
-      supportsDmlReturning: true
-    });
+export type PostgresDialectImplementation = Dialect & ProcedureCompiler;
 
-    this.procedureCompiler = new PostgresProcedureCompiler({
-      quoteIdentifier: id => this.quoteIdentifier(id),
-      createCompilerContext: () => this.createCompilerContext(),
-      compileOperand: (node, ctx) => this.compileOperand(node, ctx)
-    });
+/** Creates the PostgreSQL dialect entirely from composable compiler components. */
+export const createPostgresDialect = (): PostgresDialectImplementation => {
+  const composition = composeSqlDialect({
+    name: 'postgres',
+    quoteIdentifier,
+    formatPlaceholder: index => `$${index}`,
+    functionStrategy: new PostgresFunctionStrategy(),
+    tableFunctionStrategy: new PostgresTableFunctionStrategy(),
+    returningStrategy: new PostgresReturningStrategy(),
+    upsertStrategy: new PostgresUpsertStrategy(),
+    supportsDmlReturning: true,
+    compileSetTarget: (column: ColumnNode, _table: TableNode) => {
+      void _table;
+      return quoteIdentifier(column.name);
+    },
+    compileJsonPath(node: JsonPathNode): string {
+      const column = `${quoteIdentifier(node.column.table)}.${quoteIdentifier(node.column.name)}`;
+      return `${column}->>'${node.path}'`;
+    },
+    configureExpressions(api) {
+      api.registerExpressionCompiler('BitwiseExpression', (node: BitwiseExpressionNode, ctx) => {
+        const left = api.compileOperand(node.left, ctx);
+        const right = api.compileOperand(node.right, ctx);
+        const operator = node.operator === '^' ? '#' : node.operator;
+        return `${left} ${operator} ${right}`;
+      });
+      api.registerOperandCompiler('BitwiseExpression', (node: BitwiseExpressionNode, ctx) => {
+        const left = api.compileOperand(node.left, ctx);
+        const right = api.compileOperand(node.right, ctx);
+        const operator = node.operator === '^' ? '#' : node.operator;
+        return `(${left} ${operator} ${right})`;
+      });
+    }
+  });
 
-    this.registerExpressionCompiler('BitwiseExpression', (node: BitwiseExpressionNode, ctx) => {
-      const left = this.compileOperand(node.left, ctx);
-      const right = this.compileOperand(node.right, ctx);
-      const operator = node.operator === '^' ? '#' : node.operator;
-      return `${left} ${operator} ${right}`;
-    });
-    this.registerOperandCompiler('BitwiseExpression', (node: BitwiseExpressionNode, ctx) => {
-      const left = this.compileOperand(node.left, ctx);
-      const right = this.compileOperand(node.right, ctx);
-      const operator = node.operator === '^' ? '#' : node.operator;
-      return `(${left} ${operator} ${right})`;
-    });
-  }
+  const procedures = new PostgresProcedureCompiler(composition.runtime);
+  return {
+    ...composition.dialect,
+    compileProcedureCall: ast => procedures.compileProcedureCall(ast)
+  };
+};
+
+/** Ergonomic constructor facade over the composed PostgreSQL dialect. */
+export class PostgresDialect implements Dialect, ProcedureCompiler {
+  private readonly impl: PostgresDialectImplementation = createPostgresDialect();
 
   quoteIdentifier(id: string): string {
-    return `"${id}"`;
+    return this.impl.quoteIdentifier(id);
+  }
+
+  supportsDmlReturningClause(): boolean {
+    return this.impl.supportsDmlReturningClause();
+  }
+
+  compileSelect(ast: SelectQueryNode): CompiledQuery {
+    return this.impl.compileSelect(ast);
   }
 
-  protected formatPlaceholder(index: number): string {
-    return `$${index}`;
+  compileInsert(ast: InsertQueryNode): CompiledQuery {
+    return this.impl.compileInsert(ast);
   }
 
-  protected compileJsonPath(node: JsonPathNode): string {
-    const column = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
-    return `${column}->>'${node.path}'`;
+  compileUpdate(ast: UpdateQueryNode): CompiledQuery {
+    return this.impl.compileUpdate(ast);
   }
 
-  /** PostgreSQL requires unqualified column names in SET clauses. */
-  protected compileSetTarget(column: ColumnNode, _table: TableNode): string {
-    void _table;
-    return this.quoteIdentifier(column.name);
+  compileDelete(ast: DeleteQueryNode): CompiledQuery {
+    return this.impl.compileDelete(ast);
   }
 
   compileProcedureCall(ast: ProcedureCallNode): CompiledProcedureCall {
-    return this.procedureCompiler.compileProcedureCall(ast);
+    return this.impl.compileProcedureCall(ast);
   }
 }

package/src/core/dialect/sqlite/index.ts

@@ -1,51 +1,81 @@
 import type { BitwiseExpressionNode, ColumnNode, JsonPathNode } from '../../ast/expression.js';
-import type { TableNode } from '../../ast/query.js';
-import { SqlDialectBase } from '../base/sql-dialect.js';
+import type {
+  DeleteQueryNode,
+  InsertQueryNode,
+  SelectQueryNode,
+  TableNode,
+  UpdateQueryNode
+} from '../../ast/query.js';
+import type { CompiledQuery, Dialect } from '../abstract.js';
+import { composeSqlDialect } from '../base/sql-dialect-composer.js';
 import { SqliteFunctionStrategy } from './functions.js';
 import { SqliteReturningStrategy } from './returning.js';
 import { SqliteUpsertStrategy } from './upsert.js';
 
-/** SQLite dialect assembled from reusable compiler components. */
-export class SqliteDialect extends SqlDialectBase {
-  protected readonly dialect = 'sqlite';
-
-  public constructor() {
-    super({
-      functionStrategy: new SqliteFunctionStrategy(),
-      returningStrategy: new SqliteReturningStrategy(),
-      upsertStrategy: new SqliteUpsertStrategy(),
-      supportsDmlReturning: true
-    });
-
-    this.registerExpressionCompiler('BitwiseExpression', (node: BitwiseExpressionNode, ctx) => {
-      const left = this.compileOperand(node.left, ctx);
-      const right = this.compileOperand(node.right, ctx);
-      if (node.operator === '^') {
-        return `(${left} | ${right}) & ~(${left} & ${right})`;
-      }
-      return `${left} ${node.operator} ${right}`;
-    });
-    this.registerOperandCompiler('BitwiseExpression', (node: BitwiseExpressionNode, ctx) => {
-      const left = this.compileOperand(node.left, ctx);
-      const right = this.compileOperand(node.right, ctx);
-      if (node.operator === '^') {
-        return `((${left} | ${right}) & ~(${left} & ${right}))`;
-      }
-      return `(${left} ${node.operator} ${right})`;
-    });
-  }
+const quoteIdentifier = (id: string): string => `"${id}"`;
+
+/** Creates the SQLite dialect entirely from composable compiler components. */
+export const createSqliteDialect = (): Dialect =>
+  composeSqlDialect({
+    name: 'sqlite',
+    quoteIdentifier,
+    functionStrategy: new SqliteFunctionStrategy(),
+    returningStrategy: new SqliteReturningStrategy(),
+    upsertStrategy: new SqliteUpsertStrategy(),
+    supportsDmlReturning: true,
+    compileSetTarget: (column: ColumnNode, _table: TableNode) => {
+      void _table;
+      return quoteIdentifier(column.name);
+    },
+    compileJsonPath(node: JsonPathNode): string {
+      const column = `${quoteIdentifier(node.column.table)}.${quoteIdentifier(node.column.name)}`;
+      return `json_extract(${column}, '${node.path}')`;
+    },
+    configureExpressions(api) {
+      api.registerExpressionCompiler('BitwiseExpression', (node: BitwiseExpressionNode, ctx) => {
+        const left = api.compileOperand(node.left, ctx);
+        const right = api.compileOperand(node.right, ctx);
+        if (node.operator === '^') {
+          return `(${left} | ${right}) & ~(${left} & ${right})`;
+        }
+        return `${left} ${node.operator} ${right}`;
+      });
+      api.registerOperandCompiler('BitwiseExpression', (node: BitwiseExpressionNode, ctx) => {
+        const left = api.compileOperand(node.left, ctx);
+        const right = api.compileOperand(node.right, ctx);
+        if (node.operator === '^') {
+          return `((${left} | ${right}) & ~(${left} & ${right}))`;
+        }
+        return `(${left} ${node.operator} ${right})`;
+      });
+    }
+  }).dialect;
+
+/** Ergonomic constructor facade over the composed SQLite dialect. */
+export class SqliteDialect implements Dialect {
+  private readonly impl: Dialect = createSqliteDialect();
 
   quoteIdentifier(id: string): string {
-    return `"${id}"`;
+    return this.impl.quoteIdentifier(id);
+  }
+
+  supportsDmlReturningClause(): boolean {
+    return this.impl.supportsDmlReturningClause();
+  }
+
+  compileSelect(ast: SelectQueryNode): CompiledQuery {
+    return this.impl.compileSelect(ast);
+  }
+
+  compileInsert(ast: InsertQueryNode): CompiledQuery {
+    return this.impl.compileInsert(ast);
   }
 
-  protected compileJsonPath(node: JsonPathNode): string {
-    const column = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
-    return `json_extract(${column}, '${node.path}')`;
+  compileUpdate(ast: UpdateQueryNode): CompiledQuery {
+    return this.impl.compileUpdate(ast);
   }
 
-  protected compileQualifiedColumn(column: ColumnNode, _table: TableNode): string {
-    void _table;
-    return this.quoteIdentifier(column.name);
+  compileDelete(ast: DeleteQueryNode): CompiledQuery {
+    return this.impl.compileDelete(ast);
   }
 }

package/src/core/driver/mssql-driver.ts

@@ -1,20 +1,18 @@
-import { DatabaseDriver } from './database-driver.js';
-import { SqlServerDialect } from '../dialect/mssql/index.js';
-import { MSSqlSchemaDialect } from '../ddl/dialects/mssql-schema-dialect.js';
+import type { DatabaseDriver } from './database-driver.js';
+import { createSqlServerDialect } from '../dialect/mssql/index.js';
+import { createMssqlSchemaDialect } from '../ddl/dialects/mssql-schema-dialect.js';
 import { mssqlIntrospector } from '../ddl/introspect/mssql.js';
 
-/**
- * Database driver for Microsoft SQL Server.
- */
+/** Database driver for Microsoft SQL Server. */
 export class MssqlDriver implements DatabaseDriver {
   readonly name = 'mssql';
 
   createDialect() {
-    return new SqlServerDialect();
+    return createSqlServerDialect();
   }
 
   createSchemaDialect() {
-    return new MSSqlSchemaDialect();
+    return createMssqlSchemaDialect();
   }
 
   createIntrospector() {

package/src/core/driver/mysql-driver.ts

@@ -1,20 +1,18 @@
-import { DatabaseDriver } from './database-driver.js';
-import { MySqlDialect } from '../dialect/mysql/index.js';
-import { MySqlSchemaDialect } from '../ddl/dialects/mysql-schema-dialect.js';
+import type { DatabaseDriver } from './database-driver.js';
+import { createMySqlDialect } from '../dialect/mysql/index.js';
+import { createMySqlSchemaDialect } from '../ddl/dialects/mysql-schema-dialect.js';
 import { mysqlIntrospector } from '../ddl/introspect/mysql.js';
 
-/**
- * Database driver for MySQL.
- */
+/** Database driver for MySQL. */
 export class MySqlDriver implements DatabaseDriver {
   readonly name = 'mysql';
 
   createDialect() {
-    return new MySqlDialect();
+    return createMySqlDialect();
   }
 
   createSchemaDialect() {
-    return new MySqlSchemaDialect();
+    return createMySqlSchemaDialect();
   }
 
   createIntrospector() {

package/src/core/driver/postgres-driver.ts

@@ -1,20 +1,18 @@
-import { DatabaseDriver } from './database-driver.js';
-import { PostgresDialect } from '../dialect/postgres/index.js';
-import { PostgresSchemaDialect } from '../ddl/dialects/postgres-schema-dialect.js';
+import type { DatabaseDriver } from './database-driver.js';
+import { createPostgresDialect } from '../dialect/postgres/index.js';
+import { createPostgresSchemaDialect } from '../ddl/dialects/postgres-schema-dialect.js';
 import { postgresIntrospector } from '../ddl/introspect/postgres.js';
 
-/**
- * Database driver for PostgreSQL.
- */
+/** Database driver for PostgreSQL. */
 export class PostgresDriver implements DatabaseDriver {
   readonly name = 'postgres';
 
   createDialect() {
-    return new PostgresDialect();
+    return createPostgresDialect();
   }
 
   createSchemaDialect() {
-    return new PostgresSchemaDialect();
+    return createPostgresSchemaDialect();
   }
 
   createIntrospector() {

package/src/core/driver/sqlite-driver.ts

@@ -1,20 +1,18 @@
-import { DatabaseDriver } from './database-driver.js';
-import { SqliteDialect } from '../dialect/sqlite/index.js';
-import { SQLiteSchemaDialect } from '../ddl/dialects/sqlite-schema-dialect.js';
+import type { DatabaseDriver } from './database-driver.js';
+import { createSqliteDialect } from '../dialect/sqlite/index.js';
+import { createSqliteSchemaDialect } from '../ddl/dialects/sqlite-schema-dialect.js';
 import { sqliteIntrospector } from '../ddl/introspect/sqlite.js';
 
-/**
- * Database driver for SQLite.
- */
+/** Database driver for SQLite. */
 export class SqliteDriver implements DatabaseDriver {
   readonly name = 'sqlite';
 
   createDialect() {
-    return new SqliteDialect();
+    return createSqliteDialect();
   }
 
   createSchemaDialect() {
-    return new SQLiteSchemaDialect();
+    return createSqliteSchemaDialect();
   }
 
   createIntrospector() {

package/src/index.ts

@@ -20,7 +20,7 @@ export * from './core/hydration/types.js';
 export * from './core/dialect/abstract.js';
 export * from './core/dialect/dialect-factory.js';
 export * from './core/dialect/capabilities/procedure-compiler.js';
-export * from './core/dialect/base/sql-dialect.js';
+export * from './core/dialect/base/sql-dialect-composer.js';
 export * from './core/dialect/base/sql-compiler-set.js';
 export * from './core/dialect/base/upsert-strategy.js';
 export * from './core/dialect/base/returning-strategy.js';
@@ -55,6 +55,18 @@ export * from './core/ddl/schema-generator.js';
 export * from './core/ddl/schema-types.js';
 export * from './core/ddl/schema-diff.js';
 export * from './core/ddl/schema-introspect.js';
+export * from './core/ddl/schema-dialect-composer.js';
+export * from './core/ddl/dialects/index.js';
+export { createLiteralFormatter } from './core/ddl/sql-writing.js';
+export type { LiteralFormatter, LiteralFormatOptions } from './core/ddl/sql-writing.js';
+export type {
+  SchemaDialect,
+  SchemaMutationCapabilities,
+  DropTableCapability,
+  DropColumnCapability,
+  DropIndexCapability,
+  AlterColumnCapability
+} from './core/ddl/schema-dialect.js';
 export * from './core/ddl/introspect/registry.js';
 export * from './core/functions/text.js';
 export * from './core/functions/numeric.js';

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

@@ -1,96 +0,0 @@
-import { SchemaDialect, DialectName } from '../schema-dialect.js';
-import { formatLiteral, quoteQualified, LiteralFormatter } from '../sql-writing.js';
-import { ColumnDef, ForeignKeyReference } from '../../../schema/column-types.js';
-import { IndexDef, TableDef } from '../../../schema/table.js';
-import { DatabaseTable, DatabaseColumn, ColumnDiff } from '../schema-types.js';
-
-/** A table-like object with name and optional schema. */
-type TableLike = { name: string; schema?: string };
-
-/**
- * Common behavior for schema dialects (DDL).
- * Concrete dialects only override the small surface area instead of reimplementing everything.
- */
-export abstract class BaseSchemaDialect implements SchemaDialect {
-  /** The name of the dialect. */
-  abstract readonly name: DialectName;
-  /** Quotes an identifier for use in SQL. */
-  abstract quoteIdentifier(id: string): string;
-  /** Renders the column type for SQL. */
-  abstract renderColumnType(column: ColumnDef): string;
-  /** Renders the auto-increment clause for SQL. */
-  abstract renderAutoIncrement(column: ColumnDef, table: TableDef): string | undefined;
-  /** Renders an index for SQL. */
-  abstract renderIndex(table: TableDef, index: IndexDef): string;
-  supportsPartialIndexes(): boolean {
-    return false;
-  }
-  formatTableName(table: TableLike): string {
-    if (table.schema) {
-      return `${this.quoteIdentifier(table.schema)}.${this.quoteIdentifier(table.name)}`;
-    }
-    return this.quoteIdentifier(table.name);
-  }
-  /** The literal formatter for the dialect. */
-  abstract get literalFormatter(): LiteralFormatter;
-
-  renderDefault(value: unknown, _column: ColumnDef): string {
-    void _column;
-    return formatLiteral(this.literalFormatter, value);
-  }
-  renderReference(ref: ForeignKeyReference, _table: TableDef): string {
-    void _table;
-    const parts = ['REFERENCES', quoteQualified(this, ref.table), `(${this.quoteIdentifier(ref.column)})`];
-    if (ref.onDelete) parts.push('ON DELETE', ref.onDelete);
-    if (ref.onUpdate) parts.push('ON UPDATE', ref.onUpdate);
-    const suffix = this.renderReferenceSuffix(ref, _table);
-    if (suffix) parts.push(suffix);
-    return parts.join(' ');
-  }
-
-  protected renderReferenceSuffix(ref: ForeignKeyReference, _table: TableDef): string | undefined {
-    void ref;
-    void _table;
-    return undefined;
-  }
-  renderTableOptions(_table: TableDef): string | undefined {
-    void _table;
-    return undefined;
-  }
-  dropTableSql(table: DatabaseTable): string[] {
-    return [`DROP TABLE IF EXISTS ${this.formatTableName(table)};`];
-  }
-  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 {
-    void _table;
-    void _column;
-    return undefined;
-  }
-  alterColumnSql?(_table: TableDef, _column: ColumnDef, _actualColumn: DatabaseColumn, _diff: ColumnDiff): string[] {
-    void _table;
-    void _column;
-    void _actualColumn;
-    void _diff;
-    return [];
-  }
-  warnAlterColumn?(_table: TableDef, _column: ColumnDef, _actual: DatabaseColumn, _diff: ColumnDiff): string | undefined {
-    void _table;
-    void _column;
-    void _actual;
-    void _diff;
-    return undefined;
-  }
-
-  preferInlinePkAutoincrement(_column: ColumnDef, _table: TableDef, _pk: string[]): boolean {
-    void _column;
-    void _table;
-    void _pk;
-    return false;
-  }
-}
-