metal-orm 1.0.81 → 1.0.83

package/dist/index.js

@@ -360,6 +360,7 @@ var operandTypes = /* @__PURE__ */ new Set([
   "AliasRef",
   "Column",
   "Literal",
+  "Param",
   "Function",
   "JsonPath",
   "ScalarSubquery",
@@ -388,6 +389,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(
@@ -397,6 +406,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;
   }
@@ -406,6 +419,10 @@ var toOperandNode = (value) => {
   return columnRefToNode(value);
 };
 var valueToOperand = (value) => {
+  const paramNode = toParamNode(value);
+  if (paramNode) {
+    return paramNode;
+  }
   if (isOperandNode(value)) {
     return value;
   }
@@ -799,6 +816,9 @@ var visitOperand = (node, visitor) => {
     case "Literal":
       if (visitor.visitLiteral) return visitor.visitLiteral(node);
       break;
+    case "Param":
+      if (visitor.visitParam) return visitor.visitParam(node);
+      break;
     case "Function":
       if (visitor.visitFunction) return visitor.visitFunction(node);
       break;
@@ -830,6 +850,44 @@ var visitOperand = (node, visitor) => {
   return unsupportedOperand(node);
 };
 
+// src/core/ast/param-proxy.ts
+var buildParamProxy = (name) => {
+  const target = { type: "Param", name };
+  return new Proxy(target, {
+    get(t, prop, receiver) {
+      if (prop === "then") return void 0;
+      if (typeof prop === "symbol") {
+        return Reflect.get(t, prop, receiver);
+      }
+      if (typeof prop === "string" && prop.startsWith("$")) {
+        const trimmed = prop.slice(1);
+        const nextName2 = name ? `${name}.${trimmed}` : trimmed;
+        return buildParamProxy(nextName2);
+      }
+      if (prop in t && name === "") {
+        return t[prop];
+      }
+      const nextName = name ? `${name}.${prop}` : prop;
+      return buildParamProxy(nextName);
+    }
+  });
+};
+var createParamProxy = () => {
+  const target = {};
+  return new Proxy(target, {
+    get(t, prop, receiver) {
+      if (prop === "then") return void 0;
+      if (typeof prop === "symbol") {
+        return Reflect.get(t, prop, receiver);
+      }
+      if (typeof prop === "string" && prop.startsWith("$")) {
+        return buildParamProxy(prop.slice(1));
+      }
+      return buildParamProxy(String(prop));
+    }
+  });
+};
+
 // src/core/ast/adapters.ts
 var hasAlias = (obj) => typeof obj === "object" && obj !== null && "alias" in obj;
 var toColumnRef = (col2) => ({
@@ -1241,6 +1299,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();
@@ -1311,13 +1379,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);
@@ -1539,6 +1609,12 @@ var Dialect = class _Dialect {
   }
   registerDefaultOperandCompilers() {
     this.registerOperandCompiler("Literal", (literal, ctx) => ctx.addParameter(literal.value));
+    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);
@@ -4062,6 +4138,7 @@ var collectFromOperand = (node, collector) => {
       break;
     case "Literal":
     case "AliasRef":
+    case "Param":
       break;
     default:
       break;
@@ -7328,6 +7405,7 @@ var collectFilterColumns = (expr, table, rootTables) => {
       }
       case "AliasRef":
       case "Literal":
+      case "Param":
         return;
       default:
         return;
@@ -7405,6 +7483,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;
@@ -7878,6 +8177,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),
@@ -7891,6 +8201,7 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
    * users[0] instanceof User; // true
    */
   async execute(ctx) {
+    this.validateNoParamOperands();
     if (this.entityConstructor) {
       return this.executeAs(this.entityConstructor, ctx);
     }
@@ -7909,6 +8220,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;
@@ -7928,6 +8240,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);
@@ -7939,6 +8252,7 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
    * const total = await qb.count(session);
    */
   async count(session) {
+    this.validateNoParamOperands();
     return executeCount(this.context, this.env, session);
   }
   /**
@@ -7948,6 +8262,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));
   }
@@ -7962,6 +8277,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) {
@@ -11367,6 +11683,7 @@ var TypeScriptGenerator = class {
       case "WindowFunction":
       case "Cast":
       case "Collate":
+      case "Param":
         return this.printOperand(term);
       default:
         return this.printExpression(term);
@@ -11411,6 +11728,9 @@ var TypeScriptGenerator = class {
   visitLiteral(node) {
     return this.printLiteralOperand(node);
   }
+  visitParam(node) {
+    return this.printParamOperand(node);
+  }
   visitFunction(node) {
     return this.printFunctionOperand(node);
   }
@@ -11532,6 +11852,10 @@ var TypeScriptGenerator = class {
     if (literal.value === null) return "null";
     return typeof literal.value === "string" ? `'${literal.value}'` : String(literal.value);
   }
+  printParamOperand(param) {
+    const name = param.name.replace(/'/g, "\\'");
+    return `{ type: 'Param', name: '${name}' }`;
+  }
   /**
    * Prints a function operand to TypeScript code
    * @param fn - Function node
@@ -13839,6 +14163,7 @@ export {
   createExecutorFromQueryRunner,
   createMssqlExecutor,
   createMysqlExecutor,
+  createParamProxy,
   createPooledExecutorFactory,
   createPostgresExecutor,
   createQueryLoggingExecutor,