metal-orm 1.1.10 → 1.1.16

package/src/query-builder/delete.ts

@@ -1,148 +1,148 @@
-import { TableDef } from '../schema/table.js';
-import { ColumnDef } from '../schema/column-types.js';
-import { ColumnNode, ExpressionNode } from '../core/ast/expression.js';
-import { JOIN_KINDS, JoinKind } from '../core/sql/sql.js';
-import { CompiledQuery, Dialect } from '../core/dialect/abstract.js';
-import { DialectKey, resolveDialectInput } from '../core/dialect/dialect-factory.js';
-import { TableSourceNode, DeleteQueryNode } from '../core/ast/query.js';
-import { DeleteQueryState } from './delete-query-state.js';
-import { createJoinNode } from '../core/ast/join-node.js';
-import { buildColumnNode } from '../core/ast/builders.js';
-import { OrmSession } from '../orm/orm-session.js';
+import { TableDef } from '../schema/table.js';
+import { ColumnDef } from '../schema/column-types.js';
+import { ColumnNode, ExpressionNode } from '../core/ast/expression.js';
+import { JOIN_KINDS, JoinKind } from '../core/sql/sql.js';
+import { CompiledQuery, Dialect } from '../core/dialect/abstract.js';
+import { DialectKey, resolveDialectInput } from '../core/dialect/dialect-factory.js';
+import { TableSourceNode, DeleteQueryNode } from '../core/ast/query.js';
+import { DeleteQueryState } from './delete-query-state.js';
+import { createJoinNode } from '../core/ast/join-node.js';
+import { buildColumnNode } from '../core/ast/builders.js';
+import { OrmSession } from '../orm/orm-session.js';
 import { payloadResultSets, QueryResult } from '../core/execution/db-executor.js';
