metal-orm 1.1.11 → 1.1.18

package/src/query-builder/query-resolution.ts

@@ -1,78 +1,78 @@
-import { SelectQueryNode, UpdateQueryNode, DeleteQueryNode, TableSourceNode } from '../core/ast/query.js';
-import { TableDef } from '../schema/table.js';
-import type { SelectQueryBuilder } from './select.js';
-import type { UpdateQueryBuilder } from './update.js';
-import type { DeleteQueryBuilder } from './delete.js';
-
-/**
- * Resolves a SelectQueryBuilder or SelectQueryNode to a SelectQueryNode AST
- * @param query - Query builder or AST node
- * @returns SelectQueryNode AST
- */
-export function resolveSelectQuery<TSub extends TableDef>(
-    query: SelectQueryBuilder<unknown, TSub> | SelectQueryNode
-): SelectQueryNode {
-    const candidate = query as { getAST?: () => SelectQueryNode };
-    return typeof candidate.getAST === 'function' && candidate.getAST
-        ? candidate.getAST()
-        : (query as SelectQueryNode);
-}
-
-/**
- * Resolves a UpdateQueryBuilder or UpdateQueryNode to a UpdateQueryNode AST
- * @param query - Query builder or AST node
- * @returns UpdateQueryNode AST
- */
-export function resolveUpdateQuery<T>(
-    query: UpdateQueryBuilder<T> | UpdateQueryNode
-): UpdateQueryNode {
-    const candidate = query as { getAST?: () => UpdateQueryNode };
-    return typeof candidate.getAST === 'function' && candidate.getAST
-        ? candidate.getAST()
-        : (query as UpdateQueryNode);
-}
-
-/**
- * Resolves a DeleteQueryBuilder or DeleteQueryNode to a DeleteQueryNode AST
- * @param query - Query builder or AST node
- * @returns DeleteQueryNode AST
- */
-export function resolveDeleteQuery<T>(
-    query: DeleteQueryBuilder<T> | DeleteQueryNode
-): DeleteQueryNode {
-    const candidate = query as { getAST?: () => DeleteQueryNode };
-    return typeof candidate.getAST === 'function' && candidate.getAST
-        ? candidate.getAST()
-        : (query as DeleteQueryNode);
-}
-
-/**
- * Resolves a TableDef or TableSourceNode to a TableSourceNode
- * @param source - Table definition or source node
- * @returns TableSourceNode
- */
-export function resolveTableSource(source: TableDef | TableSourceNode): TableSourceNode {
-    if (isTableSourceNode(source)) {
-        return source;
-    }
-    return { type: 'Table', name: source.name, schema: source.schema };
-}
-
-/**
- * Resolves a join target (TableDef, TableSourceNode, or string relation name)
- * @param table - Join target
- * @returns TableSourceNode or string
- */
-export function resolveJoinTarget(table: TableDef | TableSourceNode | string): TableSourceNode | string {
-    if (typeof table === 'string') return table;
-    return resolveTableSource(table);
-}
-
-/**
- * Type guard to check if a value is a TableSourceNode
- * @param source - Value to check
- * @returns True if value is a TableSourceNode
- */
-function isTableSourceNode(source: TableDef | TableSourceNode): source is TableSourceNode {
-    return typeof (source as TableSourceNode).type === 'string';
-}
+import { SelectQueryNode, UpdateQueryNode, DeleteQueryNode, TableSourceNode } from '../core/ast/query.js';
+import { TableDef } from '../schema/table.js';
+import type { SelectQueryBuilder } from './select.js';
+import type { UpdateQueryBuilder } from './update.js';
+import type { DeleteQueryBuilder } from './delete.js';
+
+/**
+ * Resolves a SelectQueryBuilder or SelectQueryNode to a SelectQueryNode AST
+ * @param query - Query builder or AST node
+ * @returns SelectQueryNode AST
+ */
+export function resolveSelectQuery<TSub extends TableDef>(
+    query: SelectQueryBuilder<unknown, TSub> | SelectQueryNode
+): SelectQueryNode {
+    const candidate = query as { getAST?: () => SelectQueryNode };
+    return typeof candidate.getAST === 'function' && candidate.getAST
+        ? candidate.getAST()
+        : (query as SelectQueryNode);
+}
+
+/**
+ * Resolves a UpdateQueryBuilder or UpdateQueryNode to a UpdateQueryNode AST
+ * @param query - Query builder or AST node
+ * @returns UpdateQueryNode AST
+ */
+export function resolveUpdateQuery<T>(
+    query: UpdateQueryBuilder<T> | UpdateQueryNode
+): UpdateQueryNode {
+    const candidate = query as { getAST?: () => UpdateQueryNode };
+    return typeof candidate.getAST === 'function' && candidate.getAST
+        ? candidate.getAST()
+        : (query as UpdateQueryNode);
+}
+
+/**
+ * Resolves a DeleteQueryBuilder or DeleteQueryNode to a DeleteQueryNode AST
+ * @param query - Query builder or AST node
+ * @returns DeleteQueryNode AST
+ */
+export function resolveDeleteQuery<T>(
+    query: DeleteQueryBuilder<T> | DeleteQueryNode
+): DeleteQueryNode {
+    const candidate = query as { getAST?: () => DeleteQueryNode };
+    return typeof candidate.getAST === 'function' && candidate.getAST
+        ? candidate.getAST()
+        : (query as DeleteQueryNode);
+}
+
+/**
+ * Resolves a TableDef or TableSourceNode to a TableSourceNode
+ * @param source - Table definition or source node
+ * @returns TableSourceNode
+ */
+export function resolveTableSource(source: TableDef | TableSourceNode): TableSourceNode {
+    if (isTableSourceNode(source)) {
+        return source;
+    }
+    return { type: 'Table', name: source.name, schema: source.schema };
+}
+
+/**
+ * Resolves a join target (TableDef, TableSourceNode, or string relation name)
+ * @param table - Join target
+ * @returns TableSourceNode or string
+ */
+export function resolveJoinTarget(table: TableDef | TableSourceNode | string): TableSourceNode | string {
+    if (typeof table === 'string') return table;
+    return resolveTableSource(table);
+}
+
+/**
+ * Type guard to check if a value is a TableSourceNode
+ * @param source - Value to check
+ * @returns True if value is a TableSourceNode
+ */
+function isTableSourceNode(source: TableDef | TableSourceNode): source is TableSourceNode {
+    return typeof (source as TableSourceNode).type === 'string';
+}

