metal-orm 1.1.25 → 1.1.26

package/src/core/dialect/dialect-factory.ts

@@ -1,20 +1,20 @@
 // Dialect factory for the SQL DSL.
-// Centralizes how we go from a symbolic name ("sqlite") to a concrete Dialect instance.
+// Centralizes how we go from a symbolic name ("sqlite") to a structural Dialect.
 
 import type { Dialect } from './abstract.js';
-import { PostgresDialect } from './postgres/index.js';
-import { MySqlDialect } from './mysql/index.js';
-import { SqliteDialect } from './sqlite/index.js';
-import { SqlServerDialect } from './mssql/index.js';
+import { createPostgresDialect } from './postgres/index.js';
+import { createMySqlDialect } from './mysql/index.js';
+import { createSqliteDialect } from './sqlite/index.js';
+import { createSqlServerDialect } from './mssql/index.js';
 
 export type DialectKey =
   | 'postgres'
   | 'mysql'
   | 'sqlite'
   | 'mssql'
-  | (string & {}); // allow user-defined keys without constraining too much
+  | (string & {});
 
-type DialectFactoryFn = () => Dialect;
+export type DialectFactoryFn = () => Dialect;
 
 export class DialectFactory {
   private static registry = new Map<DialectKey, DialectFactoryFn>();
@@ -24,67 +24,35 @@ export class DialectFactory {
     if (this.defaultsInitialized) return;
     this.defaultsInitialized = true;
 
-    // Register built-in dialects only if no override exists yet.
-    if (!this.registry.has('postgres')) {
-      this.registry.set('postgres', () => new PostgresDialect());
-    }
-    if (!this.registry.has('mysql')) {
-      this.registry.set('mysql', () => new MySqlDialect());
-    }
-    if (!this.registry.has('sqlite')) {
-      this.registry.set('sqlite', () => new SqliteDialect());
-    }
-    if (!this.registry.has('mssql')) {
-      this.registry.set('mssql', () => new SqlServerDialect());
-    }
+    if (!this.registry.has('postgres')) this.registry.set('postgres', createPostgresDialect);
+    if (!this.registry.has('mysql')) this.registry.set('mysql', createMySqlDialect);
+    if (!this.registry.has('sqlite')) this.registry.set('sqlite', createSqliteDialect);
+    if (!this.registry.has('mssql')) this.registry.set('mssql', createSqlServerDialect);
   }
 
-  /**
-   * Register (or override) a dialect factory for a key.
-   *
-   * Implementations are structural: extending DialectBase/SqlDialectBase is
-   * optional. A composed object satisfying Dialect is a valid registration.
-   */
+  /** Register or replace a structural dialect factory. */
   public static register(key: DialectKey, factory: DialectFactoryFn): void {
     this.registry.set(key, factory);
   }
 
-  /**
-   * Resolve a key into a Dialect instance.
-   * Throws if the key is not registered.
-   */
+  /** Resolve a key into a new Dialect instance. */
   public static create(key: DialectKey): Dialect {
     this.ensureDefaults();
     const factory = this.registry.get(key);
     if (!factory) {
       throw new Error(
-        `Dialect "${String(
-          key
-        )}" is not registered. Use DialectFactory.register(...) to register it.`
+        `Dialect "${String(key)}" is not registered. Use DialectFactory.register(...) to register it.`
       );
     }
     return factory();
   }
 
-  /**
-   * Clear all registrations (mainly for tests).
-   * Built-ins will be re-registered lazily on the next create().
-   */
+  /** Clear registrations; built-ins are restored lazily on the next create(). */
   public static clear(): void {
     this.registry.clear();
     this.defaultsInitialized = false;
   }
 }
 
-/**
- * Helper to normalize either a Dialect instance OR a key into a Dialect instance.
- * This is what query builders will use.
- */
-export const resolveDialectInput = (
-  dialect: Dialect | DialectKey
-): Dialect => {
-  if (typeof dialect === 'string') {
-    return DialectFactory.create(dialect);
-  }
-  return dialect;
-};
+export const resolveDialectInput = (dialect: Dialect | DialectKey): Dialect =>
+  typeof dialect === 'string' ? DialectFactory.create(dialect) : dialect;

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

@@ -1,46 +1,75 @@
 import type { ProcedureCallNode } from '../../ast/procedure.js';
 import type { JsonPathNode } from '../../ast/expression.js';
