metal-orm 1.1.10 → 1.1.16

package/src/codegen/typescript.ts

@@ -1,222 +1,222 @@
-import { OrderingTerm, SelectQueryNode } from '../core/ast/query.js';
-import {
-  ExpressionNode,
-  OperandNode,
+import { OrderingTerm, SelectQueryNode } from '../core/ast/query.js';
+import {
+  ExpressionNode,
+  OperandNode,
   BinaryExpressionNode,
   LogicalExpressionNode,
   NotExpressionNode,
   InExpressionNode,
-  NullExpressionNode,
-  JsonPathNode,
-  ExistsExpressionNode,
-  BetweenExpressionNode,
-  ScalarSubqueryNode,
-  CaseExpressionNode,
-  WindowFunctionNode,
-  ArithmeticExpressionNode,
-  ColumnNode,
-  LiteralNode,
-  FunctionNode,
-  AliasRefNode,
-  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';
-import { HydrationMetadata } from '../core/hydration/types.js';
-import { getJoinRelationName } from '../core/ast/join-metadata.js';
-import { NamingStrategy, DefaultNamingStrategy } from './naming-strategy.js';
-
-const assertNever = (value: never): never => {
-  throw new Error(`Unhandled SQL operator: ${value}`);
-};
-
-/**
- * Generates TypeScript code from query AST nodes
- */
-type SelectionColumn =
-  | ColumnNode
-  | FunctionNode
-  | ScalarSubqueryNode
-  | CaseExpressionNode
-  | WindowFunctionNode
-  | CastExpressionNode;
-
-export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVisitor<string> {
-  constructor(private namingStrategy: NamingStrategy = new DefaultNamingStrategy()) { }
-
-  /**
-   * Generates TypeScript code from a query AST
-   * @param ast - Query AST to generate code from
-   * @returns Generated TypeScript code
-   */
-  generate(ast: SelectQueryNode): string {
-    const chainLines = this.buildSelectLines(ast);
-    const lines = chainLines.map((line, index) => (index === 0 ? `const query = ${line}` : line));
-    lines.push(';', '', 'await query.execute();');
-    return lines.join('\n');
-  }
-
-  /**
-   * Builds TypeScript method chain lines from query AST
-   * @param ast - Query AST
-   * @returns Array of TypeScript method chain lines
-   */
-  private buildSelectLines(ast: SelectQueryNode): string[] {
-    const lines: string[] = [];
-    const hydration = (ast.meta as HydrationMetadata | undefined)?.hydration;
-    const hydratedRelations = new Set(hydration?.relations?.map(r => r.name) ?? []);
-
-    const selections = ast.columns
-      .filter((col): col is SelectionColumn => !(hydration && isRelationAlias(col.alias)))
-      .map((col, index) => `${this.getSelectionKey(col, index)}: ${this.printOperand(col)}`);
-
-    lines.push(`db.select({`);
-    selections.forEach((sel, index) => {
-      lines.push(`  ${sel}${index < selections.length - 1 ? ',' : ''}`);
-    });
-    lines.push(`})`);
-    lines.push(`.from(${this.namingStrategy.tableToSymbol(ast.from)})`);
-
-    if (ast.distinct && ast.distinct.length) {
-      const cols = ast.distinct.map(c => `${this.namingStrategy.tableToSymbol(c.table)}.${c.name}`).join(', ');
-      lines.push(`.distinct(${cols})`);
-    }
-
-    ast.joins.forEach(join => {
-      const relationName = getJoinRelationName(join);
-      if (relationName && hydratedRelations.has(relationName)) {
-        return;
-      }
-
-      if (relationName) {
-        if (join.kind === 'INNER') {
-          lines.push(`.joinRelation('${relationName}')`);
-        } else {
-          lines.push(`.joinRelation('${relationName}', '${join.kind}')`);
-        }
-      } else {
-        const table = this.namingStrategy.tableToSymbol(join.table);
-        const cond = this.printExpression(join.condition);
-        let method = 'innerJoin';
-        if (join.kind === 'LEFT') method = 'leftJoin';
-        if (join.kind === 'RIGHT') method = 'rightJoin';
-        lines.push(`.${method}(${table}, ${cond})`);
-      }
-    });
-
-    if (hydration?.relations?.length) {
-      hydration.relations.forEach(rel => {
-        const options: string[] = [];
-        if (rel.columns.length) options.push(`columns: [${rel.columns.map(c => `'${c}'`).join(', ')}]`);
-        if (rel.aliasPrefix !== rel.name) options.push(`aliasPrefix: '${rel.aliasPrefix}'`);
-        const opts = options.length ? `, { ${options.join(', ')} }` : '';
-        lines.push(`.include('${rel.name}'${opts})`);
-      });
-    }
-
-    if (ast.where) {
-      lines.push(`.where(${this.printExpression(ast.where)})`);
-    }
-
-    if (ast.groupBy && ast.groupBy.length) {
-      const cols = ast.groupBy.map(term => this.printOrderingTerm(term)).join(', ');
-      lines.push(`.groupBy(${cols})`);
-    }
-
-    if (ast.having) {
-      lines.push(`.having(${this.printExpression(ast.having)})`);
-    }
-
-    if (ast.orderBy && ast.orderBy.length) {
-      ast.orderBy.forEach(o => {
-        const term = this.printOrderingTerm(o.term);
-        const opts: string[] = [`direction: '${o.direction}'`];
-        if (o.nulls) opts.push(`nulls: '${o.nulls}'`);
-        if (o.collation) opts.push(`collation: '${o.collation}'`);
-        const hasOpts = opts.length > 1;
-        if (hasOpts) {
-          lines.push(`.orderBy(${term}, { ${opts.join(', ')} })`);
-        } else {
-          lines.push(`.orderBy(${term}, '${o.direction}')`);
-        }
-      });
-    }
-
-    if (ast.limit) lines.push(`.limit(${ast.limit})`);
-    if (ast.offset) lines.push(`.offset(${ast.offset})`);
-
-    return lines;
-  }
-
-  /**
-   * Prints an expression node to TypeScript code
-   * @param expr - Expression node to print
-   * @returns TypeScript code representation
-   */
-  private printExpression(expr: ExpressionNode): string {
-    return visitExpression(expr, this);
-  }
-
-  /**
-   * Prints an operand node to TypeScript code
-   * @param node - Operand node to print
-   * @returns TypeScript code representation
-   */
-  private printOperand(node: OperandNode): string {
-    return visitOperand(node, this);
-  }
-
-  /**
-   * Prints an ordering term (operand/expression/alias) to TypeScript code.
-   */
-  private printOrderingTerm(term: OrderingTerm): string {
-    if (!term || !('type' in term)) {
-      throw new Error('Unsupported ordering term');
-    }
-
-    switch (term.type) {
-      case 'Column':
-        return `${this.namingStrategy.tableToSymbol(term.table)}.${term.name}`;
-      case 'AliasRef':
-        return this.visitAliasRef(term);
-      case 'Literal':
-      case 'Function':
-      case 'JsonPath':
-      case 'ScalarSubquery':
-      case 'CaseExpression':
-      case 'WindowFunction':
-      case 'Cast':
-      case 'Collate':
-        return this.printOperand(term);
-      default:
-        return this.printExpression(term);
-    }
-  }
-
-  private getSelectionKey(selection: SelectionColumn, index: number): string {
-    if (selection.alias) {
-      return selection.alias;
-    }
-    if (this.isNamedSelection(selection)) {
-      return selection.name;
-    }
-    return `selection${index + 1}`;
-  }
-
-  private isNamedSelection(selection: SelectionColumn): selection is ColumnNode | FunctionNode | WindowFunctionNode {
-    return 'name' in selection;
-  }
-
-  public visitBinaryExpression(binary: BinaryExpressionNode): string {
-    return this.printBinaryExpression(binary);
-  }
-
+  NullExpressionNode,
+  JsonPathNode,
+  ExistsExpressionNode,
+  BetweenExpressionNode,
+  ScalarSubqueryNode,
+  CaseExpressionNode,
+  WindowFunctionNode,
+  ArithmeticExpressionNode,
+  ColumnNode,
+  LiteralNode,
+  FunctionNode,
+  AliasRefNode,
+  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';
+import { HydrationMetadata } from '../core/hydration/types.js';
+import { getJoinRelationName } from '../core/ast/join-metadata.js';
+import { NamingStrategy, DefaultNamingStrategy } from './naming-strategy.js';
+
+const assertNever = (value: never): never => {
+  throw new Error(`Unhandled SQL operator: ${value}`);
+};
+
+/**
+ * Generates TypeScript code from query AST nodes
+ */
+type SelectionColumn =
+  | ColumnNode
+  | FunctionNode
+  | ScalarSubqueryNode
+  | CaseExpressionNode
+  | WindowFunctionNode
+  | CastExpressionNode;
+
+export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVisitor<string> {
+  constructor(private namingStrategy: NamingStrategy = new DefaultNamingStrategy()) { }
+
+  /**
+   * Generates TypeScript code from a query AST
+   * @param ast - Query AST to generate code from
+   * @returns Generated TypeScript code
+   */
+  generate(ast: SelectQueryNode): string {
+    const chainLines = this.buildSelectLines(ast);
+    const lines = chainLines.map((line, index) => (index === 0 ? `const query = ${line}` : line));
+    lines.push(';', '', 'await query.execute();');
+    return lines.join('\n');
+  }
+
+  /**
+   * Builds TypeScript method chain lines from query AST
+   * @param ast - Query AST
+   * @returns Array of TypeScript method chain lines
+   */
+  private buildSelectLines(ast: SelectQueryNode): string[] {
+    const lines: string[] = [];
+    const hydration = (ast.meta as HydrationMetadata | undefined)?.hydration;
+    const hydratedRelations = new Set(hydration?.relations?.map(r => r.name) ?? []);
+
+    const selections = ast.columns
+      .filter((col): col is SelectionColumn => !(hydration && isRelationAlias(col.alias)))
+      .map((col, index) => `${this.getSelectionKey(col, index)}: ${this.printOperand(col)}`);
+
+    lines.push(`db.select({`);
+    selections.forEach((sel, index) => {
+      lines.push(`  ${sel}${index < selections.length - 1 ? ',' : ''}`);
+    });
+    lines.push(`})`);
+    lines.push(`.from(${this.namingStrategy.tableToSymbol(ast.from)})`);
+
+    if (ast.distinct && ast.distinct.length) {
+      const cols = ast.distinct.map(c => `${this.namingStrategy.tableToSymbol(c.table)}.${c.name}`).join(', ');
+      lines.push(`.distinct(${cols})`);
+    }
+
+    ast.joins.forEach(join => {
+      const relationName = getJoinRelationName(join);
+      if (relationName && hydratedRelations.has(relationName)) {
+        return;
+      }
+
+      if (relationName) {
+        if (join.kind === 'INNER') {
+          lines.push(`.joinRelation('${relationName}')`);
+        } else {
+          lines.push(`.joinRelation('${relationName}', '${join.kind}')`);
+        }
+      } else {
+        const table = this.namingStrategy.tableToSymbol(join.table);
+        const cond = this.printExpression(join.condition);
+        let method = 'innerJoin';
+        if (join.kind === 'LEFT') method = 'leftJoin';
+        if (join.kind === 'RIGHT') method = 'rightJoin';
+        lines.push(`.${method}(${table}, ${cond})`);
+      }
+    });
+
+    if (hydration?.relations?.length) {
+      hydration.relations.forEach(rel => {
+        const options: string[] = [];
+        if (rel.columns.length) options.push(`columns: [${rel.columns.map(c => `'${c}'`).join(', ')}]`);
+        if (rel.aliasPrefix !== rel.name) options.push(`aliasPrefix: '${rel.aliasPrefix}'`);
+        const opts = options.length ? `, { ${options.join(', ')} }` : '';
+        lines.push(`.include('${rel.name}'${opts})`);
+      });
+    }
+
+    if (ast.where) {
+      lines.push(`.where(${this.printExpression(ast.where)})`);
+    }
+
+    if (ast.groupBy && ast.groupBy.length) {
+      const cols = ast.groupBy.map(term => this.printOrderingTerm(term)).join(', ');
+      lines.push(`.groupBy(${cols})`);
+    }
+
+    if (ast.having) {
+      lines.push(`.having(${this.printExpression(ast.having)})`);
+    }
+
+    if (ast.orderBy && ast.orderBy.length) {
+      ast.orderBy.forEach(o => {
+        const term = this.printOrderingTerm(o.term);
+        const opts: string[] = [`direction: '${o.direction}'`];
+        if (o.nulls) opts.push(`nulls: '${o.nulls}'`);
+        if (o.collation) opts.push(`collation: '${o.collation}'`);
+        const hasOpts = opts.length > 1;
+        if (hasOpts) {
+          lines.push(`.orderBy(${term}, { ${opts.join(', ')} })`);
+        } else {
+          lines.push(`.orderBy(${term}, '${o.direction}')`);
+        }
+      });
+    }
+
+    if (ast.limit) lines.push(`.limit(${ast.limit})`);
+    if (ast.offset) lines.push(`.offset(${ast.offset})`);
+
+    return lines;
+  }
+
+  /**
+   * Prints an expression node to TypeScript code
+   * @param expr - Expression node to print
+   * @returns TypeScript code representation
+   */
+  private printExpression(expr: ExpressionNode): string {
+    return visitExpression(expr, this);
+  }
+
+  /**
+   * Prints an operand node to TypeScript code
+   * @param node - Operand node to print
+   * @returns TypeScript code representation
+   */
+  private printOperand(node: OperandNode): string {
+    return visitOperand(node, this);
+  }
+
+  /**
+   * Prints an ordering term (operand/expression/alias) to TypeScript code.
+   */
+  private printOrderingTerm(term: OrderingTerm): string {
+    if (!term || !('type' in term)) {
+      throw new Error('Unsupported ordering term');
+    }
+
+    switch (term.type) {
+      case 'Column':
+        return `${this.namingStrategy.tableToSymbol(term.table)}.${term.name}`;
+      case 'AliasRef':
+        return this.visitAliasRef(term);
+      case 'Literal':
+      case 'Function':
+      case 'JsonPath':
+      case 'ScalarSubquery':
+      case 'CaseExpression':
+      case 'WindowFunction':
+      case 'Cast':
+      case 'Collate':
+        return this.printOperand(term);
+      default:
+        return this.printExpression(term);
+    }
+  }
+
+  private getSelectionKey(selection: SelectionColumn, index: number): string {
+    if (selection.alias) {
+      return selection.alias;
+    }
+    if (this.isNamedSelection(selection)) {
+      return selection.name;
+    }
+    return `selection${index + 1}`;
+  }
+
+  private isNamedSelection(selection: SelectionColumn): selection is ColumnNode | FunctionNode | WindowFunctionNode {
+    return 'name' in selection;
+  }
+
+  public visitBinaryExpression(binary: BinaryExpressionNode): string {
+    return this.printBinaryExpression(binary);
+  }
+
   public visitLogicalExpression(logical: LogicalExpressionNode): string {
     return this.printLogicalExpression(logical);
   }
@@ -228,84 +228,84 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
   public visitNullExpression(nullExpr: NullExpressionNode): string {
     return this.printNullExpression(nullExpr);
   }
-
-  public visitInExpression(inExpr: InExpressionNode): string {
-    return this.printInExpression(inExpr);
-  }
-
-  public visitExistsExpression(existsExpr: ExistsExpressionNode): string {
-    return this.printExistsExpression(existsExpr);
-  }
-
-  public visitBetweenExpression(betweenExpr: BetweenExpressionNode): string {
-    return this.printBetweenExpression(betweenExpr);
-  }
-
-  public visitArithmeticExpression(arithExpr: ArithmeticExpressionNode): string {
-    return this.printArithmeticExpression(arithExpr);
-  }
-
-  public visitColumn(node: ColumnNode): string {
-    return this.printColumnOperand(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);
-  }
-
-  public visitScalarSubquery(node: ScalarSubqueryNode): string {
-    return this.printScalarSubqueryOperand(node);
-  }
-
-  public visitCaseExpression(node: CaseExpressionNode): string {
-    return this.printCaseExpressionOperand(node);
-  }
-
-  public visitWindowFunction(node: WindowFunctionNode): string {
-    return this.printWindowFunctionOperand(node);
-  }
-
-  public visitCast(node: CastExpressionNode): string {
-    return this.printCastOperand(node);
-  }
-
-  public visitCollate(node: CollateExpressionNode): string {
-    return this.printCollateOperand(node);
-  }
-
-  public visitAliasRef(node: AliasRefNode): string {
-    return `aliasRef('${node.name}')`;
-  }
-
-  /**
-   * Prints a binary expression to TypeScript code
-   * @param binary - Binary expression node
-   * @returns TypeScript code representation
-   */
-  private printBinaryExpression(binary: BinaryExpressionNode): string {
-    const left = this.printOperand(binary.left);
-    const right = this.printOperand(binary.right);
-    const fn = this.mapOp(binary.operator);
-    const args = [left, right];
-    if (binary.escape) {
-      args.push(this.printOperand(binary.escape));
-    }
-    return `${fn}(${args.join(', ')})`;
-  }
-
-  /**
-   * Prints a logical expression to TypeScript code
-   * @param logical - Logical expression node
-   * @returns TypeScript code representation
-   */
+
+  public visitInExpression(inExpr: InExpressionNode): string {
+    return this.printInExpression(inExpr);
+  }
+
+  public visitExistsExpression(existsExpr: ExistsExpressionNode): string {
+    return this.printExistsExpression(existsExpr);
+  }
+
+  public visitBetweenExpression(betweenExpr: BetweenExpressionNode): string {
+    return this.printBetweenExpression(betweenExpr);
+  }
+
+  public visitArithmeticExpression(arithExpr: ArithmeticExpressionNode): string {
+    return this.printArithmeticExpression(arithExpr);
+  }
+
+  public visitColumn(node: ColumnNode): string {
+    return this.printColumnOperand(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);
+  }
+
+  public visitScalarSubquery(node: ScalarSubqueryNode): string {
+    return this.printScalarSubqueryOperand(node);
+  }
+
+  public visitCaseExpression(node: CaseExpressionNode): string {
+    return this.printCaseExpressionOperand(node);
+  }
+
+  public visitWindowFunction(node: WindowFunctionNode): string {
+    return this.printWindowFunctionOperand(node);
+  }
+
+  public visitCast(node: CastExpressionNode): string {
+    return this.printCastOperand(node);
+  }
+
+  public visitCollate(node: CollateExpressionNode): string {
+    return this.printCollateOperand(node);
+  }
+
+  public visitAliasRef(node: AliasRefNode): string {
+    return `aliasRef('${node.name}')`;
+  }
+
+  /**
+   * Prints a binary expression to TypeScript code
+   * @param binary - Binary expression node
+   * @returns TypeScript code representation
+   */
+  private printBinaryExpression(binary: BinaryExpressionNode): string {
+    const left = this.printOperand(binary.left);
+    const right = this.printOperand(binary.right);
+    const fn = this.mapOp(binary.operator);
+    const args = [left, right];
+    if (binary.escape) {
+      args.push(this.printOperand(binary.escape));
+    }
+    return `${fn}(${args.join(', ')})`;
+  }
+
+  /**
+   * Prints a logical expression to TypeScript code
+   * @param logical - Logical expression node
+   * @returns TypeScript code representation
+   */
   private printLogicalExpression(logical: LogicalExpressionNode): string {
     if (logical.operands.length === 0) return '';
     const parts = logical.operands.map(op => {
@@ -321,192 +321,192 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
 
   private printArithmeticExpression(expr: ArithmeticExpressionNode): string {
     const left = this.printOperand(expr.left);
-    const right = this.printOperand(expr.right);
-    return `${left} ${expr.operator} ${right}`;
-  }
-
-  /**
-   * Prints an IN expression to TypeScript code
-   * @param inExpr - IN expression node
-   * @returns TypeScript code representation
-   */
-  private printInExpression(inExpr: InExpressionNode): string {
-    const left = this.printOperand(inExpr.left);
-    const fn = this.mapOp(inExpr.operator);
-    if (Array.isArray(inExpr.right)) {
-      const values = inExpr.right.map(v => this.printOperand(v)).join(', ');
-      return `${fn}(${left}, [${values}])`;
-    }
-    const subquery = this.inlineChain(this.buildSelectLines(inExpr.right.query));
-    return `${fn}(${left}, (${subquery}))`;
-  }
-
-  /**
-   * Prints a null expression to TypeScript code
-   * @param nullExpr - Null expression node
-   * @returns TypeScript code representation
-   */
-  private printNullExpression(nullExpr: NullExpressionNode): string {
-    const left = this.printOperand(nullExpr.left);
-    const fn = this.mapOp(nullExpr.operator);
-    return `${fn}(${left})`;
-  }
-
-  /**
-   * Prints a BETWEEN expression to TypeScript code
-   * @param betweenExpr - BETWEEN expression node
-   * @returns TypeScript code representation
-   */
-  private printBetweenExpression(betweenExpr: BetweenExpressionNode): string {
-    const left = this.printOperand(betweenExpr.left);
-    const lower = this.printOperand(betweenExpr.lower);
-    const upper = this.printOperand(betweenExpr.upper);
-    return `${this.mapOp(betweenExpr.operator)}(${left}, ${lower}, ${upper})`;
-  }
-
-  /**
-   * Prints an EXISTS expression to TypeScript code
-   * @param existsExpr - EXISTS expression node
-   * @returns TypeScript code representation
-   */
-  private printExistsExpression(existsExpr: ExistsExpressionNode): string {
-    const subquery = this.inlineChain(this.buildSelectLines(existsExpr.subquery));
-    return `${this.mapOp(existsExpr.operator)}(${subquery})`;
-  }
-
-  /**
-   * Prints a column operand to TypeScript code
-   * @param column - Column node
-   * @returns TypeScript code representation
-   */
-  private printColumnOperand(column: ColumnNode): string {
-    return `${this.namingStrategy.tableToSymbol(column.table)}.${column.name}`;
-  }
-
-  /**
-   * Prints a literal operand to TypeScript code
-   * @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);
-  }
-
-  /**
-   * Prints a function operand to TypeScript code
-   * @param fn - Function node
-   * @returns TypeScript code representation
-   */
-  private printFunctionOperand(fn: FunctionNode): string {
-    const args = fn.args.map(a => this.printOperand(a)).join(', ');
-    return `${fn.name.toLowerCase()}(${args})`;
-  }
-
-  /**
-   * Prints a JSON path operand to TypeScript code
-   * @param json - JSON path node
-   * @returns TypeScript code representation
-   */
-  private printJsonPathOperand(json: JsonPathNode): string {
-    return `jsonPath(${this.namingStrategy.tableToSymbol(json.column.table)}.${json.column.name}, '${json.path}')`;
-  }
-
-  /**
-   * Prints a scalar subquery operand to TypeScript code
-   * @param node - Scalar subquery node
-   * @returns TypeScript code representation
-   */
-  private printScalarSubqueryOperand(node: ScalarSubqueryNode): string {
-    const subquery = this.inlineChain(this.buildSelectLines(node.query));
-    return `(${subquery})`;
-  }
-
-  /**
-   * Prints a CASE expression operand to TypeScript code
-   * @param node - CASE expression node
-   * @returns TypeScript code representation
-   */
-  private printCaseExpressionOperand(node: CaseExpressionNode): string {
-    const clauses = node.conditions.map(
-      condition =>
-        `{ when: ${this.printExpression(condition.when)}, then: ${this.printOperand(condition.then)} }`
-    );
-    const elseValue = node.else ? `, ${this.printOperand(node.else)}` : '';
-    return `caseWhen([${clauses.join(', ')}]${elseValue})`;
-  }
-
-  /**
-   * Prints a window function operand to TypeScript code
-   * @param node - Window function node
-   * @returns TypeScript code representation
-   */
-  private printWindowFunctionOperand(node: WindowFunctionNode): string {
-    let result = `${node.name}(`;
-    if (node.args.length > 0) {
-      result += node.args.map(arg => this.printOperand(arg)).join(', ');
-    }
-    result += ') OVER (';
-
-    const parts: string[] = [];
-
-    if (node.partitionBy && node.partitionBy.length > 0) {
-      const partitionClause =
-        'PARTITION BY ' + node.partitionBy.map(col => `${this.namingStrategy.tableToSymbol(col.table)}.${col.name}`).join(', ');
-      parts.push(partitionClause);
-    }
-
-    if (node.orderBy && node.orderBy.length > 0) {
-      const orderClause =
-        'ORDER BY ' +
-        node.orderBy
-          .map(o => {
-            const term = this.printOrderingTerm(o.term);
-            const collation = o.collation ? ` COLLATE ${o.collation}` : '';
-            const nulls = o.nulls ? ` NULLS ${o.nulls}` : '';
-            return `${term} ${o.direction}${collation}${nulls}`;
-          })
-          .join(', ');
-      parts.push(orderClause);
-    }
-
-    result += parts.join(' ');
-    result += ')';
-
-    return result;
-  }
-
-  private printCastOperand(node: CastExpressionNode): string {
-    const typeLiteral = node.castType.replace(/'/g, "\\'");
-    return `cast(${this.printOperand(node.expression)}, '${typeLiteral}')`;
-  }
-
-  private printCollateOperand(node: CollateExpressionNode): string {
-    return `collate(${this.printOperand(node.expression)}, '${node.collation}')`;
-  }
-
-  /**
-   * Converts method chain lines to inline format
-   * @param lines - Method chain lines
-   * @returns Inline method chain string
-   */
-  private inlineChain(lines: string[]): string {
-    return lines
-      .map(line => line.trim())
-      .filter(line => line.length > 0)
-      .join(' ');
-  }
-
-  /**
-   * Maps SQL operators to TypeScript function names
-   * @param op - SQL operator
-   * @returns TypeScript function name
-   */
-  private mapOp(op: SqlOperator): string {
-    const config = SQL_OPERATOR_REGISTRY[op];
-    if (!config) {
-      return assertNever(op as never);
-    }
-    return config.tsName;
-  }
-}
+    const right = this.printOperand(expr.right);
+    return `${left} ${expr.operator} ${right}`;
+  }
+
+  /**
+   * Prints an IN expression to TypeScript code
+   * @param inExpr - IN expression node
+   * @returns TypeScript code representation
+   */
+  private printInExpression(inExpr: InExpressionNode): string {
+    const left = this.printOperand(inExpr.left);
+    const fn = this.mapOp(inExpr.operator);
+    if (Array.isArray(inExpr.right)) {
+      const values = inExpr.right.map(v => this.printOperand(v)).join(', ');
+      return `${fn}(${left}, [${values}])`;
+    }
+    const subquery = this.inlineChain(this.buildSelectLines(inExpr.right.query));
+    return `${fn}(${left}, (${subquery}))`;
+  }
+
+  /**
+   * Prints a null expression to TypeScript code
+   * @param nullExpr - Null expression node
+   * @returns TypeScript code representation
+   */
+  private printNullExpression(nullExpr: NullExpressionNode): string {
+    const left = this.printOperand(nullExpr.left);
+    const fn = this.mapOp(nullExpr.operator);
+    return `${fn}(${left})`;
+  }
+
+  /**
+   * Prints a BETWEEN expression to TypeScript code
+   * @param betweenExpr - BETWEEN expression node
+   * @returns TypeScript code representation
+   */
+  private printBetweenExpression(betweenExpr: BetweenExpressionNode): string {
+    const left = this.printOperand(betweenExpr.left);
+    const lower = this.printOperand(betweenExpr.lower);
+    const upper = this.printOperand(betweenExpr.upper);
+    return `${this.mapOp(betweenExpr.operator)}(${left}, ${lower}, ${upper})`;
+  }
+
+  /**
+   * Prints an EXISTS expression to TypeScript code
+   * @param existsExpr - EXISTS expression node
+   * @returns TypeScript code representation
+   */
+  private printExistsExpression(existsExpr: ExistsExpressionNode): string {
+    const subquery = this.inlineChain(this.buildSelectLines(existsExpr.subquery));
+    return `${this.mapOp(existsExpr.operator)}(${subquery})`;
+  }
+
+  /**
+   * Prints a column operand to TypeScript code
+   * @param column - Column node
+   * @returns TypeScript code representation
+   */
+  private printColumnOperand(column: ColumnNode): string {
+    return `${this.namingStrategy.tableToSymbol(column.table)}.${column.name}`;
+  }
+
+  /**
+   * Prints a literal operand to TypeScript code
+   * @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);
+  }
+
+  /**
+   * Prints a function operand to TypeScript code
+   * @param fn - Function node
+   * @returns TypeScript code representation
+   */
+  private printFunctionOperand(fn: FunctionNode): string {
+    const args = fn.args.map(a => this.printOperand(a)).join(', ');
+    return `${fn.name.toLowerCase()}(${args})`;
+  }
+
+  /**
+   * Prints a JSON path operand to TypeScript code
+   * @param json - JSON path node
+   * @returns TypeScript code representation
+   */
+  private printJsonPathOperand(json: JsonPathNode): string {
+    return `jsonPath(${this.namingStrategy.tableToSymbol(json.column.table)}.${json.column.name}, '${json.path}')`;
+  }
+
+  /**
+   * Prints a scalar subquery operand to TypeScript code
+   * @param node - Scalar subquery node
+   * @returns TypeScript code representation
+   */
+  private printScalarSubqueryOperand(node: ScalarSubqueryNode): string {
+    const subquery = this.inlineChain(this.buildSelectLines(node.query));
+    return `(${subquery})`;
+  }
+
+  /**
+   * Prints a CASE expression operand to TypeScript code
+   * @param node - CASE expression node
+   * @returns TypeScript code representation
+   */
+  private printCaseExpressionOperand(node: CaseExpressionNode): string {
+    const clauses = node.conditions.map(
+      condition =>
+        `{ when: ${this.printExpression(condition.when)}, then: ${this.printOperand(condition.then)} }`
+    );
+    const elseValue = node.else ? `, ${this.printOperand(node.else)}` : '';
+    return `caseWhen([${clauses.join(', ')}]${elseValue})`;
+  }
+
+  /**
+   * Prints a window function operand to TypeScript code
+   * @param node - Window function node
+   * @returns TypeScript code representation
+   */
+  private printWindowFunctionOperand(node: WindowFunctionNode): string {
+    let result = `${node.name}(`;
+    if (node.args.length > 0) {
+      result += node.args.map(arg => this.printOperand(arg)).join(', ');
+    }
+    result += ') OVER (';
+
+    const parts: string[] = [];
+
+    if (node.partitionBy && node.partitionBy.length > 0) {
+      const partitionClause =
+        'PARTITION BY ' + node.partitionBy.map(col => `${this.namingStrategy.tableToSymbol(col.table)}.${col.name}`).join(', ');
+      parts.push(partitionClause);
+    }
+
+    if (node.orderBy && node.orderBy.length > 0) {
+      const orderClause =
+        'ORDER BY ' +
+        node.orderBy
+          .map(o => {
+            const term = this.printOrderingTerm(o.term);
+            const collation = o.collation ? ` COLLATE ${o.collation}` : '';
+            const nulls = o.nulls ? ` NULLS ${o.nulls}` : '';
+            return `${term} ${o.direction}${collation}${nulls}`;
+          })
+          .join(', ');
+      parts.push(orderClause);
+    }
+
+    result += parts.join(' ');
+    result += ')';
+
+    return result;
+  }
+
+  private printCastOperand(node: CastExpressionNode): string {
+    const typeLiteral = node.castType.replace(/'/g, "\\'");
+    return `cast(${this.printOperand(node.expression)}, '${typeLiteral}')`;
+  }
+
+  private printCollateOperand(node: CollateExpressionNode): string {
+    return `collate(${this.printOperand(node.expression)}, '${node.collation}')`;
+  }
+
+  /**
+   * Converts method chain lines to inline format
+   * @param lines - Method chain lines
+   * @returns Inline method chain string
+   */
+  private inlineChain(lines: string[]): string {
+    return lines
+      .map(line => line.trim())
+      .filter(line => line.length > 0)
+      .join(' ');
+  }
+
+  /**
+   * Maps SQL operators to TypeScript function names
+   * @param op - SQL operator
+   * @returns TypeScript function name
+   */
+  private mapOp(op: SqlOperator): string {
+    const config = SQL_OPERATOR_REGISTRY[op];
+    if (!config) {
+      return assertNever(op as never);
+    }
+    return config.tsName;
+  }
+}