metal-orm 1.0.58 → 1.0.59

package/src/query-builder/relation-filter-utils.ts

@@ -0,0 +1,159 @@
+import { ExpressionNode, OperandNode, isOperandNode } from '../core/ast/expression.js';
+import { OrderingTerm } from '../core/ast/query.js';
+
+type FilterTableCollector = {
+  tables: Set<string>;
+  hasSubquery: boolean;
+};
+
+export type SplitFilterExpressionsResult = {
+  selfFilters: ExpressionNode[];
+  crossFilters: ExpressionNode[];
+};
+
+export const splitFilterExpressions = (
+  filter: ExpressionNode | undefined,
+  allowedTables: Set<string>
+): SplitFilterExpressionsResult => {
+  const terms = flattenAnd(filter);
+  const selfFilters: ExpressionNode[] = [];
+  const crossFilters: ExpressionNode[] = [];
+
+  for (const term of terms) {
+    if (isExpressionSelfContained(term, allowedTables)) {
+      selfFilters.push(term);
+    } else {
+      crossFilters.push(term);
+    }
+  }
+
+  return { selfFilters, crossFilters };
+};
+
+const flattenAnd = (node?: ExpressionNode): ExpressionNode[] => {
+  if (!node) return [];
+  if (node.type === 'LogicalExpression' && node.operator === 'AND') {
+    return node.operands.flatMap(operand => flattenAnd(operand));
+  }
+  return [node];
+};
+
+const isExpressionSelfContained = (expr: ExpressionNode, allowedTables: Set<string>): boolean => {
+  const collector = collectReferencedTables(expr);
+  if (collector.hasSubquery) return false;
+  if (collector.tables.size === 0) return true;
+  for (const table of collector.tables) {
+    if (!allowedTables.has(table)) {
+      return false;
+    }
+  }
+  return true;
+};
+
+const collectReferencedTables = (expr: ExpressionNode): FilterTableCollector => {
+  const collector: FilterTableCollector = {
+    tables: new Set(),
+    hasSubquery: false
+  };
+  collectFromExpression(expr, collector);
+  return collector;
+};
+
+const collectFromExpression = (expr: ExpressionNode, collector: FilterTableCollector): void => {
+  switch (expr.type) {
+    case 'BinaryExpression':
+      collectFromOperand(expr.left, collector);
+      collectFromOperand(expr.right, collector);
+      break;
+    case 'LogicalExpression':
+      expr.operands.forEach(operand => collectFromExpression(operand, collector));
+      break;
+    case 'NullExpression':
+      collectFromOperand(expr.left, collector);
+      break;
+    case 'InExpression':
+      collectFromOperand(expr.left, collector);
+      if (Array.isArray(expr.right)) {
+        expr.right.forEach(value => collectFromOperand(value, collector));
+      } else {
+        collector.hasSubquery = true;
+      }
+      break;
+    case 'ExistsExpression':
+      collector.hasSubquery = true;
+      break;
+    case 'BetweenExpression':
+      collectFromOperand(expr.left, collector);
+      collectFromOperand(expr.lower, collector);
+      collectFromOperand(expr.upper, collector);
+      break;
+    case 'ArithmeticExpression':
+    case 'BitwiseExpression':
+      collectFromOperand(expr.left, collector);
+      collectFromOperand(expr.right, collector);
+      break;
+    default:
+      break;
+  }
+};
+
+const collectFromOperand = (node: OperandNode, collector: FilterTableCollector): void => {
+  switch (node.type) {
+    case 'Column':
+      collector.tables.add(node.table);
+      break;
+    case 'Function':
+      node.args.forEach(arg => collectFromOperand(arg, collector));
+      if (node.separator) {
+        collectFromOperand(node.separator, collector);
+      }
+      if (node.orderBy) {
+        node.orderBy.forEach(order => collectFromOrderingTerm(order.term, collector));
+      }
+      break;
+    case 'JsonPath':
+      collectFromOperand(node.column, collector);
+      break;
+    case 'ScalarSubquery':
+      collector.hasSubquery = true;
+      break;
+    case 'CaseExpression':
+      node.conditions.forEach(({ when, then }) => {
+        collectFromExpression(when, collector);
+        collectFromOperand(then, collector);
+      });
+      if (node.else) {
+        collectFromOperand(node.else, collector);
+      }
+      break;
+    case 'Cast':
+      collectFromOperand(node.expression, collector);
+      break;
+    case 'WindowFunction':
+      node.args.forEach(arg => collectFromOperand(arg, collector));
+      node.partitionBy?.forEach(part => collectFromOperand(part, collector));
+      node.orderBy?.forEach(order => collectFromOrderingTerm(order.term, collector));
+      break;
+    case 'Collate':
+      collectFromOperand(node.expression, collector);
+      break;
+    case 'ArithmeticExpression':
+    case 'BitwiseExpression':
+      collectFromOperand(node.left, collector);
+      collectFromOperand(node.right, collector);
+      break;
+    case 'Literal':
+    case 'AliasRef':
+      break;
+    default:
+      break;
+  }
+};
+
+const collectFromOrderingTerm = (term: OrderingTerm, collector: FilterTableCollector): void => {
+  if (isOperandNode(term)) {
+    collectFromOperand(term, collector);
+    return;
+  }
+  collectFromExpression(term, collector);
+};

