metal-orm 1.1.22 → 1.1.23

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,98 +1662,62 @@ 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 {
-  /**
-   * 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)").
-   */
-  static format(fn9, ctx, dialect) {
-    const schemaPart = this.formatSchema(fn9, dialect);
-    const args = this.formatArgs(fn9, ctx, dialect);
+  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, dialect);
-    const colAliases = this.formatColumnAliases(fn9, dialect);
+    const alias = this.formatAlias(fn9, formatter);
+    const colAliases = this.formatColumnAliases(fn9, formatter);
     return `${lateral}${base}${alias}${colAliases}`;
   }
-  /**
-   * 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
-   */
-  static formatSchema(fn9, dialect) {
+  static formatSchema(fn9, formatter) {
     if (!fn9.schema) return "";
-    const quoted = dialect ? dialect.quoteIdentifier(fn9.schema) : fn9.schema;
-    return `${quoted}.`;
+    return `${formatter.quoteIdentifier(fn9.schema)}.`;
   }
-  /**
-   * 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
-   */
-  static formatArgs(fn9, ctx, dialect) {
-    return (fn9.args || []).map((a) => {
-      if (ctx && dialect) {
-        return dialect.compileOperand(a, ctx);
-      }
-      return String(a);
-    }).join(", ");
+  static formatArgs(fn9, ctx, formatter) {
+    return (fn9.args || []).map((arg) => ctx ? formatter.compileOperand(arg, ctx) : String(arg)).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
-   */
   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}`;
+    return ` AS ${formatter.quoteIdentifier(fn9.alias)}`;
   }
-  /**
-   * 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) {
+  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})`;
   }
 };
@@ -1954,7 +1843,7 @@ var OrderByCompiler = class {
 };
 
 // src/core/dialect/base/sql-dialect.ts
-var SqlDialectBase = class extends Dialect {
+var SqlDialectBase = class extends DialectBase {
   paginationStrategy = new StandardLimitOffsetPagination();
   returningStrategy = new NoReturningStrategy();
   compileSelectAst(ast, ctx) {
@@ -1964,14 +1853,12 @@ var SqlDialectBase = class extends Dialect {
       ctx,
       this.quoteIdentifier.bind(this),
       this.compileSelectAst.bind(this),
-      this.normalizeSelectAst?.bind(this) ?? ((a) => a),
+      this.normalizeSelectAst.bind(this),
       this.stripTrailingSemicolon.bind(this)
     );
     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}`;
-    }
+    if (!hasSetOps) return `${ctes}${baseSelect}`;
     return this.compileSelectWithSetOps(ast, baseSelect, ctes, ctx);
   }
   compileSelectWithSetOps(ast, baseSelect, ctes, ctx) {
@@ -2020,9 +1907,7 @@ var SqlDialectBase = class extends Dialect {
     return columns.map((column) => this.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);
@@ -2055,8 +1940,7 @@ var SqlDialectBase = class extends Dialect {
   }
   compileUpdateAssignments(assignments, table, ctx) {
     return assignments.map((assignment) => {
-      const col2 = assignment.column;
-      const target = this.compileSetTarget(col2, table);
+      const target = this.compileSetTarget(assignment.column, table);
       const value = this.compileOperand(assignment.value, ctx);
       return `${target} = ${value}`;
     }).join(", ");
@@ -2069,9 +1953,7 @@ 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) {
@@ -2088,27 +1970,20 @@ var SqlDialectBase = class extends Dialect {
     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)}`;
+    if (!ast.columns || ast.columns.length === 0) return "*";
+    return ast.columns.map((column) => {
+      const expr = this.compileOperand(column, ctx);
+      if (column.alias) {
+        if (column.alias.includes("(")) return column.alias;
+        return `${expr} AS ${this.quoteIdentifier(column.alias)}`;
       }
       return expr;
     }).join(", ");
   }
   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);
+    if (ast.type === "FunctionTable") return this.compileFunctionTable(ast, ctx);
+    if (ast.type === "DerivedTable") return this.compileDerivedTable(ast, ctx);
+    return this.compileTableSource(ast);
   }
   compileFunctionTable(fn9, ctx) {
     const key = fn9.key ?? fn9.name;
@@ -2127,23 +2002,20 @@ var SqlDialectBase = class extends Dialect {
         throw new Error(`Table function "${key}" is not supported by dialect "${this.dialect}".`);
       }
     }
-    return FunctionTableFormatter.format(fn9, ctx, this);
+    return FunctionTableFormatter.format(fn9, ctx, {
+      quoteIdentifier: (id) => this.quoteIdentifier(id),
+      compileOperand: (node, compilerContext) => this.compileOperand(node, compilerContext)
+    });
   }
   compileDerivedTable(table, ctx) {
-    if (!table.alias) {
-      throw new Error("Derived tables must have an alias.");
-    }
+    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}`;
   }
   compileTableSource(table) {
-    if (table.type === "FunctionTable") {
-      return this.compileFunctionTable(table);
-    }
-    if (table.type === "DerivedTable") {
-      return this.compileDerivedTable(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;
   }
@@ -2159,9 +2031,7 @@ var SqlDialectBase = class extends Dialect {
   }
   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.");
-    }
+    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,
@@ -2173,9 +2043,7 @@ var SqlDialectBase = class extends Dialect {
   }
   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.");
-    }
+    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,
@@ -2193,8 +2061,7 @@ var SqlDialectBase = class extends Dialect {
     return sql.trim().replace(/;$/, "");
   }
   wrapSetOperand(sql) {
-    const trimmed = this.stripTrailingSemicolon(sql);
-    return `(${trimmed})`;
+    return `(${this.stripTrailingSemicolon(sql)})`;
   }
   renderOrderByNulls(order) {
     return order.nulls ? ` NULLS ${order.nulls}` : "";
@@ -2903,10 +2770,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 +3204,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 +10778,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 +10825,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 +10898,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 +10911,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 +21640,8 @@ export {
   DefaultMorphToReference,
   DefaultTypeStrategy,
   DeleteQueryBuilder,
+  DialectBase,
+  DialectFactory,
   DomainEventBus,
   Email,
   Entity,
@@ -22010,6 +21869,7 @@ export {
   isNull,
   isNullableColumn,
   isOperandNode,
+  isProcedureCompiler,
   isSingleTargetRelation,
   isTableDef2 as isTableDef,
   isTreeConfig,
@@ -22107,6 +21967,8 @@ export {
   repeat,
   replace,
   replaceWithRefs,
+  requireProcedureCompiler,
+  resolveDialectInput,
   resolveTreeConfig,
   resolveValidator,
   responseToRef,