metal-orm 1.1.24 → 1.1.26

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

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

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

@@ -0,0 +1,44 @@
+import type { CompilerContext } from '../abstract.js';
+import type {
+  InsertQueryNode,
+  TableNode,
+  UpdateAssignmentNode
+} from '../../ast/query.js';
+import type { ExpressionNode, OperandNode } from '../../ast/expression.js';
+
+/** Narrow services needed by backend-specific UPSERT implementations. */
+export interface UpsertCompilationServices {
+  getDialectName(): string;
+  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/dialect-factory.ts

@@ -1,20 +1,20 @@
 // Dialect factory for the SQL DSL.
-// Centralizes how we go from a symbolic name ("sqlite") to a concrete Dialect instance.
+// Centralizes how we go from a symbolic name ("sqlite") to a structural Dialect.
 
 import type { Dialect } from './abstract.js';
-import { PostgresDialect } from './postgres/index.js';
-import { MySqlDialect } from './mysql/index.js';
-import { SqliteDialect } from './sqlite/index.js';
-import { SqlServerDialect } from './mssql/index.js';
+import { createPostgresDialect } from './postgres/index.js';
+import { createMySqlDialect } from './mysql/index.js';
+import { createSqliteDialect } from './sqlite/index.js';
+import { createSqlServerDialect } from './mssql/index.js';
 
 export type DialectKey =
   | 'postgres'
   | 'mysql'
   | 'sqlite'
   | 'mssql'
-  | (string & {}); // allow user-defined keys without constraining too much
+  | (string & {});
 
-type DialectFactoryFn = () => Dialect;
+export type DialectFactoryFn = () => Dialect;
 
 export class DialectFactory {
   private static registry = new Map<DialectKey, DialectFactoryFn>();
@@ -24,67 +24,35 @@ export class DialectFactory {
     if (this.defaultsInitialized) return;
     this.defaultsInitialized = true;
 
-    // Register built-in dialects only if no override exists yet.
-    if (!this.registry.has('postgres')) {
-      this.registry.set('postgres', () => new PostgresDialect());
-    }
-    if (!this.registry.has('mysql')) {
-      this.registry.set('mysql', () => new MySqlDialect());
-    }
-    if (!this.registry.has('sqlite')) {
-      this.registry.set('sqlite', () => new SqliteDialect());
-    }
-    if (!this.registry.has('mssql')) {
-      this.registry.set('mssql', () => new SqlServerDialect());
-    }
+    if (!this.registry.has('postgres')) this.registry.set('postgres', createPostgresDialect);
+    if (!this.registry.has('mysql')) this.registry.set('mysql', createMySqlDialect);
+    if (!this.registry.has('sqlite')) this.registry.set('sqlite', createSqliteDialect);
+    if (!this.registry.has('mssql')) this.registry.set('mssql', createSqlServerDialect);
   }
 
-  /**
-   * Register (or override) a dialect factory for a key.
-   *
-   * Implementations are structural: extending DialectBase/SqlDialectBase is
-   * optional. A composed object satisfying Dialect is a valid registration.
-   */
+  /** Register or replace a structural dialect factory. */
   public static register(key: DialectKey, factory: DialectFactoryFn): void {
     this.registry.set(key, factory);
   }
 
-  /**
-   * Resolve a key into a Dialect instance.
-   * Throws if the key is not registered.
-   */
+  /** Resolve a key into a new Dialect instance. */
   public static create(key: DialectKey): Dialect {
     this.ensureDefaults();
     const factory = this.registry.get(key);
     if (!factory) {
       throw new Error(
-        `Dialect "${String(
-          key
-        )}" is not registered. Use DialectFactory.register(...) to register it.`
+        `Dialect "${String(key)}" is not registered. Use DialectFactory.register(...) to register it.`
       );
     }
     return factory();
   }
 
-  /**
-   * Clear all registrations (mainly for tests).
-   * Built-ins will be re-registered lazily on the next create().
-   */
+  /** Clear registrations; built-ins are restored lazily on the next create(). */
   public static clear(): void {
     this.registry.clear();
     this.defaultsInitialized = false;
   }
 }
 
-/**
- * Helper to normalize either a Dialect instance OR a key into a Dialect instance.
- * This is what query builders will use.
- */
-export const resolveDialectInput = (
-  dialect: Dialect | DialectKey
-): Dialect => {
-  if (typeof dialect === 'string') {
-    return DialectFactory.create(dialect);
-  }
-  return dialect;
-};
+export const resolveDialectInput = (dialect: Dialect | DialectKey): Dialect =>
+  typeof dialect === 'string' ? DialectFactory.create(dialect) : dialect;

package/src/core/dialect/mssql/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}`;
+  }
+}