-
-type DeleteDialectInput = Dialect | DialectKey;
-
-/**
- * Builder for DELETE queries
- */
-export class DeleteQueryBuilder<T> {
-  private readonly table: TableDef;
-  private readonly state: DeleteQueryState;
-
-  /**
-   * Creates a new DeleteQueryBuilder instance
-   * @param table - The table definition for the DELETE query
-   * @param state - Optional initial query state, defaults to a new DeleteQueryState
-   */
-  constructor(table: TableDef, state?: DeleteQueryState) {
-    this.table = table;
-    this.state = state ?? new DeleteQueryState(table);
-  }
-
-  private clone(state: DeleteQueryState): DeleteQueryBuilder<T> {
-    return new DeleteQueryBuilder(this.table, state);
-  }
-
-  /**
-   * Adds a WHERE clause to the DELETE query
-   * @param expr - The expression to use as the WHERE condition
-   * @returns A new DeleteQueryBuilder with the WHERE clause added
-   */
-  where(expr: ExpressionNode): DeleteQueryBuilder<T> {
-    return this.clone(this.state.withWhere(expr));
-  }
-
-  /**
-   * Sets an alias for the table in the DELETE query
-   * @param alias - The alias to assign to the table
-   * @returns A new DeleteQueryBuilder with the table alias set
-   */
-  as(alias: string): DeleteQueryBuilder<T> {
-    return this.clone(this.state.withTableAlias(alias));
-  }
-
-  /**
-   * Adds a USING clause to the DELETE query
-   * @param source - The table source to use in the USING clause
-   * @returns A new DeleteQueryBuilder with the USING clause added
-   */
-  using(source: TableDef | TableSourceNode): DeleteQueryBuilder<T> {
-    return this.clone(this.state.withUsing(this.resolveTableSource(source)));
-  }
-
-  /**
-   * Adds a JOIN clause to the DELETE query
-   * @param table - The table to join with
-   * @param condition - The join condition expression
-   * @param kind - The type of join (defaults to INNER)
-   * @param relationName - Optional name for the relation
-   * @returns A new DeleteQueryBuilder with the JOIN clause added
-   */
-  join(
-    table: TableDef | TableSourceNode | string,
-    condition: ExpressionNode,
-    kind: JoinKind = JOIN_KINDS.INNER,
-    relationName?: string
-  ): DeleteQueryBuilder<T> {
-    const target = this.resolveJoinTarget(table);
-    const joinNode = createJoinNode(kind, target, condition, relationName);
-    return this.clone(this.state.withJoin(joinNode));
-  }
-
-  /**
-   * Adds a RETURNING clause to the DELETE query
-   * @param columns - The columns to return after deletion
-   * @returns A new DeleteQueryBuilder with the RETURNING clause added
-   */
-  returning(...columns: (ColumnDef | ColumnNode)[]): DeleteQueryBuilder<T> {
-    if (!columns.length) return this;
-    const nodes = columns.map(column => buildColumnNode(this.table, column));
-    return this.clone(this.state.withReturning(nodes));
-  }
-
-  private resolveTableSource(source: TableDef | TableSourceNode): TableSourceNode {
-    if (isTableSourceNode(source)) {
-      return source;
-    }
-    return { type: 'Table', name: source.name, schema: source.schema };
-  }
-
-  private resolveJoinTarget(table: TableDef | TableSourceNode | string): TableSourceNode | string {
-    if (typeof table === 'string') return table;
-    return this.resolveTableSource(table);
-  }
-
-  /**
-   * Compiles the DELETE query for the specified dialect
-   * @param dialect - The SQL dialect to compile for
-   * @returns The compiled query with SQL and parameters
-   */
-  compile(dialect: DeleteDialectInput): CompiledQuery {
-    const resolved = resolveDialectInput(dialect);
-    return resolved.compileDelete(this.state.ast);
-  }
-
-  /**
-   * Returns the SQL string for the DELETE query
-   * @param dialect - The SQL dialect to generate SQL for
-   * @returns The SQL string representation of the query
-   */
-  toSql(dialect: DeleteDialectInput): string {
-    return this.compile(dialect).sql;
-  }
-
-  /**
-   * Executes the DELETE query using the provided session
-   * @param session - The ORM session to execute the query with
-   * @returns A promise that resolves to the query results
-   */
+
+type DeleteDialectInput = Dialect | DialectKey;
+
+/**
+ * Builder for DELETE queries
+ */
+export class DeleteQueryBuilder<T> {
+  private readonly table: TableDef;
+  private readonly state: DeleteQueryState;
+
+  /**
+   * Creates a new DeleteQueryBuilder instance
+   * @param table - The table definition for the DELETE query
+   * @param state - Optional initial query state, defaults to a new DeleteQueryState
+   */
+  constructor(table: TableDef, state?: DeleteQueryState) {
+    this.table = table;
+    this.state = state ?? new DeleteQueryState(table);
+  }
+
+  private clone(state: DeleteQueryState): DeleteQueryBuilder<T> {
+    return new DeleteQueryBuilder(this.table, state);
+  }
+
+  /**
+   * Adds a WHERE clause to the DELETE query
+   * @param expr - The expression to use as the WHERE condition
+   * @returns A new DeleteQueryBuilder with the WHERE clause added
+   */
+  where(expr: ExpressionNode): DeleteQueryBuilder<T> {
+    return this.clone(this.state.withWhere(expr));
+  }
+
+  /**
+   * Sets an alias for the table in the DELETE query
+   * @param alias - The alias to assign to the table
+   * @returns A new DeleteQueryBuilder with the table alias set
+   */
+  as(alias: string): DeleteQueryBuilder<T> {
+    return this.clone(this.state.withTableAlias(alias));
+  }
+
+  /**
+   * Adds a USING clause to the DELETE query
+   * @param source - The table source to use in the USING clause
+   * @returns A new DeleteQueryBuilder with the USING clause added
+   */
+  using(source: TableDef | TableSourceNode): DeleteQueryBuilder<T> {
+    return this.clone(this.state.withUsing(this.resolveTableSource(source)));
+  }
+
+  /**
+   * Adds a JOIN clause to the DELETE query
+   * @param table - The table to join with
+   * @param condition - The join condition expression
+   * @param kind - The type of join (defaults to INNER)
+   * @param relationName - Optional name for the relation
+   * @returns A new DeleteQueryBuilder with the JOIN clause added
+   */
+  join(
+    table: TableDef | TableSourceNode | string,
+    condition: ExpressionNode,
+    kind: JoinKind = JOIN_KINDS.INNER,
+    relationName?: string
+  ): DeleteQueryBuilder<T> {
+    const target = this.resolveJoinTarget(table);
+    const joinNode = createJoinNode(kind, target, condition, relationName);
+    return this.clone(this.state.withJoin(joinNode));
+  }
+
+  /**
+   * Adds a RETURNING clause to the DELETE query
+   * @param columns - The columns to return after deletion
+   * @returns A new DeleteQueryBuilder with the RETURNING clause added
+   */
+  returning(...columns: (ColumnDef | ColumnNode)[]): DeleteQueryBuilder<T> {
+    if (!columns.length) return this;
+    const nodes = columns.map(column => buildColumnNode(this.table, column));
+    return this.clone(this.state.withReturning(nodes));
+  }
+
+  private resolveTableSource(source: TableDef | TableSourceNode): TableSourceNode {
+    if (isTableSourceNode(source)) {
+      return source;
+    }
+    return { type: 'Table', name: source.name, schema: source.schema };
+  }
+
+  private resolveJoinTarget(table: TableDef | TableSourceNode | string): TableSourceNode | string {
+    if (typeof table === 'string') return table;
+    return this.resolveTableSource(table);
+  }
+
+  /**
+   * Compiles the DELETE query for the specified dialect
+   * @param dialect - The SQL dialect to compile for
+   * @returns The compiled query with SQL and parameters
+   */
+  compile(dialect: DeleteDialectInput): CompiledQuery {
+    const resolved = resolveDialectInput(dialect);
+    return resolved.compileDelete(this.state.ast);
+  }
+
+  /**
+   * Returns the SQL string for the DELETE query
+   * @param dialect - The SQL dialect to generate SQL for
+   * @returns The SQL string representation of the query
+   */
+  toSql(dialect: DeleteDialectInput): string {
+    return this.compile(dialect).sql;
+  }
+
+  /**
+   * Executes the DELETE query using the provided session
+   * @param session - The ORM session to execute the query with
+   * @returns A promise that resolves to the query results
+   */
   async execute(session: OrmSession): Promise<QueryResult[]> {
     const execCtx = session.getExecutionContext();
     const compiled = this.compile(execCtx.dialect);
     const payload = await execCtx.interceptors.run({ sql: compiled.sql, params: compiled.params }, execCtx.executor);
     return payloadResultSets(payload);
   }
-
-  /**
-   * Returns the Abstract Syntax Tree (AST) representation of the query
-   * @returns The AST node for the DELETE query
-   */
-  getAST(): DeleteQueryNode {
-    return this.state.ast;
-  }
-}
-
-const isTableSourceNode = (source: TableDef | TableSourceNode): source is TableSourceNode =>
-  typeof (source as TableSourceNode).type === 'string';
-
+
+  /**
+   * Returns the Abstract Syntax Tree (AST) representation of the query
+   * @returns The AST node for the DELETE query
+   */
+  getAST(): DeleteQueryNode {
+    return this.state.ast;
+  }
+}
+
+const isTableSourceNode = (source: TableDef | TableSourceNode): source is TableSourceNode =>
+  typeof (source as TableSourceNode).type === 'string';
+

