metal-orm 1.0.39 → 1.0.41

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/hydration-manager.ts

@@ -7,63 +7,63 @@ import { ProjectionNode, SelectQueryState } from './select-query-state.js';
 import { ColumnNode, eq } from '../core/ast/expression.js';
 import { createJoinNode } from '../core/ast/join-node.js';
 import { JOIN_KINDS } from '../core/sql/sql.js';
-
-/**
- * Manages hydration planning for query results
- */
-export class HydrationManager {
-  /**
-   * Creates a new HydrationManager instance
-   * @param table - Table definition
-   * @param planner - Hydration planner
-   */
-  constructor(
-    private readonly table: TableDef,
-    private readonly planner: HydrationPlanner
-  ) {}
-
-  /**
-   * Creates a new HydrationManager with updated planner
-   * @param nextPlanner - Updated hydration planner
-   * @returns New HydrationManager instance
-   */
-  private clone(nextPlanner: HydrationPlanner): HydrationManager {
-    return new HydrationManager(this.table, nextPlanner);
-  }
-
-  /**
-   * Handles column selection for hydration planning
-   * @param state - Current query state
-   * @param newColumns - Newly selected columns
-   * @returns Updated HydrationManager with captured columns
-   */
-  onColumnsSelected(state: SelectQueryState, newColumns: ProjectionNode[]): HydrationManager {
-    const updated = this.planner.captureRootColumns(newColumns);
-    return this.clone(updated);
-  }
-
-  /**
-   * Handles relation inclusion for hydration planning
-   * @param state - Current query state
-   * @param relation - Relation definition
-   * @param relationName - Name of the relation
-   * @param aliasPrefix - Alias prefix for the relation
-   * @param targetColumns - Target columns to include
-   * @returns Updated HydrationManager with included relation
-   */
-  onRelationIncluded(
-    state: SelectQueryState,
-    relation: RelationDef,
-    relationName: string,
-    aliasPrefix: string,
-    targetColumns: string[],
-    pivot?: { aliasPrefix: string; columns: string[] }
-  ): HydrationManager {
-    const withRoots = this.planner.captureRootColumns(state.ast.columns);
-    const next = withRoots.includeRelation(relation, relationName, aliasPrefix, targetColumns, pivot);
-    return this.clone(next);
-  }
-
+
+/**
+ * Manages hydration planning for query results
+ */
+export class HydrationManager {
+  /**
+   * Creates a new HydrationManager instance
+   * @param table - Table definition
+   * @param planner - Hydration planner
+   */
+  constructor(
+    private readonly table: TableDef,
+    private readonly planner: HydrationPlanner
+  ) {}
+
+  /**
+   * Creates a new HydrationManager with updated planner
+   * @param nextPlanner - Updated hydration planner
+   * @returns New HydrationManager instance
+   */
+  private clone(nextPlanner: HydrationPlanner): HydrationManager {
+    return new HydrationManager(this.table, nextPlanner);
+  }
+
+  /**
+   * Handles column selection for hydration planning
+   * @param state - Current query state
+   * @param newColumns - Newly selected columns
+   * @returns Updated HydrationManager with captured columns
+   */
+  onColumnsSelected(state: SelectQueryState, newColumns: ProjectionNode[]): HydrationManager {
+    const updated = this.planner.captureRootColumns(newColumns);
+    return this.clone(updated);
+  }
+
+  /**
+   * Handles relation inclusion for hydration planning
+   * @param state - Current query state
+   * @param relation - Relation definition
+   * @param relationName - Name of the relation
+   * @param aliasPrefix - Alias prefix for the relation
+   * @param targetColumns - Target columns to include
+   * @returns Updated HydrationManager with included relation
+   */
+  onRelationIncluded(
+    state: SelectQueryState,
+    relation: RelationDef,
+    relationName: string,
+    aliasPrefix: string,
+    targetColumns: string[],
+    pivot?: { aliasPrefix: string; columns: string[] }
+  ): HydrationManager {
+    const withRoots = this.planner.captureRootColumns(state.ast.columns);
+    const next = withRoots.includeRelation(relation, relationName, aliasPrefix, targetColumns, pivot);
+    return this.clone(next);
+  }
+
   /**
    * Applies hydration plan to the AST
    * @param ast - Query AST to modify
@@ -82,11 +82,11 @@ export class HydrationManager {
     const rewritten = needsPaginationGuard ? this.wrapForParentPagination(ast, plan) : ast;
     return this.attachHydrationMeta(rewritten, plan);
   }
-
-  /**
-   * Gets the current hydration plan
-   * @returns Hydration plan or undefined if none exists
-   */
+
+  /**
+   * Gets the current hydration plan
+   * @returns Hydration plan or undefined if none exists
+   */
   getPlan(): HydrationPlan | undefined {
     return this.planner.getPlan();
   }
@@ -251,38 +251,52 @@ export class HydrationManager {
     const mapped: OrderByNode[] = [];
 
     for (const ob of orderBy) {
-      // Only rewrite when ordering by root columns; child columns would reintroduce the pagination bug.
-      if (ob.column.table !== plan.rootTable) {
-        return null;
-      }
+      const mappedTerm = this.mapOrderingTerm(ob.term, plan, projectionAliases, baseAlias, availableColumns);
+      if (!mappedTerm) return null;
 
-      const alias = projectionAliases.get(`${ob.column.table}.${ob.column.name}`) ?? ob.column.name;
-      if (!availableColumns.has(alias)) {
-        return null;
-      }
-
-      mapped.push({
-        type: 'OrderBy',
-        column: { type: 'Column', table: baseAlias, name: alias },
-        direction: ob.direction
-      });
+      mapped.push({ ...ob, term: mappedTerm });
     }
 
     return mapped;
   }
 
+  private mapOrderingTerm(
+    term: OrderByNode['term'],
+    plan: HydrationPlan,
+    projectionAliases: Map<string, string>,
+    baseAlias: string,
+    availableColumns: Set<string>
+  ): OrderByNode['term'] | null {
+    if ((term as any).type === 'Column') {
+      const col = term as ColumnNode;
+      if (col.table !== plan.rootTable) return null;
+      const alias = projectionAliases.get(`${col.table}.${col.name}`) ?? col.name;
+      if (!availableColumns.has(alias)) return null;
+      return { type: 'Column', table: baseAlias, name: alias };
+    }
+
+    if ((term as any).type === 'AliasRef') {
+      const aliasName = (term as any).name;
+      if (!availableColumns.has(aliasName)) return null;
+      return { type: 'Column', table: baseAlias, name: aliasName };
+    }
+
+    return null;
+  }
+
   private buildPagingColumns(primaryKey: string, orderBy: OrderByNode[] | undefined, tableAlias: string): ColumnNode[] {
     const columns: ColumnNode[] = [{ type: 'Column', table: tableAlias, name: primaryKey, alias: primaryKey }];
 
     if (!orderBy) return columns;
 
     for (const ob of orderBy) {
-      if (!columns.some(col => col.name === ob.column.name)) {
+      const term = ob.term as ColumnNode;
+      if (!columns.some(col => col.name === term.name)) {
         columns.push({
           type: 'Column',
           table: tableAlias,
-          name: ob.column.name,
-          alias: ob.column.name
+          name: term.name,
+          alias: term.name
         });
       }
     }

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):