metal-orm 1.1.22 → 1.1.24

package/src/core/dialect/base/standard-sql-source-compiler.ts

@@ -0,0 +1,88 @@
+import type { CompilerContext } from '../abstract.js';
+import type {
+  DerivedTableNode,
+  FunctionTableNode,
+  TableSourceNode
+} from '../../ast/query.js';
+import { FunctionTableFormatter } from './function-table-formatter.js';
+import type { StandardSqlCompilerServices } from './standard-sql-services.js';
+
+/** Shared FROM/table-source rendering used by the standard query compilers. */
+export class StandardSqlSourceCompiler {
+  public constructor(private readonly services: StandardSqlCompilerServices) {}
+
+  compileFrom(source: TableSourceNode, ctx?: CompilerContext): string {
+    if (source.type === 'FunctionTable') return this.compileFunctionTable(source, ctx);
+    if (source.type === 'DerivedTable') return this.compileDerivedTable(source, ctx);
+    return this.compileTableSource(source);
+  }
+
+  compileFunctionTable(fn: FunctionTableNode, ctx?: CompilerContext): string {
+    const key = fn.key ?? fn.name;
+
+    if (ctx) {
+      const renderer = this.services.getTableFunctionStrategy().getRenderer(key);
+      if (renderer) {
+        const compiledArgs = (fn.args ?? []).map(arg => this.services.compileOperand(arg, ctx));
+        return renderer({
+          node: fn,
+          compiledArgs,
+          compileOperand: operand => this.services.compileOperand(operand, ctx),
+          quoteIdentifier: id => this.services.quoteIdentifier(id)
+        });
+      }
+
+      if (fn.key) {
+        throw new Error(
+          `Table function "${key}" is not supported by dialect "${this.services.getDialectName()}".`
+        );
+      }
+    }
+
+    return FunctionTableFormatter.format(fn, ctx, {
+      quoteIdentifier: id => this.services.quoteIdentifier(id),
+      compileOperand: (node, compilerContext) => this.services.compileOperand(node, compilerContext)
+    });
+  }
+
+  compileDerivedTable(table: DerivedTableNode, ctx?: CompilerContext): string {
+    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: TableSourceNode): string {
+    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: { name: string; schema?: string }): string {
+    if (table.schema) {
+      return `${this.services.quoteIdentifier(table.schema)}.${this.services.quoteIdentifier(table.name)}`;
+    }
+    return this.services.quoteIdentifier(table.name);
+  }
+
+  compileTableReference(table: { name: string; schema?: string; alias?: string }): string {
+    const base = this.compileTableName(table);
+    return table.alias ? `${base} AS ${this.services.quoteIdentifier(table.alias)}` : base;
+  }
+
+  stripTrailingSemicolon(sql: string): string {
+    return sql.trim().replace(/;$/, '');
+  }
+
+  wrapSetOperand(sql: string): string {
+    return `(${this.stripTrailingSemicolon(sql)})`;
+  }
+}

package/src/core/dialect/base/standard-update-compiler.ts

@@ -0,0 +1,53 @@
+import type { CompilerContext } from '../abstract.js';
+import type { UpdateQueryNode, TableNode } from '../../ast/query.js';
+import type { ColumnNode, OperandNode } from '../../ast/expression.js';
+import { JoinCompiler } from './join-compiler.js';
+import { StandardSqlSourceCompiler } from './standard-sql-source-compiler.js';
+import type { StandardSqlCompilerServices } from './standard-sql-services.js';
+
+/** Standard UPDATE orchestration, independent from concrete dialect classes. */
+export class StandardUpdateCompiler {
+  public constructor(
+    private readonly services: StandardSqlCompilerServices,
+    private readonly sources: StandardSqlSourceCompiler
+  ) {}
+
+  compile(ast: UpdateQueryNode, ctx: CompilerContext): string {
+    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: { column: ColumnNode; value: OperandNode }[],
+    table: TableNode,
+    ctx: CompilerContext
+  ): string {
+    return assignments
+      .map(assignment => {
+        const target = this.services.compileSetTarget(assignment.column, table);
+        const value = this.services.compileOperand(assignment.value, ctx);
+        return `${target} = ${value}`;
+      })
+      .join(', ');
+  }
+
+  private compileFromClause(ast: UpdateQueryNode, ctx: CompilerContext): string {
+    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,
+      (source, compilerContext) => this.sources.compileFrom(source, compilerContext),
+      (expression, compilerContext) => this.services.compileExpression(expression, compilerContext)
+    );
+    return ` FROM ${from}${joins}`;
+  }
+}