package/src/query-builder/insert-query-state.ts

@@ -4,155 +4,155 @@ import {
   ColumnNode,
   OperandNode,
   isValueOperandInput,
-  valueToOperand
-} from '../core/ast/expression.js';
-import type { ValueOperandInput } from '../core/ast/expression.js';
-import {
-  buildColumnNodes,
-  createTableNode
-} from '../core/ast/builders.js';
-
-type InsertRows = Record<string, ValueOperandInput>[];
-
-/**
- * Maintains immutable state for building INSERT queries
- */
-export class InsertQueryState {
-  public readonly table: TableDef;
-  public readonly ast: InsertQueryNode;
-
-  /**
-   * Creates a new InsertQueryState instance
-   * @param table - The table definition for the INSERT query
-   * @param ast - Optional initial AST node, defaults to a basic INSERT query
-   */
-  constructor(table: TableDef, ast?: InsertQueryNode) {
-    this.table = table;
-    this.ast = ast ?? {
-      type: 'InsertQuery',
-      into: createTableNode(table),
-      columns: [],
-      source: {
-        type: 'InsertValues',
-        rows: []
-      }
-    };
-  }
-
-  private clone(nextAst: InsertQueryNode): InsertQueryState {
-    return new InsertQueryState(this.table, nextAst);
-  }
-
-  private ensureColumnsFromRow(rows: InsertRows): ColumnNode[] {
-    if (this.ast.columns.length) return this.ast.columns;
-    return buildColumnNodes(this.table, Object.keys(rows[0]));
-  }
-
-  private appendValues(rows: OperandNode[][]): OperandNode[][] {
-    if (this.ast.source.type === 'InsertValues') {
-      return [...this.ast.source.rows, ...rows];
-    }
-    return rows;
-  }
-
-  private getTableColumns(): ColumnNode[] {
-    const names = Object.keys(this.table.columns);
-    if (!names.length) return [];
-    return buildColumnNodes(this.table, names);
-  }
-
-  /**
-   * Adds VALUES clause to the INSERT query
-   * @param rows - Array of row objects to insert
-   * @returns A new InsertQueryState with the VALUES clause added
-   * @throws Error if mixing VALUES with SELECT source
-   * @throws Error if invalid values are provided
-   */
-  withValues(rows: InsertRows): InsertQueryState {
-    if (!rows.length) return this;
-
-    if (this.ast.source.type === 'InsertSelect') {
-      throw new Error('Cannot mix INSERT ... VALUES with INSERT ... SELECT source.');
-    }
-
-    const definedColumns = this.ensureColumnsFromRow(rows);
-
-    const newRows: OperandNode[][] = rows.map((row, rowIndex) =>
-      definedColumns.map(column => {
-        const rawValue = row[column.name];
-
-        if (!isValueOperandInput(rawValue)) {
-          throw new Error(
-            `Invalid insert value for column "${column.name}" in row ${rowIndex}: only string, number, boolean, Date, Buffer, null, or OperandNodes are allowed`
-          );
-        }
-
-        return valueToOperand(rawValue);
-      })
-    );
-
-    return this.clone({
-      ...this.ast,
-      columns: definedColumns,
-      source: {
-        type: 'InsertValues',
-        rows: this.appendValues(newRows)
-      }
-    });
-  }
-
-  /**
-   * Sets the columns for the INSERT query
-   * @param columns - Column nodes to insert into
-   * @returns A new InsertQueryState with the specified columns
-   */
-  withColumns(columns: ColumnNode[]): InsertQueryState {
-    if (!columns.length) return this;
-    return this.clone({
-      ...this.ast,
-      columns: [...columns]
-    });
-  }
-
-  /**
-   * Adds SELECT source to the INSERT query
-   * @param query - The SELECT query to use as source
-   * @param columns - Target columns for the INSERT
-   * @returns A new InsertQueryState with the SELECT source
-   * @throws Error if mixing SELECT with VALUES source
-   * @throws Error if no destination columns specified
-   */
-  withSelect(query: SelectQueryNode, columns: ColumnNode[]): InsertQueryState {
-    const targetColumns =
-      columns.length
-        ? columns
-        : this.ast.columns.length
-          ? this.ast.columns
-          : this.getTableColumns();
-
-    if (!targetColumns.length) {
-      throw new Error('INSERT ... SELECT requires specifying destination columns.');
-    }
-
-    if (this.ast.source.type === 'InsertValues' && this.ast.source.rows.length) {
-      throw new Error('Cannot mix INSERT ... SELECT with INSERT ... VALUES source.');
-    }
-
-    return this.clone({
-      ...this.ast,
-      columns: [...targetColumns],
-      source: {
-        type: 'InsertSelect',
-        query
-      }
-    });
-  }
-
-  /**
-   * Adds a RETURNING clause to the INSERT query
-   * @param columns - Columns to return after insertion
-   * @returns A new InsertQueryState with the RETURNING clause added
-   */
+  valueToOperand
+} from '../core/ast/expression.js';
+import type { ValueOperandInput } from '../core/ast/expression.js';
+import {
+  buildColumnNodes,
+  createTableNode
+} from '../core/ast/builders.js';
+
+type InsertRows = Record<string, ValueOperandInput>[];
+
+/**
+ * Maintains immutable state for building INSERT queries
+ */
+export class InsertQueryState {
+  public readonly table: TableDef;
+  public readonly ast: InsertQueryNode;
+
+  /**
+   * Creates a new InsertQueryState instance
+   * @param table - The table definition for the INSERT query
+   * @param ast - Optional initial AST node, defaults to a basic INSERT query
+   */
+  constructor(table: TableDef, ast?: InsertQueryNode) {
+    this.table = table;
+    this.ast = ast ?? {
+      type: 'InsertQuery',
+      into: createTableNode(table),
+      columns: [],
+      source: {
+        type: 'InsertValues',
+        rows: []
+      }
+    };
+  }
+
+  private clone(nextAst: InsertQueryNode): InsertQueryState {
+    return new InsertQueryState(this.table, nextAst);
+  }
+
+  private ensureColumnsFromRow(rows: InsertRows): ColumnNode[] {
+    if (this.ast.columns.length) return this.ast.columns;
+    return buildColumnNodes(this.table, Object.keys(rows[0]));
+  }
+
+  private appendValues(rows: OperandNode[][]): OperandNode[][] {
+    if (this.ast.source.type === 'InsertValues') {
+      return [...this.ast.source.rows, ...rows];
+    }
+    return rows;
+  }
+
+  private getTableColumns(): ColumnNode[] {
+    const names = Object.keys(this.table.columns);
+    if (!names.length) return [];
+    return buildColumnNodes(this.table, names);
+  }
+
+  /**
+   * Adds VALUES clause to the INSERT query
+   * @param rows - Array of row objects to insert
+   * @returns A new InsertQueryState with the VALUES clause added
+   * @throws Error if mixing VALUES with SELECT source
+   * @throws Error if invalid values are provided
+   */
+  withValues(rows: InsertRows): InsertQueryState {
+    if (!rows.length) return this;
+
+    if (this.ast.source.type === 'InsertSelect') {
+      throw new Error('Cannot mix INSERT ... VALUES with INSERT ... SELECT source.');
+    }
+
+    const definedColumns = this.ensureColumnsFromRow(rows);
+
+    const newRows: OperandNode[][] = rows.map((row, rowIndex) =>
+      definedColumns.map(column => {
+        const rawValue = row[column.name];
+
+        if (!isValueOperandInput(rawValue)) {
+          throw new Error(
+            `Invalid insert value for column "${column.name}" in row ${rowIndex}: only string, number, boolean, Date, Buffer, null, or OperandNodes are allowed`
+          );
+        }
+
+        return valueToOperand(rawValue);
+      })
+    );
+
+    return this.clone({
+      ...this.ast,
+      columns: definedColumns,
+      source: {
+        type: 'InsertValues',
+        rows: this.appendValues(newRows)
+      }
+    });
+  }
+
+  /**
+   * Sets the columns for the INSERT query
+   * @param columns - Column nodes to insert into
+   * @returns A new InsertQueryState with the specified columns
+   */
+  withColumns(columns: ColumnNode[]): InsertQueryState {
+    if (!columns.length) return this;
+    return this.clone({
+      ...this.ast,
+      columns: [...columns]
+    });
+  }
+
+  /**
+   * Adds SELECT source to the INSERT query
+   * @param query - The SELECT query to use as source
+   * @param columns - Target columns for the INSERT
+   * @returns A new InsertQueryState with the SELECT source
+   * @throws Error if mixing SELECT with VALUES source
+   * @throws Error if no destination columns specified
+   */
+  withSelect(query: SelectQueryNode, columns: ColumnNode[]): InsertQueryState {
+    const targetColumns =
+      columns.length
+        ? columns
+        : this.ast.columns.length
+          ? this.ast.columns
+          : this.getTableColumns();
+
+    if (!targetColumns.length) {
+      throw new Error('INSERT ... SELECT requires specifying destination columns.');
+    }
+
+    if (this.ast.source.type === 'InsertValues' && this.ast.source.rows.length) {
+      throw new Error('Cannot mix INSERT ... SELECT with INSERT ... VALUES source.');
+    }
+
+    return this.clone({
+      ...this.ast,
+      columns: [...targetColumns],
+      source: {
+        type: 'InsertSelect',
+        query
+      }
+    });
+  }
+
+  /**
+   * Adds a RETURNING clause to the INSERT query
+   * @param columns - Columns to return after insertion
+   * @returns A new InsertQueryState with the RETURNING clause added
+   */
   withReturning(columns: ColumnNode[]): InsertQueryState {
     return this.clone({
       ...this.ast,