metal-orm 1.0.82 → 1.0.85

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metal-orm",
-  "version": "1.0.82",
+  "version": "1.0.85",
   "type": "module",
   "types": "./dist/index.d.ts",
   "engines": {

package/src/core/ast/ast-validation.ts

@@ -0,0 +1,14 @@
+import type { SelectQueryNode } from './query.js';
+import { visitSelectQuery } from './query-visitor.js';
+
+export const hasParamOperandsInQuery = (ast: SelectQueryNode): boolean => {
+  let hasParams = false;
+
+  visitSelectQuery(ast, {
+    visitParam: () => {
+      hasParams = true;
+    }
+  });
+
+  return hasParams;
+};

package/src/core/ast/expression-builders.ts

@@ -2,13 +2,14 @@ import { SelectQueryNode } from './query.js';
 import { SqlOperator, BitwiseOperator } from '../sql/sql.js';
 import { ColumnRef } from './types.js';
 import {
-  ColumnNode,
-  LiteralNode,
-  JsonPathNode,
-  OperandNode,
-  CaseExpressionNode,
-  CastExpressionNode,
-  BinaryExpressionNode,
+  ColumnNode,
+  LiteralNode,
+  ParamNode,
+  JsonPathNode,
+  OperandNode,
+  CaseExpressionNode,
+  CastExpressionNode,
+  BinaryExpressionNode,
   ExpressionNode,
   LogicalExpressionNode,
   NullExpressionNode,
@@ -47,12 +48,21 @@ const toLiteralNode = (value: LiteralValue): LiteralNode => ({
   type: 'Literal',
   value: value instanceof Date ? value.toISOString() : value
 });
-
-/**
- * Converts a ColumnRef to a ColumnNode
- * @throws Error if the ColumnRef doesn't have a table specified
- */
-const columnRefToNode = (col: ColumnRef): ColumnNode => {
+
+const toParamNode = (value: unknown): ParamNode | undefined => {
+  if (typeof value !== 'object' || value === null) return undefined;
+  const type = Object.getOwnPropertyDescriptor(value, 'type')?.value;
+  if (type !== 'Param') return undefined;
+  const name = Object.getOwnPropertyDescriptor(value, 'name')?.value;
+  if (typeof name !== 'string') return undefined;
+  return { type: 'Param', name };
+};
+
+/**
+ * Converts a ColumnRef to a ColumnNode
+ * @throws Error if the ColumnRef doesn't have a table specified
+ */
+const columnRefToNode = (col: ColumnRef): ColumnNode => {
   if (!col.table) {
     throw new Error(
       `Column "${col.name}" requires a table reference. ` +
@@ -67,11 +77,16 @@ const columnRefToNode = (col: ColumnRef): ColumnNode => {
  * @param value - Value to convert (OperandNode, ColumnRef, or literal value)
  * @returns OperandNode representing the value
  */
-const toOperandNode = (value: OperandNode | ColumnRef | LiteralValue): OperandNode => {
-  // Already an operand node
-  if (isOperandNode(value)) {
-    return value;
-  }
+const toOperandNode = (value: OperandNode | ColumnRef | LiteralValue): OperandNode => {
+  const paramNode = toParamNode(value);
+  if (paramNode) {
+    return paramNode;
+  }
+
+  // Already an operand node
+  if (isOperandNode(value)) {
+    return value;
+  }
 
   // Literal value
   if (isLiteralValue(value)) {
@@ -87,12 +102,16 @@ const toOperandNode = (value: OperandNode | ColumnRef | LiteralValue): OperandNo
  * @param value - Value or operand to normalize
  * @returns OperandNode representing the value
  */
-export const valueToOperand = (value: ValueOperandInput): OperandNode => {
-  if (isOperandNode(value)) {
-    return value;
-  }
-  return toLiteralNode(value);
-};
+export const valueToOperand = (value: ValueOperandInput): OperandNode => {
+  const paramNode = toParamNode(value);
+  if (paramNode) {
+    return paramNode;
+  }
+  if (isOperandNode(value)) {
+    return value;
+  }
+  return toLiteralNode(value);
+};
 
 /**
  * Converts various input types to an OperandNode

package/src/core/ast/expression-nodes.ts

@@ -183,31 +183,41 @@ const operandTypes = new Set<OperandNode['type']>([
   'ScalarSubquery',
   'CaseExpression',
   'Cast',
-  'WindowFunction',
-  'ArithmeticExpression',
-  'BitwiseExpression',
-  'Collate'
-]);
-
-const hasTypeProperty = (value: unknown): value is { type?: string } =>
-  typeof value === 'object' && value !== null && 'type' in value;
-
-export const isOperandNode = (node: unknown): node is OperandNode => {
-  if (!hasTypeProperty(node)) return false;
-  return operandTypes.has(node.type as OperandNode['type']);
-};
-
-export const isFunctionNode = (node: unknown): node is FunctionNode =>
-  isOperandNode(node) && node.type === 'Function';
-export const isCaseExpressionNode = (node: unknown): node is CaseExpressionNode =>
-  isOperandNode(node) && node.type === 'CaseExpression';
-
-export const isCastExpressionNode = (node: unknown): node is CastExpressionNode =>
-  isOperandNode(node) && node.type === 'Cast';
-export const isCollateExpressionNode = (node: unknown): node is CollateExpressionNode =>
-  isOperandNode(node) && node.type === 'Collate';
-export const isWindowFunctionNode = (node: unknown): node is WindowFunctionNode =>
-  isOperandNode(node) && node.type === 'WindowFunction';
+  'WindowFunction',
+  'ArithmeticExpression',
+  'BitwiseExpression',
+  'Collate'
+]);
+
+const getNodeType = (value: unknown): string | undefined => {
+  if (typeof value !== 'object' || value === null) return undefined;
+  const descriptor = Object.getOwnPropertyDescriptor(value, 'type');
+  if (descriptor && typeof descriptor.value === 'string') {
+    return descriptor.value;
+  }
+  if ('type' in value) {
+    const type = (value as { type?: unknown }).type;
+    return typeof type === 'string' ? type : undefined;
+  }
+  return undefined;
+};
+
+export const isOperandNode = (node: unknown): node is OperandNode => {
+  const type = getNodeType(node);
+  return type !== undefined && operandTypes.has(type as OperandNode['type']);
+};
+
+export const isFunctionNode = (node: unknown): node is FunctionNode =>
+  isOperandNode(node) && getNodeType(node) === 'Function';
+export const isCaseExpressionNode = (node: unknown): node is CaseExpressionNode =>
+  isOperandNode(node) && getNodeType(node) === 'CaseExpression';
+
+export const isCastExpressionNode = (node: unknown): node is CastExpressionNode =>
+  isOperandNode(node) && getNodeType(node) === 'Cast';
+export const isCollateExpressionNode = (node: unknown): node is CollateExpressionNode =>
+  isOperandNode(node) && getNodeType(node) === 'Collate';
+export const isWindowFunctionNode = (node: unknown): node is WindowFunctionNode =>
+  isOperandNode(node) && getNodeType(node) === 'WindowFunction';
 export const isExpressionSelectionNode = (
   node: ColumnRef | FunctionNode | CaseExpressionNode | CastExpressionNode | WindowFunctionNode
 ): node is FunctionNode | CaseExpressionNode | CastExpressionNode | WindowFunctionNode =>

package/src/core/ast/expression-visitor.ts

@@ -122,8 +122,15 @@ export const clearOperandDispatchers = (): void => {
   operandRegistry = operandRegistry.clear();
 };
 
-const getNodeType = (node: { type?: string } | null | undefined): string | undefined =>
-  typeof node === 'object' && node !== null && typeof node.type === 'string' ? node.type : undefined;
+const getNodeType = (node: { type?: string } | null | undefined): string | undefined => {
+  if (typeof node !== 'object' || node === null) return undefined;
+  const descriptor = Object.getOwnPropertyDescriptor(node, 'type');
+  if (descriptor && typeof descriptor.value === 'string') {
+    return descriptor.value;
+  }
+  const type = node.type;
+  return typeof type === 'string' ? type : undefined;
+};
 
 const unsupportedExpression = (node: ExpressionNode): never => {
   throw new Error(`Unsupported expression type "${getNodeType(node) ?? 'unknown'}"`);
@@ -138,33 +145,34 @@ const unsupportedOperand = (node: OperandNode): never => {
  * @param visitor - Visitor implementation
  */
 export const visitExpression = <R>(node: ExpressionNode, visitor: ExpressionVisitor<R>): R => {
-  const dynamic = expressionRegistry.get(node.type);
+  const type = getNodeType(node);
+  const dynamic = type ? expressionRegistry.get(type) : undefined;
   if (dynamic) return dynamic(node, visitor);
 
-  switch (node.type) {
+  switch (type) {
     case 'BinaryExpression':
-      if (visitor.visitBinaryExpression) return visitor.visitBinaryExpression(node);
+      if (visitor.visitBinaryExpression) return visitor.visitBinaryExpression(node as BinaryExpressionNode);
       break;
     case 'LogicalExpression':
-      if (visitor.visitLogicalExpression) return visitor.visitLogicalExpression(node);
+      if (visitor.visitLogicalExpression) return visitor.visitLogicalExpression(node as LogicalExpressionNode);
       break;
     case 'NullExpression':
-      if (visitor.visitNullExpression) return visitor.visitNullExpression(node);
+      if (visitor.visitNullExpression) return visitor.visitNullExpression(node as NullExpressionNode);
       break;
     case 'InExpression':
-      if (visitor.visitInExpression) return visitor.visitInExpression(node);
+      if (visitor.visitInExpression) return visitor.visitInExpression(node as InExpressionNode);
       break;
     case 'ExistsExpression':
-      if (visitor.visitExistsExpression) return visitor.visitExistsExpression(node);
+      if (visitor.visitExistsExpression) return visitor.visitExistsExpression(node as ExistsExpressionNode);
       break;
     case 'BetweenExpression':
-      if (visitor.visitBetweenExpression) return visitor.visitBetweenExpression(node);
+      if (visitor.visitBetweenExpression) return visitor.visitBetweenExpression(node as BetweenExpressionNode);
       break;
     case 'ArithmeticExpression':
-      if (visitor.visitArithmeticExpression) return visitor.visitArithmeticExpression(node);
+      if (visitor.visitArithmeticExpression) return visitor.visitArithmeticExpression(node as ArithmeticExpressionNode);
       break;
     case 'BitwiseExpression':
-      if (visitor.visitBitwiseExpression) return visitor.visitBitwiseExpression(node);
+      if (visitor.visitBitwiseExpression) return visitor.visitBitwiseExpression(node as BitwiseExpressionNode);
       break;
     default:
       break;
@@ -179,42 +187,43 @@ export const visitExpression = <R>(node: ExpressionNode, visitor: ExpressionVisi
  * @param visitor - Visitor implementation
  */
 export const visitOperand = <R>(node: OperandNode, visitor: OperandVisitor<R>): R => {
-  const dynamic = operandRegistry.get(node.type);
+  const type = getNodeType(node);
+  const dynamic = type ? operandRegistry.get(type) : undefined;
   if (dynamic) return dynamic(node, visitor);
 
-  switch (node.type) {
+  switch (type) {
     case 'Column':
-      if (visitor.visitColumn) return visitor.visitColumn(node);
+      if (visitor.visitColumn) return visitor.visitColumn(node as ColumnNode);
       break;
     case 'Literal':
-      if (visitor.visitLiteral) return visitor.visitLiteral(node);
+      if (visitor.visitLiteral) return visitor.visitLiteral(node as LiteralNode);
       break;
     case 'Param':
-      if (visitor.visitParam) return visitor.visitParam(node);
+      if (visitor.visitParam) return visitor.visitParam(node as ParamNode);
       break;
     case 'Function':
-      if (visitor.visitFunction) return visitor.visitFunction(node);
+      if (visitor.visitFunction) return visitor.visitFunction(node as FunctionNode);
       break;
     case 'JsonPath':
-      if (visitor.visitJsonPath) return visitor.visitJsonPath(node);
+      if (visitor.visitJsonPath) return visitor.visitJsonPath(node as JsonPathNode);
       break;
     case 'ScalarSubquery':
-      if (visitor.visitScalarSubquery) return visitor.visitScalarSubquery(node);
+      if (visitor.visitScalarSubquery) return visitor.visitScalarSubquery(node as ScalarSubqueryNode);
       break;
     case 'CaseExpression':
-      if (visitor.visitCaseExpression) return visitor.visitCaseExpression(node);
+      if (visitor.visitCaseExpression) return visitor.visitCaseExpression(node as CaseExpressionNode);
       break;
     case 'WindowFunction':
-      if (visitor.visitWindowFunction) return visitor.visitWindowFunction(node);
+      if (visitor.visitWindowFunction) return visitor.visitWindowFunction(node as WindowFunctionNode);
       break;
     case 'AliasRef':
-      if (visitor.visitAliasRef) return visitor.visitAliasRef(node);
+      if (visitor.visitAliasRef) return visitor.visitAliasRef(node as AliasRefNode);
       break;
     case 'Cast':
-      if (visitor.visitCast) return visitor.visitCast(node);
+      if (visitor.visitCast) return visitor.visitCast(node as CastExpressionNode);
       break;
     case 'Collate':
-      if (visitor.visitCollate) return visitor.visitCollate(node);
+      if (visitor.visitCollate) return visitor.visitCollate(node as CollateExpressionNode);
       break;
     default:
       break;

package/src/core/ast/param-proxy.ts

@@ -21,7 +21,7 @@ const buildParamProxy = (name: string): ParamProxy => {
         const nextName = name ? `${name}.${trimmed}` : trimmed;
         return buildParamProxy(nextName);
       }
-      if (prop in t) {
+      if (prop in t && name === '') {
         return (t as unknown as Record<string, unknown>)[prop];
       }
       const nextName = name ? `${name}.${prop}` : prop;
@@ -41,9 +41,6 @@ export const createParamProxy = (): ParamProxyRoot => {
       if (typeof prop === 'string' && prop.startsWith('$')) {
         return buildParamProxy(prop.slice(1));
       }
-      if (prop in t) {
-        return (t as unknown as Record<string, unknown>)[prop];
-      }
       return buildParamProxy(String(prop));
     }
   }) as ParamProxyRoot;

package/src/core/ast/query-visitor.ts

@@ -0,0 +1,227 @@
+import type {
+  CommonTableExpressionNode,
+  DerivedTableNode,
+  FunctionTableNode,
+  OrderByNode,
+  OrderingTerm,
+  SelectQueryNode,
+  SetOperationNode,
+  TableSourceNode
+} from './query.js';
+import type { JoinNode } from './join.js';
+import type {
+  ExpressionNode,
+  OperandNode,
+  ParamNode
+} from './expression-nodes.js';
+import { isOperandNode } from './expression-nodes.js';
+
+export interface SelectQueryVisitor {
+  visitSelectQuery?(node: SelectQueryNode): void;
+  visitTableSource?(node: TableSourceNode): void;
+  visitDerivedTable?(node: DerivedTableNode): void;
+  visitFunctionTable?(node: FunctionTableNode): void;
+  visitJoin?(node: JoinNode): void;
+  visitCte?(node: CommonTableExpressionNode): void;
+  visitSetOperation?(node: SetOperationNode): void;
+  visitOrderBy?(node: OrderByNode): void;
+  visitExpression?(node: ExpressionNode): void;
+  visitOperand?(node: OperandNode): void;
+  visitParam?(node: ParamNode): void;
+}
+
+const getNodeType = (value: unknown): string | undefined => {
+  if (typeof value !== 'object' || value === null) return undefined;
+  const descriptor = Object.getOwnPropertyDescriptor(value, 'type');
+  if (descriptor && typeof descriptor.value === 'string') {
+    return descriptor.value;
+  }
+  if ('type' in value) {
+    const type = (value as { type?: unknown }).type;
+    return typeof type === 'string' ? type : undefined;
+  }
+  return undefined;
+};
+
+const visitOrderingTerm = (term: OrderingTerm, visitor: SelectQueryVisitor): void => {
+  if (isOperandNode(term)) {
+    visitOperandNode(term, visitor);
+    return;
+  }
+  visitExpressionNode(term as ExpressionNode, visitor);
+};
+
+const visitOrderByNode = (node: OrderByNode, visitor: SelectQueryVisitor): void => {
+  visitor.visitOrderBy?.(node);
+  visitOrderingTerm(node.term, visitor);
+};
+
+const visitTableSource = (source: TableSourceNode, visitor: SelectQueryVisitor): void => {
+  visitor.visitTableSource?.(source);
+  if (source.type === 'DerivedTable') {
+    visitor.visitDerivedTable?.(source);
+    visitSelectQuery(source.query, visitor);
+    return;
+  }
+  if (source.type === 'FunctionTable') {
+    visitor.visitFunctionTable?.(source);
+    source.args?.forEach(arg => visitOperandNode(arg, visitor));
+  }
+};
+
+const visitExpressionNode = (node: ExpressionNode, visitor: SelectQueryVisitor): void => {
+  visitor.visitExpression?.(node);
+  const type = getNodeType(node);
+  if (!type) return;
+  switch (type) {
+    case 'BinaryExpression':
+      visitOperandNode(node.left, visitor);
+      visitOperandNode(node.right, visitor);
+      if (node.escape) {
+        visitOperandNode(node.escape, visitor);
+      }
+      return;
+    case 'LogicalExpression':
+      node.operands.forEach(operand => visitExpressionNode(operand, visitor));
+      return;
+    case 'NullExpression':
+      visitOperandNode(node.left, visitor);
+      return;
+    case 'InExpression':
+      visitOperandNode(node.left, visitor);
+      if (Array.isArray(node.right)) {
+        node.right.forEach(operand => visitOperandNode(operand, visitor));
+      } else {
+        visitOperandNode(node.right, visitor);
+      }
+      return;
+    case 'ExistsExpression':
+      visitSelectQuery(node.subquery, visitor);
+      return;
+    case 'BetweenExpression':
+      visitOperandNode(node.left, visitor);
+      visitOperandNode(node.lower, visitor);
+      visitOperandNode(node.upper, visitor);
+      return;
+    case 'ArithmeticExpression':
+      visitOperandNode(node.left, visitor);
+      visitOperandNode(node.right, visitor);
+      return;
+    case 'BitwiseExpression':
+      visitOperandNode(node.left, visitor);
+      visitOperandNode(node.right, visitor);
+      return;
+    default: {
+      return;
+    }
+  }
+};
+
+const visitOperandNode = (node: OperandNode, visitor: SelectQueryVisitor): void => {
+  visitor.visitOperand?.(node);
+  const type = getNodeType(node);
+  if (type === 'Param') {
+    visitor.visitParam?.(node);
+  }
+  if (!type) return;
+  switch (type) {
+    case 'Column':
+    case 'Literal':
+    case 'Param':
+    case 'AliasRef':
+      return;
+    case 'Function':
+      node.args?.forEach(arg => visitOperandNode(arg, visitor));
+      node.orderBy?.forEach(order => visitOrderByNode(order, visitor));
+      if (node.separator) {
+        visitOperandNode(node.separator, visitor);
+      }
+      return;
+    case 'JsonPath':
+      visitOperandNode(node.column, visitor);
+      return;
+    case 'ScalarSubquery':
+      visitSelectQuery(node.query, visitor);
+      return;
+    case 'CaseExpression':
+      node.conditions.forEach(cond => {
+        visitExpressionNode(cond.when, visitor);
+        visitOperandNode(cond.then, visitor);
+      });
+      if (node.else) {
+        visitOperandNode(node.else, visitor);
+      }
+      return;
+    case 'Cast':
+      visitOperandNode(node.expression, visitor);
+      return;
+    case 'WindowFunction':
+      node.args?.forEach(arg => visitOperandNode(arg, visitor));
+      node.partitionBy?.forEach(term => visitOperandNode(term, visitor));
+      node.orderBy?.forEach(order => visitOrderByNode(order, visitor));
+      return;
+    case 'ArithmeticExpression':
+      visitOperandNode(node.left, visitor);
+      visitOperandNode(node.right, visitor);
+      return;
+    case 'BitwiseExpression':
+      visitOperandNode(node.left, visitor);
+      visitOperandNode(node.right, visitor);
+      return;
+    case 'Collate':
+      visitOperandNode(node.expression, visitor);
+      return;
+    default: {
+      const _exhaustive: never = node;
+      return _exhaustive;
+    }
+  }
+};
+
+export const visitSelectQuery = (ast: SelectQueryNode, visitor: SelectQueryVisitor): void => {
+  visitor.visitSelectQuery?.(ast);
+
+  if (ast.ctes) {
+    for (const cte of ast.ctes) {
+      visitor.visitCte?.(cte);
+      visitSelectQuery(cte.query, visitor);
+    }
+  }
+
+  visitTableSource(ast.from, visitor);
+
+  ast.columns?.forEach(col => {
+    visitOperandNode(col as OperandNode, visitor);
+  });
+
+  ast.joins?.forEach(join => {
+    visitor.visitJoin?.(join);
+    visitTableSource(join.table, visitor);
+    visitExpressionNode(join.condition, visitor);
+  });
+
+  if (ast.where) {
+    visitExpressionNode(ast.where, visitor);
+  }
+
+  ast.groupBy?.forEach(term => {
+    visitOrderingTerm(term, visitor);
+  });
+
+  if (ast.having) {
+    visitExpressionNode(ast.having, visitor);
+  }
+
+  ast.orderBy?.forEach(order => {
+    visitOrderByNode(order, visitor);
+  });
+
+  ast.distinct?.forEach(col => {
+    visitOperandNode(col, visitor);
+  });
+
+  ast.setOps?.forEach(op => {
+    visitor.visitSetOperation?.(op);
+    visitSelectQuery(op.query, visitor);
+  });
+};