metal-orm 1.1.23 → 1.1.25

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

@@ -0,0 +1,82 @@
+import type { CompilerContext } from '../abstract.js';
+import type { SelectQueryNode } from '../../ast/query.js';
+import { CteCompiler } from './cte-compiler.js';
+import { JoinCompiler } from './join-compiler.js';
+import { GroupByCompiler } from './groupby-compiler.js';
+import { OrderByCompiler } from './orderby-compiler.js';
+import { StandardSqlSourceCompiler } from './standard-sql-source-compiler.js';
+import type { StandardSqlCompilerServices } from './standard-sql-services.js';
+
+/** Standard SELECT orchestration, independent from any dialect class hierarchy. */
+export class StandardSelectCompiler {
+  public constructor(
+    private readonly services: StandardSqlCompilerServices,
+    private readonly sources: StandardSqlSourceCompiler
+  ) {}
+
+  compile(ast: SelectQueryNode, ctx: CompilerContext): string {
+    const hasSetOps = !!(ast.setOps && ast.setOps.length);
+    const ctes = CteCompiler.compileCtes(
+      ast,
+      ctx,
+      id => this.services.quoteIdentifier(id),
+      (query, compilerContext) => this.services.compileSelectAst(query, compilerContext),
+      query => this.services.normalizeSelectAst(query),
+      sql => this.sources.stripTrailingSemicolon(sql)
+    );
+
+    const baseAst: SelectQueryNode = hasSetOps
+      ? { ...ast, setOps: undefined, orderBy: undefined, limit: undefined, offset: undefined }
+      : ast;
+    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}`;
+  }
+
+  private compileCore(ast: SelectQueryNode, ctx: CompilerContext): string {
+    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.services.compileOrderingTerm(term, ctx)
+    );
+    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}`;
+  }
+
+  private compileColumns(ast: SelectQueryNode, ctx: CompilerContext): string {
+    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(', ');
+  }
+
+  private compileOrderBy(ast: SelectQueryNode, ctx: CompilerContext): string {
+    return OrderByCompiler.compileOrderBy(
+      ast,
+      term => this.services.compileOrderingTerm(term, ctx),
+      order => this.services.renderOrderByNulls(order),
+      order => this.services.renderOrderByCollation(order)
+    );
+  }
+}

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

@@ -0,0 +1,44 @@
+import type { CompilerContext } from '../abstract.js';
+import type {
+  SelectQueryNode,
+  InsertQueryNode,
+  OrderByNode,
+  OrderingTerm,
+  TableNode
+} from '../../ast/query.js';
+import type {
+  ColumnNode,
+  ExpressionNode,
+  OperandNode
+} from '../../ast/expression.js';
+import type { DialectName } from '../../sql/sql.js';
+import type { PaginationStrategy } from './pagination-strategy.js';
+import type { TableFunctionStrategy } from '../../functions/table-types.js';
+
+/**
+ * Narrow callback surface consumed by the standard SQL compilers.
+ *
+ * The compilers deliberately know nothing about SqlDialectBase or any concrete
+ * backend class. A dialect can assemble these services through inheritance,
+ * composition, or a plain object.
+ */
+export interface StandardSqlCompilerServices {
+  getDialectName(): DialectName;
+  getPaginationStrategy(): PaginationStrategy;
+  getTableFunctionStrategy(): TableFunctionStrategy;
+
+  quoteIdentifier(id: string): string;
+  compileOperand(node: OperandNode, ctx: CompilerContext): string;
+  compileExpression(node: ExpressionNode, ctx: CompilerContext): string;
+  compileOrderingTerm(term: OrderingTerm, ctx: CompilerContext): string;
+
+  normalizeSelectAst(ast: SelectQueryNode): SelectQueryNode;
+  compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string;
+
+  compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string;
+  compileUpsertClause(ast: InsertQueryNode, ctx: CompilerContext): string;
+  compileSetTarget(column: ColumnNode, table: TableNode): string;
+
+  renderOrderByNulls(order: OrderByNode): string | undefined;
+  renderOrderByCollation(order: OrderByNode): string | undefined;
+}

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/base/upsert-strategy.ts

