metal-orm 1.0.16 → 1.0.18

package/src/query-builder/select.ts

@@ -6,27 +6,30 @@ import { SelectQueryNode, SetOperationKind } from '../core/ast/query.js';
 
 import { HydrationPlan } from '../core/hydration/types.js';
 
-import {
-
-  ColumnNode,
-
-  ExpressionNode,
-
-  FunctionNode,
-
-  LiteralNode,
-
-  BinaryExpressionNode,
-
-  CaseExpressionNode,
-
-  WindowFunctionNode,
-
-  exists,
-
-  notExists
-
-} from '../core/ast/expression.js';
+import {
+
+  ColumnNode,
+
+  ExpressionNode,
+
+  FunctionNode,
+
+  LiteralNode,
+
+  BinaryExpressionNode,
+
+  CaseExpressionNode,
+
+  WindowFunctionNode,
+
+  and,
+
+  exists,
+
+  notExists
+
+} from '../core/ast/expression.js';
+import { derivedTable } from '../core/ast/builders.js';
 
 import { CompiledQuery, Dialect } from '../core/dialect/abstract.js';
 
@@ -54,15 +57,17 @@ import {
 
 import { QueryAstService } from './query-ast-service.js';
 
-import { ColumnSelector } from './column-selector.js';
-
-import { RelationManager } from './relation-manager.js';
-
-import { RelationIncludeOptions } from './relation-types.js';
+import { ColumnSelector } from './column-selector.js';
+
+import { RelationManager } from './relation-manager.js';
+
+import { RelationIncludeOptions } from './relation-types.js';
+
+import type { RelationDef } from '../schema/relation.js';
+
+import { JOIN_KINDS, JoinKind, ORDER_DIRECTIONS, OrderDirection } from '../core/sql/sql.js';
 
-import { JOIN_KINDS, JoinKind, ORDER_DIRECTIONS, OrderDirection } from '../core/sql/sql.js';
-
-import { Entity, RelationMap } from '../schema/types.js';
+import { Entity, RelationMap, RelationTargetTable } from '../schema/types.js';
 
 import { OrmSession } from '../orm/orm-session.ts';
 
@@ -72,11 +77,29 @@ import { HydrationContext } from '../orm/hydration-context.js';
 
 import { executeHydrated, executeHydratedWithContexts } from '../orm/execute.js';
 
-import { createJoinNode } from '../core/ast/join-node.js';
-
-
-
-/**
+import { createJoinNode } from '../core/ast/join-node.js';
+
+
+type ColumnSelectionValue = ColumnDef | FunctionNode | CaseExpressionNode | WindowFunctionNode;
+
+type DeepSelectConfig<TTable extends TableDef> = {
+  root?: (keyof TTable['columns'] & string)[];
+} & {
+  [K in keyof TTable['relations'] & string]?: (
+    keyof RelationTargetTable<TTable['relations'][K]>['columns'] & string
+  )[];
+};
+
+type WhereHasOptions = {
+  correlate?: ExpressionNode;
+};
+
+type RelationCallback = <TChildTable extends TableDef>(
+  qb: SelectQueryBuilder<any, TChildTable>
+) => SelectQueryBuilder<any, TChildTable>;
+
+
+/**
 
  * Main query builder class for constructing SQL SELECT queries
 
@@ -154,29 +177,52 @@ export class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
 
 
 
-  private clone(
-
-    context: SelectQueryBuilderContext = this.context,
-
-    lazyRelations = new Set(this.lazyRelations)
-
-  ): SelectQueryBuilder<T, TTable> {
-
-    return new SelectQueryBuilder(this.env.table as TTable, context.state, context.hydration, this.env.deps, lazyRelations);
-
-  }
-
-
-
-  private resolveQueryNode(query: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): SelectQueryNode {
-
-    return typeof (query as any).getAST === 'function'
-
-      ? (query as SelectQueryBuilder<any, TableDef<any>>).getAST()
-
-      : (query as SelectQueryNode);
-
-  }
+  private clone(
+
+    context: SelectQueryBuilderContext = this.context,
+
+    lazyRelations = new Set(this.lazyRelations)
+
+  ): SelectQueryBuilder<T, TTable> {
+
+    return new SelectQueryBuilder(this.env.table as TTable, context.state, context.hydration, this.env.deps, lazyRelations);
+
+  }
+
+  /**
+   * Applies an alias to the root FROM table.
+   * @param alias - Alias to apply
+   */
+  as(alias: string): SelectQueryBuilder<T, TTable> {
+    const from = this.context.state.ast.from;
+    if (from.type !== 'Table') {
+      throw new Error('Cannot alias non-table FROM sources');
+    }
+    const nextFrom = { ...from, alias };
+    const nextContext = this.applyAst(this.context, service => service.withFrom(nextFrom));
+    return this.clone(nextContext);
+  }
+
+
+
+  private resolveQueryNode(query: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): SelectQueryNode {
+
+    return typeof (query as any).getAST === 'function'
+
+      ? (query as SelectQueryBuilder<any, TableDef<any>>).getAST()
+
+      : (query as SelectQueryNode);
+
+  }
+
+  private applyCorrelation(ast: SelectQueryNode, correlation?: ExpressionNode): SelectQueryNode {
+    if (!correlation) return ast;
+    const combinedWhere = ast.where ? and(correlation, ast.where) : correlation;
+    return {
+      ...ast,
+      where: combinedWhere
+    };
+  }
 
 
 
@@ -252,12 +298,31 @@ export class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
 
    */
 
-  select(columns: Record<string, ColumnDef | FunctionNode | CaseExpressionNode | WindowFunctionNode>): SelectQueryBuilder<T, TTable> {
-
-    return this.clone(this.columnSelector.select(this.context, columns));
-
-  }
-
+  select(columns: Record<string, ColumnSelectionValue>): SelectQueryBuilder<T, TTable> {
+
+    return this.clone(this.columnSelector.select(this.context, columns));
+
+  }
+
+
+  /**
+   * Selects columns from the root table by name (typed).
+   * @param cols - Column names on the root table
+   */
+  selectColumns<K extends keyof TTable['columns'] & string>(...cols: K[]): SelectQueryBuilder<T, TTable> {
+    const selection: Record<string, ColumnDef> = {};
+
+    for (const key of cols) {
+      const col = this.env.table.columns[key];
+      if (!col) {
+        throw new Error(`Column '${key}' not found on table '${this.env.table.name}'`);
+      }
+      selection[key] = col;
+    }
+
+    return this.select(selection);
+  }
+
 
 
   /**
@@ -318,15 +383,34 @@ export class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
 
    */
 
-  withRecursive(name: string, query: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode, columns?: string[]): SelectQueryBuilder<T, TTable> {
-
-    const subAst = this.resolveQueryNode(query);
-
-    const nextContext = this.applyAst(this.context, service => service.withCte(name, subAst, columns, true));
-
-    return this.clone(nextContext);
-
-  }
+  withRecursive(name: string, query: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode, columns?: string[]): SelectQueryBuilder<T, TTable> {
+
+    const subAst = this.resolveQueryNode(query);
+
+    const nextContext = this.applyAst(this.context, service => service.withCte(name, subAst, columns, true));
+
+    return this.clone(nextContext);
+
+  }
+
+
+  /**
+   * Replaces the FROM clause with a derived table (subquery with alias)
+   * @param subquery - Subquery to use as the FROM source
+   * @param alias - Alias for the derived table
+   * @param columnAliases - Optional column alias list
+   * @returns New query builder instance with updated FROM
+   */
+  fromSubquery(
+    subquery: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode,
+    alias: string,
+    columnAliases?: string[]
+  ): SelectQueryBuilder<T, TTable> {
+    const subAst = this.resolveQueryNode(subquery);
+    const fromNode = derivedTable(subAst, alias, columnAliases);
+    const nextContext = this.applyAst(this.context, service => service.withFrom(fromNode));
+    return this.clone(nextContext);
+  }
 
 
 
@@ -342,14 +426,37 @@ export class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
 
    */
 
-  selectSubquery(alias: string, sub: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): SelectQueryBuilder<T, TTable> {
-
-    const query = this.resolveQueryNode(sub);
-
-    return this.clone(this.columnSelector.selectSubquery(this.context, alias, query));
-
-  }
-
+  selectSubquery(alias: string, sub: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): SelectQueryBuilder<T, TTable> {
+
+    const query = this.resolveQueryNode(sub);
+
+    return this.clone(this.columnSelector.selectSubquery(this.context, alias, query));
+
+  }
+
+
+  /**
+   * Adds a JOIN against a derived table (subquery with alias)
+   * @param subquery - Subquery to join
+   * @param alias - Alias for the derived table
+   * @param condition - Join condition expression
+   * @param joinKind - Join kind (defaults to INNER)
+   * @param columnAliases - Optional column alias list for the derived table
+   * @returns New query builder instance with the derived-table join
+   */
+  joinSubquery(
+    subquery: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode,
+    alias: string,
+    condition: BinaryExpressionNode,
+    joinKind: JoinKind = JOIN_KINDS.INNER,
+    columnAliases?: string[]
+  ): SelectQueryBuilder<T, TTable> {
+    const subAst = this.resolveQueryNode(subquery);
+    const joinNode = createJoinNode(joinKind, derivedTable(subAst, alias, columnAliases), condition);
+    const nextContext = this.applyAst(this.context, service => service.withJoin(joinNode));
+    return this.clone(nextContext);
+  }
+
 
 
   /**
@@ -494,16 +601,77 @@ export class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
 
 
 
-  includeLazy<K extends keyof RelationMap<TTable>>(relationName: K): SelectQueryBuilder<T, TTable> {
-
-    const nextLazy = new Set(this.lazyRelations);
-
-    nextLazy.add(relationName as string);
-
-    return this.clone(this.context, nextLazy);
-
-  }
-
+  includeLazy<K extends keyof RelationMap<TTable>>(relationName: K): SelectQueryBuilder<T, TTable> {
+
+    const nextLazy = new Set(this.lazyRelations);
+
+    nextLazy.add(relationName as string);
+
+    return this.clone(this.context, nextLazy);
+
+  }
+
+  /**
+   * Selects columns for a related table in a single hop.
+   */
+  selectRelationColumns<
+    K extends keyof TTable['relations'] & string,
+    TRel extends RelationDef = TTable['relations'][K],
+    TTarget extends TableDef = RelationTargetTable<TRel>,
+    C extends keyof TTarget['columns'] & string = keyof TTarget['columns'] & string
+  >(relationName: K, ...cols: C[]): SelectQueryBuilder<T, TTable> {
+    const relation = this.env.table.relations[relationName] as RelationDef | undefined;
+    if (!relation) {
+      throw new Error(`Relation '${relationName}' not found on table '${this.env.table.name}'`);
+    }
+    const target = relation.target;
+
+    for (const col of cols) {
+      if (!target.columns[col]) {
+        throw new Error(
+          `Column '${col}' not found on related table '${target.name}' for relation '${relationName}'`
+        );
+      }
+    }
+
+    return this.include(relationName as string, { columns: cols as string[] });
+  }
+
+
+  /**
+   * Convenience alias for selecting specific columns from a relation.
+   */
+  includePick<
+    K extends keyof TTable['relations'] & string,
+    TRel extends RelationDef = TTable['relations'][K],
+    TTarget extends TableDef = RelationTargetTable<TRel>,
+    C extends keyof TTarget['columns'] & string = keyof TTarget['columns'] & string
+  >(relationName: K, cols: C[]): SelectQueryBuilder<T, TTable> {
+    return this.selectRelationColumns(relationName, ...cols);
+  }
+
+
+  /**
+   * Selects columns for the root table and relations from a single config object.
+   */
+  selectColumnsDeep(config: DeepSelectConfig<TTable>): SelectQueryBuilder<T, TTable> {
+    let qb: SelectQueryBuilder<T, TTable> = this;
+
+    if (config.root?.length) {
+      qb = qb.selectColumns(...config.root);
+    }
+
+    for (const key of Object.keys(config) as (keyof typeof config)[]) {
+      if (key === 'root') continue;
+      const relName = key as keyof TTable['relations'] & string;
+      const cols = config[relName as keyof DeepSelectConfig<TTable>] as string[] | undefined;
+      if (!cols || !cols.length) continue;
+      qb = qb.selectRelationColumns(relName, ...(cols as string[]));
+    }
+
+    return qb;
+  }
+
 
 
   getLazyRelations(): (keyof RelationMap<TTable>)[] {
@@ -760,13 +928,14 @@ export class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
 
    */
 
-  whereExists(subquery: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): SelectQueryBuilder<T, TTable> {
-
-    const subAst = this.resolveQueryNode(subquery);
-
-    return this.where(exists(subAst));
-
-  }
+  whereExists(
+    subquery: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode,
+    correlate?: ExpressionNode
+  ): SelectQueryBuilder<T, TTable> {
+    const subAst = this.resolveQueryNode(subquery);
+    const correlated = this.applyCorrelation(subAst, correlate);
+    return this.where(exists(correlated));
+  }
 
 
 
@@ -780,13 +949,14 @@ export class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
 
    */
 
-  whereNotExists(subquery: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): SelectQueryBuilder<T, TTable> {
-
-    const subAst = this.resolveQueryNode(subquery);
-
-    return this.where(notExists(subAst));
-
-  }
+  whereNotExists(
+    subquery: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode,
+    correlate?: ExpressionNode
+  ): SelectQueryBuilder<T, TTable> {
+    const subAst = this.resolveQueryNode(subquery);
+    const correlated = this.applyCorrelation(subAst, correlate);
+    return this.where(notExists(correlated));
+  }
 
 
 
@@ -802,45 +972,46 @@ export class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
 
    */
 
-  whereHas(
-
-    relationName: string,
-
-    callback?: <TChildTable extends TableDef>(
-
-      qb: SelectQueryBuilder<any, TChildTable>
-
-    ) => SelectQueryBuilder<any, TChildTable>
-
-  ): SelectQueryBuilder<T, TTable> {
-
-    const relation = this.env.table.relations[relationName];
-
-    if (!relation) {
-
+  whereHas(
+
+    relationName: string,
+
+    callbackOrOptions?: RelationCallback | WhereHasOptions,
+
+    maybeOptions?: WhereHasOptions
+
+  ): SelectQueryBuilder<T, TTable> {
+
+    const relation = this.env.table.relations[relationName];
+
+    if (!relation) {
+
       throw new Error(`Relation '${relationName}' not found on table '${this.env.table.name}'`);
 
     }
 
 
 
-    let subQb = this.createChildBuilder<any, typeof relation.target>(relation.target);
-
-    if (callback) {
-
-      subQb = callback(subQb);
-
-    }
+    const callback = typeof callbackOrOptions === 'function' ? callbackOrOptions as RelationCallback : undefined;
+    const options = (typeof callbackOrOptions === 'function' ? maybeOptions : callbackOrOptions) as WhereHasOptions | undefined;
+
+    let subQb = this.createChildBuilder<any, typeof relation.target>(relation.target);
+
+    if (callback) {
+
+      subQb = callback(subQb);
+
+    }
 
 
 
-    const subAst = subQb.getAST();
-
-    const finalSubAst = this.relationManager.applyRelationCorrelation(this.context, relationName, subAst);
-
-    return this.where(exists(finalSubAst));
-
-  }
+    const subAst = subQb.getAST();
+
+    const finalSubAst = this.relationManager.applyRelationCorrelation(this.context, relationName, subAst, options?.correlate);
+
+    return this.where(exists(finalSubAst));
+
+  }
 
 
 
@@ -856,45 +1027,46 @@ export class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
 
    */
 
-  whereHasNot(
-
-    relationName: string,
-
-    callback?: <TChildTable extends TableDef>(
-
-      qb: SelectQueryBuilder<any, TChildTable>
-
-    ) => SelectQueryBuilder<any, TChildTable>
-
-  ): SelectQueryBuilder<T, TTable> {
-
-    const relation = this.env.table.relations[relationName];
-
-    if (!relation) {
-
+  whereHasNot(
+
+    relationName: string,
+
+    callbackOrOptions?: RelationCallback | WhereHasOptions,
+
+    maybeOptions?: WhereHasOptions
+
+  ): SelectQueryBuilder<T, TTable> {
+
+    const relation = this.env.table.relations[relationName];
+
+    if (!relation) {
+
       throw new Error(`Relation '${relationName}' not found on table '${this.env.table.name}'`);
 
     }
 
 
 
-    let subQb = this.createChildBuilder<any, typeof relation.target>(relation.target);
-
-    if (callback) {
-
-      subQb = callback(subQb);
-
-    }
-
-
-
-    const subAst = subQb.getAST();
-
-    const finalSubAst = this.relationManager.applyRelationCorrelation(this.context, relationName, subAst);
-
-    return this.where(notExists(finalSubAst));
-
-  }
+    const callback = typeof callbackOrOptions === 'function' ? callbackOrOptions as RelationCallback : undefined;
+    const options = (typeof callbackOrOptions === 'function' ? maybeOptions : callbackOrOptions) as WhereHasOptions | undefined;
+
+    let subQb = this.createChildBuilder<any, typeof relation.target>(relation.target);
+
+    if (callback) {
+
+      subQb = callback(subQb);
+
+    }
+
+
+
+    const subAst = subQb.getAST();
+
+    const finalSubAst = this.relationManager.applyRelationCorrelation(this.context, relationName, subAst, options?.correlate);
+
+    return this.where(notExists(finalSubAst));
+
+  }
 
 
 

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

@@ -1,7 +1,21 @@
 import { TableDef } from '../schema/table.js';
-import { ColumnNode, ExpressionNode, valueToOperand } from '../core/ast/expression.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
@@ -24,14 +38,22 @@ export class UpdateQueryState {
   }
 
   withSet(values: Record<string, unknown>): UpdateQueryState {
-    const assignments: UpdateAssignmentNode[] = Object.entries(values).map(([column, value]) => ({
-      column: {
-        type: 'Column',
-        table: this.table.name,
-        name: column
-      },
-      value: valueToOperand(value)
-    }));
+    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,