metal-orm 1.0.85 → 1.0.87

package/dist/index.cjs

@@ -175,8 +175,10 @@ __export(index_exports, {
   groupConcat: () => groupConcat,
   gt: () => gt,
   gte: () => gte,
+  hasExpressionDispatcher: () => hasExpressionDispatcher,
   hasMany: () => hasMany,
   hasOne: () => hasOne,
+  hasOperandDispatcher: () => hasOperandDispatcher,
   hour: () => hour,
   hydrateRows: () => hydrateRows,
   ifNull: () => ifNull,
@@ -1054,6 +1056,8 @@ var registerExpressionDispatcher = (type, dispatcher) => {
 var registerOperandDispatcher = (type, dispatcher) => {
   operandRegistry = operandRegistry.register(type, dispatcher);
 };
+var hasExpressionDispatcher = (type) => expressionRegistry.get(type) !== void 0;
+var hasOperandDispatcher = (type) => operandRegistry.get(type) !== void 0;
 var clearExpressionDispatchers = () => {
   expressionRegistry = expressionRegistry.clear();
 };
@@ -1148,6 +1152,12 @@ var visitOperand = (node, visitor) => {
     case "Collate":
       if (visitor.visitCollate) return visitor.visitCollate(node);
       break;
+    case "ArithmeticExpression":
+      if (visitor.visitArithmeticExpression) return visitor.visitArithmeticExpression(node);
+      break;
+    case "BitwiseExpression":
+      if (visitor.visitBitwiseExpression) return visitor.visitBitwiseExpression(node);
+      break;
     default:
       break;
   }
@@ -7651,7 +7661,7 @@ var collectFilterColumns = (expr, table, rootTables) => {
       columns.add(node.name);
     }
   };
-  const visitOrderingTerm2 = (term) => {
+  const visitOrderingTerm = (term) => {
     if (!term || typeof term !== "object") return;
     if (isOperandNode(term)) {
       visitOperand2(term);
@@ -7663,7 +7673,7 @@ var collectFilterColumns = (expr, table, rootTables) => {
   };
   const visitOrderBy = (orderBy) => {
     if (!orderBy) return;
-    orderBy.forEach((node) => visitOrderingTerm2(node.term));
+    orderBy.forEach((node) => visitOrderingTerm(node.term));
   };
   const visitOperand2 = (node) => {
     switch (node.type) {
@@ -7815,137 +7825,174 @@ var getNodeType3 = (value) => {
   }
   return void 0;
 };
-var visitOrderingTerm = (term, visitor) => {
-  if (isOperandNode(term)) {
-    visitOperandNode(term, visitor);
-    return;
-  }
-  visitExpressionNode(term, visitor);
-};
-var visitOrderByNode = (node, visitor) => {
-  visitor.visitOrderBy?.(node);
-  visitOrderingTerm(node.term, visitor);
-};
-var visitTableSource = (source, visitor) => {
-  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));
-  }
-};
-var visitExpressionNode = (node, visitor) => {
-  visitor.visitExpression?.(node);
-  const type = getNodeType3(node);
-  if (!type) return;
-  switch (type) {
-    case "BinaryExpression":
-      visitOperandNode(node.left, visitor);
-      visitOperandNode(node.right, visitor);
-      if (node.escape) {
-        visitOperandNode(node.escape, visitor);
-      }
+var visitSelectQuery = (ast, visitor) => {
+  const visitExpressionNode = (node) => {
+    visitExpression(node, expressionVisitor);
+  };
+  const visitOperandNode = (node) => {
+    visitOperand(node, operandVisitor);
+  };
+  const visitOrderingTerm = (term) => {
+    if (!term || typeof term !== "object") return;
+    if (isOperandNode(term)) {
+      visitOperandNode(term);
       return;
-    case "LogicalExpression":
-      node.operands.forEach((operand) => visitExpressionNode(operand, visitor));
+    }
+    const type = getNodeType3(term);
+    if (type && hasOperandDispatcher(type)) {
+      visitOperandNode(term);
       return;
-    case "NullExpression":
-      visitOperandNode(node.left, visitor);
+    }
+    if (type) {
+      visitExpressionNode(term);
+    }
+  };
+  const visitOrderByNode = (node) => {
+    visitor.visitOrderBy?.(node);
+    visitOrderingTerm(node.term);
+  };
+  const visitTableSource = (source) => {
+    visitor.visitTableSource?.(source);
+    if (source.type === "DerivedTable") {
+      visitor.visitDerivedTable?.(source);
+      visitSelectQuery(source.query, visitor);
       return;
-    case "InExpression":
-      visitOperandNode(node.left, visitor);
+    }
+    if (source.type === "FunctionTable") {
+      visitor.visitFunctionTable?.(source);
+      source.args?.forEach((arg) => visitOperandNode(arg));
+    }
+  };
+  const expressionVisitor = {
+    visitBinaryExpression: (node) => {
+      visitor.visitExpression?.(node);
+      visitOperandNode(node.left);
+      visitOperandNode(node.right);
+      if (node.escape) {
+        visitOperandNode(node.escape);
+      }
+    },
+    visitLogicalExpression: (node) => {
+      visitor.visitExpression?.(node);
+      node.operands.forEach((operand) => visitExpressionNode(operand));
+    },
+    visitNullExpression: (node) => {
+      visitor.visitExpression?.(node);
+      visitOperandNode(node.left);
+    },
+    visitInExpression: (node) => {
+      visitor.visitExpression?.(node);
+      visitOperandNode(node.left);
       if (Array.isArray(node.right)) {
-        node.right.forEach((operand) => visitOperandNode(operand, visitor));
+        node.right.forEach((operand) => visitOperandNode(operand));
       } else {
-        visitOperandNode(node.right, visitor);
+        visitOperandNode(node.right);
       }
-      return;
-    case "ExistsExpression":
+    },
+    visitExistsExpression: (node) => {
+      visitor.visitExpression?.(node);
       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;
+    },
+    visitBetweenExpression: (node) => {
+      visitor.visitExpression?.(node);
+      visitOperandNode(node.left);
+      visitOperandNode(node.lower);
+      visitOperandNode(node.upper);
+    },
+    visitArithmeticExpression: (node) => {
+      visitor.visitExpression?.(node);
+      visitOperandNode(node.left);
+      visitOperandNode(node.right);
+    },
+    visitBitwiseExpression: (node) => {
+      visitor.visitExpression?.(node);
+      visitOperandNode(node.left);
+      visitOperandNode(node.right);
+    },
+    visitOperand: (node) => {
+      visitOperandNode(node);
+    },
+    visitSelectQuery: (node) => {
+      visitSelectQuery(node, visitor);
+    },
+    otherwise: (node) => {
+      visitor.visitExpression?.(node);
     }
-  }
-};
-var visitOperandNode = (node, visitor) => {
-  visitor.visitOperand?.(node);
-  const type = getNodeType3(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));
+  };
+  const operandVisitor = {
+    visitColumn: (node) => {
+      visitor.visitOperand?.(node);
+    },
+    visitLiteral: (node) => {
+      visitor.visitOperand?.(node);
+    },
+    visitParam: (node) => {
+      visitor.visitOperand?.(node);
+      visitor.visitParam?.(node);
+    },
+    visitFunction: (node) => {
+      visitor.visitOperand?.(node);
+      node.args?.forEach((arg) => visitOperandNode(arg));
+      node.orderBy?.forEach((order) => visitOrderByNode(order));
       if (node.separator) {
-        visitOperandNode(node.separator, visitor);
+        visitOperandNode(node.separator);
       }
-      return;
-    case "JsonPath":
-      visitOperandNode(node.column, visitor);
-      return;
-    case "ScalarSubquery":
+    },
+    visitJsonPath: (node) => {
+      visitor.visitOperand?.(node);
+      visitOperandNode(node.column);
+    },
+    visitScalarSubquery: (node) => {
+      visitor.visitOperand?.(node);
       visitSelectQuery(node.query, visitor);
-      return;
-    case "CaseExpression":
+    },
+    visitCaseExpression: (node) => {
+      visitor.visitOperand?.(node);
       node.conditions.forEach((cond) => {
-        visitExpressionNode(cond.when, visitor);
-        visitOperandNode(cond.then, visitor);
+        visitExpressionNode(cond.when);
+        visitOperandNode(cond.then);
       });
       if (node.else) {
-        visitOperandNode(node.else, visitor);
+        visitOperandNode(node.else);
       }
-      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 = node;
-      return _exhaustive;
+    },
+    visitCast: (node) => {
+      visitor.visitOperand?.(node);
+      visitOperandNode(node.expression);
+    },
+    visitWindowFunction: (node) => {
+      visitor.visitOperand?.(node);
+      node.args?.forEach((arg) => visitOperandNode(arg));
+      node.partitionBy?.forEach((term) => visitOperandNode(term));
+      node.orderBy?.forEach((order) => visitOrderByNode(order));
+    },
+    visitArithmeticExpression: (node) => {
+      visitor.visitOperand?.(node);
+      visitOperandNode(node.left);
+      visitOperandNode(node.right);
+    },
+    visitBitwiseExpression: (node) => {
+      visitor.visitOperand?.(node);
+      visitOperandNode(node.left);
+      visitOperandNode(node.right);
+    },
+    visitExpression: (node) => {
+      visitExpressionNode(node);
+    },
+    visitSelectQuery: (node) => {
+      visitSelectQuery(node, visitor);
+    },
+    visitCollate: (node) => {
+      visitor.visitOperand?.(node);
+      visitOperandNode(node.expression);
+    },
+    visitAliasRef: (node) => {
+      visitor.visitOperand?.(node);
+    },
+    otherwise: (node) => {
+      visitor.visitOperand?.(node);
     }
-  }
-};
-var visitSelectQuery = (ast, visitor) => {
+  };
   visitor.visitSelectQuery?.(ast);
   if (ast.ctes) {
     for (const cte of ast.ctes) {
@@ -7953,29 +8000,29 @@ var visitSelectQuery = (ast, visitor) => {
       visitSelectQuery(cte.query, visitor);
     }
   }
-  visitTableSource(ast.from, visitor);
+  visitTableSource(ast.from);
   ast.columns?.forEach((col2) => {
-    visitOperandNode(col2, visitor);
+    visitOperandNode(col2);
   });
   ast.joins?.forEach((join) => {
     visitor.visitJoin?.(join);
-    visitTableSource(join.table, visitor);
-    visitExpressionNode(join.condition, visitor);
+    visitTableSource(join.table);
+    visitExpressionNode(join.condition);
   });
   if (ast.where) {
-    visitExpressionNode(ast.where, visitor);
+    visitExpressionNode(ast.where);
   }
   ast.groupBy?.forEach((term) => {
-    visitOrderingTerm(term, visitor);
+    visitOrderingTerm(term);
   });
   if (ast.having) {
-    visitExpressionNode(ast.having, visitor);
+    visitExpressionNode(ast.having);
   }
   ast.orderBy?.forEach((order) => {
-    visitOrderByNode(order, visitor);
+    visitOrderByNode(order);
   });
   ast.distinct?.forEach((col2) => {
-    visitOperandNode(col2, visitor);
+    visitOperandNode(col2);
   });
   ast.setOps?.forEach((op) => {
     visitor.visitSetOperation?.(op);
@@ -7984,14 +8031,16 @@ var visitSelectQuery = (ast, visitor) => {
 };
 
 // src/core/ast/ast-validation.ts
-var hasParamOperandsInQuery = (ast) => {
-  let hasParams = false;
+var findFirstParamOperandName = (ast) => {
+  let name;
   visitSelectQuery(ast, {
-    visitParam: () => {
-      hasParams = true;
+    visitParam: (node) => {
+      if (!name) {
+        name = node.name;
+      }
     }
   });
-  return hasParams;
+  return name;
 };
 
 // src/query-builder/select.ts
@@ -8473,9 +8522,9 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
    */
   validateNoParamOperands() {
     const ast = this.context.hydration.applyToAst(this.context.state.ast);
-    const hasParams = hasParamOperandsInQuery(ast);
-    if (hasParams) {
-      throw new Error("Cannot execute query containing Param operands. Param proxies are only for schema generation (getSchema()). If you need real parameters, use literal values.");
+    const paramName = findFirstParamOperandName(ast);
+    if (paramName) {
+      throw new Error(`Cannot execute query containing Param operand "${paramName}". Param proxies are only for schema generation (getSchema()). If you need real parameters, use literal values.`);
     }
   }
   /**
@@ -8802,9 +8851,17 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
    *   .compile('postgres');
    * console.log(compiled.sql); // SELECT "id", "name" FROM "users" WHERE "active" = true
    */
-  compile(dialect) {
+  compile(dialect, options) {
     const resolved = resolveDialectInput(dialect);
-    return resolved.compileSelect(this.getAST());
+    const ast = this.getAST();
+    if (!options?.allowParamOperands) {
+      const paramName = findFirstParamOperandName(ast);
+      if (paramName) {
+        throw new Error(`Cannot compile query containing Param operand "${paramName}". Param proxies are only for schema generation (getSchema()). If you need real parameters, use literal values.`);
+      }
+      return resolved.compileSelect(ast);
+    }
+    return resolved.compileSelectWithOptions(ast, { allowParams: true });
   }
   /**
    * Converts the query to SQL string for a specific dialect
@@ -8816,8 +8873,8 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
    *   .toSql('postgres');
    * console.log(sql); // SELECT "id", "name" FROM "users" WHERE "active" = true
    */
-  toSql(dialect) {
-    return this.compile(dialect).sql;
+  toSql(dialect, options) {
+    return this.compile(dialect, options).sql;
   }
   /**
    * Gets hydration plan for query
@@ -14506,8 +14563,10 @@ function createPooledExecutorFactory(opts) {
   groupConcat,
   gt,
   gte,
+  hasExpressionDispatcher,
   hasMany,
   hasOne,
+  hasOperandDispatcher,
   hour,
   hydrateRows,
   ifNull,