package/src/query-builder/raw-column-parser.ts

@@ -1,38 +1,38 @@
-import { ColumnNode } from '../core/ast/expression.js';
-import { CommonTableExpressionNode } from '../core/ast/query.js';
-
-/**
- * Best-effort helper that tries to convert a raw column expression into a `ColumnNode`.
- * This parser is intentionally limited; use it only for simple references or function calls.
- *
- * @param col - Raw column expression string (e.g., "column", "table.column", "COUNT(column)")
- * @param tableName - Default table name to use when no table is specified
- * @param ctes - Optional array of CTEs for context when parsing column references
- * @returns A ColumnNode representing the parsed column expression
- */
-export const parseRawColumn = (
-  col: string,
-  tableName: string,
-  ctes?: CommonTableExpressionNode[]
-): ColumnNode => {
-  if (col.includes('(')) {
-    const [_fn, rest] = col.split('(');
-    void _fn;
-    const colName = rest.replace(')', '');
-    const [table, name] = colName.includes('.') ? colName.split('.') : [tableName, colName];
-    return { type: 'Column', table, name, alias: col };
-  }
-
-  if (col.includes('.')) {
-    const [potentialCteName, columnName] = col.split('.');
-    const hasCte = ctes?.some(cte => cte.name === potentialCteName);
-
-    if (hasCte) {
-      return { type: 'Column', table: tableName, name: col };
-    }
-
-    return { type: 'Column', table: potentialCteName, name: columnName };
-  }
-
-  return { type: 'Column', table: tableName, name: col };
-};
+import { ColumnNode } from '../core/ast/expression.js';
+import { CommonTableExpressionNode } from '../core/ast/query.js';
+
+/**
+ * Best-effort helper that tries to convert a raw column expression into a `ColumnNode`.
+ * This parser is intentionally limited; use it only for simple references or function calls.
+ *
+ * @param col - Raw column expression string (e.g., "column", "table.column", "COUNT(column)")
+ * @param tableName - Default table name to use when no table is specified
+ * @param ctes - Optional array of CTEs for context when parsing column references
+ * @returns A ColumnNode representing the parsed column expression
+ */
+export const parseRawColumn = (
+  col: string,
+  tableName: string,
+  ctes?: CommonTableExpressionNode[]
+): ColumnNode => {
+  if (col.includes('(')) {
+    const [_fn, rest] = col.split('(');
+    void _fn;
+    const colName = rest.replace(')', '');
+    const [table, name] = colName.includes('.') ? colName.split('.') : [tableName, colName];
+    return { type: 'Column', table, name, alias: col };
+  }
+
+  if (col.includes('.')) {
+    const [potentialCteName, columnName] = col.split('.');
+    const hasCte = ctes?.some(cte => cte.name === potentialCteName);
+
+    if (hasCte) {
+      return { type: 'Column', table: tableName, name: col };
+    }
+
+    return { type: 'Column', table: potentialCteName, name: columnName };
+  }
+
+  return { type: 'Column', table: tableName, name: col };
+};

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

@@ -1,70 +1,70 @@
-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;
+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;
@@ -74,89 +74,89 @@ const collectFromExpression = (expr: ExpressionNode, collector: FilterTableColle
     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);
-};
+    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-join-planner.ts

@@ -1,23 +1,23 @@
-import { TableDef } from '../schema/table.js';
+import { TableDef } from '../schema/table.js';
 import { RelationDef } from '../schema/relation.js';
 import { SelectQueryState } from './select-query-state.js';
 import { TableSourceNode } from '../core/ast/query.js';
 import { ExpressionNode } from '../core/ast/expression.js';
 import { JoinKind } from '../core/sql/sql.js';
 import { addRelationJoin } from './relation-join-strategies.js';
-
+
 export class RelationJoinPlanner {
   constructor(
     private readonly table: TableDef
   ) {}
-
-  withJoin(
-    state: SelectQueryState,
-    relationName: string,
-    relation: RelationDef,
-    joinKind: JoinKind,
-    extraCondition?: ExpressionNode,
-    tableSource?: TableSourceNode
+
+  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;
     return addRelationJoin({