metal-orm 1.0.89 → 1.0.91

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metal-orm",
-  "version": "1.0.89",
+  "version": "1.0.91",
   "type": "module",
   "types": "./dist/index.d.ts",
   "engines": {
@@ -30,6 +30,7 @@
     "test": "vitest",
     "test:ui": "vitest --ui",
     "test:mysql": "vitest --run tests/e2e/mysql-memory.test.ts tests/e2e/decorators-mysql-memory.test.ts tests/e2e/save-graph-mysql-memory.test.ts",
+    "test:mysql:optimized": "vitest --run --config tests/e2e/mysql/vitest.config.ts",
     "test:sqlite": "vitest --run tests/e2e/sqlite-memory.test.ts tests/e2e/decorators-sqlite-memory.test.ts tests/e2e/save-graph-sqlite-memory.test.ts",
     "test:pglite": "vitest --run tests/e2e/pglite-memory.test.ts",
     "test:e2e": "vitest tests/e2e",
@@ -58,8 +59,6 @@
     }
   },
   "devDependencies": {
-    "@electric-sql/pglite": "^0.3.14",
-    "@types/express": "^5.0.6",
     "@typescript-eslint/eslint-plugin": "^8.20.0",
     "@typescript-eslint/parser": "^8.20.0",
     "@vitest/ui": "^4.0.14",
@@ -70,9 +69,13 @@
     "mysql2": "^3.15.3",
     "pg": "^8.16.3",
     "sqlite3": "^5.1.7",
+    "supertest": "^7.2.2",
     "tedious": "^19.1.3",
     "tsup": "^8.0.0",
     "typescript": "^5.5.0",
     "vitest": "^4.0.14"
+  },
+  "dependencies": {
+    "@electric-sql/pglite": "^0.3.14"
   }
 }

package/src/codegen/typescript.ts

@@ -17,14 +17,13 @@ import {
   LiteralNode,
   FunctionNode,
   AliasRefNode,
-  CastExpressionNode,
-  CollateExpressionNode,
-  ParamNode,
-  ExpressionVisitor,
-  OperandVisitor,
-  visitExpression,
-  visitOperand
-} from '../core/ast/expression.js';
+  CastExpressionNode,
+  CollateExpressionNode,
+  ExpressionVisitor,
+  OperandVisitor,
+  visitExpression,
+  visitOperand
+} from '../core/ast/expression.js';
 import { SQL_OPERATOR_REGISTRY } from '../core/sql/sql-operator-config.js';
 import { SqlOperator } from '../core/sql/sql.js';
 import { isRelationAlias } from '../query-builder/relation-alias.js';
@@ -191,14 +190,13 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
       case 'ScalarSubquery':
       case 'CaseExpression':
       case 'WindowFunction':