package/src/query-builder/relation-include-strategies.ts

@@ -0,0 +1,177 @@
+import { TableDef } from '../schema/table.js';
+import { ColumnDef } from '../schema/column-types.js';
+import {
+  RelationDef,
+  RelationKinds,
+  BelongsToManyRelation,
+  HasManyRelation,
+  HasOneRelation,
+  BelongsToRelation
+} from '../schema/relation.js';
+import { ColumnNode } from '../core/ast/expression.js';
+import { SelectQueryState } from './select-query-state.js';
+import { HydrationManager } from './hydration-manager.js';
+import type { RelationResult } from './relation-projection-helper.js';
+import { RelationIncludeOptions } from './relation-types.js';
+import { makeRelationAlias } from './relation-alias.js';
+import { buildDefaultPivotColumns } from './relation-utils.js';
+import { findPrimaryKey } from './hydration-planner.js';
+
+type RelationWithForeignKey =
+  | HasManyRelation
+  | HasOneRelation
+  | BelongsToRelation;
+
+type IncludeStrategyContext = {
+  rootTable: TableDef;
+  state: SelectQueryState;
+  hydration: HydrationManager;
+  relation: RelationDef;
+  relationName: string;
+  aliasPrefix: string;
+  options?: RelationIncludeOptions;
+  selectColumns: (
+    state: SelectQueryState,
+    hydration: HydrationManager,
+    columns: Record<string, ColumnDef>
+  ) => RelationResult;
+};
+
+type IncludeStrategy = (context: IncludeStrategyContext) => RelationResult;
+
+const buildTypedSelection = (
+  columns: Record<string, ColumnDef>,
+  prefix: string,
+  keys: string[],
+  missingMsg: (col: string) => string
+): Record<string, ColumnDef> => {
+  return keys.reduce((acc, key) => {
+    const def = columns[key];
+    if (!def) {
+      throw new Error(missingMsg(key));
+    }
+    acc[makeRelationAlias(prefix, key)] = def;
+    return acc;
+  }, {} as Record<string, ColumnDef>);
+};
+
+const resolveTargetColumns = (relation: RelationDef, options?: RelationIncludeOptions): string[] => {
+  const requestedColumns = options?.columns?.length
+    ? [...options.columns]
+    : Object.keys(relation.target.columns);
+  const targetPrimaryKey = findPrimaryKey(relation.target);
+  if (!requestedColumns.includes(targetPrimaryKey)) {
+    requestedColumns.push(targetPrimaryKey);
+  }
+  return requestedColumns;
+};
+
+const ensureRootForeignKeySelected = (
+  context: IncludeStrategyContext,
+  relation: RelationWithForeignKey
+): RelationResult => {
+  const fkColumn = context.rootTable.columns[relation.foreignKey];
+  if (!fkColumn) {
+    return { state: context.state, hydration: context.hydration };
+  }
+
+  const hasForeignKeySelected = context.state.ast.columns.some(col => {
+    if ((col as ColumnNode).type !== 'Column') return false;
+    const node = col as ColumnNode;
+    const alias = node.alias ?? node.name;
+    return alias === relation.foreignKey;
+  });
+
+  if (hasForeignKeySelected) {
+    return { state: context.state, hydration: context.hydration };
+  }
+
+  return context.selectColumns(context.state, context.hydration, {
+    [relation.foreignKey]: fkColumn
+  });
+};
+
+const standardIncludeStrategy: IncludeStrategy = context => {
+  const relation = context.relation as RelationWithForeignKey;
+  let { state, hydration } = context;
+
+  const fkSelectionResult = ensureRootForeignKeySelected(context, relation);
+  state = fkSelectionResult.state;
+  hydration = fkSelectionResult.hydration;
+
+  const targetColumns = resolveTargetColumns(relation, context.options);
+  const targetSelection = buildTypedSelection(
+    relation.target.columns as Record<string, ColumnDef>,
+    context.aliasPrefix,
+    targetColumns,
+    key => `Column '${key}' not found on relation '${context.relationName}'`
+  );
+
+  const relationSelectionResult = context.selectColumns(state, hydration, targetSelection);
+  state = relationSelectionResult.state;
+  hydration = relationSelectionResult.hydration;
+
+  hydration = hydration.onRelationIncluded(
+    state,
+    relation,
+    context.relationName,
+    context.aliasPrefix,
+    targetColumns
+  );
+
+  return { state, hydration };
+};
+
+const belongsToManyStrategy: IncludeStrategy = context => {
+  const relation = context.relation as BelongsToManyRelation;
+  let { state, hydration } = context;
+
+  const targetColumns = resolveTargetColumns(relation, context.options);
+  const targetSelection = buildTypedSelection(
+    relation.target.columns as Record<string, ColumnDef>,
+    context.aliasPrefix,
+    targetColumns,
+    key => `Column '${key}' not found on relation '${context.relationName}'`
+  );
+
+  const pivotAliasPrefix = context.options?.pivot?.aliasPrefix ?? `${context.aliasPrefix}_pivot`;
+  const pivotPk = relation.pivotPrimaryKey || findPrimaryKey(relation.pivotTable);
+  const defaultPivotColumns = relation.defaultPivotColumns ?? buildDefaultPivotColumns(relation, pivotPk);
+  const pivotColumns = context.options?.pivot?.columns
+    ? [...context.options.pivot.columns]
+    : [...defaultPivotColumns];
+
+  const pivotSelection = buildTypedSelection(
+    relation.pivotTable.columns as Record<string, ColumnDef>,
+    pivotAliasPrefix,
+    pivotColumns,
+    key => `Column '${key}' not found on pivot table '${relation.pivotTable.name}'`
+  );
+
+  const combinedSelection = {
+    ...targetSelection,
+    ...pivotSelection
+  };
+
+  const relationSelectionResult = context.selectColumns(state, hydration, combinedSelection);
+  state = relationSelectionResult.state;
+  hydration = relationSelectionResult.hydration;
+
+  hydration = hydration.onRelationIncluded(
+    state,
+    relation,
+    context.relationName,
+    context.aliasPrefix,
+    targetColumns,
+    { aliasPrefix: pivotAliasPrefix, columns: pivotColumns }
+  );
+
+  return { state, hydration };
+};
+
+export const relationIncludeStrategies: Record<RelationDef['type'], IncludeStrategy> = {
+  [RelationKinds.HasMany]: standardIncludeStrategy,
+  [RelationKinds.HasOne]: standardIncludeStrategy,
+  [RelationKinds.BelongsTo]: standardIncludeStrategy,
+  [RelationKinds.BelongsToMany]: belongsToManyStrategy
+};