@@ -0,0 +1,45 @@
+import type { CompilerContext } from '../abstract.js';
+import type {
+  InsertQueryNode,
+  TableNode,
+  UpdateAssignmentNode
+} from '../../ast/query.js';
+import type { ExpressionNode, OperandNode } from '../../ast/expression.js';
+import type { DialectName } from '../../sql/sql.js';
+
+/** Narrow services needed by backend-specific UPSERT implementations. */
+export interface UpsertCompilationServices {
+  getDialectName(): DialectName;
+  quoteIdentifier(id: string): string;
+  compileOperand(node: OperandNode, ctx: CompilerContext): string;
+  compileExpression(node: ExpressionNode, ctx: CompilerContext): string;
+  compileUpdateAssignments(
+    assignments: UpdateAssignmentNode[],
+    table: TableNode,
+    ctx: CompilerContext
+  ): string;
+}
+
+/** Backend-specific INSERT conflict/upsert rendering strategy. */
+export interface UpsertStrategy {
+  compile(
+    ast: InsertQueryNode,
+    ctx: CompilerContext,
+    services: UpsertCompilationServices
+  ): string;
+}
+
+/** Default strategy for dialects without UPSERT support. */
+export class NoUpsertStrategy implements UpsertStrategy {
+  compile(
+    ast: InsertQueryNode,
+    _ctx: CompilerContext,
+    services: UpsertCompilationServices
+  ): string {
+    void _ctx;
+    if (!ast.onConflict) return '';
+    throw new Error(
+      `UPSERT/ON CONFLICT is not supported by dialect "${services.getDialectName()}".`
+    );
+  }
+}

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

@@ -1,5 +1,6 @@
 import type { ProcedureCallNode } from '../../ast/procedure.js';
-import type { CompiledQuery } from '../abstract.js';
+import type { OperandNode } from '../../ast/expression.js';
+import type { CompiledQuery, CompilerContext } from '../abstract.js';
 
 export interface CompiledProcedureCall extends CompiledQuery {
   outParams: {
@@ -8,13 +9,14 @@ export interface CompiledProcedureCall extends CompiledQuery {
   };
 }
 
-/**
- * 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.
- */
+/** Narrow SQL services consumed by reusable procedure compiler components. */
+export interface ProcedureCompilerServices {
+  quoteIdentifier(id: string): string;
+  createCompilerContext(): CompilerContext;
+  compileOperand(node: OperandNode, ctx: CompilerContext): string;
+}
+
+/** Optional dialect capability for stored-procedure compilation. */
 export interface ProcedureCompiler {
   compileProcedureCall(ast: ProcedureCallNode): CompiledProcedureCall;
 }

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

@@ -0,0 +1,12 @@
+import type { SqlCompilerFactory } from '../base/sql-compiler-set.js';
+import { MssqlDeleteCompiler } from './delete-compiler.js';
+import { MssqlInsertCompiler } from './insert-compiler.js';
+import { MssqlSelectCompiler } from './select-compiler.js';
+import { MssqlUpdateCompiler } from './update-compiler.js';
+
+export const createMssqlCompilerSet: SqlCompilerFactory = ({ services, sources }) => ({
+  select: new MssqlSelectCompiler(services, sources),
+  insert: new MssqlInsertCompiler(services, sources),
+  update: new MssqlUpdateCompiler(services, sources),
+  delete: new MssqlDeleteCompiler(services, sources)
+});

package/src/core/dialect/mssql/delete-compiler.ts

@@ -0,0 +1,40 @@
+import type { DeleteQueryNode } from '../../ast/query.js';
+import type { CompilerContext } from '../abstract.js';
+import { JoinCompiler } from '../base/join-compiler.js';
+import type { SqlAstCompiler } from '../base/sql-compiler-set.js';
+import type { StandardSqlCompilerServices } from '../base/standard-sql-services.js';
+import type { StandardSqlSourceCompiler } from '../base/standard-sql-source-compiler.js';
+import { MssqlOutputStrategy } from './output.js';
+
+export class MssqlDeleteCompiler implements SqlAstCompiler<DeleteQueryNode> {
+  private readonly output = new MssqlOutputStrategy();
+
+  constructor(
+    private readonly services: StandardSqlCompilerServices,
+    private readonly sources: StandardSqlSourceCompiler
+  ) {}
+
+  compile(ast: DeleteQueryNode, ctx: CompilerContext): string {
+    if (ast.using) {
+      throw new Error('DELETE ... USING is not supported in the MSSQL dialect; use join() instead.');
+    }
+
+    const alias = ast.from.alias ?? ast.from.name;
+    const target = this.sources.compileTableReference(ast.from);
+    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 returning = this.output.compileOutput(
+      ast.returning,
+      'deleted',
+      id => this.services.quoteIdentifier(id)
+    );
+    return `DELETE ${this.services.quoteIdentifier(alias)}${returning} FROM ${target}${joins}${where}`;
+  }
+}