metal-orm 1.0.40 → 1.0.42

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

@@ -1,38 +1,67 @@
-import { TableDef } from '../schema/table.js';
-import { ColumnNode, ExpressionNode } from '../core/ast/expression.js';
-import { TableNode, DeleteQueryNode } from '../core/ast/query.js';
-import { createTableNode } from '../core/ast/builders.js';
-
-/**
- * Maintains immutable state for DELETE queries
- */
-export class DeleteQueryState {
-  public readonly table: TableDef;
-  public readonly ast: DeleteQueryNode;
-
-  constructor(table: TableDef, ast?: DeleteQueryNode) {
-    this.table = table;
-    this.ast = ast ?? {
-      type: 'DeleteQuery',
-      from: createTableNode(table)
-    };
-  }
-
-  private clone(nextAst: DeleteQueryNode): DeleteQueryState {
-    return new DeleteQueryState(this.table, nextAst);
-  }
-
-  withWhere(expr: ExpressionNode): DeleteQueryState {
-    return this.clone({
-      ...this.ast,
-      where: expr
-    });
-  }
-
-  withReturning(columns: ColumnNode[]): DeleteQueryState {
-    return this.clone({
-      ...this.ast,
-      returning: [...columns]
-    });
-  }
-}
+import { TableDef } from '../schema/table.js';
+import { ColumnNode, ExpressionNode } from '../core/ast/expression.js';
+import {
+  DeleteQueryNode,
+  TableSourceNode
+} from '../core/ast/query.js';
+import { JoinNode } from '../core/ast/join.js';
+import { createTableNode } from '../core/ast/builders.js';
+
+/**
+ * Maintains immutable state for DELETE queries
+ */
+export class DeleteQueryState {
+  public readonly table: TableDef;
+  public readonly ast: DeleteQueryNode;
+
+  constructor(table: TableDef, ast?: DeleteQueryNode) {
+    this.table = table;
+    this.ast = ast ?? {
+      type: 'DeleteQuery',
+      from: createTableNode(table),
+      joins: []
+    };
+  }
+
+  private clone(nextAst: DeleteQueryNode): DeleteQueryState {
+    return new DeleteQueryState(this.table, nextAst);
+  }
+
+  withWhere(expr: ExpressionNode): DeleteQueryState {
+    return this.clone({
+      ...this.ast,
+      where: expr
+    });
+  }
+
+  withReturning(columns: ColumnNode[]): DeleteQueryState {
+    return this.clone({
+      ...this.ast,
+      returning: [...columns]
+    });
+  }
+
+  withUsing(source: TableSourceNode): DeleteQueryState {
+    return this.clone({
+      ...this.ast,
+      using: source
+    });
+  }
+
+  withJoin(join: JoinNode): DeleteQueryState {
+    return this.clone({
+      ...this.ast,
+      joins: [...(this.ast.joins ?? []), join]
+    });
+  }
+
+  withTableAlias(alias: string): DeleteQueryState {
+    return this.clone({
+      ...this.ast,
+      from: {
+        ...this.ast.from,
+        alias
+      }
+    });
+  }
+}

package/src/query-builder/delete.ts

@@ -1,10 +1,12 @@
 import { TableDef } from '../schema/table.js';
 import { ColumnDef } from '../schema/column.js';
 import { ColumnNode, ExpressionNode } from '../core/ast/expression.js';
+import { JOIN_KINDS, JoinKind } from '../core/sql/sql.js';
 import { CompiledQuery, DeleteCompiler, Dialect } from '../core/dialect/abstract.js';
 import { DialectKey, resolveDialectInput } from '../core/dialect/dialect-factory.js';
-import { DeleteQueryNode } from '../core/ast/query.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';
 
 type DeleteDialectInput = Dialect | DialectKey;
@@ -29,12 +31,43 @@ export class DeleteQueryBuilder<T> {
     return this.clone(this.state.withWhere(expr));
   }
 
+  as(alias: string): DeleteQueryBuilder<T> {
+    return this.clone(this.state.withTableAlias(alias));
+  }
+
+  using(source: TableDef | TableSourceNode): DeleteQueryBuilder<T> {
+    return this.clone(this.state.withUsing(this.resolveTableSource(source)));
+  }
+
+  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));
+  }
+
   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);
+  }
+
   // Existing compiler-based compile stays, but we add a new overload.
 
   // 1) Keep the old behavior (used internally / tests, if any):