package/src/query-builder/relation-join-planner.ts

@@ -0,0 +1,80 @@
+import { TableDef } from '../schema/table.js';
+import { RelationDef, RelationKinds, BelongsToManyRelation } from '../schema/relation.js';
+import { SelectQueryState } from './select-query-state.js';
+import { QueryAstService } from './query-ast-service.js';
+import { TableSourceNode } from '../core/ast/query.js';
+import { ExpressionNode } from '../core/ast/expression.js';
+import { JoinKind } from '../core/sql/sql.js';
+import { buildRelationJoinCondition, buildBelongsToManyJoins } from './relation-conditions.js';
+import { createJoinNode } from '../core/ast/join-node.js';
+
+export class RelationJoinPlanner {
+  constructor(
+    private readonly table: TableDef,
+    private readonly createQueryAstService: (table: TableDef, state: SelectQueryState) => QueryAstService
+  ) {}
+
+  withJoin(
+    state: SelectQueryState,
+    relationName: string,
+    relation: RelationDef,
+    joinKind: JoinKind,
+    extraCondition?: ExpressionNode,
+    tableSource?: TableSourceNode
+  ): SelectQueryState {
+    const rootAlias = state.ast.from.type === 'Table' ? state.ast.from.alias : undefined;
+    if (relation.type === RelationKinds.BelongsToMany) {
+      const targetTableSource: TableSourceNode = tableSource ?? {
+        type: 'Table',
+        name: relation.target.name,
+        schema: relation.target.schema
+      };
+      const targetName = this.resolveTargetTableName(targetTableSource, relation);
+      const joins = buildBelongsToManyJoins(
+        this.table,
+        relationName,
+        relation as BelongsToManyRelation,
+        joinKind,
+        extraCondition,
+        rootAlias,
+        targetTableSource,
+        targetName
+      );
+      return joins.reduce((current, join) => this.astService(current).withJoin(join), state);
+    }
+
+    const targetTable: TableSourceNode = tableSource ?? {
+      type: 'Table',
+      name: relation.target.name,
+      schema: relation.target.schema
+    };
+    const targetName = this.resolveTargetTableName(targetTable, relation);
+    const condition = buildRelationJoinCondition(
+      this.table,
+      relation,
+      extraCondition,
+      rootAlias,
+      targetName
+    );
+    const joinNode = createJoinNode(joinKind, targetTable, condition, relationName);
+
+    return this.astService(state).withJoin(joinNode);
+  }
+
+  private astService(state: SelectQueryState): QueryAstService {
+    return this.createQueryAstService(this.table, state);
+  }
+
+  private resolveTargetTableName(target: TableSourceNode, relation: RelationDef): string {
+    if (target.type === 'Table') {
+      return target.alias ?? target.name;
+    }
+    if (target.type === 'DerivedTable') {
+      return target.alias;
+    }
+    if (target.type === 'FunctionTable') {
+      return target.alias ?? relation.target.name;
+    }
+    return relation.target.name;
+  }
+}