metal-orm 1.1.22 → 1.1.24

package/dist/index.js

@@ -1314,268 +1314,40 @@ var StandardTableFunctionStrategy = class {
   }
 };
 
-// src/core/dialect/abstract.ts
-var Dialect = class _Dialect {
-  /**
-   * Compiles a SELECT query AST to SQL
-   * @param ast - Query AST to compile
-   * @returns Compiled query with SQL and parameters
-   */
-  compileSelect(ast) {
-    const ctx = this.createCompilerContext();
-    const normalized = this.normalizeSelectAst(ast);
-    const rawSql = this.compileSelectAst(normalized, ctx).trim();
-    const sql = rawSql.endsWith(";") ? rawSql : `${rawSql};`;
-    return {
-      sql,
-      params: [...ctx.params]
-    };
-  }
-  compileInsert(ast) {
-    const ctx = this.createCompilerContext();
-    const rawSql = this.compileInsertAst(ast, ctx).trim();
-    const sql = rawSql.endsWith(";") ? rawSql : `${rawSql};`;
-    return {
-      sql,
-      params: [...ctx.params]
-    };
-  }
-  compileUpdate(ast) {
-    const ctx = this.createCompilerContext();
-    const rawSql = this.compileUpdateAst(ast, ctx).trim();
-    const sql = rawSql.endsWith(";") ? rawSql : `${rawSql};`;
-    return {
-      sql,
-      params: [...ctx.params]
-    };
-  }
-  compileDelete(ast) {
-    const ctx = this.createCompilerContext();
-    const rawSql = this.compileDeleteAst(ast, ctx).trim();
-    const sql = rawSql.endsWith(";") ? rawSql : `${rawSql};`;
-    return {
-      sql,
-      params: [...ctx.params]
-    };
-  }
-  supportsDmlReturningClause() {
-    return false;
-  }
-  /**
-   * Compiles a WHERE clause
-   * @param where - WHERE expression
-   * @param ctx - Compiler context
-   * @returns SQL WHERE clause or empty string
-   */
-  compileWhere(where, ctx) {
-    if (!where) return "";
-    return ` WHERE ${this.compileExpression(where, ctx)}`;
-  }
-  compileReturning(returning, _ctx) {
-    void _ctx;
-    if (!returning || returning.length === 0) return "";
-    throw new Error("RETURNING is not supported by this dialect.");
-  }
-  /**
-   * Generates subquery for EXISTS expressions
-   * Rule: Always forces SELECT 1, ignoring column list
-   * Maintains FROM, JOINs, WHERE, GROUP BY, ORDER BY, LIMIT/OFFSET
-   * Does not add ';' at the end
-   * @param ast - Query AST
-   * @param ctx - Compiler context
-   * @returns SQL for EXISTS subquery
-   */
-  compileSelectForExists(ast, ctx) {
-    const normalized = this.normalizeSelectAst(ast);
-    const full = this.compileSelectAst(normalized, ctx).trim().replace(/;$/, "");
-    if (normalized.setOps && normalized.setOps.length > 0) {
-      return `SELECT 1 FROM (${full}) AS _exists`;
-    }
-    const upper2 = full.toUpperCase();
-    const fromIndex = upper2.indexOf(" FROM ");
-    if (fromIndex === -1) {
-      return full;
-    }
-    const tail = full.slice(fromIndex);
-    return `SELECT 1${tail}`;
-  }
-  /**
-   * Creates a new compiler context
-   * @returns Compiler context with parameter management
-   */
-  createCompilerContext() {
-    const params = [];
-    let counter = 0;
-    return {
-      params,
-      addParameter: (value) => {
-        counter += 1;
-        params.push(value);
-        return this.formatPlaceholder(counter);
-      }
-    };
-  }
-  /**
-   * Formats a parameter placeholder
-   * @param index - Parameter index
-   * @returns Formatted placeholder string
-   */
-  formatPlaceholder(_index) {
-    void _index;
-    return "?";
-  }
-  /**
-   * Whether the current dialect supports a given set operation.
-   * Override in concrete dialects to restrict support.
-   */
-  supportsSetOperation(_kind) {
-    void _kind;
-    return true;
-  }
-  /**
-   * Validates set-operation semantics:
-   * - Ensures the dialect supports requested operators.
-   * - Enforces that only the outermost compound query may have ORDER/LIMIT/OFFSET.
-   * @param ast - Query to validate
-   * @param isOutermost - Whether this node is the outermost compound query
-   */
-  validateSetOperations(ast, isOutermost = true) {
-    const hasSetOps = !!(ast.setOps && ast.setOps.length);
-    if (!isOutermost && (ast.orderBy || ast.limit !== void 0 || ast.offset !== void 0)) {
-      throw new Error("ORDER BY / LIMIT / OFFSET are only allowed on the outermost compound query.");
-    }
-    if (hasSetOps) {
-      for (const op of ast.setOps) {
-        if (!this.supportsSetOperation(op.operator)) {
-          throw new Error(`Set operation ${op.operator} is not supported by this dialect.`);
-        }
-        this.validateSetOperations(op.query, false);
-      }
-    }
-  }
-  /**
-   * Hoists CTEs from set-operation operands to the outermost query so WITH appears once.
-   * @param ast - Query AST
-   * @returns Normalized AST without inner CTEs and a list of hoisted CTEs
-   */
-  hoistCtes(ast) {
-    let hoisted = [];
-    const normalizedSetOps = ast.setOps?.map((op) => {
-      const { normalized: child, hoistedCtes: childHoisted } = this.hoistCtes(op.query);
-      const childCtes = child.ctes ?? [];
-      if (childCtes.length) {
-        hoisted = hoisted.concat(childCtes);
-      }
-      hoisted = hoisted.concat(childHoisted);
-      const queryWithoutCtes = childCtes.length ? { ...child, ctes: void 0 } : child;
-      return { ...op, query: queryWithoutCtes };
-    });
-    const normalized = normalizedSetOps ? { ...ast, setOps: normalizedSetOps } : ast;
-    return { normalized, hoistedCtes: hoisted };
-  }
-  /**
-   * Normalizes a SELECT AST before compilation (validation + CTE hoisting).
-   * @param ast - Query AST
-   * @returns Normalized query AST
-   */
-  normalizeSelectAst(ast) {
-    this.validateSetOperations(ast, true);
-    const { normalized, hoistedCtes } = this.hoistCtes(ast);
-    const combinedCtes = [...normalized.ctes ?? [], ...hoistedCtes];
-    return combinedCtes.length ? { ...normalized, ctes: combinedCtes } : normalized;
-  }
-  expressionCompilers;
-  operandCompilers;
-  functionStrategy;
-  tableFunctionStrategy;
-  constructor(functionStrategy, tableFunctionStrategy) {
-    this.expressionCompilers = /* @__PURE__ */ new Map();
-    this.operandCompilers = /* @__PURE__ */ new Map();
-    this.functionStrategy = functionStrategy || new StandardFunctionStrategy();
-    this.tableFunctionStrategy = tableFunctionStrategy || new StandardTableFunctionStrategy();
+// src/core/dialect/base/expression-compiler-registry.ts
+var ExpressionCompilerRegistry = class {
+  constructor(host) {
+    this.host = host;
     this.registerDefaultOperandCompilers();
     this.registerDefaultExpressionCompilers();
   }
-  /**
-   * Creates a new Dialect instance (for testing purposes)
-   * @param functionStrategy - Optional function strategy
-   * @returns New Dialect instance
-   */
-  static create(functionStrategy, tableFunctionStrategy) {
-    class TestDialect extends _Dialect {
-      dialect = "sqlite";
-      quoteIdentifier(id) {
-        return `"${id}"`;
-      }
-      compileSelectAst() {
-        throw new Error("Not implemented");
-      }
-      compileInsertAst() {
-        throw new Error("Not implemented");
-      }
-      compileUpdateAst() {
-        throw new Error("Not implemented");
-      }
-      compileDeleteAst() {
-        throw new Error("Not implemented");
-      }
-      compileProcedureCall() {
-        throw new Error("Not implemented");
-      }
-    }
-    return new TestDialect(functionStrategy, tableFunctionStrategy);
-  }
-  /**
-   * Registers an expression compiler for a specific node type
-   * @param type - Expression node type
-   * @param compiler - Compiler function
-   */
+  expressionCompilers = /* @__PURE__ */ new Map();
+  operandCompilers = /* @__PURE__ */ new Map();
   registerExpressionCompiler(type, compiler) {
     this.expressionCompilers.set(type, compiler);
   }
-  /**
-   * Registers an operand compiler for a specific node type
-   * @param type - Operand node type
-   * @param compiler - Compiler function
-   */
   registerOperandCompiler(type, compiler) {
     this.operandCompilers.set(type, compiler);
   }
-  /**
-   * Compiles an expression node
-   * @param node - Expression node to compile
-   * @param ctx - Compiler context
-   * @returns Compiled SQL expression
-   */
   compileExpression(node, ctx) {
     const compiler = this.expressionCompilers.get(node.type);
     if (!compiler) {
-      throw new Error(`Unsupported expression node type "${node.type}" for ${this.constructor.name}`);
+      throw new Error(`Unsupported expression node type "${node.type}" for ${this.host.describe()}`);
     }
     return compiler(node, ctx);
   }
-  /**
-   * Compiles an operand node
-   * @param node - Operand node to compile
-   * @param ctx - Compiler context
-   * @returns Compiled SQL operand
-   */
   compileOperand(node, ctx) {
     const compiler = this.operandCompilers.get(node.type);
     if (!compiler) {
-      throw new Error(`Unsupported operand node type "${node.type}" for ${this.constructor.name}`);
+      throw new Error(`Unsupported operand node type "${node.type}" for ${this.host.describe()}`);
     }
     return compiler(node, ctx);
   }
-  /**
-   * Compiles an ordering term (operand, expression, or alias reference).
-   */
   compileOrderingTerm(term, ctx) {
     if (isOperandNode(term)) {
       return this.compileOperand(term, ctx);
     }
-    const expr = this.compileExpression(term, ctx);
-    return `(${expr})`;
+    return `(${this.compileExpression(term, ctx)})`;
   }
   registerDefaultExpressionCompilers() {
     this.registerExpressionCompiler("BinaryExpression", (binary, ctx) => {
@@ -1610,11 +1382,11 @@ var Dialect = class _Dialect {
         const values = inExpr.right.map((v) => this.compileOperand(v, ctx)).join(", ");
         return `${left2} ${inExpr.operator} (${values})`;
       }
-      const subquerySql = this.compileSelectAst(inExpr.right.query, ctx).trim().replace(/;$/, "");
+      const subquerySql = this.host.compileSelectAst(inExpr.right.query, ctx).trim().replace(/;$/, "");
       return `${left2} ${inExpr.operator} (${subquerySql})`;
     });
     this.registerExpressionCompiler("ExistsExpression", (existsExpr, ctx) => {
-      const subquerySql = this.compileSelectForExists(existsExpr.subquery, ctx);
+      const subquerySql = this.host.compileSelectForExists(existsExpr.subquery, ctx);
       return `${existsExpr.operator} (${subquerySql})`;
     });
     this.registerExpressionCompiler("BetweenExpression", (betweenExpr, ctx) => {
@@ -1640,25 +1412,28 @@ var Dialect = class _Dialect {
     });
   }
   registerDefaultOperandCompilers() {
-    this.registerOperandCompiler("Literal", (literal, ctx) => ctx.addParameter(literal.value));
-    this.registerOperandCompiler("AliasRef", (alias, _ctx) => {
-      void _ctx;
-      return this.quoteIdentifier(alias.name);
-    });
-    this.registerOperandCompiler("Column", (column, _ctx) => {
-      void _ctx;
-      return `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`;
-    });
+    this.registerOperandCompiler(
+      "Literal",
+      (literal, ctx) => ctx.addParameter(literal.value)
+    );
+    this.registerOperandCompiler(
+      "AliasRef",
+      (alias) => this.host.quoteIdentifier(alias.name)
+    );
+    this.registerOperandCompiler(
+      "Column",
+      (column) => `${this.host.quoteIdentifier(column.table)}.${this.host.quoteIdentifier(column.name)}`
+    );
     this.registerOperandCompiler(
       "Function",
-      (fnNode, ctx) => this.compileFunctionOperand(fnNode, ctx)
+      (fnNode, ctx) => this.host.compileFunctionOperand(fnNode, ctx)
+    );
+    this.registerOperandCompiler(
+      "JsonPath",
+      (path) => this.host.compileJsonPath(path)
     );
-    this.registerOperandCompiler("JsonPath", (path, _ctx) => {
-      void _ctx;
-      return this.compileJsonPath(path);
-    });
     this.registerOperandCompiler("ScalarSubquery", (node, ctx) => {
-      const sql = this.compileSelectAst(node.query, ctx).trim().replace(/;$/, "");
+      const sql = this.host.compileSelectAst(node.query, ctx).trim().replace(/;$/, "");
       return `(${sql})`;
     });
     this.registerOperandCompiler("CaseExpression", (node, ctx) => {
@@ -1685,7 +1460,7 @@ var Dialect = class _Dialect {
       const parts = [];
       if (node.partitionBy && node.partitionBy.length > 0) {
         const partitionClause = "PARTITION BY " + node.partitionBy.map(
-          (col2) => `${this.quoteIdentifier(col2.table)}.${this.quoteIdentifier(col2.name)}`
+          (col2) => `${this.host.quoteIdentifier(col2.table)}.${this.host.quoteIdentifier(col2.name)}`
         ).join(", ");
         parts.push(partitionClause);
       }
@@ -1717,14 +1492,164 @@ var Dialect = class _Dialect {
       return `${expr} COLLATE ${node.collation}`;
     });
   }
-  // Default fallback, should be overridden by dialects if supported
+};
+
+// src/core/dialect/base/select-ast-normalizer.ts
+var SelectAstNormalizer = class {
+  constructor(supportsSetOperation) {
+    this.supportsSetOperation = supportsSetOperation;
+  }
+  normalize(ast) {
+    this.validateSetOperations(ast, true);
+    const { normalized, hoistedCtes } = this.hoistCtes(ast);
+    const combinedCtes = [...normalized.ctes ?? [], ...hoistedCtes];
+    return combinedCtes.length ? { ...normalized, ctes: combinedCtes } : normalized;
+  }
+  validateSetOperations(ast, isOutermost) {
+    const hasSetOps = !!(ast.setOps && ast.setOps.length);
+    if (!isOutermost && (ast.orderBy || ast.limit !== void 0 || ast.offset !== void 0)) {
+      throw new Error("ORDER BY / LIMIT / OFFSET are only allowed on the outermost compound query.");
+    }
+    if (!hasSetOps) return;
+    for (const op of ast.setOps) {
+      if (!this.supportsSetOperation(op.operator)) {
+        throw new Error(`Set operation ${op.operator} is not supported by this dialect.`);
+      }
+      this.validateSetOperations(op.query, false);
+    }
+  }
+  hoistCtes(ast) {
+    let hoisted = [];
+    const normalizedSetOps = ast.setOps?.map((op) => {
+      const { normalized: child, hoistedCtes: childHoisted } = this.hoistCtes(op.query);
+      const childCtes = child.ctes ?? [];
+      if (childCtes.length) hoisted = hoisted.concat(childCtes);
+      hoisted = hoisted.concat(childHoisted);
+      const queryWithoutCtes = childCtes.length ? { ...child, ctes: void 0 } : child;
+      return { ...op, query: queryWithoutCtes };
+    });
+    const normalized = normalizedSetOps ? { ...ast, setOps: normalizedSetOps } : ast;
+    return { normalized, hoistedCtes: hoisted };
+  }
+};
+
+// src/core/dialect/abstract.ts
+var DialectBase = class _DialectBase {
+  expressionCompilerRegistry;
+  selectAstNormalizer;
+  functionStrategy;
+  tableFunctionStrategy;
+  constructor(functionStrategy, tableFunctionStrategy) {
+    this.functionStrategy = functionStrategy ?? new StandardFunctionStrategy();
+    this.tableFunctionStrategy = tableFunctionStrategy ?? new StandardTableFunctionStrategy();
+    this.selectAstNormalizer = new SelectAstNormalizer((kind) => this.supportsSetOperation(kind));
+    this.expressionCompilerRegistry = new ExpressionCompilerRegistry({
+      quoteIdentifier: (id) => this.quoteIdentifier(id),
+      compileSelectAst: (ast, ctx) => this.compileSelectAst(ast, ctx),
+      compileSelectForExists: (ast, ctx) => this.compileSelectForExists(ast, ctx),
+      compileJsonPath: (node) => this.compileJsonPath(node),
+      compileFunctionOperand: (node, ctx) => this.compileFunctionOperand(node, ctx),
+      describe: () => this.constructor.name
+    });
+  }
+  compileSelect(ast) {
+    const ctx = this.createCompilerContext();
+    const normalized = this.normalizeSelectAst(ast);
+    const rawSql = this.compileSelectAst(normalized, ctx).trim();
+    return {
+      sql: rawSql.endsWith(";") ? rawSql : `${rawSql};`,
+      params: [...ctx.params]
+    };
+  }
+  compileInsert(ast) {
+    const ctx = this.createCompilerContext();
+    const rawSql = this.compileInsertAst(ast, ctx).trim();
+    return {
+      sql: rawSql.endsWith(";") ? rawSql : `${rawSql};`,
+      params: [...ctx.params]
+    };
+  }
+  compileUpdate(ast) {
+    const ctx = this.createCompilerContext();
+    const rawSql = this.compileUpdateAst(ast, ctx).trim();
+    return {
+      sql: rawSql.endsWith(";") ? rawSql : `${rawSql};`,
+      params: [...ctx.params]
+    };
+  }
+  compileDelete(ast) {
+    const ctx = this.createCompilerContext();
+    const rawSql = this.compileDeleteAst(ast, ctx).trim();
+    return {
+      sql: rawSql.endsWith(";") ? rawSql : `${rawSql};`,
+      params: [...ctx.params]
+    };
+  }
+  supportsDmlReturningClause() {
+    return false;
+  }
+  compileWhere(where, ctx) {
+    if (!where) return "";
+    return ` WHERE ${this.compileExpression(where, ctx)}`;
+  }
+  compileReturning(returning, _ctx) {
+    void _ctx;
+    if (!returning || returning.length === 0) return "";
+    throw new Error("RETURNING is not supported by this dialect.");
+  }
+  compileSelectForExists(ast, ctx) {
+    const normalized = this.normalizeSelectAst(ast);
+    const full = this.compileSelectAst(normalized, ctx).trim().replace(/;$/, "");
+    if (normalized.setOps && normalized.setOps.length > 0) {
+      return `SELECT 1 FROM (${full}) AS _exists`;
+    }
+    const upper2 = full.toUpperCase();
+    const fromIndex = upper2.indexOf(" FROM ");
+    if (fromIndex === -1) return full;
+    return `SELECT 1${full.slice(fromIndex)}`;
+  }
+  createCompilerContext() {
+    const params = [];
+    let counter = 0;
+    return {
+      params,
+      addParameter: (value) => {
+        counter += 1;
+        params.push(value);
+        return this.formatPlaceholder(counter);
+      }
+    };
+  }
+  formatPlaceholder(_index) {
+    void _index;
+    return "?";
+  }
+  supportsSetOperation(_kind) {
+    void _kind;
+    return true;
+  }
+  normalizeSelectAst(ast) {
+    return this.selectAstNormalizer.normalize(ast);
+  }
+  registerExpressionCompiler(type, compiler) {
+    this.expressionCompilerRegistry.registerExpressionCompiler(type, compiler);
+  }
+  registerOperandCompiler(type, compiler) {
+    this.expressionCompilerRegistry.registerOperandCompiler(type, compiler);
+  }
+  compileExpression(node, ctx) {
+    return this.expressionCompilerRegistry.compileExpression(node, ctx);
+  }
+  compileOperand(node, ctx) {
+    return this.expressionCompilerRegistry.compileOperand(node, ctx);
+  }
+  compileOrderingTerm(term, ctx) {
+    return this.expressionCompilerRegistry.compileOrderingTerm(term, ctx);
+  }
   compileJsonPath(_node) {
     void _node;
     throw new Error("JSON Path not supported by this dialect");
   }
-  /**
-   * Compiles a function operand, using the dialect's function strategy.
-   */
   compileFunctionOperand(fnNode, ctx) {
     const compiledArgs = fnNode.args.map((arg) => this.compileOperand(arg, ctx));
     const renderer = this.functionStrategy.getRenderer(fnNode.name);
@@ -1737,115 +1662,175 @@ var Dialect = class _Dialect {
     }
     return `${fnNode.name}(${compiledArgs.join(", ")})`;
   }
+  /** Creates a minimal dialect implementation for isolated compiler tests. */
+  static create(functionStrategy, tableFunctionStrategy) {
+    class TestDialect extends _DialectBase {
+      dialect = "sqlite";
+      quoteIdentifier(id) {
+        return `"${id}"`;
+      }
+      compileSelectAst() {
+        throw new Error("Not implemented");
+      }
+      compileInsertAst() {
+        throw new Error("Not implemented");
+      }
+      compileUpdateAst() {
+        throw new Error("Not implemented");
+      }
+      compileDeleteAst() {
+        throw new Error("Not implemented");
+      }
+    }
+    return new TestDialect(functionStrategy, tableFunctionStrategy);
+  }
 };
 
-// src/core/dialect/base/function-table-formatter.ts
-var FunctionTableFormatter = class {
+// src/core/dialect/base/pagination-strategy.ts
+var StandardLimitOffsetPagination = class {
   /**
-   * Formats a function table node into SQL syntax.
-   * @param fn - The function table node containing schema, name, args, and aliases.
-   * @param ctx - Optional compiler context for operand compilation.
-   * @param dialect - The dialect instance for compiling operands.
-   * @returns SQL function table expression (e.g., "LATERAL schema.func(args) WITH ORDINALITY AS alias(col1, col2)").
+   * Compiles LIMIT/OFFSET pagination clause.
+   * @param limit - The maximum number of rows to return.
+   * @param offset - The number of rows to skip.
+   * @returns SQL pagination clause with LIMIT and/or OFFSET.
    */
-  static format(fn9, ctx, dialect) {
-    const schemaPart = this.formatSchema(fn9, dialect);
-    const args = this.formatArgs(fn9, ctx, dialect);
-    const base = this.formatBase(fn9, schemaPart, args);
-    const lateral = this.formatLateral(fn9);
-    const alias = this.formatAlias(fn9, dialect);
-    const colAliases = this.formatColumnAliases(fn9, dialect);
-    return `${lateral}${base}${alias}${colAliases}`;
+  compilePagination(limit, offset) {
+    const parts = [];
+    if (limit !== void 0) parts.push(`LIMIT ${limit}`);
+    if (offset !== void 0) parts.push(`OFFSET ${offset}`);
+    return parts.length ? ` ${parts.join(" ")}` : "";
   }
+};
+
+// src/core/dialect/base/returning-strategy.ts
+var NoReturningStrategy = class {
   /**
-   * Formats the schema prefix for the function name.
-   * @param fn - The function table node.
-   * @param dialect - The dialect instance for quoting identifiers.
-   * @returns Schema prefix (e.g., "schema.") or empty string.
-   * @internal
+   * Throws an error as RETURNING is not supported.
+   * @param returning - Columns to return (causes error if non-empty).
+   * @param _ctx - Compiler context (unused).
+   * @throws Error indicating RETURNING is not supported.
    */
-  static formatSchema(fn9, dialect) {
-    if (!fn9.schema) return "";
-    const quoted = dialect ? dialect.quoteIdentifier(fn9.schema) : fn9.schema;
-    return `${quoted}.`;
+  compileReturning(returning, _ctx) {
+    void _ctx;
+    if (!returning || returning.length === 0) return "";
+    throw new Error("RETURNING is not supported by this dialect.");
   }
   /**
-   * Formats function arguments into SQL syntax.
-   * @param fn - The function table node containing arguments.
-   * @param ctx - Optional compiler context for operand compilation.
-   * @param dialect - The dialect instance for compiling operands.
-   * @returns Comma-separated function arguments.
-   * @internal
+   * Formats column names for RETURNING clause.
+   * @param returning - Columns to format.
+   * @param quoteIdentifier - Function to quote identifiers according to dialect rules.
+   * @returns Simple comma-separated column names.
    */
-  static formatArgs(fn9, ctx, dialect) {
-    return (fn9.args || []).map((a) => {
-      if (ctx && dialect) {
-        return dialect.compileOperand(a, ctx);
-      }
-      return String(a);
+  formatReturningColumns(returning, quoteIdentifier) {
+    return returning.map((column) => {
+      const tablePart = column.table ? `${quoteIdentifier(column.table)}.` : "";
+      const aliasPart = column.alias ? ` AS ${quoteIdentifier(column.alias)}` : "";
+      return `${tablePart}${quoteIdentifier(column.name)}${aliasPart}`;
     }).join(", ");
   }
-  /**
-   * Formats the base function call with WITH ORDINALITY if present.
-   * @param fn - The function table node.
-   * @param schemaPart - Formatted schema prefix.
-   * @param args - Formatted function arguments.
-   * @param dialect - The dialect instance for quoting identifiers.
-   * @returns Base function call expression (e.g., "schema.func(args) WITH ORDINALITY").
-   * @internal
-   */
+};
+
+// src/core/dialect/base/function-table-formatter.ts
+var FunctionTableFormatter = class {
+  static format(fn9, ctx, formatter) {
+    const schemaPart = this.formatSchema(fn9, formatter);
+    const args = this.formatArgs(fn9, ctx, formatter);
+    const base = this.formatBase(fn9, schemaPart, args);
+    const lateral = this.formatLateral(fn9);
+    const alias = this.formatAlias(fn9, formatter);
+    const colAliases = this.formatColumnAliases(fn9, formatter);
+    return `${lateral}${base}${alias}${colAliases}`;
+  }
+  static formatSchema(fn9, formatter) {
+    if (!fn9.schema) return "";
+    return `${formatter.quoteIdentifier(fn9.schema)}.`;
+  }
+  static formatArgs(fn9, ctx, formatter) {
+    return (fn9.args || []).map((arg) => ctx ? formatter.compileOperand(arg, ctx) : String(arg)).join(", ");
+  }
   static formatBase(fn9, schemaPart, args) {
     const ordinality = fn9.withOrdinality ? " WITH ORDINALITY" : "";
     return `${schemaPart}${fn9.name}(${args})${ordinality}`;
   }
-  /**
-   * Formats the LATERAL keyword if present.
-   * @param fn - The function table node.
-   * @returns "LATERAL " or empty string.
-   * @internal
-   */
   static formatLateral(fn9) {
     return fn9.lateral ? "LATERAL " : "";
   }
-  /**
-   * Formats the table alias for the function table.
-   * @param fn - The function table node.
-   * @param dialect - The dialect instance for quoting identifiers.
-   * @returns " AS alias" or empty string.
-   * @internal
-   */
-  static formatAlias(fn9, dialect) {
+  static formatAlias(fn9, formatter) {
     if (!fn9.alias) return "";
-    const quoted = dialect ? dialect.quoteIdentifier(fn9.alias) : fn9.alias;
-    return ` AS ${quoted}`;
-  }
-  /**
-   * Formats column aliases for the function table result columns.
-   * @param fn - The function table node containing column aliases.
-   * @param dialect - The dialect instance for quoting identifiers.
-   * @returns "(col1, col2, ...)" or empty string.
-   * @internal
-   */
-  static formatColumnAliases(fn9, dialect) {
+    return ` AS ${formatter.quoteIdentifier(fn9.alias)}`;
+  }
+  static formatColumnAliases(fn9, formatter) {
     if (!fn9.columnAliases || !fn9.columnAliases.length) return "";
-    const aliases = fn9.columnAliases.map((col2) => dialect ? dialect.quoteIdentifier(col2) : col2).join(", ");
+    const aliases = fn9.columnAliases.map((col2) => formatter.quoteIdentifier(col2)).join(", ");
     return `(${aliases})`;
   }
 };
 
-// src/core/dialect/base/pagination-strategy.ts
-var StandardLimitOffsetPagination = class {
-  /**
-   * Compiles LIMIT/OFFSET pagination clause.
-   * @param limit - The maximum number of rows to return.
-   * @param offset - The number of rows to skip.
-   * @returns SQL pagination clause with LIMIT and/or OFFSET.
-   */
-  compilePagination(limit, offset) {
-    const parts = [];
-    if (limit !== void 0) parts.push(`LIMIT ${limit}`);
-    if (offset !== void 0) parts.push(`OFFSET ${offset}`);
-    return parts.length ? ` ${parts.join(" ")}` : "";
+// src/core/dialect/base/standard-sql-source-compiler.ts
+var StandardSqlSourceCompiler = class {
+  constructor(services) {
+    this.services = services;
+  }
+  compileFrom(source, ctx) {
+    if (source.type === "FunctionTable") return this.compileFunctionTable(source, ctx);
+    if (source.type === "DerivedTable") return this.compileDerivedTable(source, ctx);
+    return this.compileTableSource(source);
+  }
+  compileFunctionTable(fn9, ctx) {
+    const key = fn9.key ?? fn9.name;
+    if (ctx) {
+      const renderer = this.services.getTableFunctionStrategy().getRenderer(key);
+      if (renderer) {
+        const compiledArgs = (fn9.args ?? []).map((arg) => this.services.compileOperand(arg, ctx));
+        return renderer({
+          node: fn9,
+          compiledArgs,
+          compileOperand: (operand) => this.services.compileOperand(operand, ctx),
+          quoteIdentifier: (id) => this.services.quoteIdentifier(id)
+        });
+      }
+      if (fn9.key) {
+        throw new Error(
+          `Table function "${key}" is not supported by dialect "${this.services.getDialectName()}".`
+        );
+      }
+    }
+    return FunctionTableFormatter.format(fn9, ctx, {
+      quoteIdentifier: (id) => this.services.quoteIdentifier(id),
+      compileOperand: (node, compilerContext) => this.services.compileOperand(node, compilerContext)
+    });
+  }
+  compileDerivedTable(table, ctx) {
+    if (!table.alias) throw new Error("Derived tables must have an alias.");
+    if (!ctx) throw new Error("Derived table compilation requires a compiler context.");
+    const normalized = this.services.normalizeSelectAst(table.query);
+    const subquery = this.services.compileSelectAst(normalized, ctx).trim().replace(/;$/, "");
+    const columns = table.columnAliases?.length ? ` (${table.columnAliases.map((column) => this.services.quoteIdentifier(column)).join(", ")})` : "";
+    return `(${subquery}) AS ${this.services.quoteIdentifier(table.alias)}${columns}`;
+  }
+  compileTableSource(table) {
+    if (table.type === "FunctionTable") return this.compileFunctionTable(table);
+    if (table.type === "DerivedTable") {
+      throw new Error("Derived table compilation requires a compiler context.");
+    }
+    const base = this.compileTableName(table);
+    return table.alias ? `${base} AS ${this.services.quoteIdentifier(table.alias)}` : base;
+  }
+  compileTableName(table) {
+    if (table.schema) {
+      return `${this.services.quoteIdentifier(table.schema)}.${this.services.quoteIdentifier(table.name)}`;
+    }
+    return this.services.quoteIdentifier(table.name);
+  }
+  compileTableReference(table) {
+    const base = this.compileTableName(table);
+    return table.alias ? `${base} AS ${this.services.quoteIdentifier(table.alias)}` : base;
+  }
+  stripTrailingSemicolon(sql) {
+    return sql.trim().replace(/;$/, "");
+  }
+  wrapSetOperand(sql) {
+    return `(${this.stripTrailingSemicolon(sql)})`;
   }
 };
 
@@ -1875,34 +1860,6 @@ var CteCompiler = class {
   }
 };
 
-// src/core/dialect/base/returning-strategy.ts
-var NoReturningStrategy = class {
-  /**
-   * Throws an error as RETURNING is not supported.
-   * @param returning - Columns to return (causes error if non-empty).
-   * @param _ctx - Compiler context (unused).
-   * @throws Error indicating RETURNING is not supported.
-   */
-  compileReturning(returning, _ctx) {
-    void _ctx;
-    if (!returning || returning.length === 0) return "";
-    throw new Error("RETURNING is not supported by this dialect.");
-  }
-  /**
-   * Formats column names for RETURNING clause.
-   * @param returning - Columns to format.
-   * @param quoteIdentifier - Function to quote identifiers according to dialect rules.
-   * @returns Simple comma-separated column names.
-   */
-  formatReturningColumns(returning, quoteIdentifier) {
-    return returning.map((column) => {
-      const tablePart = column.table ? `${quoteIdentifier(column.table)}.` : "";
-      const aliasPart = column.alias ? ` AS ${quoteIdentifier(column.alias)}` : "";
-      return `${tablePart}${quoteIdentifier(column.name)}${aliasPart}`;
-    }).join(", ");
-  }
-};
-
 // src/core/dialect/base/join-compiler.ts
 var JoinCompiler = class {
   static compileJoins(joins, ctx, compileFrom, compileExpression) {
@@ -1953,113 +1910,229 @@ var OrderByCompiler = class {
   }
 };
 
-// src/core/dialect/base/sql-dialect.ts
-var SqlDialectBase = class extends Dialect {
-  paginationStrategy = new StandardLimitOffsetPagination();
-  returningStrategy = new NoReturningStrategy();
-  compileSelectAst(ast, ctx) {
+// src/core/dialect/base/standard-select-compiler.ts
+var StandardSelectCompiler = class {
+  constructor(services, sources) {
+    this.services = services;
+    this.sources = sources;
+  }
+  compile(ast, ctx) {
     const hasSetOps = !!(ast.setOps && ast.setOps.length);
     const ctes = CteCompiler.compileCtes(
       ast,
       ctx,
-      this.quoteIdentifier.bind(this),
-      this.compileSelectAst.bind(this),
-      this.normalizeSelectAst?.bind(this) ?? ((a) => a),
-      this.stripTrailingSemicolon.bind(this)
+      (id) => this.services.quoteIdentifier(id),
+      (query, compilerContext) => this.services.compileSelectAst(query, compilerContext),
+      (query) => this.services.normalizeSelectAst(query),
+      (sql) => this.sources.stripTrailingSemicolon(sql)
     );
     const baseAst = hasSetOps ? { ...ast, setOps: void 0, orderBy: void 0, limit: void 0, offset: void 0 } : ast;
-    const baseSelect = this.compileSelectCore(baseAst, ctx);
-    if (!hasSetOps) {
-      return `${ctes}${baseSelect}`;
-    }
-    return this.compileSelectWithSetOps(ast, baseSelect, ctes, ctx);
+    const baseSelect = this.compileCore(baseAst, ctx);
+    if (!hasSetOps) return `${ctes}${baseSelect}`;
+    const compound = ast.setOps.map((op) => `${op.operator} ${this.sources.wrapSetOperand(this.services.compileSelectAst(op.query, ctx))}`).join(" ");
+    const orderBy = this.compileOrderBy(ast, ctx);
+    const pagination = this.services.getPaginationStrategy().compilePagination(ast.limit, ast.offset);
+    const combined = `${this.sources.wrapSetOperand(baseSelect)} ${compound}`;
+    return `${ctes}${combined}${orderBy}${pagination}`;
   }
-  compileSelectWithSetOps(ast, baseSelect, ctes, ctx) {
-    const compound = ast.setOps.map((op) => `${op.operator} ${this.wrapSetOperand(this.compileSelectAst(op.query, ctx))}`).join(" ");
-    const orderBy = OrderByCompiler.compileOrderBy(
+  compileCore(ast, ctx) {
+    const columns = this.compileColumns(ast, ctx);
+    const from = this.sources.compileFrom(ast.from, ctx);
+    const joins = JoinCompiler.compileJoins(
+      ast.joins,
+      ctx,
+      (source, compilerContext) => this.sources.compileFrom(source, compilerContext),
+      (expression, compilerContext) => this.services.compileExpression(expression, compilerContext)
+    );
+    const where = ast.where ? ` WHERE ${this.services.compileExpression(ast.where, ctx)}` : "";
+    const groupBy = GroupByCompiler.compileGroupBy(
       ast,
-      (term) => this.compileOrderingTerm(term, ctx),
-      this.renderOrderByNulls.bind(this),
-      this.renderOrderByCollation.bind(this)
+      (term) => this.services.compileOrderingTerm(term, ctx)
     );
-    const pagination = this.paginationStrategy.compilePagination(ast.limit, ast.offset);
-    const combined = `${this.wrapSetOperand(baseSelect)} ${compound}`;
-    return `${ctes}${combined}${orderBy}${pagination}`;
+    const having = ast.having ? ` HAVING ${this.services.compileExpression(ast.having, ctx)}` : "";
+    const orderBy = this.compileOrderBy(ast, ctx);
+    const pagination = this.services.getPaginationStrategy().compilePagination(ast.limit, ast.offset);
+    return `SELECT ${ast.distinct ? "DISTINCT " : ""}${columns} FROM ${from}${joins}${where}${groupBy}${having}${orderBy}${pagination}`;
+  }
+  compileColumns(ast, ctx) {
+    if (!ast.columns || ast.columns.length === 0) return "*";
+    return ast.columns.map((column) => {
+      const expr = this.services.compileOperand(column, ctx);
+      if (!column.alias) return expr;
+      if (column.alias.includes("(")) return column.alias;
+      return `${expr} AS ${this.services.quoteIdentifier(column.alias)}`;
+    }).join(", ");
   }
-  compileInsertAst(ast, ctx) {
+  compileOrderBy(ast, ctx) {
+    return OrderByCompiler.compileOrderBy(
+      ast,
+      (term) => this.services.compileOrderingTerm(term, ctx),
+      (order) => this.services.renderOrderByNulls(order),
+      (order) => this.services.renderOrderByCollation(order)
+    );
+  }
+};
+
+// src/core/dialect/base/standard-insert-compiler.ts
+var StandardInsertCompiler = class {
+  constructor(services, sources) {
+    this.services = services;
+    this.sources = sources;
+  }
+  compile(ast, ctx) {
     if (!ast.columns.length) {
       throw new Error("INSERT queries must specify columns.");
     }
-    const table = this.compileTableName(ast.into);
-    const columnList = this.compileInsertColumnList(ast.columns);
-    const source = this.compileInsertSource(ast.source, ctx);
-    const upsert = this.compileUpsertClause(ast, ctx);
-    const returning = this.compileReturning(ast.returning, ctx);
+    const table = this.sources.compileTableName(ast.into);
+    const columnList = this.compileColumnList(ast.columns);
+    const source = this.compileSource(ast.source, ctx);
+    const upsert = this.services.compileUpsertClause(ast, ctx);
+    const returning = this.services.compileReturning(ast.returning, ctx);
     return `INSERT INTO ${table} (${columnList}) ${source}${upsert}${returning}`;
   }
-  compileUpsertClause(ast, _ctx) {
-    void _ctx;
-    if (!ast.onConflict) return "";
-    throw new Error(`UPSERT/ON CONFLICT is not supported by dialect "${this.dialect}".`);
-  }
-  compileReturning(returning, ctx) {
-    return this.returningStrategy.compileReturning(returning, ctx);
-  }
-  compileInsertSource(source, ctx) {
+  compileSource(source, ctx) {
     if (source.type === "InsertValues") {
       if (!source.rows.length) {
         throw new Error("INSERT ... VALUES requires at least one row.");
       }
-      const values = source.rows.map((row) => `(${row.map((value) => this.compileOperand(value, ctx)).join(", ")})`).join(", ");
+      const values = source.rows.map((row) => `(${row.map((value) => this.services.compileOperand(value, ctx)).join(", ")})`).join(", ");
       return `VALUES ${values}`;
     }
-    const normalized = this.normalizeSelectAst(source.query);
-    return this.compileSelectAst(normalized, ctx).trim();
+    const normalized = this.services.normalizeSelectAst(source.query);
+    return this.services.compileSelectAst(normalized, ctx).trim();
   }
-  compileInsertColumnList(columns) {
-    return columns.map((column) => this.quoteIdentifier(column.name)).join(", ");
+  compileColumnList(columns) {
+    return columns.map((column) => this.services.quoteIdentifier(column.name)).join(", ");
   }
   ensureConflictColumns(clause, message) {
-    if (!clause.target.columns.length) {
-      throw new Error(message);
-    }
+    if (!clause.target.columns.length) throw new Error(message);
   }
-  compileSelectCore(ast, ctx) {
-    const columns = this.compileSelectColumns(ast, ctx);
-    const from = this.compileFrom(ast.from, ctx);
+};
+
+// src/core/dialect/base/standard-update-compiler.ts
+var StandardUpdateCompiler = class {
+  constructor(services, sources) {
+    this.services = services;
+    this.sources = sources;
+  }
+  compile(ast, ctx) {
+    const target = this.sources.compileTableReference(ast.table);
+    const assignments = this.compileAssignments(ast.set, ast.table, ctx);
+    const from = this.compileFromClause(ast, ctx);
+    const where = ast.where ? ` WHERE ${this.services.compileExpression(ast.where, ctx)}` : "";
+    const returning = this.services.compileReturning(ast.returning, ctx);
+    return `UPDATE ${target} SET ${assignments}${from}${where}${returning}`;
+  }
+  compileAssignments(assignments, table, ctx) {
+    return assignments.map((assignment) => {
+      const target = this.services.compileSetTarget(assignment.column, table);
+      const value = this.services.compileOperand(assignment.value, ctx);
+      return `${target} = ${value}`;
+    }).join(", ");
+  }
+  compileFromClause(ast, ctx) {
+    if (!ast.from && (!ast.joins || ast.joins.length === 0)) return "";
+    if (!ast.from) {
+      throw new Error("UPDATE with JOINs requires an explicit FROM clause.");
+    }
+    const from = this.sources.compileFrom(ast.from, ctx);
     const joins = JoinCompiler.compileJoins(
       ast.joins,
       ctx,
-      this.compileFrom.bind(this),
-      this.compileExpression.bind(this)
+      (source, compilerContext) => this.sources.compileFrom(source, compilerContext),
+      (expression, compilerContext) => this.services.compileExpression(expression, compilerContext)
     );
-    const whereClause = this.compileWhere(ast.where, ctx);
-    const groupBy = GroupByCompiler.compileGroupBy(ast, (term) => this.compileOrderingTerm(term, ctx));
-    const having = this.compileHaving(ast, ctx);
-    const orderBy = OrderByCompiler.compileOrderBy(
-      ast,
-      (term) => this.compileOrderingTerm(term, ctx),
-      this.renderOrderByNulls.bind(this),
-      this.renderOrderByCollation.bind(this)
+    return ` FROM ${from}${joins}`;
+  }
+};
+
+// src/core/dialect/base/standard-delete-compiler.ts
+var StandardDeleteCompiler = class {
+  constructor(services, sources) {
+    this.services = services;
+    this.sources = sources;
+  }
+  compile(ast, ctx) {
+    const target = this.sources.compileTableReference(ast.from);
+    const using = this.compileUsingClause(ast, ctx);
+    const where = ast.where ? ` WHERE ${this.services.compileExpression(ast.where, ctx)}` : "";
+    const returning = this.services.compileReturning(ast.returning, ctx);
+    return `DELETE FROM ${target}${using}${where}${returning}`;
+  }
+  compileUsingClause(ast, ctx) {
+    if (!ast.using && (!ast.joins || ast.joins.length === 0)) return "";
+    if (!ast.using) {
+      throw new Error("DELETE with JOINs requires a USING clause.");
+    }
+    const usingTable = this.sources.compileFrom(ast.using, ctx);
+    const joins = JoinCompiler.compileJoins(
+      ast.joins,
+      ctx,
+      (source, compilerContext) => this.sources.compileFrom(source, compilerContext),
+      (expression, compilerContext) => this.services.compileExpression(expression, compilerContext)
     );
-    const pagination = this.paginationStrategy.compilePagination(ast.limit, ast.offset);
-    return `SELECT ${this.compileDistinct(ast)}${columns} FROM ${from}${joins}${whereClause}${groupBy}${having}${orderBy}${pagination}`;
+    return ` USING ${usingTable}${joins}`;
+  }
+};
+
+// src/core/dialect/base/sql-dialect.ts
+var SqlDialectBase = class extends DialectBase {
+  paginationStrategy = new StandardLimitOffsetPagination();
+  returningStrategy = new NoReturningStrategy();
+  sourceCompiler;
+  selectCompiler;
+  insertCompiler;
+  updateCompiler;
+  deleteCompiler;
+  constructor(functionStrategy, tableFunctionStrategy) {
+    super(functionStrategy, tableFunctionStrategy);
+    const services = {
+      getDialectName: () => this.dialect,
+      getPaginationStrategy: () => this.paginationStrategy,
+      getTableFunctionStrategy: () => this.tableFunctionStrategy,
+      quoteIdentifier: (id) => this.quoteIdentifier(id),
+      compileOperand: (node, ctx) => this.compileOperand(node, ctx),
+      compileExpression: (node, ctx) => this.compileExpression(node, ctx),
+      compileOrderingTerm: (term, ctx) => this.compileOrderingTerm(term, ctx),
+      normalizeSelectAst: (ast) => this.normalizeSelectAst(ast),
+      compileSelectAst: (ast, ctx) => this.compileSelectAst(ast, ctx),
+      compileReturning: (returning, ctx) => this.compileReturning(returning, ctx),
+      compileUpsertClause: (ast, ctx) => this.compileUpsertClause(ast, ctx),
+      compileSetTarget: (column, table) => this.compileSetTarget(column, table),
+      renderOrderByNulls: (order) => this.renderOrderByNulls(order),
+      renderOrderByCollation: (order) => this.renderOrderByCollation(order)
+    };
+    this.sourceCompiler = new StandardSqlSourceCompiler(services);
+    this.selectCompiler = new StandardSelectCompiler(services, this.sourceCompiler);
+    this.insertCompiler = new StandardInsertCompiler(services, this.sourceCompiler);
+    this.updateCompiler = new StandardUpdateCompiler(services, this.sourceCompiler);
+    this.deleteCompiler = new StandardDeleteCompiler(services, this.sourceCompiler);
+  }
+  compileSelectAst(ast, ctx) {
+    return this.selectCompiler.compile(ast, ctx);
+  }
+  compileInsertAst(ast, ctx) {
+    return this.insertCompiler.compile(ast, ctx);
   }
   compileUpdateAst(ast, ctx) {
-    const target = this.compileTableReference(ast.table);
-    const assignments = this.compileUpdateAssignments(ast.set, ast.table, ctx);
-    const fromClause = this.compileUpdateFromClause(ast, ctx);
-    const whereClause = this.compileWhere(ast.where, ctx);
-    const returning = this.compileReturning(ast.returning, ctx);
-    return `UPDATE ${target} SET ${assignments}${fromClause}${whereClause}${returning}`;
+    return this.updateCompiler.compile(ast, ctx);
+  }
+  compileDeleteAst(ast, ctx) {
+    return this.deleteCompiler.compile(ast, ctx);
+  }
+  compileUpsertClause(ast, _ctx) {
+    void _ctx;
+    if (!ast.onConflict) return "";
+    throw new Error(`UPSERT/ON CONFLICT is not supported by dialect "${this.dialect}".`);
+  }
+  compileReturning(returning, ctx) {
+    return this.returningStrategy.compileReturning(returning, ctx);
+  }
+  ensureConflictColumns(clause, message) {
+    this.insertCompiler.ensureConflictColumns(clause, message);
   }
   compileUpdateAssignments(assignments, table, ctx) {
-    return assignments.map((assignment) => {
-      const col2 = assignment.column;
-      const target = this.compileSetTarget(col2, table);
-      const value = this.compileOperand(assignment.value, ctx);
-      return `${target} = ${value}`;
-    }).join(", ");
+    return this.updateCompiler.compileAssignments(assignments, table, ctx);
   }
   compileSetTarget(column, table) {
     return this.compileQualifiedColumn(column, table);
@@ -2069,132 +2142,38 @@ var SqlDialectBase = class extends Dialect {
     const alias = table.alias;
     const columnTable = column.table ?? alias ?? baseTableName;
     const tableQualifier = alias && column.table === baseTableName ? alias : columnTable;
-    if (!tableQualifier) {
-      return this.quoteIdentifier(column.name);
-    }
+    if (!tableQualifier) return this.quoteIdentifier(column.name);
     return `${this.quoteIdentifier(tableQualifier)}.${this.quoteIdentifier(column.name)}`;
   }
-  compileDeleteAst(ast, ctx) {
-    const target = this.compileTableReference(ast.from);
-    const usingClause = this.compileDeleteUsingClause(ast, ctx);
-    const whereClause = this.compileWhere(ast.where, ctx);
-    const returning = this.compileReturning(ast.returning, ctx);
-    return `DELETE FROM ${target}${usingClause}${whereClause}${returning}`;
-  }
   formatReturningColumns(returning) {
-    return this.returningStrategy.formatReturningColumns(returning, this.quoteIdentifier.bind(this));
-  }
-  compileDistinct(ast) {
-    return ast.distinct ? "DISTINCT " : "";
-  }
-  compileSelectColumns(ast, ctx) {
-    if (!ast.columns || ast.columns.length === 0) {
-      return "*";
-    }
-    return ast.columns.map((c) => {
-      const expr = this.compileOperand(c, ctx);
-      if (c.alias) {
-        if (c.alias.includes("(")) return c.alias;
-        return `${expr} AS ${this.quoteIdentifier(c.alias)}`;
-      }
-      return expr;
-    }).join(", ");
+    return this.returningStrategy.formatReturningColumns(
+      returning,
+      (id) => this.quoteIdentifier(id)
+    );
   }
-  compileFrom(ast, ctx) {
-    const tableSource = ast;
-    if (tableSource.type === "FunctionTable") {
-      return this.compileFunctionTable(tableSource, ctx);
-    }
-    if (tableSource.type === "DerivedTable") {
-      return this.compileDerivedTable(tableSource, ctx);
-    }
-    return this.compileTableSource(tableSource);
+  compileFrom(source, ctx) {
+    return this.sourceCompiler.compileFrom(source, ctx);
   }
   compileFunctionTable(fn9, ctx) {
-    const key = fn9.key ?? fn9.name;
-    if (ctx) {
-      const renderer = this.tableFunctionStrategy.getRenderer(key);
-      if (renderer) {
-        const compiledArgs = (fn9.args ?? []).map((arg) => this.compileOperand(arg, ctx));
-        return renderer({
-          node: fn9,
-          compiledArgs,
-          compileOperand: (operand) => this.compileOperand(operand, ctx),
-          quoteIdentifier: this.quoteIdentifier.bind(this)
-        });
-      }
-      if (fn9.key) {
-        throw new Error(`Table function "${key}" is not supported by dialect "${this.dialect}".`);
-      }
-    }
-    return FunctionTableFormatter.format(fn9, ctx, this);
+    return this.sourceCompiler.compileFunctionTable(fn9, ctx);
   }
   compileDerivedTable(table, ctx) {
-    if (!table.alias) {
-      throw new Error("Derived tables must have an alias.");
-    }
-    const subquery = this.compileSelectAst(this.normalizeSelectAst(table.query), ctx).trim().replace(/;$/, "");
-    const columns = table.columnAliases?.length ? ` (${table.columnAliases.map((c) => this.quoteIdentifier(c)).join(", ")})` : "";
-    return `(${subquery}) AS ${this.quoteIdentifier(table.alias)}${columns}`;
+    return this.sourceCompiler.compileDerivedTable(table, ctx);
   }
   compileTableSource(table) {
-    if (table.type === "FunctionTable") {
-      return this.compileFunctionTable(table);
-    }
-    if (table.type === "DerivedTable") {
-      return this.compileDerivedTable(table);
-    }
-    const base = this.compileTableName(table);
-    return table.alias ? `${base} AS ${this.quoteIdentifier(table.alias)}` : base;
+    return this.sourceCompiler.compileTableSource(table);
   }
   compileTableName(table) {
-    if (table.schema) {
-      return `${this.quoteIdentifier(table.schema)}.${this.quoteIdentifier(table.name)}`;
-    }
-    return this.quoteIdentifier(table.name);
+    return this.sourceCompiler.compileTableName(table);
   }
   compileTableReference(table) {
-    const base = this.compileTableName(table);
-    return table.alias ? `${base} AS ${this.quoteIdentifier(table.alias)}` : base;
-  }
-  compileUpdateFromClause(ast, ctx) {
-    if (!ast.from && (!ast.joins || ast.joins.length === 0)) return "";
-    if (!ast.from) {
-      throw new Error("UPDATE with JOINs requires an explicit FROM clause.");
-    }
-    const from = this.compileFrom(ast.from, ctx);
-    const joins = JoinCompiler.compileJoins(
-      ast.joins,
-      ctx,
-      this.compileFrom.bind(this),
-      this.compileExpression.bind(this)
-    );
-    return ` FROM ${from}${joins}`;
-  }
-  compileDeleteUsingClause(ast, ctx) {
-    if (!ast.using && (!ast.joins || ast.joins.length === 0)) return "";
-    if (!ast.using) {
-      throw new Error("DELETE with JOINs requires a USING clause.");
-    }
-    const usingTable = this.compileFrom(ast.using, ctx);
-    const joins = JoinCompiler.compileJoins(
-      ast.joins,
-      ctx,
-      this.compileFrom.bind(this),
-      this.compileExpression.bind(this)
-    );
-    return ` USING ${usingTable}${joins}`;
-  }
-  compileHaving(ast, ctx) {
-    if (!ast.having) return "";
-    return ` HAVING ${this.compileExpression(ast.having, ctx)}`;
+    return this.sourceCompiler.compileTableReference(table);
   }
   stripTrailingSemicolon(sql) {
-    return sql.trim().replace(/;$/, "");
+    return this.sourceCompiler.stripTrailingSemicolon(sql);
   }
   wrapSetOperand(sql) {
-    const trimmed = this.stripTrailingSemicolon(sql);
-    return `(${trimmed})`;
+    return this.sourceCompiler.wrapSetOperand(sql);
   }
   renderOrderByNulls(order) {
     return order.nulls ? ` NULLS ${order.nulls}` : "";
@@ -2903,10 +2882,6 @@ var SqliteDialect = class extends SqlDialectBase {
   supportsDmlReturningClause() {
     return true;
   }
-  compileProcedureCall(_ast) {
-    void _ast;
-    throw new Error("Stored procedures are not supported by the SQLite dialect.");
-  }
 };
 
 // src/core/dialect/mssql/functions.ts
@@ -3341,9 +3316,8 @@ var DialectFactory = class {
   /**
    * Register (or override) a dialect factory for a key.
    *
-   * Examples:
-   *   DialectFactory.register('sqlite', () => new SqliteDialect());
-   *   DialectFactory.register('my-tenant-dialect', () => new CustomDialect());
+   * Implementations are structural: extending DialectBase/SqlDialectBase is
+   * optional. A composed object satisfying Dialect is a valid registration.
    */
   static register(key, factory) {
     this.registry.set(key, factory);
@@ -10916,6 +10890,15 @@ var DeleteQueryBuilder = class _DeleteQueryBuilder {
 };
 var isTableSourceNode2 = (source) => typeof source.type === "string";
 
+// src/core/dialect/capabilities/procedure-compiler.ts
+var isProcedureCompiler = (value) => typeof value?.compileProcedureCall === "function";
+var requireProcedureCompiler = (value) => {
+  if (!isProcedureCompiler(value)) {
+    throw new Error("Stored procedures are not supported by this dialect.");
+  }
+  return value;
+};
+
 // src/orm/execute-procedure.ts
 var resolveColumnIndex = (columns, expectedName) => {
   const exact = columns.findIndex((column) => column === expectedName);
@@ -10954,7 +10937,7 @@ var extractOutValues = (compiled, resultSets) => {
 };
 var executeProcedureAst = async (session, ast) => {
   const execCtx = session.getExecutionContext();
-  const compiled = execCtx.dialect.compileProcedureCall(ast);
+  const compiled = requireProcedureCompiler(execCtx.dialect).compileProcedureCall(ast);
   const payload = await execCtx.interceptors.run(
     { sql: compiled.sql, params: compiled.params },
     execCtx.executor
@@ -11027,8 +11010,7 @@ var ProcedureCallBuilder = class _ProcedureCallBuilder {
   }
   compile(dialect) {
     const resolved = resolveDialectInput(dialect);
-    this.validateMssqlOutDbType(resolved);
-    return resolved.compileProcedureCall(this.getAST());
+    return requireProcedureCompiler(resolved).compileProcedureCall(this.getAST());
   }
   toSql(dialect) {
     return this.compile(dialect).sql;
@@ -11041,21 +11023,8 @@ var ProcedureCallBuilder = class _ProcedureCallBuilder {
     };
   }
   async execute(session) {
-    this.validateMssqlOutDbType(session.getExecutionContext().dialect);
     return executeProcedureAst(session, this.getAST());
   }
-  validateMssqlOutDbType(dialect) {
-    const isMssqlDialect = dialect.constructor.name === "SqlServerDialect";
-    if (!isMssqlDialect) return;
-    for (const param of this.ast.params) {
-      const needsDbType = param.direction === "out" || param.direction === "inout";
-      if (needsDbType && !param.dbType) {
-        throw new Error(
-          `MSSQL requires "dbType" for procedure parameter "${param.name}" with direction "${param.direction}".`
-        );
-      }
-    }
-  }
 };
 var callProcedure = (name, options) => new ProcedureCallBuilder(name, options);
 
@@ -21783,6 +21752,8 @@ export {
   DefaultMorphToReference,
   DefaultTypeStrategy,
   DeleteQueryBuilder,
+  DialectBase,
+  DialectFactory,
   DomainEventBus,
   Email,
   Entity,
@@ -21816,6 +21787,11 @@ export {
   SelectQueryBuilder,
   SqlServerDialect,
   SqliteDialect,
+  StandardDeleteCompiler,
+  StandardInsertCompiler,
+  StandardSelectCompiler,
+  StandardSqlSourceCompiler,
+  StandardUpdateCompiler,
   StringTypeStrategy,
   TagIndex,
   Title,
@@ -22010,6 +21986,7 @@ export {
   isNull,
   isNullableColumn,
   isOperandNode,
+  isProcedureCompiler,
   isSingleTargetRelation,
   isTableDef2 as isTableDef,
   isTreeConfig,
@@ -22107,6 +22084,8 @@ export {
   repeat,
   replace,
   replaceWithRefs,
+  requireProcedureCompiler,
+  resolveDialectInput,
   resolveTreeConfig,
   resolveValidator,
   responseToRef,