package/src/core/dialect/capabilities/procedure-compiler.ts

@@ -0,0 +1,30 @@
+import type { ProcedureCallNode } from '../../ast/procedure.js';
+import type { CompiledQuery } from '../abstract.js';
+
+export interface CompiledProcedureCall extends CompiledQuery {
+  outParams: {
+    source: 'none' | 'firstResultSet' | 'lastResultSet';
+    names: string[];
+  };
+}
+
+/**
+ * Optional dialect capability for stored-procedure compilation.
+ *
+ * Dialects that do not support procedures simply do not implement this
+ * interface; unsupported behavior is resolved at the capability boundary
+ * rather than through mandatory methods that only throw.
+ */
+export interface ProcedureCompiler {
+  compileProcedureCall(ast: ProcedureCallNode): CompiledProcedureCall;
+}
+
+export const isProcedureCompiler = (value: unknown): value is ProcedureCompiler =>
+  typeof (value as { compileProcedureCall?: unknown } | null)?.compileProcedureCall === 'function';
+
+export const requireProcedureCompiler = (value: unknown): ProcedureCompiler => {
+  if (!isProcedureCompiler(value)) {
+    throw new Error('Stored procedures are not supported by this dialect.');
+  }
+  return value;
+};

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

@@ -1,7 +1,7 @@
 // Dialect factory for the SQL DSL.
 // Centralizes how we go from a symbolic name ("sqlite") to a concrete Dialect instance.
 
-import { Dialect } from './abstract.js';
+import type { Dialect } from './abstract.js';
 import { PostgresDialect } from './postgres/index.js';
 import { MySqlDialect } from './mysql/index.js';
 import { SqliteDialect } from './sqlite/index.js';