@@ -61,3 +94,6 @@ export class DeleteQueryBuilder<T> {
     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

@@ -1,61 +1,131 @@
-import { TableDef } from '../schema/table.js';
-import { InsertQueryNode, TableNode } from '../core/ast/query.js';
-import { ColumnNode, OperandNode, isValueOperandInput, valueToOperand } from '../core/ast/expression.js';
-import { buildColumnNodes, createTableNode } from '../core/ast/builders.js';
-
-/**
- * Maintains immutable state for building INSERT queries
- */
-export class InsertQueryState {
-  public readonly table: TableDef;
-  public readonly ast: InsertQueryNode;
-
-  constructor(table: TableDef, ast?: InsertQueryNode) {
-    this.table = table;
-    this.ast = ast ?? {
-      type: 'InsertQuery',
-      into: createTableNode(table),
-      columns: [],
-      values: []
-    };
-  }
-
-  private clone(nextAst: InsertQueryNode): InsertQueryState {
-    return new InsertQueryState(this.table, nextAst);
-  }
-
-  withValues(rows: Record<string, unknown>[]): InsertQueryState {
-    if (!rows.length) return this;
-
-    const definedColumns = this.ast.columns.length
-      ? this.ast.columns
-      : buildColumnNodes(this.table, Object.keys(rows[0]));
-
-    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 primitives, null, or OperandNodes are allowed`
-          );
-        }
-
-        return valueToOperand(rawValue);
-      })
-    );
-
-    return this.clone({
-      ...this.ast,
-      columns: definedColumns,
-      values: [...this.ast.values, ...newRows]
-    });
-  }
-
-  withReturning(columns: ColumnNode[]): InsertQueryState {
-    return this.clone({
-      ...this.ast,
-      returning: [...columns]
-    });
-  }
-}
+import { TableDef } from '../schema/table.js';
+import { InsertQueryNode, SelectQueryNode } from '../core/ast/query.js';
+import {
+  ColumnNode,
+  OperandNode,
+  isValueOperandInput,
+  valueToOperand
+} from '../core/ast/expression.js';
+import {
+  buildColumnNodes,
+  createTableNode
+} from '../core/ast/builders.js';
+
+type InsertRows = Record<string, unknown>[];
+
+/**
+ * Maintains immutable state for building INSERT queries
+ */
+export class InsertQueryState {
+  public readonly table: TableDef;
+  public readonly ast: InsertQueryNode;
+
+  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);
+  }
+
+  withValues(rows: Record<string, unknown>[]): 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 primitives, null, or OperandNodes are allowed`
+          );
+        }
+
+        return valueToOperand(rawValue);
+      })
+    );
+
+    return this.clone({
+      ...this.ast,
+      columns: definedColumns,
+      source: {
+        type: 'InsertValues',
+        rows: this.appendValues(newRows)
+      }
+    });
+  }
+
+  withColumns(columns: ColumnNode[]): InsertQueryState {
+    if (!columns.length) return this;
+    return this.clone({
+      ...this.ast,
+      columns: [...columns]
+    });
+  }
+
+  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
+      }
+    });
+  }
+
+  withReturning(columns: ColumnNode[]): InsertQueryState {
+    return this.clone({
+      ...this.ast,
+      returning: [...columns]
+    });
+  }
+}

package/src/query-builder/insert.ts

@@ -1,9 +1,10 @@
+import type { SelectQueryBuilder } from './select.js';
 import { TableDef } from '../schema/table.js';
 import { ColumnDef } from '../schema/column.js';
 import { ColumnNode } 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 } from '../core/ast/query.js';
+import { InsertQueryNode, SelectQueryNode } from '../core/ast/query.js';
 import { InsertQueryState } from './insert-query-state.js';
 import { buildColumnNode } from '../core/ast/builders.js';
 
@@ -31,12 +32,37 @@ export class InsertQueryBuilder<T> {
     return this.clone(this.state.withValues(rows));
   }
 
+  columns(...columns: (ColumnDef | ColumnNode)[]): InsertQueryBuilder<T> {
+    if (!columns.length) return this;
+    return this.clone(this.state.withColumns(this.resolveColumnNodes(columns)));
+  }
+
+  fromSelect(
+    query: SelectQueryNode | SelectQueryBuilder<any, TableDef<any>>,
+    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));
+  }
+
   returning(...columns: (ColumnDef | ColumnNode)[]): InsertQueryBuilder<T> {
     if (!columns.length) return this;
     const nodes = columns.map(column => buildColumnNode(this.table, column));
     return this.clone(this.state.withReturning(nodes));
   }
 
