metal-orm 1.0.82 → 1.0.83

package/dist/index.cjs

@@ -673,6 +673,14 @@ var toLiteralNode = (value) => ({
   type: "Literal",
   value: value instanceof Date ? value.toISOString() : value
 });
+var toParamNode = (value) => {
+  if (typeof value !== "object" || value === null) return void 0;
+  const type = Object.getOwnPropertyDescriptor(value, "type")?.value;
+  if (type !== "Param") return void 0;
+  const name = Object.getOwnPropertyDescriptor(value, "name")?.value;
+  if (typeof name !== "string") return void 0;
+  return { type: "Param", name };
+};
 var columnRefToNode = (col2) => {
   if (!col2.table) {
     throw new Error(
@@ -682,6 +690,10 @@ var columnRefToNode = (col2) => {
   return { type: "Column", table: col2.table, name: col2.name };
 };
 var toOperandNode = (value) => {
+  const paramNode = toParamNode(value);
+  if (paramNode) {
+    return paramNode;
+  }
   if (isOperandNode(value)) {
     return value;
   }
@@ -691,6 +703,10 @@ var toOperandNode = (value) => {
   return columnRefToNode(value);
 };
 var valueToOperand = (value) => {
+  const paramNode = toParamNode(value);
+  if (paramNode) {
+    return paramNode;
+  }
   if (isOperandNode(value)) {
     return value;
   }
@@ -1132,7 +1148,7 @@ var buildParamProxy = (name) => {
         const nextName2 = name ? `${name}.${trimmed}` : trimmed;
         return buildParamProxy(nextName2);
       }
-      if (prop in t) {
+      if (prop in t && name === "") {
         return t[prop];
       }
       const nextName = name ? `${name}.${prop}` : prop;
@@ -1151,9 +1167,6 @@ var createParamProxy = () => {
       if (typeof prop === "string" && prop.startsWith("$")) {
         return buildParamProxy(prop.slice(1));
       }
-      if (prop in t) {
-        return t[prop];
-      }
       return buildParamProxy(String(prop));
     }
   });
@@ -1570,6 +1583,16 @@ var Dialect = class _Dialect {
       params: [...ctx.params]
     };
   }
+  compileSelectWithOptions(ast, options = {}) {
+    const ctx = this.createCompilerContext(options);
+    const normalized = this.normalizeSelectAst(ast);
+    const rawSql = this.compileSelectAst(normalized, ctx).trim();
+    const sql = rawSql.endsWith(";") ? rawSql : `${rawSql};`;
+    return {
+      sql,
+      params: [...ctx.params]
+    };
+  }
   compileInsert(ast) {
     const ctx = this.createCompilerContext();
     const rawSql = this.compileInsertAst(ast, ctx).trim();
@@ -1640,13 +1663,15 @@ var Dialect = class _Dialect {
   }
   /**
    * Creates a new compiler context
+   * @param options - Optional compiler context options
    * @returns Compiler context with parameter management
    */
-  createCompilerContext() {
+  createCompilerContext(options = {}) {
     const params = [];
     let counter = 0;
     return {
       params,
+      allowParams: options.allowParams ?? false,
       addParameter: (value) => {
         counter += 1;
         params.push(value);
@@ -1868,7 +1893,12 @@ var Dialect = class _Dialect {
   }
   registerDefaultOperandCompilers() {
     this.registerOperandCompiler("Literal", (literal, ctx) => ctx.addParameter(literal.value));
-    this.registerOperandCompiler("Param", (_param, ctx) => ctx.addParameter(null));
+    this.registerOperandCompiler("Param", (_param, ctx) => {
+      if (!ctx.allowParams) {
+        throw new Error("Cannot compile query with Param operands. Param proxies are only for schema generation (getSchema()). If you need real parameters, use literal values.");
+      }
+      return ctx.addParameter(null);
+    });
     this.registerOperandCompiler("AliasRef", (alias, _ctx) => {
       void _ctx;
       return this.quoteIdentifier(alias.name);
@@ -7737,6 +7767,227 @@ var buildFilterParameters = (table, where, from, options = {}) => {
   }];
 };
 
+// src/core/ast/ast-validation.ts
+var hasParamOperandsInExpression = (expr) => {
+  let hasParams = false;
+  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;
+};
+var hasParamOperandsInOperand = (operand) => {
+  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)) {
+            hasParams = true;
+          }
+        }
+      });
+    },
+    visitCollate: (node) => {
+      if (hasParamOperandsInOperand(node.expression)) {
+        hasParams = true;
+      }
+    },
+    visitAliasRef: () => {
+    },
+    otherwise: () => {
+    }
+  });
+  return hasParams;
+};
+var hasParamOperandsInQuery = (ast) => {
+  if (ast.where && hasParamOperandsInExpression(ast.where)) {
+    return true;
+  }
+  if (ast.having && hasParamOperandsInExpression(ast.having)) {
+    return true;
+  }
+  ast.columns?.forEach((col2) => {
+    if (typeof col2 === "object" && col2 !== null && "type" in col2) {
+      if (hasParamOperandsInOperand(col2)) {
+        return true;
+      }
+    }
+  });
+  ast.orderBy?.forEach((ord) => {
+    if (ord.term) {
+      if (hasParamOperandsInOperand(ord.term)) {
+        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;
+};
+
 // src/query-builder/select.ts
 var SelectQueryBuilder = class _SelectQueryBuilder {
   env;
@@ -8210,6 +8461,17 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
     }
     return this;
   }
+  /**
+   * Validates that the query does not contain Param operands.
+   * Param proxies are only for schema generation, not execution.
+   */
+  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.");
+    }
+  }
   /**
    * Executes the query and returns hydrated results.
    * If the builder was created with an entity constructor (e.g. via selectFromEntity),
@@ -8223,6 +8485,7 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
    * users[0] instanceof User; // true
    */
   async execute(ctx) {
+    this.validateNoParamOperands();
     if (this.entityConstructor) {
       return this.executeAs(this.entityConstructor, ctx);
     }
@@ -8241,6 +8504,7 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
    * rows[0] instanceof User; // false
    */
   async executePlain(ctx) {
+    this.validateNoParamOperands();
     const builder = this.ensureDefaultSelection();
     const rows = await executeHydratedPlain(ctx, builder);
     return rows;
@@ -8260,6 +8524,7 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
    * users[0].getFullName();   // works!
    */
   async executeAs(entityClass, ctx) {
+    this.validateNoParamOperands();
     const builder = this.ensureDefaultSelection();
     const results = await executeHydrated(ctx, builder);
     return materializeAs(entityClass, results);
@@ -8271,6 +8536,7 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
    * const total = await qb.count(session);
    */
   async count(session) {
+    this.validateNoParamOperands();
     return executeCount(this.context, this.env, session);
   }
   /**
@@ -8280,6 +8546,7 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
    * const { items, totalItems, page, pageSize } = await qb.executePaged(session, { page: 1, pageSize: 20 });
    */
   async executePaged(session, options) {
+    this.validateNoParamOperands();
     const builder = this.ensureDefaultSelection();
     return executePagedQuery(builder, session, options, (sess) => builder.count(sess));
   }
@@ -8294,6 +8561,7 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
    * const users = await qb.executeWithContexts(execCtx, hydCtx);
    */
   async executeWithContexts(execCtx, hydCtx) {
+    this.validateNoParamOperands();
     const builder = this.ensureDefaultSelection();
     const results = await executeHydratedWithContexts(execCtx, hydCtx, builder);
     if (this.entityConstructor) {