+import type {
+  DeleteQueryNode,
+  InsertQueryNode,
+  SelectQueryNode,
+  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 { MssqlFunctionStrategy } from './functions.js';
 import { createMssqlCompilerSet } from './compiler-factory.js';
 import { MssqlOutputStrategy } from './output.js';
 import { MssqlProcedureCompiler } from './procedure-compiler.js';
 
-/** Microsoft SQL Server dialect assembled from backend compiler components. */
-export class SqlServerDialect extends SqlDialectBase implements ProcedureCompiler {
-  protected readonly dialect = 'mssql';
-  private readonly procedureCompiler: MssqlProcedureCompiler;
-
-  public constructor() {
-    super({
-      functionStrategy: new MssqlFunctionStrategy(),
-      returningStrategy: new MssqlOutputStrategy(),
-      compilerFactory: createMssqlCompilerSet,
-      supportsDmlReturning: true
-    });
-
-    this.procedureCompiler = new MssqlProcedureCompiler({
-      quoteIdentifier: id => this.quoteIdentifier(id),
-      createCompilerContext: () => this.createCompilerContext(),
-      compileOperand: (node, ctx) => this.compileOperand(node, ctx)
-    });
-  }
+const quoteIdentifier = (id: string): string => `[${id}]`;
+
+export type SqlServerDialectImplementation = Dialect & ProcedureCompiler;
+
+/** Creates the SQL Server dialect entirely from composable compiler components. */
+export const createSqlServerDialect = (): SqlServerDialectImplementation => {
+  const composition = composeSqlDialect({
+    name: 'mssql',
+    quoteIdentifier,
+    formatPlaceholder: index => `@p${index}`,
+    functionStrategy: new MssqlFunctionStrategy(),
+    returningStrategy: new MssqlOutputStrategy(),
+    compilerFactory: createMssqlCompilerSet,
+    supportsDmlReturning: true,
+    compileJsonPath(node: JsonPathNode): string {
+      const column = `${quoteIdentifier(node.column.table)}.${quoteIdentifier(node.column.name)}`;
+      return `JSON_VALUE(${column}, '${node.path}')`;
+    }
+  });
+
+  const procedures = new MssqlProcedureCompiler(composition.runtime);
+  return {
+    ...composition.dialect,
+    compileProcedureCall: ast => procedures.compileProcedureCall(ast)
+  };
+};
+
+/** Ergonomic constructor facade over the composed SQL Server dialect. */
+export class SqlServerDialect implements Dialect, ProcedureCompiler {
+  private readonly impl: SqlServerDialectImplementation = createSqlServerDialect();
 
   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_VALUE(${column}, '${node.path}')`;
+  compileUpdate(ast: UpdateQueryNode): CompiledQuery {
+    return this.impl.compileUpdate(ast);
   }
 
-  protected formatPlaceholder(index: number): string {
-    return `@p${index}`;
+  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/mysql/index.ts

@@ -1,51 +1,84 @@
 import type { ProcedureCallNode } from '../../ast/procedure.js';
-import type { JsonPathNode, IsDistinctExpressionNode } from '../../ast/expression.js';
+import type { IsDistinctExpressionNode, JsonPathNode } from '../../ast/expression.js';
+import type {
+  DeleteQueryNode,
+  InsertQueryNode,
+  SelectQueryNode,
+  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 { MysqlFunctionStrategy } from './functions.js';
 import { MySqlProcedureCompiler } from './procedure-compiler.js';
 import { MySqlUpsertStrategy } from './upsert.js';
 
-/** MySQL dialect assembled from reusable compiler components. */
-export class MySqlDialect extends SqlDialectBase implements ProcedureCompiler {
-  protected readonly dialect = 'mysql';
-  private readonly procedureCompiler: MySqlProcedureCompiler;
-
-  public constructor() {
-    super({
-      functionStrategy: new MysqlFunctionStrategy(),
-      upsertStrategy: new MySqlUpsertStrategy()
-    });
-
-    this.procedureCompiler = new MySqlProcedureCompiler({
-      quoteIdentifier: id => this.quoteIdentifier(id),
-      createCompilerContext: () => this.createCompilerContext(),
-      compileOperand: (node, ctx) => this.compileOperand(node, ctx)
-    });
-
-    this.registerExpressionCompiler(
-      'IsDistinctExpression',
-      (node: IsDistinctExpressionNode, ctx): string => {
-        const left = this.compileOperand(node.left, ctx);
-        const right = this.compileOperand(node.right, ctx);
-        const spaceship = `${left} <=> ${right}`;
-        return node.operator === 'IS NOT DISTINCT FROM'
-          ? spaceship
-          : `NOT (${spaceship})`;
-      }
-    );
-  }
+const quoteIdentifier = (id: string): string => `\`${id}\``;
+
+export type MySqlDialectImplementation = Dialect & ProcedureCompiler;
+
+/** Creates the MySQL dialect entirely from composable compiler components. */
+export const createMySqlDialect = (): MySqlDialectImplementation => {
+  const composition = composeSqlDialect({
+    name: 'mysql',
+    quoteIdentifier,
+    functionStrategy: new MysqlFunctionStrategy(),
+    upsertStrategy: new MySqlUpsertStrategy(),
+    compileJsonPath(node: JsonPathNode): string {
+      const column = `${quoteIdentifier(node.column.table)}.${quoteIdentifier(node.column.name)}`;
+      return `${column}->'${node.path}'`;
+    },
+    configureExpressions(api) {
+      api.registerExpressionCompiler(
+        'IsDistinctExpression',
+        (node: IsDistinctExpressionNode, ctx): string => {
+          const left = api.compileOperand(node.left, ctx);
+          const right = api.compileOperand(node.right, ctx);
+          const spaceship = `${left} <=> ${right}`;
+          return node.operator === 'IS NOT DISTINCT FROM'
+            ? spaceship
+            : `NOT (${spaceship})`;
+        }
+      );
+    }
+  });
+
+  const procedures = new MySqlProcedureCompiler(composition.runtime);
+  return {
+    ...composition.dialect,
+    compileProcedureCall: ast => procedures.compileProcedureCall(ast)
+  };
+};
+
+/** Ergonomic constructor facade over the composed MySQL dialect. */
+export class MySqlDialect implements Dialect, ProcedureCompiler {
+  private readonly impl: MySqlDialectImplementation = createMySqlDialect();
 
   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);
+  }
+
+  compileUpdate(ast: UpdateQueryNode): CompiledQuery {
+    return this.impl.compileUpdate(ast);
   }
 
-  protected compileJsonPath(node: JsonPathNode): string {
-    const column = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
-    return `${column}->'${node.path}'`;
+  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/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/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';