@@ -42,9 +42,8 @@ export class DialectFactory {
   /**
    * 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.
    */
   public static register(key: DialectKey, factory: DialectFactoryFn): void {
     this.registry.set(key, factory);

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

@@ -1,4 +1,5 @@
-import { CompilerContext, CompiledProcedureCall } from '../abstract.js';
+import { CompilerContext } from '../abstract.js';
+import type { CompiledProcedureCall, ProcedureCompiler } from '../capabilities/procedure-compiler.js';
 import {
   SelectQueryNode,
   InsertQueryNode,
@@ -21,7 +22,7 @@ const toProcedureParamReference = (value: string): string =>
 /**
  * Microsoft SQL Server dialect implementation
  */
-export class SqlServerDialect extends SqlDialectBase {
+export class SqlServerDialect extends SqlDialectBase implements ProcedureCompiler {
   protected readonly dialect = 'mssql';
   /**
    * Creates a new SqlServerDialect instance

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

@@ -1,4 +1,5 @@
-import { CompilerContext, CompiledProcedureCall } from '../abstract.js';
+import { CompilerContext } from '../abstract.js';
+import type { CompiledProcedureCall, ProcedureCompiler } from '../capabilities/procedure-compiler.js';
 import { JsonPathNode, IsDistinctExpressionNode } from '../../ast/expression.js';
 import { InsertQueryNode } from '../../ast/query.js';
 import { SqlDialectBase } from '../base/sql-dialect.js';
@@ -11,7 +12,7 @@ const sanitizeVariableSuffix = (value: string): string =>
 /**
  * MySQL dialect implementation
  */
-export class MySqlDialect extends SqlDialectBase {
+export class MySqlDialect extends SqlDialectBase implements ProcedureCompiler {
   protected readonly dialect = 'mysql';
   /**
    * Creates a new MySqlDialect instance

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

@@ -1,4 +1,5 @@
-import { CompilerContext, CompiledProcedureCall } from '../abstract.js';
+import { CompilerContext } from '../abstract.js';
+import type { CompiledProcedureCall, ProcedureCompiler } from '../capabilities/procedure-compiler.js';
 import { JsonPathNode, ColumnNode, BitwiseExpressionNode } from '../../ast/expression.js';
 import { InsertQueryNode, TableNode } from '../../ast/query.js';
 import { SqlDialectBase } from '../base/sql-dialect.js';
@@ -9,7 +10,7 @@ import { ProcedureCallNode } from '../../ast/procedure.js';
 /**
  * PostgreSQL dialect implementation
  */
-export class PostgresDialect extends SqlDialectBase {
+export class PostgresDialect extends SqlDialectBase implements ProcedureCompiler {
   protected readonly dialect = 'postgres';
   /**
    * Creates a new PostgresDialect instance

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

@@ -1,9 +1,8 @@
-import { CompilerContext, CompiledProcedureCall } from '../abstract.js';
+import { CompilerContext } from '../abstract.js';
 import { JsonPathNode, ColumnNode, BitwiseExpressionNode } from '../../ast/expression.js';
 import { InsertQueryNode, TableNode } from '../../ast/query.js';
 import { SqlDialectBase } from '../base/sql-dialect.js';
 import { SqliteFunctionStrategy } from './functions.js';
-import { ProcedureCallNode } from '../../ast/procedure.js';
 
 /**
  * SQLite dialect implementation
@@ -104,9 +103,4 @@ export class SqliteDialect extends SqlDialectBase {
   supportsDmlReturningClause(): boolean {
     return true;
   }
-
-  compileProcedureCall(_ast: ProcedureCallNode): CompiledProcedureCall {
-    void _ast;
-    throw new Error('Stored procedures are not supported by the SQLite dialect.');
-  }
 }

package/src/index.ts

@@ -17,6 +17,15 @@ export * from './core/ast/expression.js';
 export * from './core/ast/procedure.js';
 export * from './core/ast/window-functions.js';
 export * from './core/hydration/types.js';
+export * from './core/dialect/abstract.js';
+export * from './core/dialect/dialect-factory.js';
+export * from './core/dialect/capabilities/procedure-compiler.js';
+export * from './core/dialect/base/standard-sql-services.js';
+export * from './core/dialect/base/standard-sql-source-compiler.js';
+export * from './core/dialect/base/standard-select-compiler.js';
+export * from './core/dialect/base/standard-insert-compiler.js';
+export * from './core/dialect/base/standard-update-compiler.js';
+export * from './core/dialect/base/standard-delete-compiler.js';
 export * from './core/dialect/mysql/index.js';
 export * from './core/dialect/mssql/index.js';
 export * from './core/dialect/sqlite/index.js';
@@ -85,4 +94,4 @@ export * from './tree/index.js';
 export * from './cache/index.js';
 
 // Bulk operations module
-export * from './bulk/index.js';
+export * from './bulk/index.js';

package/src/orm/execute-procedure.ts

@@ -1,7 +1,8 @@
 import type { ProcedureCallNode } from '../core/ast/procedure.js';
 import type { QueryResult } from '../core/execution/db-executor.js';
 import { payloadResultSets } from '../core/execution/db-executor.js';
-import type { CompiledProcedureCall } from '../core/dialect/abstract.js';
+import type { CompiledProcedureCall } from '../core/dialect/capabilities/procedure-compiler.js';
+import { requireProcedureCompiler } from '../core/dialect/capabilities/procedure-compiler.js';
 import type { OrmSession } from './orm-session.js';
 
 export interface ProcedureExecutionResult {
@@ -63,7 +64,7 @@ export const executeProcedureAst = async (
   ast: ProcedureCallNode
 ): Promise<ProcedureExecutionResult> => {
   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

package/src/query-builder/procedure-call.ts

@@ -1,5 +1,7 @@
 import type { ProcedureCallNode, ProcedureParamNode } from '../core/ast/procedure.js';
-import type { CompiledProcedureCall, Dialect } from '../core/dialect/abstract.js';
+import type { Dialect } from '../core/dialect/abstract.js';
+import type { CompiledProcedureCall } from '../core/dialect/capabilities/procedure-compiler.js';
+import { requireProcedureCompiler } from '../core/dialect/capabilities/procedure-compiler.js';
 import { DialectKey, resolveDialectInput } from '../core/dialect/dialect-factory.js';
 import { valueToOperand, ValueOperandInput } from '../core/ast/expression-builders.js';
 import type { OrmSession } from '../orm/orm-session.js';
@@ -82,8 +84,7 @@ export class ProcedureCallBuilder {
 
   compile(dialect: ProcedureDialectInput): CompiledProcedureCall {
     const resolved = resolveDialectInput(dialect);
-    this.validateMssqlOutDbType(resolved);
-    return resolved.compileProcedureCall(this.getAST());
+    return requireProcedureCompiler(resolved).compileProcedureCall(this.getAST());
   }
 
   toSql(dialect: ProcedureDialectInput): string {
@@ -99,23 +100,8 @@ export class ProcedureCallBuilder {
   }
 
   async execute(session: OrmSession): Promise<ProcedureExecutionResult> {
-    this.validateMssqlOutDbType(session.getExecutionContext().dialect);
     return executeProcedureAst(session, this.getAST());
   }
-
-  private validateMssqlOutDbType(dialect: Dialect): void {
-    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}".`
-        );
-      }
-    }
-  }
 }
 
 export const callProcedure = (name: string, options?: CallProcedureOptions): ProcedureCallBuilder =>