+  // Helpers for column/AST resolution
+  private resolveColumnNodes(columns: (ColumnDef | ColumnNode)[]): ColumnNode[] {
+    return columns.map(column => buildColumnNode(this.table, column));
+  }
+
+  private resolveSelectQuery(query: SelectQueryNode | SelectQueryBuilder<any>): SelectQueryNode {
+    return typeof (query as any).getAST === 'function'
+      ? (query as SelectQueryBuilder<any>).getAST()
+      : (query as SelectQueryNode);
+  }
+
   // Existing compiler-based compile stays, but we add a new overload.
 
   // 1) Keep the old behavior (used internally / tests, if any):

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

@@ -1,77 +1,114 @@
-import { TableDef } from '../schema/table.js';
-import { ColumnNode, ExpressionNode, OperandNode, isOperandNode, valueToOperand } from '../core/ast/expression.js';
-import { TableNode, UpdateQueryNode, UpdateAssignmentNode } from '../core/ast/query.js';
-import { createTableNode } from '../core/ast/builders.js';
-type LiteralValue = string | number | boolean | null;
-type UpdateValue = OperandNode | LiteralValue;
-
-const isUpdateValue = (value: unknown): value is UpdateValue => {
-  if (value === null) return true;
-  switch (typeof value) {
-    case 'string':
-    case 'number':
-    case 'boolean':
-      return true;
-    default:
-      return isOperandNode(value);
-  }
-};
-
-/**
- * Immutable state for UPDATE queries
- */
-export class UpdateQueryState {
-  public readonly table: TableDef;
-  public readonly ast: UpdateQueryNode;
-
-  constructor(table: TableDef, ast?: UpdateQueryNode) {
-    this.table = table;
-    this.ast = ast ?? {
-      type: 'UpdateQuery',
-      table: createTableNode(table),
-      set: []
-    };
-  }
-
-  private clone(nextAst: UpdateQueryNode): UpdateQueryState {
-    return new UpdateQueryState(this.table, nextAst);
-  }
-
-  withSet(values: Record<string, unknown>): UpdateQueryState {
-    const assignments: UpdateAssignmentNode[] = Object.entries(values).map(([column, rawValue]) => {
-      if (!isUpdateValue(rawValue)) {
-        throw new Error(
-          `Invalid update value for column "${column}": only primitives, null, or OperandNodes are allowed`
-        );
-      }
-
-      return {
-        column: {
-          type: 'Column',
-          table: this.table.name,
-          name: column
-        },
-        value: valueToOperand(rawValue)
-      };
-    });
-
-    return this.clone({
-      ...this.ast,
-      set: assignments
-    });
-  }
-
-  withWhere(expr: ExpressionNode): UpdateQueryState {
-    return this.clone({
-      ...this.ast,
-      where: expr
-    });
-  }
-
-  withReturning(columns: ColumnNode[]): UpdateQueryState {
-    return this.clone({
-      ...this.ast,
-      returning: [...columns]
-    });
-  }
-}
+import { TableDef } from '../schema/table.js';
+import {
+  ColumnNode,
+  ExpressionNode,
+  OperandNode,
+  isOperandNode,
+  valueToOperand
+} from '../core/ast/expression.js';
+import {
+  TableSourceNode,
+  UpdateQueryNode,
+  UpdateAssignmentNode
+} from '../core/ast/query.js';
+import { JoinNode } from '../core/ast/join.js';
+import { createTableNode } from '../core/ast/builders.js';
+
+type LiteralValue = string | number | boolean | null;
+type UpdateValue = OperandNode | LiteralValue;
+
+const isUpdateValue = (value: unknown): value is UpdateValue => {
+  if (value === null) return true;
+  switch (typeof value) {
+    case 'string':
+    case 'number':
+    case 'boolean':
+      return true;
+    default:
+      return isOperandNode(value);
+  }
+};
+
+/**
+ * Immutable state for UPDATE queries
+ */
+export class UpdateQueryState {
+  public readonly table: TableDef;
+  public readonly ast: UpdateQueryNode;
+
+  constructor(table: TableDef, ast?: UpdateQueryNode) {
+    this.table = table;
+    this.ast = ast ?? {
+      type: 'UpdateQuery',
+      table: createTableNode(table),
+      set: [],
+      joins: []
+    };
+  }
+
+  private clone(nextAst: UpdateQueryNode): UpdateQueryState {
+    return new UpdateQueryState(this.table, nextAst);
+  }
+
+  withSet(values: Record<string, unknown>): UpdateQueryState {
+    const assignments: UpdateAssignmentNode[] = Object.entries(values).map(([column, rawValue]) => {
+      if (!isUpdateValue(rawValue)) {
+        throw new Error(
+          `Invalid update value for column "${column}": only primitives, null, or OperandNodes are allowed`
+        );
+      }
+
+      return {
+        column: {
+          type: 'Column',
+          table: this.table.name,
+          name: column
+        },
+        value: valueToOperand(rawValue)
+      };
+    });
+
+    return this.clone({
+      ...this.ast,
+      set: assignments
+    });
+  }
+
+  withWhere(expr: ExpressionNode): UpdateQueryState {
+    return this.clone({
+      ...this.ast,
+      where: expr
+    });
+  }
+
+  withReturning(columns: ColumnNode[]): UpdateQueryState {
+    return this.clone({
+      ...this.ast,
+      returning: [...columns]
+    });
+  }
+
+  withFrom(from: TableSourceNode): UpdateQueryState {
+    return this.clone({
+      ...this.ast,
+      from
+    });
+  }
+
+  withJoin(join: JoinNode): UpdateQueryState {
+    return this.clone({
+      ...this.ast,
+      joins: [...(this.ast.joins ?? []), join]
+    });
+  }
+
+  withTableAlias(alias: string): UpdateQueryState {
+    return this.clone({
+      ...this.ast,
+      table: {
+        ...this.ast.table,
+        alias
+      }
+    });
+  }
+}

