metal-orm 1.0.82 → 1.0.83

package/package.json

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

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

@@ -0,0 +1,188 @@
+import type { ExpressionNode, OperandNode } from './expression-nodes.js';
+import { visitExpression, visitOperand } from './expression-visitor.js';
+import type { SelectQueryNode } from './query.js';
+
+const hasParamOperandsInExpression = (expr: ExpressionNode): boolean => {
+  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;
+};
+
+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;
+      }
+    }
+  });
+
+  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;
+};

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/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/dialect/abstract.ts

@@ -37,15 +37,17 @@ import { StandardFunctionStrategy } from '../functions/standard-strategy.js';
 import type { TableFunctionStrategy } from '../functions/table-types.js';
 import { StandardTableFunctionStrategy } from '../functions/standard-table-strategy.js';
 
-/**
- * Context for SQL compilation with parameter management
- */
-export interface CompilerContext {
-  /** Array of parameters */
-  params: unknown[];
-  /** Function to add a parameter and get its placeholder */
-  addParameter(value: unknown): string;
-}
+/**
+ * Context for SQL compilation with parameter management
+ */
+export interface CompilerContext {
+  /** Array of parameters */
+  params: unknown[];
+  /** Function to add a parameter and get its placeholder */
+  addParameter(value: unknown): string;
+  /** Whether Param operands are allowed (for schema generation) */
+  allowParams?: boolean;
+}
 
 /**
  * Result of SQL compilation
@@ -86,18 +88,29 @@ export abstract class Dialect
    * @param ast - Query AST to compile
    * @returns Compiled query with SQL and parameters
    */
-  compileSelect(ast: SelectQueryNode): CompiledQuery {
-    const ctx = this.createCompilerContext();
-    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: InsertQueryNode): CompiledQuery {
+  compileSelect(ast: SelectQueryNode): CompiledQuery {
+    const ctx = this.createCompilerContext();
+    const normalized = this.normalizeSelectAst(ast);
+    const rawSql = this.compileSelectAst(normalized, ctx).trim();
+    const sql = rawSql.endsWith(';') ? rawSql : `${rawSql};`;
+    return {
+      sql,
+      params: [...ctx.params]
+    };
+  }
+
+  compileSelectWithOptions(ast: SelectQueryNode, options: { allowParams?: boolean } = {}): CompiledQuery {
+    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: InsertQueryNode): CompiledQuery {
     const ctx = this.createCompilerContext();
     const rawSql = this.compileInsertAst(ast, ctx).trim();
     const sql = rawSql.endsWith(';') ? rawSql : `${rawSql};`;
@@ -198,22 +211,24 @@ export abstract class Dialect
     return `SELECT 1${tail}`;
   }
 
-  /**
-   * Creates a new compiler context
-   * @returns Compiler context with parameter management
-   */
-  protected createCompilerContext(): CompilerContext {
-    const params: unknown[] = [];
-    let counter = 0;
-    return {
-      params,
-      addParameter: (value: unknown) => {
-        counter += 1;
-        params.push(value);
-        return this.formatPlaceholder(counter);
-      }
-    };
-  }
+  /**
+   * Creates a new compiler context
+   * @param options - Optional compiler context options
+   * @returns Compiler context with parameter management
+   */
+  protected createCompilerContext(options: { allowParams?: boolean } = {}): CompilerContext {
+    const params: unknown[] = [];
+    let counter = 0;
+    return {
+      params,
+      allowParams: options.allowParams ?? false,
+      addParameter: (value: unknown) => {
+        counter += 1;
+        params.push(value);
+        return this.formatPlaceholder(counter);
+      }
+    };
+  }
 
   /**
    * Formats a parameter placeholder
@@ -453,9 +468,14 @@ export abstract class Dialect
     });
   }
 
-  private registerDefaultOperandCompilers(): void {
+  private registerDefaultOperandCompilers(): void {
     this.registerOperandCompiler('Literal', (literal: LiteralNode, ctx) => ctx.addParameter(literal.value));
-    this.registerOperandCompiler('Param', (_param: ParamNode, ctx) => ctx.addParameter(null));
+    this.registerOperandCompiler('Param', (_param: ParamNode, 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: AliasRefNode, _ctx) => {
       void _ctx;