metal-orm 1.0.83 → 1.0.86

package/package.json

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

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

@@ -1,188 +1,19 @@
-import type { ExpressionNode, OperandNode } from './expression-nodes.js';
-import { visitExpression, visitOperand } from './expression-visitor.js';
 import type { SelectQueryNode } from './query.js';
+import { visitSelectQuery } from './query-visitor.js';
 
-const hasParamOperandsInExpression = (expr: ExpressionNode): boolean => {
-  let hasParams = false;
+export const findFirstParamOperandName = (ast: SelectQueryNode): string | undefined => {
+  let name: string | undefined;
 
-  visitExpression(expr, {
-    visitBinaryExpression: (node) => {
-      visitOperand(node.left, {
-        visitParam: () => { hasParams = true; },
-        otherwise: () => {}
-      });
-      visitOperand(node.right, {
-        visitParam: () => { hasParams = true; },
-        otherwise: () => {}
-      });
-      if (node.escape) {
-        visitOperand(node.escape, {
-          visitParam: () => { hasParams = true; },
-          otherwise: () => {}
-        });
-      }
-    },
-    visitLogicalExpression: (node) => {
-      node.operands.forEach(operand => {
-        if (hasParamOperandsInExpression(operand)) {
-          hasParams = true;
-        }
-      });
-    },
-    visitNullExpression: () => {},
-    visitInExpression: (node) => {
-      visitOperand(node.left, {
-        visitParam: () => { hasParams = true; },
-        otherwise: () => {}
-      });
-      if (Array.isArray(node.right)) {
-        node.right.forEach(operand => visitOperand(operand, {
-          visitParam: () => { hasParams = true; },
-          otherwise: () => {}
-        }));
-      }
-    },
-    visitExistsExpression: () => {},
-    visitBetweenExpression: (node) => {
-      visitOperand(node.left, {
-        visitParam: () => { hasParams = true; },
-        otherwise: () => {}
-      });
-      visitOperand(node.lower, {
-        visitParam: () => { hasParams = true; },
-        otherwise: () => {}
-      });
-      visitOperand(node.upper, {
-        visitParam: () => { hasParams = true; },
-        otherwise: () => {}
-      });
-    },
-    visitArithmeticExpression: (node) => {
-      visitOperand(node.left, {
-        visitParam: () => { hasParams = true; },
-        otherwise: () => {}
-      });
-      visitOperand(node.right, {
-        visitParam: () => { hasParams = true; },
-        otherwise: () => {}
-      });
-    },
-    visitBitwiseExpression: (node) => {
-      visitOperand(node.left, {
-        visitParam: () => { hasParams = true; },
-        otherwise: () => {}
-      });
-      visitOperand(node.right, {
-        visitParam: () => { hasParams = true; },
-        otherwise: () => {}
-      });
-    },
-    otherwise: () => {}
-  });
-
-  return hasParams;
-};
-
-const hasParamOperandsInOperand = (operand: OperandNode): boolean => {
-  let hasParams = false;
-
-  visitOperand(operand, {
-    visitColumn: () => {},
-    visitLiteral: () => {},
-    visitParam: () => { hasParams = true; },
-    visitFunction: (node) => {
-      node.args?.forEach(arg => {
-        if (hasParamOperandsInOperand(arg)) {
-          hasParams = true;
-        }
-      });
-    },
-    visitJsonPath: () => {},
-    visitScalarSubquery: () => {},
-    visitCaseExpression: (node) => {
-      node.conditions.forEach(cond => {
-        if (hasParamOperandsInExpression(cond.when)) {
-          hasParams = true;
-        }
-        if (hasParamOperandsInOperand(cond.then)) {
-          hasParams = true;
-        }
-      });
-      if (node.else && hasParamOperandsInOperand(node.else)) {
-        hasParams = true;
-      }
-    },
-    visitCast: (node) => {
-      if (hasParamOperandsInOperand(node.expression)) {
-        hasParams = true;
-      }
-    },
-    visitWindowFunction: (node) => {
-      node.args?.forEach(arg => {
-        if (hasParamOperandsInOperand(arg)) {
-          hasParams = true;
-        }
-      });
-      node.orderBy?.forEach(ord => {
-        if (ord.term) {
-          if (hasParamOperandsInOperand(ord.term as OperandNode)) {
-            hasParams = true;
-          }
-        }
-      });
-    },
-    visitCollate: (node) => {
-      if (hasParamOperandsInOperand(node.expression)) {
-        hasParams = true;
-      }
-    },
-    visitAliasRef: () => {},
-    otherwise: () => {}
-  });
-
-  return hasParams;
-};
-
-export const hasParamOperandsInQuery = (ast: SelectQueryNode): boolean => {
-  if (ast.where && hasParamOperandsInExpression(ast.where)) {
-    return true;
-  }
-
-  if (ast.having && hasParamOperandsInExpression(ast.having)) {
-    return true;
-  }
-
-  ast.columns?.forEach(col => {
-    if (typeof col === 'object' && col !== null && 'type' in col) {
-      if (hasParamOperandsInOperand(col as OperandNode)) {
-        return true;
+  visitSelectQuery(ast, {
+    visitParam: (node) => {
+      if (!name) {
+        name = node.name;
       }
     }
   });
 
-  ast.orderBy?.forEach(ord => {
-    if (ord.term) {
-      if (hasParamOperandsInOperand(ord.term as OperandNode)) {
-        return true;
-      }
-    }
-  });
-
-  if (ast.ctes) {
-    for (const cte of ast.ctes) {
-      if (cte.query.where && hasParamOperandsInExpression(cte.query.where)) {
-        return true;
-      }
-    }
-  }
-
-  if (ast.setOps) {
-    for (const op of ast.setOps) {
-      if (hasParamOperandsInQuery(op.query)) {
-        return true;
-      }
-    }
-  }
-
-  return false;
+  return name;
 };
+
+export const hasParamOperandsInQuery = (ast: SelectQueryNode): boolean =>
+  !!findFirstParamOperandName(ast);

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

@@ -21,6 +21,7 @@ import {
   BitwiseExpressionNode,
   ParamNode
 } from './expression-nodes.js';
+import type { SelectQueryNode } from './query.js';
 
 /**
  * Visitor for expression nodes
@@ -34,6 +35,8 @@ export interface ExpressionVisitor<R> {
   visitBetweenExpression?(node: BetweenExpressionNode): R;
   visitArithmeticExpression?(node: ArithmeticExpressionNode): R;
   visitBitwiseExpression?(node: BitwiseExpressionNode): R;
+  visitOperand?(node: OperandNode): R;
+  visitSelectQuery?(node: SelectQueryNode): R;
   otherwise?(node: ExpressionNode): R;
 }
 
@@ -50,6 +53,10 @@ export interface OperandVisitor<R> {
   visitCaseExpression?(node: CaseExpressionNode): R;
   visitCast?(node: CastExpressionNode): R;
   visitWindowFunction?(node: WindowFunctionNode): R;
+  visitArithmeticExpression?(node: ArithmeticExpressionNode): R;
+  visitBitwiseExpression?(node: BitwiseExpressionNode): R;
+  visitExpression?(node: ExpressionNode): R;
+  visitSelectQuery?(node: SelectQueryNode): R;
   visitCollate?(node: CollateExpressionNode): R;
   visitAliasRef?(node: AliasRefNode): R;
   otherwise?(node: OperandNode): R;
@@ -111,6 +118,12 @@ export const registerOperandDispatcher = (type: string, dispatcher: OperandDispa
   operandRegistry = operandRegistry.register(type, dispatcher);
 };
 
+export const hasExpressionDispatcher = (type: string): boolean =>
+  expressionRegistry.get(type) !== undefined;
+
+export const hasOperandDispatcher = (type: string): boolean =>
+  operandRegistry.get(type) !== undefined;
+
 /**
  * Clears all registered dispatchers. Primarily for tests.
  */
@@ -122,8 +135,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 +158,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 +200,49 @@ 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;
+    case 'ArithmeticExpression':
+      if (visitor.visitArithmeticExpression) return visitor.visitArithmeticExpression(node as ArithmeticExpressionNode);
+      break;
+    case 'BitwiseExpression':
+      if (visitor.visitBitwiseExpression) return visitor.visitBitwiseExpression(node as BitwiseExpressionNode);
       break;
     default:
       break;