package/src/query-builder/update.ts

@@ -1,10 +1,12 @@
 import { TableDef } from '../schema/table.js';
 import { ColumnDef } from '../schema/column.js';
 import { ColumnNode, ExpressionNode } from '../core/ast/expression.js';
+import { JOIN_KINDS, JoinKind } from '../core/sql/sql.js';
 import { CompiledQuery, UpdateCompiler, Dialect } from '../core/dialect/abstract.js';
 import { DialectKey, resolveDialectInput } from '../core/dialect/dialect-factory.js';
-import { UpdateQueryNode } from '../core/ast/query.js';
+import { TableSourceNode, UpdateQueryNode } from '../core/ast/query.js';
 import { UpdateQueryState } from './update-query-state.js';
+import { createJoinNode } from '../core/ast/join-node.js';
 import { buildColumnNode } from '../core/ast/builders.js';
 
 type UpdateDialectInput = Dialect | DialectKey;
@@ -25,6 +27,26 @@ export class UpdateQueryBuilder<T> {
     return new UpdateQueryBuilder(this.table, state);
   }
 
+  as(alias: string): UpdateQueryBuilder<T> {
+    return this.clone(this.state.withTableAlias(alias));
+  }
+
+  from(source: TableDef | TableSourceNode): UpdateQueryBuilder<T> {
+    const tableSource = this.resolveTableSource(source);
+    return this.clone(this.state.withFrom(tableSource));
+  }
+
+  join(
+    table: TableDef | TableSourceNode | string,
+    condition: ExpressionNode,
+    kind: JoinKind = JOIN_KINDS.INNER,
+    relationName?: string
+  ): UpdateQueryBuilder<T> {
+    const joinTarget = this.resolveJoinTarget(table);
+    const joinNode = createJoinNode(kind, joinTarget, condition, relationName);
+    return this.clone(this.state.withJoin(joinNode));
+  }
+
   set(values: Record<string, unknown>): UpdateQueryBuilder<T> {
     return this.clone(this.state.withSet(values));
   }
@@ -39,6 +61,18 @@ export class UpdateQueryBuilder<T> {
     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);
+  }
+
   // Existing compiler-based compile stays, but we add a new overload.
 
   // 1) Keep the old behavior (used internally / tests, if any):
@@ -65,3 +99,6 @@ export class UpdateQueryBuilder<T> {
     return this.state.ast;
   }
 }
+
+const isTableSourceNode = (source: TableDef | TableSourceNode): source is TableSourceNode =>
+  typeof (source as TableSourceNode).type === 'string';