metal-orm 1.1.3 → 1.1.5

package/src/query-builder/insert.ts

@@ -1,20 +1,111 @@
-import type { SelectQueryBuilder } from './select.js';
-import { TableDef } from '../schema/table.js';
-import { ColumnDef } from '../schema/column-types.js';
-import { ColumnNode } from '../core/ast/expression.js';
+import type { SelectQueryBuilder } from './select.js';
+import { TableDef } from '../schema/table.js';
+import { ColumnDef } from '../schema/column-types.js';
+import {
+  ColumnNode,
+  ExpressionNode,
+  isValueOperandInput,
+  valueToOperand
+} from '../core/ast/expression.js';
 import type { ValueOperandInput } from '../core/ast/expression.js';
-import { CompiledQuery, InsertCompiler, Dialect } from '../core/dialect/abstract.js';
-import { DialectKey, resolveDialectInput } from '../core/dialect/dialect-factory.js';
-import { InsertQueryNode, SelectQueryNode } from '../core/ast/query.js';
-import { InsertQueryState } from './insert-query-state.js';
-import { buildColumnNode } from '../core/ast/builders.js';
-
-type InsertDialectInput = Dialect | DialectKey;
-
-/**
- * Builder for INSERT queries
- */
-export class InsertQueryBuilder<T> {
+import { CompiledQuery, InsertCompiler, Dialect } from '../core/dialect/abstract.js';
+import { DialectKey, resolveDialectInput } from '../core/dialect/dialect-factory.js';
+import {
+  InsertQueryNode,
+  SelectQueryNode,
+  UpsertClause,
+  UpdateAssignmentNode
+} from '../core/ast/query.js';
+import { InsertQueryState } from './insert-query-state.js';
+import { buildColumnNode } from '../core/ast/builders.js';
+
+type InsertDialectInput = Dialect | DialectKey;
+
+/**
+ * Builder returned by InsertQueryBuilder.onConflict()
+ */
+export class ConflictBuilder<T> {
+  private readonly table: TableDef;
+  private readonly columns: ColumnNode[];
+  private readonly constraint?: string;
+  private readonly applyClause: (clause: UpsertClause) => InsertQueryBuilder<T>;
+
+  constructor(
+    table: TableDef,
+    columns: ColumnNode[],
+    constraint: string | undefined,
+    applyClause: (clause: UpsertClause) => InsertQueryBuilder<T>
+  ) {
+    this.table = table;
+    this.columns = columns;
+    this.constraint = constraint;
+    this.applyClause = applyClause;
+  }
+
+  /**
+   * Adds ON CONFLICT ... DO UPDATE
+   * @param set - Column assignments for update branch
+   * @param where - Optional filter for update branch
+   * @returns InsertQueryBuilder with the upsert clause configured
+   */
+  doUpdate(
+    set: Record<string, ValueOperandInput>,
+    where?: ExpressionNode
+  ): InsertQueryBuilder<T> {
+    const assignments = this.buildAssignments(set);
+    return this.applyClause({
+      target: this.buildTarget(),
+      action: {
+        type: 'DoUpdate',
+        set: assignments,
+        where
+      }
+    });
+  }
+
+  /**
+   * Adds ON CONFLICT ... DO NOTHING
+   * @returns InsertQueryBuilder with the upsert clause configured
+   */
+  doNothing(): InsertQueryBuilder<T> {
+    return this.applyClause({
+      target: this.buildTarget(),
+      action: { type: 'DoNothing' }
+    });
+  }
+
+  private buildTarget(): UpsertClause['target'] {
+    return {
+      columns: [...this.columns],
+      constraint: this.constraint
+    };
+  }
+
+  private buildAssignments(set: Record<string, ValueOperandInput>): UpdateAssignmentNode[] {
+    const entries = Object.entries(set);
+    if (!entries.length) {
+      throw new Error('ON CONFLICT DO UPDATE requires at least one assignment.');
+    }
+
+    return entries.map(([columnName, rawValue]) => {
+      if (!isValueOperandInput(rawValue)) {
+        throw new Error(
+          `Invalid upsert value for column "${columnName}": only string, number, boolean, Date, Buffer, null, or OperandNodes are allowed`
+        );
+      }
+
+      return {
+        column: buildColumnNode(this.table, { name: columnName, table: this.table.name }),
+        value: valueToOperand(rawValue)
+      };
+    });
+  }
+}
+
+/**
+ * Builder for INSERT queries
+ */
+export class InsertQueryBuilder<T> {
   private readonly table: TableDef;
   private readonly state: InsertQueryState;
 
@@ -28,18 +119,22 @@ export class InsertQueryBuilder<T> {
     this.state = state ?? new InsertQueryState(table);
   }
 
-  private clone(state: InsertQueryState): InsertQueryBuilder<T> {
-    return new InsertQueryBuilder(this.table, state);
-  }
+  private clone(state: InsertQueryState): InsertQueryBuilder<T> {
+    return new InsertQueryBuilder(this.table, state);
+  }
+
+  private withOnConflict(clause: UpsertClause): InsertQueryBuilder<T> {
+    return this.clone(this.state.withOnConflict(clause));
+  }
 
   /**
    * Adds VALUES to the INSERT query
    * @param rowOrRows - Single row object or array of row objects to insert
    * @returns A new InsertQueryBuilder with the VALUES clause added
    */
-  values(
-    rowOrRows: Record<string, ValueOperandInput> | Record<string, ValueOperandInput>[]
-  ): InsertQueryBuilder<T> {
+  values(
+    rowOrRows: Record<string, ValueOperandInput> | Record<string, ValueOperandInput>[]
+  ): InsertQueryBuilder<T> {
     const rows = Array.isArray(rowOrRows) ? rowOrRows : [rowOrRows];
     if (!rows.length) return this;
     return this.clone(this.state.withValues(rows));
@@ -62,14 +157,33 @@ export class InsertQueryBuilder<T> {
    * @param columns - Optional target columns for the INSERT
    * @returns A new InsertQueryBuilder with the SELECT source
    */
-  fromSelect<TSource extends TableDef>(
-    query: SelectQueryNode | SelectQueryBuilder<unknown, TSource>,
-    columns: (ColumnDef | ColumnNode)[] = []
-  ): InsertQueryBuilder<T> {
+  fromSelect<TSource extends TableDef>(
+    query: SelectQueryNode | SelectQueryBuilder<unknown, TSource>,
+    columns: (ColumnDef | ColumnNode)[] = []
+  ): InsertQueryBuilder<T> {
     const ast = this.resolveSelectQuery(query);
     const nodes = columns.length ? this.resolveColumnNodes(columns) : [];
-    return this.clone(this.state.withSelect(ast, nodes));
-  }
+    return this.clone(this.state.withSelect(ast, nodes));
+  }
+
+  /**
+   * Configures UPSERT conflict handling for INSERT.
+   * @param columns - Conflict target columns (ignored by MySQL)
+   * @param constraint - Named unique/primary constraint (PostgreSQL only)
+   * @returns ConflictBuilder for selecting action (DO UPDATE / DO NOTHING)
+   */
+  onConflict(
+    columns: (ColumnDef | ColumnNode)[] = [],
+    constraint?: string
+  ): ConflictBuilder<T> {
+    const resolvedColumns = columns.length ? this.resolveColumnNodes(columns) : [];
+    return new ConflictBuilder(
+      this.table,
+      resolvedColumns,
+      constraint,
+      clause => this.withOnConflict(clause)
+    );
+  }
 
   /**
    * Adds a RETURNING clause to the INSERT query

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

@@ -0,0 +1,122 @@
+import type { ProcedureCallNode, ProcedureParamNode } from '../core/ast/procedure.js';
+import type { CompiledProcedureCall, Dialect } from '../core/dialect/abstract.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';
+import { executeProcedureAst, type ProcedureExecutionResult } from '../orm/execute-procedure.js';
+
+type ProcedureDialectInput = Dialect | DialectKey;
+
+export interface CallProcedureOptions {
+  schema?: string;
+}
+
+export interface ProcedureOutOptions {
+  dbType?: string;
+}
+
+const cloneParam = (param: ProcedureParamNode): ProcedureParamNode => ({
+  ...param,
+  value: param.value ? { ...param.value } : undefined
+});
+
+export class ProcedureCallBuilder {
+  private readonly ast: ProcedureCallNode;
+
+  constructor(name: string, options?: CallProcedureOptions, ast?: ProcedureCallNode) {
+    this.ast = ast ?? {
+      type: 'ProcedureCall',
+      ref: {
+        name,
+        schema: options?.schema
+      },
+      params: []
+    };
+  }
+
+  private clone(nextParams: ProcedureParamNode[]): ProcedureCallBuilder {
+    return new ProcedureCallBuilder(
+      this.ast.ref.name,
+      { schema: this.ast.ref.schema },
+      {
+        ...this.ast,
+        ref: { ...this.ast.ref },
+        params: nextParams
+      }
+    );
+  }
+
+  in(name: string, value: ValueOperandInput): ProcedureCallBuilder {
+    return this.clone([
+      ...this.ast.params.map(cloneParam),
+      {
+        name,
+        direction: 'in',
+        value: valueToOperand(value)
+      }
+    ]);
+  }
+
+  out(name: string, options?: ProcedureOutOptions): ProcedureCallBuilder {
+    return this.clone([
+      ...this.ast.params.map(cloneParam),
+      {
+        name,
+        direction: 'out',
+        dbType: options?.dbType
+      }
+    ]);
+  }
+
+  inOut(name: string, value: ValueOperandInput, options?: ProcedureOutOptions): ProcedureCallBuilder {
+    return this.clone([
+      ...this.ast.params.map(cloneParam),
+      {
+        name,
+        direction: 'inout',
+        value: valueToOperand(value),
+        dbType: options?.dbType
+      }
+    ]);
+  }
+
+  compile(dialect: ProcedureDialectInput): CompiledProcedureCall {
+    const resolved = resolveDialectInput(dialect);
+    this.validateMssqlOutDbType(resolved);
+    return resolved.compileProcedureCall(this.getAST());
+  }
+
+  toSql(dialect: ProcedureDialectInput): string {
+    return this.compile(dialect).sql;
+  }
+
+  getAST(): ProcedureCallNode {
+    return {
+      ...this.ast,
+      ref: { ...this.ast.ref },
+      params: this.ast.params.map(cloneParam)
+    };
+  }
+
+  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 =>
+  new ProcedureCallBuilder(name, options);

package/src/query-builder/select/select-operations.ts

@@ -11,6 +11,7 @@ import { ORDER_DIRECTIONS, OrderDirection } from '../../core/sql/sql.js';
 import { OrmSession } from '../../orm/orm-session.js';
 import type { SelectQueryBuilder } from '../select.js';
 import { findPrimaryKey } from '../hydration-planner.js';
+import { payloadResultSets } from '../../core/execution/db-executor.js';
 
 export type WhereHasOptions = {
   correlate?: ExpressionNode;
@@ -99,7 +100,8 @@ export async function executeCount(
 
   const execCtx = session.getExecutionContext();
   const compiled = execCtx.dialect.compileSelect(countQuery);
-  const results = await execCtx.interceptors.run({ sql: compiled.sql, params: compiled.params }, execCtx.executor);
+  const payload = await execCtx.interceptors.run({ sql: compiled.sql, params: compiled.params }, execCtx.executor);
+  const results = payloadResultSets(payload);
   const value = results[0]?.values?.[0]?.[0];
 
   if (typeof value === 'number') return value;
@@ -145,7 +147,8 @@ export async function executeCountRows(
 
   const execCtx = session.getExecutionContext();
   const compiled = execCtx.dialect.compileSelect(countQuery);
-  const results = await execCtx.interceptors.run({ sql: compiled.sql, params: compiled.params }, execCtx.executor);
+  const payload = await execCtx.interceptors.run({ sql: compiled.sql, params: compiled.params }, execCtx.executor);
+  const results = payloadResultSets(payload);
   const value = results[0]?.values?.[0]?.[0];
 
   if (typeof value === 'number') return value;