-      case 'Cast':
-      case 'Collate':
-      case 'Param':
-        return this.printOperand(term);
-      default:
-        return this.printExpression(term);
-    }
-  }
+      case 'Cast':
+      case 'Collate':
+        return this.printOperand(term);
+      default:
+        return this.printExpression(term);
+    }
+  }
 
   private getSelectionKey(selection: SelectionColumn, index: number): string {
     if (selection.alias) {
@@ -246,17 +244,13 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
     return this.printColumnOperand(node);
   }
 
-  public visitLiteral(node: LiteralNode): string {
-    return this.printLiteralOperand(node);
-  }
-
-  public visitParam(node: ParamNode): string {
-    return this.printParamOperand(node);
-  }
-
-  public visitFunction(node: FunctionNode): string {
-    return this.printFunctionOperand(node);
-  }
+  public visitLiteral(node: LiteralNode): string {
+    return this.printLiteralOperand(node);
+  }
+
+  public visitFunction(node: FunctionNode): string {
+    return this.printFunctionOperand(node);
+  }
 
   public visitJsonPath(node: JsonPathNode): string {
     return this.printJsonPathOperand(node);
@@ -385,19 +379,14 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
    * @param literal - Literal node
    * @returns TypeScript code representation
    */
-  private printLiteralOperand(literal: LiteralNode): string {
-    if (literal.value === null) return 'null';
-    return typeof literal.value === 'string' ? `'${literal.value}'` : String(literal.value);
-  }
-
-  private printParamOperand(param: ParamNode): string {
-    const name = param.name.replace(/'/g, "\\'");
-    return `{ type: 'Param', name: '${name}' }`;
-  }
-
-  /**
-   * Prints a function operand to TypeScript code
-   * @param fn - Function node
+  private printLiteralOperand(literal: LiteralNode): string {
+    if (literal.value === null) return 'null';
+    return typeof literal.value === 'string' ? `'${literal.value}'` : String(literal.value);
+  }
+
+  /**
+   * Prints a function operand to TypeScript code
+   * @param fn - Function node
    * @returns TypeScript code representation
    */
   private printFunctionOperand(fn: FunctionNode): string {

package/src/core/ast/expression-builders.ts

@@ -2,14 +2,13 @@ import { SelectQueryNode } from './query.js';
 import { SqlOperator, BitwiseOperator } from '../sql/sql.js';
 import { ColumnRef } from './types.js';
 import {
-  ColumnNode,
-  LiteralNode,
-  ParamNode,
-  JsonPathNode,
-  OperandNode,
-  CaseExpressionNode,
-  CastExpressionNode,
-  BinaryExpressionNode,
+  ColumnNode,
+  LiteralNode,
+  JsonPathNode,
+  OperandNode,
+  CaseExpressionNode,
+  CastExpressionNode,
+  BinaryExpressionNode,
   ExpressionNode,
   LogicalExpressionNode,
   NullExpressionNode,
@@ -33,36 +32,27 @@ export type TypedLike<T> = { tsType?: T } | { __tsType: T };
 /**
  * Type guard to check if a value is a literal value
  */
-const isLiteralValue = (value: unknown): value is LiteralValue =>
-  value === null ||
-  typeof value === 'string' ||
-  typeof value === 'number' ||
-  typeof value === 'boolean' ||
-  value instanceof Date;
+const isLiteralValue = (value: unknown): value is LiteralValue =>
+  value === null ||
+  typeof value === 'string' ||
+  typeof value === 'number' ||
+  typeof value === 'boolean' ||
+  value instanceof Date;
 
 
 /**
  * Converts a primitive value to a LiteralNode
  */
-const toLiteralNode = (value: LiteralValue): LiteralNode => ({
-  type: 'Literal',
-  value: value instanceof Date ? value.toISOString() : value
-});
-
-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 => {
+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 => {
   if (!col.table) {
     throw new Error(
       `Column "${col.name}" requires a table reference. ` +
@@ -77,16 +67,11 @@ 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 => {
-  const paramNode = toParamNode(value);
-  if (paramNode) {
-    return paramNode;
-  }
-
-  // Already an operand node
-  if (isOperandNode(value)) {
-    return value;
-  }
+const toOperandNode = (value: OperandNode | ColumnRef | LiteralValue): OperandNode => {
+  // Already an operand node
+  if (isOperandNode(value)) {
+    return value;
+  }
 
   // Literal value
   if (isLiteralValue(value)) {
@@ -102,16 +87,12 @@ 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 => {
-  const paramNode = toParamNode(value);
-  if (paramNode) {
-    return paramNode;
-  }
-  if (isOperandNode(value)) {
-    return value;
-  }
-  return toLiteralNode(value);
-};
+export const valueToOperand = (value: ValueOperandInput): OperandNode => {
+  if (isOperandNode(value)) {
+    return value;
+  }
+  return toLiteralNode(value);
+};
 
 /**
  * Converts various input types to an OperandNode

package/src/core/ast/expression-nodes.ts

@@ -2,23 +2,14 @@ import type { SelectQueryNode, OrderByNode } from './query.js';
 import { SqlOperator, BitwiseOperator } from '../sql/sql.js';
 import { ColumnRef } from './types.js';
 
-/**
- * AST node representing a literal value
- */
-export interface LiteralNode {
-  type: 'Literal';
-  /** The literal value (string, number, boolean, Date, or null) */
-  value: string | number | boolean | Date | null;
-}
-
-/**
- * AST node representing a named parameter placeholder
- */
-export interface ParamNode {
-  type: 'Param';
-  /** Stable parameter name */
-  name: string;
-}
+/**
+ * AST node representing a literal value
+ */
+export interface LiteralNode {
+  type: 'Literal';
+  /** The literal value (string, number, boolean, Date, or null) */
+  value: string | number | boolean | Date | null;
+}
 
 /**
  * AST node representing a reference to a SELECT alias (for ORDER BY / GROUP BY).
@@ -158,66 +149,54 @@ export interface ArithmeticExpressionNode {
 /**
  * Union type representing any operand that can be used in expressions
  */
-export type OperandNode =
-  | AliasRefNode
-  | ColumnNode
-  | LiteralNode
-  | ParamNode
-  | FunctionNode
-  | JsonPathNode
-  | ScalarSubqueryNode
-  | CaseExpressionNode
-  | CastExpressionNode
+export type OperandNode =
+  | AliasRefNode
+  | ColumnNode
+  | LiteralNode
+  | FunctionNode
+  | JsonPathNode
+  | ScalarSubqueryNode
+  | CaseExpressionNode
+  | CastExpressionNode
   | WindowFunctionNode
   | ArithmeticExpressionNode
   | BitwiseExpressionNode
   | CollateExpressionNode;
 
-const operandTypes = new Set<OperandNode['type']>([
-  'AliasRef',
-  'Column',
-  'Literal',
-  'Param',
-  'Function',
-  'JsonPath',
-  'ScalarSubquery',
-  'CaseExpression',
-  'Cast',
-  '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';
+const operandTypes = new Set<OperandNode['type']>([
+  'AliasRef',
+  'Column',
+  'Literal',
+  'Function',
+  'JsonPath',
+  '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';
 export const isExpressionSelectionNode = (
   node: ColumnRef | FunctionNode | CaseExpressionNode | CastExpressionNode | WindowFunctionNode
 ): node is FunctionNode | CaseExpressionNode | CastExpressionNode | WindowFunctionNode =>