metal-orm 1.1.25 → 1.1.27

package/src/core/dialect/base/sql-dialect-composer.ts

@@ -0,0 +1,294 @@
+import type {
+  DeleteQueryNode,
+  InsertQueryNode,
+  OrderByNode,
+  OrderingTerm,
+  SelectQueryNode,
+  SetOperationKind,
+  TableNode,
+  UpdateQueryNode
+} from '../../ast/query.js';
+import type {
+  ColumnNode,
+  ExpressionNode,
+  FunctionNode,
+  JsonPathNode,
+  OperandNode
+} from '../../ast/expression.js';
+import type { FunctionStrategy } from '../../functions/types.js';
+import { StandardFunctionStrategy } from '../../functions/standard-strategy.js';
+import type { TableFunctionStrategy } from '../../functions/table-types.js';
+import { StandardTableFunctionStrategy } from '../../functions/standard-table-strategy.js';
+import type { CompilerContext, Dialect } from '../abstract.js';
+import type { ProcedureCompilerServices } from '../capabilities/procedure-compiler.js';
+import { ExpressionCompilerRegistry } from './expression-compiler-registry.js';
+import { SelectAstNormalizer } from './select-ast-normalizer.js';
+import { StandardLimitOffsetPagination } from './pagination-strategy.js';
+import type { PaginationStrategy } from './pagination-strategy.js';
+import { NoReturningStrategy } from './returning-strategy.js';
+import type { ReturningStrategy } from './returning-strategy.js';
+import { NoUpsertStrategy } from './upsert-strategy.js';
+import type { UpsertStrategy } from './upsert-strategy.js';
+import { StandardSqlSourceCompiler } from './standard-sql-source-compiler.js';
+import { StandardSelectCompiler } from './standard-select-compiler.js';
+import { StandardInsertCompiler } from './standard-insert-compiler.js';
+import { StandardUpdateCompiler } from './standard-update-compiler.js';
+import { StandardDeleteCompiler } from './standard-delete-compiler.js';
+import type { StandardSqlCompilerServices } from './standard-sql-services.js';
+import type { SqlCompilerFactory, SqlCompilerSet } from './sql-compiler-set.js';
+
+export interface SqlDialectExpressionApi {
+  registerExpressionCompiler<T extends ExpressionNode>(
+    type: T['type'],
+    compiler: (node: T, ctx: CompilerContext) => string
+  ): void;
+  registerOperandCompiler<T extends OperandNode>(
+    type: T['type'],
+    compiler: (node: T, ctx: CompilerContext) => string
+  ): void;
+  compileExpression(node: ExpressionNode, ctx: CompilerContext): string;
+  compileOperand(node: OperandNode, ctx: CompilerContext): string;
+  compileOrderingTerm(term: OrderingTerm, ctx: CompilerContext): string;
+}
+
+export interface SqlDialectRuntimeServices extends ProcedureCompilerServices {
+  compileExpression(node: ExpressionNode, ctx: CompilerContext): string;
+  compileOrderingTerm(term: OrderingTerm, ctx: CompilerContext): string;
+  normalizeSelectAst(ast: SelectQueryNode): SelectQueryNode;
+  compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string;
+}
+
+export interface SqlDialectComposition {
+  dialect: Dialect;
+  runtime: SqlDialectRuntimeServices;
+}
+
+export interface SqlDialectConfig {
+  /** Human-readable/backend identifier used by diagnostics and strategies. */
+  name: string;
+  quoteIdentifier(id: string): string;
+  formatPlaceholder?(index: number): string;
+  compileJsonPath?(node: JsonPathNode): string;
+  functionStrategy?: FunctionStrategy;
+  tableFunctionStrategy?: TableFunctionStrategy;
+  paginationStrategy?: PaginationStrategy;
+  returningStrategy?: ReturningStrategy;
+  upsertStrategy?: UpsertStrategy;
+  compilerFactory?: SqlCompilerFactory;
+  supportsDmlReturning?: boolean;
+  supportsSetOperation?(kind: SetOperationKind): boolean;
+  compileSetTarget?(column: ColumnNode, table: TableNode): string;
+  renderOrderByNulls?(order: OrderByNode): string | undefined;
+  renderOrderByCollation?(order: OrderByNode): string | undefined;
+  configureExpressions?(api: SqlDialectExpressionApi): void;
+  describe?: string;
+}
+
+const terminate = (sql: string): string => {
+  const trimmed = sql.trim();
+  return trimmed.endsWith(';') ? trimmed : `${trimmed};`;
+};
+
+/**
+ * Assembles a full SQL dialect from independent compiler components.
+ * No inheritance or concrete dialect class participates in the compilation path.
+ */
+export const composeSqlDialect = (config: SqlDialectConfig): SqlDialectComposition => {
+  const functionStrategy = config.functionStrategy ?? new StandardFunctionStrategy();
+  const tableFunctionStrategy = config.tableFunctionStrategy ?? new StandardTableFunctionStrategy();
+  const paginationStrategy = config.paginationStrategy ?? new StandardLimitOffsetPagination();
+  const returningStrategy = config.returningStrategy ?? new NoReturningStrategy();
+  const upsertStrategy = config.upsertStrategy ?? new NoUpsertStrategy();
+  const selectAstNormalizer = new SelectAstNormalizer(
+    kind => config.supportsSetOperation?.(kind) ?? true
+  );
+
+  let compilerSet!: SqlCompilerSet;
+  let expressionRegistry!: ExpressionCompilerRegistry;
+
+  const createCompilerContext = (): CompilerContext => {
+    const params: unknown[] = [];
+    let counter = 0;
+    return {
+      params,
+      addParameter(value: unknown): string {
+        counter += 1;
+        params.push(value);
+        return config.formatPlaceholder?.(counter) ?? '?';
+      }
+    };
+  };
+
+  const compileSelectAst = (ast: SelectQueryNode, ctx: CompilerContext): string =>
+    compilerSet.select.compile(ast, ctx);
+
+  const normalizeSelectAst = (ast: SelectQueryNode): SelectQueryNode =>
+    selectAstNormalizer.normalize(ast);
+
+  const compileSelectForExists = (ast: SelectQueryNode, ctx: CompilerContext): string => {
+    const normalized = normalizeSelectAst(ast);
+    const full = compileSelectAst(normalized, ctx).trim().replace(/;$/, '');
+    if (normalized.setOps && normalized.setOps.length > 0) {
+      return `SELECT 1 FROM (${full}) AS _exists`;
+    }
+    const fromIndex = full.toUpperCase().indexOf(' FROM ');
+    return fromIndex === -1 ? full : `SELECT 1${full.slice(fromIndex)}`;
+  };
+
+  const compileJsonPath = (node: JsonPathNode): string => {
+    if (!config.compileJsonPath) {
+      throw new Error(`JSON Path not supported by dialect "${config.name}".`);
+    }
+    return config.compileJsonPath(node);
+  };
+
+  const compileFunctionOperand = (node: FunctionNode, ctx: CompilerContext): string => {
+    const compiledArgs = node.args.map(arg => expressionRegistry.compileOperand(arg, ctx));
+    const renderer = functionStrategy.getRenderer(node.name);
+    if (renderer) {
+      return renderer({
+        node,
+        compiledArgs,
+        compileOperand: operand => expressionRegistry.compileOperand(operand, ctx)
+      });
+    }
+    return `${node.name}(${compiledArgs.join(', ')})`;
+  };
+
+  expressionRegistry = new ExpressionCompilerRegistry({
+    quoteIdentifier: config.quoteIdentifier,
+    compileSelectAst,
+    compileSelectForExists,
+    compileJsonPath,
+    compileFunctionOperand,
+    describe: () => config.describe ?? config.name
+  });
+
+  const compileSetTarget = (column: ColumnNode, table: TableNode): string => {
+    if (config.compileSetTarget) return config.compileSetTarget(column, table);
+    const columnTable = column.table ?? table.alias ?? table.name;
+    const tableQualifier = table.alias && column.table === table.name
+      ? table.alias
+      : columnTable;
+    return tableQualifier
+      ? `${config.quoteIdentifier(tableQualifier)}.${config.quoteIdentifier(column.name)}`
+      : config.quoteIdentifier(column.name);
+  };
+
+  let standardUpdate!: StandardUpdateCompiler;
+  const services: StandardSqlCompilerServices = {
+    getDialectName: () => config.name,
+    getPaginationStrategy: () => paginationStrategy,
+    getTableFunctionStrategy: () => tableFunctionStrategy,
+    quoteIdentifier: config.quoteIdentifier,
+    compileOperand: (node, ctx) => expressionRegistry.compileOperand(node, ctx),
+    compileExpression: (node, ctx) => expressionRegistry.compileExpression(node, ctx),
+    compileOrderingTerm: (term, ctx) => expressionRegistry.compileOrderingTerm(term, ctx),
+    normalizeSelectAst: normalizeSelectAst,
+    compileSelectAst,
+    compileReturning: (returning, ctx) =>
+      returningStrategy.compileReturning(returning, ctx, config.quoteIdentifier),
+    compileUpsertClause: (ast, ctx) =>
+      upsertStrategy.compile(ast, ctx, {
+        getDialectName: () => config.name,
+        quoteIdentifier: config.quoteIdentifier,
+        compileOperand: (node, compilerContext) =>
+          expressionRegistry.compileOperand(node, compilerContext),
+        compileExpression: (node, compilerContext) =>
+          expressionRegistry.compileExpression(node, compilerContext),
+        compileUpdateAssignments: (assignments, table, compilerContext) =>
+          standardUpdate.compileAssignments(assignments, table, compilerContext)
+      }),
+    compileSetTarget,
+    renderOrderByNulls: order =>
+      config.renderOrderByNulls?.(order) ?? (order.nulls ? ` NULLS ${order.nulls}` : ''),
+    renderOrderByCollation: order =>
+      config.renderOrderByCollation?.(order) ?? (order.collation ? ` COLLATE ${order.collation}` : '')
+  };
+
+  const sources = new StandardSqlSourceCompiler(services);
+  const standardSelect = new StandardSelectCompiler(services, sources);
+  const standardInsert = new StandardInsertCompiler(services, sources);
+  standardUpdate = new StandardUpdateCompiler(services, sources);
+  const standardDelete = new StandardDeleteCompiler(services, sources);
+  const overrides = config.compilerFactory?.({ services, sources }) ?? {};
+  compilerSet = {
+    select: overrides.select ?? standardSelect,
+    insert: overrides.insert ?? standardInsert,
+    update: overrides.update ?? standardUpdate,
+    delete: overrides.delete ?? standardDelete
+  };
+
+  const expressionApi: SqlDialectExpressionApi = {
+    registerExpressionCompiler<T extends ExpressionNode>(
+      type: T['type'],
+      compiler: (node: T, ctx: CompilerContext) => string
+    ): void {
+      expressionRegistry.registerExpressionCompiler(type, compiler);
+    },
+    registerOperandCompiler<T extends OperandNode>(
+      type: T['type'],
+      compiler: (node: T, ctx: CompilerContext) => string
+    ): void {
+      expressionRegistry.registerOperandCompiler(type, compiler);
+    },
+    compileExpression(node: ExpressionNode, ctx: CompilerContext): string {
+      return expressionRegistry.compileExpression(node, ctx);
+    },
+    compileOperand(node: OperandNode, ctx: CompilerContext): string {
+      return expressionRegistry.compileOperand(node, ctx);
+    },
+    compileOrderingTerm(term: OrderingTerm, ctx: CompilerContext): string {
+      return expressionRegistry.compileOrderingTerm(term, ctx);
+    }
+  };
+  config.configureExpressions?.(expressionApi);
+
+  const dialect: Dialect = {
+    quoteIdentifier: config.quoteIdentifier,
+    supportsDmlReturningClause: () => config.supportsDmlReturning ?? false,
+    compileSelect(ast: SelectQueryNode) {
+      const ctx = createCompilerContext();
+      return {
+        sql: terminate(compileSelectAst(normalizeSelectAst(ast), ctx)),
+        params: [...ctx.params]
+      };
+    },
+    compileInsert(ast: InsertQueryNode) {
+      const ctx = createCompilerContext();
+      return {
+        sql: terminate(compilerSet.insert.compile(ast, ctx)),
+        params: [...ctx.params]
+      };
+    },
+    compileUpdate(ast: UpdateQueryNode) {
+      const ctx = createCompilerContext();
+      return {
+        sql: terminate(compilerSet.update.compile(ast, ctx)),
+        params: [...ctx.params]
+      };
+    },
+    compileDelete(ast: DeleteQueryNode) {
+      const ctx = createCompilerContext();
+      return {
+        sql: terminate(compilerSet.delete.compile(ast, ctx)),
+        params: [...ctx.params]
+      };
+    }
+  };
+
+  const runtime: SqlDialectRuntimeServices = {
+    quoteIdentifier: config.quoteIdentifier,
+    createCompilerContext,
+    compileOperand: (node, ctx) => expressionRegistry.compileOperand(node, ctx),
+    compileExpression: (node, ctx) => expressionRegistry.compileExpression(node, ctx),
+    compileOrderingTerm: (term, ctx) => expressionRegistry.compileOrderingTerm(term, ctx),
+    normalizeSelectAst: normalizeSelectAst,
+    compileSelectAst
+  };
+
+  return { dialect, runtime };
+};
+
+export const createSqlDialect = (config: SqlDialectConfig): Dialect =>
+  composeSqlDialect(config).dialect;

