metal-orm 1.0.39 → 1.0.41

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

@@ -1,19 +1,28 @@
 import type { SelectQueryNode, OrderByNode } from './query.js';
 import { SqlOperator } 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, or null) */
-  value: string | number | boolean | null;
-}
-
-/**
- * AST node representing a column reference
- */
+
+/**
+ * AST node representing a literal value
+ */
+export interface LiteralNode {
+  type: 'Literal';
+  /** The literal value (string, number, boolean, or null) */
+  value: string | number | boolean | null;
+}
+
+/**
+ * AST node representing a reference to a SELECT alias (for ORDER BY / GROUP BY).
+ */
+export interface AliasRefNode {
+  type: 'AliasRef';
+  /** Alias name to reference */
+  name: string;
+}
+
+/**
+ * AST node representing a column reference
+ */
 export interface ColumnNode {
   type: 'Column';
   /** Table name the column belongs to */
@@ -25,10 +34,10 @@ export interface ColumnNode {
   /** Optional scope marker (e.g., 'outer' for correlated references) */
   scope?: 'outer' | 'default';
 }
-
-/**
- * AST node representing a function call
- */
+
+/**
+ * AST node representing a function call
+ */
 export interface FunctionNode {
   type: 'Function';
   /** Function name (e.g., COUNT, SUM) */
@@ -46,176 +55,191 @@ export interface FunctionNode {
   /** Optional DISTINCT modifier */
   distinct?: boolean;
 }
-
-/**
- * AST node representing a JSON path expression
- */
-export interface JsonPathNode {
-  type: 'JsonPath';
-  /** Source column */
-  column: ColumnNode;
-  /** JSON path expression */
-  path: string;
-  /** Optional alias for the result */
-  alias?: string;
-}
-
-/**
- * AST node representing a scalar subquery
- */
-export interface ScalarSubqueryNode {
-  type: 'ScalarSubquery';
-  /** Subquery to execute */
-  query: SelectQueryNode;
-  /** Optional alias for the subquery result */
-  alias?: string;
-}
-
-/**
- * AST node representing a CASE expression
- */
-export interface CaseExpressionNode {
-  type: 'CaseExpression';
-  /** WHEN-THEN conditions */
-  conditions: { when: ExpressionNode; then: OperandNode }[];
-  /** Optional ELSE clause */
-  else?: OperandNode;
-  /** Optional alias for the result */
-  alias?: string;
-}
-
-/**
- * AST node representing a window function
- */
-export interface WindowFunctionNode {
-  type: 'WindowFunction';
-  /** Window function name (e.g., ROW_NUMBER, RANK) */
-  name: string;
-  /** Function arguments */
-  args: (ColumnNode | LiteralNode | JsonPathNode)[];
-  /** Optional PARTITION BY clause */
-  partitionBy?: ColumnNode[];
-  /** Optional ORDER BY clause */
-  orderBy?: OrderByNode[];
-  /** Optional alias for the result */
-  alias?: string;
-}
-
-/**
- * Union type representing any operand that can be used in expressions
- */
-export type OperandNode =
-  | ColumnNode
-  | LiteralNode
-  | FunctionNode
-  | JsonPathNode
-  | ScalarSubqueryNode
-  | CaseExpressionNode
-  | WindowFunctionNode;
-
-const operandTypes = new Set<OperandNode['type']>([
-  'Column',
-  'Literal',
-  'Function',
-  'JsonPath',
-  'ScalarSubquery',
-  'CaseExpression',
-  'WindowFunction'
-]);
-
-export const isOperandNode = (node: any): node is OperandNode => node && operandTypes.has(node.type);
-
-export const isFunctionNode = (node: any): node is FunctionNode => node?.type === 'Function';
-export const isCaseExpressionNode = (node: any): node is CaseExpressionNode => node?.type === 'CaseExpression';
-export const isWindowFunctionNode = (node: any): node is WindowFunctionNode => node?.type === 'WindowFunction';
+
+/**
+ * AST node representing a JSON path expression
+ */
+export interface JsonPathNode {
+  type: 'JsonPath';
+  /** Source column */
+  column: ColumnNode;
+  /** JSON path expression */
+  path: string;
+  /** Optional alias for the result */
+  alias?: string;
+}
+
+/**
+ * AST node representing a scalar subquery
+ */
+export interface ScalarSubqueryNode {
+  type: 'ScalarSubquery';
+  /** Subquery to execute */
+  query: SelectQueryNode;
+  /** Optional alias for the subquery result */
+  alias?: string;
+}
+
+export type InExpressionRight = OperandNode[] | ScalarSubqueryNode;
+
+/**
+ * AST node representing a CASE expression
+ */
+export interface CaseExpressionNode {
+  type: 'CaseExpression';
+  /** WHEN-THEN conditions */
+  conditions: { when: ExpressionNode; then: OperandNode }[];
+  /** Optional ELSE clause */
+  else?: OperandNode;
+  /** Optional alias for the result */
+  alias?: string;
+}
+
+/**
+ * AST node representing a window function
+ */
+export interface WindowFunctionNode {
+  type: 'WindowFunction';
+  /** Window function name (e.g., ROW_NUMBER, RANK) */
+  name: string;
+  /** Function arguments */
+  args: (ColumnNode | LiteralNode | JsonPathNode)[];
+  /** Optional PARTITION BY clause */
+  partitionBy?: ColumnNode[];
+  /** Optional ORDER BY clause */
+  orderBy?: OrderByNode[];
+  /** Optional alias for the result */
+  alias?: string;
+}
+
+/**
+ * AST node representing an arithmetic expression (e.g., a + b)
+ */
+export interface ArithmeticExpressionNode {
+  type: 'ArithmeticExpression';
+  left: OperandNode;
+  operator: '+' | '-' | '*' | '/';
+  right: OperandNode;
+}
+
+/**
+ * Union type representing any operand that can be used in expressions
+ */
+export type OperandNode =
+  | AliasRefNode
+  | ColumnNode
+  | LiteralNode
+  | FunctionNode
+  | JsonPathNode
+  | ScalarSubqueryNode
+  | CaseExpressionNode
+  | WindowFunctionNode;
+
+const operandTypes = new Set<OperandNode['type']>([
+  'AliasRef',
+  'Column',
+  'Literal',
+  'Function',
+  'JsonPath',
+  'ScalarSubquery',
+  'CaseExpression',
+  'WindowFunction'
+]);
+
+export const isOperandNode = (node: any): node is OperandNode => node && operandTypes.has(node.type);
+
+export const isFunctionNode = (node: any): node is FunctionNode => node?.type === 'Function';
+export const isCaseExpressionNode = (node: any): node is CaseExpressionNode => node?.type === 'CaseExpression';
+export const isWindowFunctionNode = (node: any): node is WindowFunctionNode => node?.type === 'WindowFunction';
 export const isExpressionSelectionNode = (
   node: ColumnRef | FunctionNode | CaseExpressionNode | WindowFunctionNode
 ): node is FunctionNode | CaseExpressionNode | WindowFunctionNode =>
   isFunctionNode(node) || isCaseExpressionNode(node) || isWindowFunctionNode(node);
-
-/**
- * AST node representing a binary expression (e.g., column = value)
- */
-export interface BinaryExpressionNode {
-  type: 'BinaryExpression';
-  /** Left operand */
-  left: OperandNode;
-  /** Comparison operator */
-  operator: SqlOperator;
-  /** Right operand */
-  right: OperandNode;
-  /** Optional escape character for LIKE expressions */
-  escape?: LiteralNode;
-}
-
-/**
- * AST node representing a logical expression (AND/OR)
- */
-export interface LogicalExpressionNode {
-  type: 'LogicalExpression';
-  /** Logical operator (AND or OR) */
-  operator: 'AND' | 'OR';
-  /** Operands to combine */
-  operands: ExpressionNode[];
-}
-
-/**
- * AST node representing a null check expression
- */
-export interface NullExpressionNode {
-  type: 'NullExpression';
-  /** Operand to check for null */
-  left: OperandNode;
-  /** Null check operator */
-  operator: 'IS NULL' | 'IS NOT NULL';
-}
-
-/**
- * AST node representing an IN/NOT IN expression
- */
-export interface InExpressionNode {
-  type: 'InExpression';
-  /** Left operand to check */
-  left: OperandNode;
-  /** IN/NOT IN operator */
-  operator: 'IN' | 'NOT IN';
-  /** Values to check against */
-  right: OperandNode[];
-}
-
-/**
- * AST node representing an EXISTS/NOT EXISTS expression
- */
-export interface ExistsExpressionNode {
-  type: 'ExistsExpression';
-  /** EXISTS/NOT EXISTS operator */
-  operator: SqlOperator;
-  /** Subquery to check */
-  subquery: SelectQueryNode;
-}
-
-/**
- * AST node representing a BETWEEN/NOT BETWEEN expression
- */
-export interface BetweenExpressionNode {
-  type: 'BetweenExpression';
-  /** Operand to check */
-  left: OperandNode;
-  /** BETWEEN/NOT BETWEEN operator */
-  operator: 'BETWEEN' | 'NOT BETWEEN';
-  /** Lower bound */
-  lower: OperandNode;
-  /** Upper bound */
-  upper: OperandNode;
-}
-
-/**
- * Union type representing any supported expression node
- */
-export type ExpressionNode =
-  | BinaryExpressionNode
-  | LogicalExpressionNode
-  | NullExpressionNode
-  | InExpressionNode
-  | ExistsExpressionNode
-  | BetweenExpressionNode;
+
+/**
+ * AST node representing a binary expression (e.g., column = value)
+ */
+export interface BinaryExpressionNode {
+  type: 'BinaryExpression';
+  /** Left operand */
+  left: OperandNode;
+  /** Comparison operator */
+  operator: SqlOperator;
+  /** Right operand */
+  right: OperandNode;
+  /** Optional escape character for LIKE expressions */
+  escape?: LiteralNode;
+}
+
+/**
+ * AST node representing a logical expression (AND/OR)
+ */
+export interface LogicalExpressionNode {
+  type: 'LogicalExpression';
+  /** Logical operator (AND or OR) */
+  operator: 'AND' | 'OR';
+  /** Operands to combine */
+  operands: ExpressionNode[];
+}
+
+/**
+ * AST node representing a null check expression
+ */
+export interface NullExpressionNode {
+  type: 'NullExpression';
+  /** Operand to check for null */
+  left: OperandNode;
+  /** Null check operator */
+  operator: 'IS NULL' | 'IS NOT NULL';
+}
+
+/**
+ * AST node representing an IN/NOT IN expression
+ */
+export interface InExpressionNode {
+  type: 'InExpression';
+  /** Left operand to check */
+  left: OperandNode;
+  /** IN/NOT IN operator */
+  operator: 'IN' | 'NOT IN';
+  /** Values to check against */
+  right: InExpressionRight;
+}
+
+/**
+ * AST node representing an EXISTS/NOT EXISTS expression
+ */
+export interface ExistsExpressionNode {
+  type: 'ExistsExpression';
+  /** EXISTS/NOT EXISTS operator */
+  operator: SqlOperator;
+  /** Subquery to check */
+  subquery: SelectQueryNode;
+}
+
+/**
+ * AST node representing a BETWEEN/NOT BETWEEN expression
+ */
+export interface BetweenExpressionNode {
+  type: 'BetweenExpression';
+  /** Operand to check */
+  left: OperandNode;
+  /** BETWEEN/NOT BETWEEN operator */
+  operator: 'BETWEEN' | 'NOT BETWEEN';
+  /** Lower bound */
+  lower: OperandNode;
+  /** Upper bound */
+  upper: OperandNode;
+}
+
+/**
+ * Union type representing any supported expression node
+ */
+export type ExpressionNode =
+  | BinaryExpressionNode
+  | LogicalExpressionNode
+  | NullExpressionNode
+  | InExpressionNode
+  | ExistsExpressionNode
+  | BetweenExpressionNode
+  | ArithmeticExpressionNode;

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

@@ -1,24 +1,26 @@
-import {
-  BinaryExpressionNode,
-  LogicalExpressionNode,
-  NullExpressionNode,
-  InExpressionNode,
-  ExistsExpressionNode,
-  BetweenExpressionNode,
-  ExpressionNode,
-  OperandNode,
-  ColumnNode,
-  LiteralNode,
-  FunctionNode,
-  JsonPathNode,
-  ScalarSubqueryNode,
-  CaseExpressionNode,
-  WindowFunctionNode
-} from './expression-nodes.js';
-
-/**
- * Visitor for expression nodes
- */
+import {
+  BinaryExpressionNode,
+  LogicalExpressionNode,
+  NullExpressionNode,
+  InExpressionNode,
+  ExistsExpressionNode,
+  BetweenExpressionNode,
+  ExpressionNode,
+  OperandNode,
+  ArithmeticExpressionNode,
+  ColumnNode,
+  LiteralNode,
+  FunctionNode,
+  JsonPathNode,
+  ScalarSubqueryNode,
+  CaseExpressionNode,
+  WindowFunctionNode,
+  AliasRefNode
+} from './expression-nodes.js';
+
+/**
+ * Visitor for expression nodes
+ */
 export interface ExpressionVisitor<R> {
   visitBinaryExpression?(node: BinaryExpressionNode): R;
   visitLogicalExpression?(node: LogicalExpressionNode): R;
@@ -26,6 +28,7 @@ export interface ExpressionVisitor<R> {
   visitInExpression?(node: InExpressionNode): R;
   visitExistsExpression?(node: ExistsExpressionNode): R;
   visitBetweenExpression?(node: BetweenExpressionNode): R;
+  visitArithmeticExpression?(node: ArithmeticExpressionNode): R;
   otherwise?(node: ExpressionNode): R;
 }
 
@@ -40,6 +43,7 @@ export interface OperandVisitor<R> {
   visitScalarSubquery?(node: ScalarSubqueryNode): R;
   visitCaseExpression?(node: CaseExpressionNode): R;
   visitWindowFunction?(node: WindowFunctionNode): R;
+  visitAliasRef?(node: AliasRefNode): R;
   otherwise?(node: OperandNode): R;
 }
 
@@ -74,12 +78,12 @@ export const clearOperandDispatchers = (): void => operandDispatchers.clear();
 const unsupportedExpression = (node: ExpressionNode): never => {
   throw new Error(`Unsupported expression type "${(node as any)?.type ?? 'unknown'}"`);
 };
-
-const unsupportedOperand = (node: OperandNode): never => {
-  throw new Error(`Unsupported operand type "${(node as any)?.type ?? 'unknown'}"`);
-};
-/**
- * Dispatches an expression node to the visitor
+
+const unsupportedOperand = (node: OperandNode): never => {
+  throw new Error(`Unsupported operand type "${(node as any)?.type ?? 'unknown'}"`);
+};
+/**
+ * Dispatches an expression node to the visitor
  * @param node - Expression node to visit
  * @param visitor - Visitor implementation
  */
@@ -106,15 +110,18 @@ export const visitExpression = <R>(node: ExpressionNode, visitor: ExpressionVisi
     case 'BetweenExpression':
       if (visitor.visitBetweenExpression) return visitor.visitBetweenExpression(node);
       break;
+    case 'ArithmeticExpression':
+      if (visitor.visitArithmeticExpression) return visitor.visitArithmeticExpression(node);
+      break;
     default:
       break;
   }
   if (visitor.otherwise) return visitor.otherwise(node);
   return unsupportedExpression(node);
 };
-
-/**
- * Dispatches an operand node to the visitor
+
+/**
+ * Dispatches an operand node to the visitor
  * @param node - Operand node to visit
  * @param visitor - Visitor implementation
  */
@@ -144,6 +151,9 @@ export const visitOperand = <R>(node: OperandNode, visitor: OperandVisitor<R>):
     case 'WindowFunction':
       if (visitor.visitWindowFunction) return visitor.visitWindowFunction(node);
       break;
+    case 'AliasRef':
+      if (visitor.visitAliasRef) return visitor.visitAliasRef(node);
+      break;
     default:
       break;
   }