package/src/core/dialect/base/standard-sql-services.ts

@@ -11,19 +11,15 @@ import type {
   ExpressionNode,
   OperandNode
 } from '../../ast/expression.js';
-import type { DialectName } from '../../sql/sql.js';
 import type { PaginationStrategy } from './pagination-strategy.js';
 import type { TableFunctionStrategy } from '../../functions/table-types.js';
 
 /**
  * Narrow callback surface consumed by the standard SQL compilers.
- *
- * The compilers deliberately know nothing about SqlDialectBase or any concrete
- * backend class. A dialect can assemble these services through inheritance,
- * composition, or a plain object.
+ * It deliberately depends on no dialect superclass or built-in dialect union.
  */
 export interface StandardSqlCompilerServices {
-  getDialectName(): DialectName;
+  getDialectName(): string;
   getPaginationStrategy(): PaginationStrategy;
   getTableFunctionStrategy(): TableFunctionStrategy;
 

package/src/core/dialect/base/upsert-strategy.ts

@@ -5,11 +5,10 @@ import type {
   UpdateAssignmentNode
 } from '../../ast/query.js';
 import type { ExpressionNode, OperandNode } from '../../ast/expression.js';
-import type { DialectName } from '../../sql/sql.js';
 
 /** Narrow services needed by backend-specific UPSERT implementations. */
 export interface UpsertCompilationServices {
-  getDialectName(): DialectName;
+  getDialectName(): string;
   quoteIdentifier(id: string): string;
   compileOperand(node: OperandNode, ctx: CompilerContext): string;
   compileExpression(node: ExpressionNode, ctx: CompilerContext): string;

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);
   }
 }