metal-orm 1.0.88 → 1.0.90

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

@@ -1,252 +1,219 @@
-import {
-  BinaryExpressionNode,
-  LogicalExpressionNode,
-  NullExpressionNode,
-  InExpressionNode,
-  ExistsExpressionNode,
-  BetweenExpressionNode,
-  ExpressionNode,
-  OperandNode,
-  ArithmeticExpressionNode,
-  ColumnNode,
-  LiteralNode,
-  FunctionNode,
-  JsonPathNode,
-  ScalarSubqueryNode,
-  CaseExpressionNode,
-  CastExpressionNode,
-  WindowFunctionNode,
-  CollateExpressionNode,
-  AliasRefNode,
-  BitwiseExpressionNode,
-  ParamNode
-} from './expression-nodes.js';
-import type { SelectQueryNode } from './query.js';
-
-/**
- * Visitor for expression nodes
- */
-export interface ExpressionVisitor<R> {
-  visitBinaryExpression?(node: BinaryExpressionNode): R;
-  visitLogicalExpression?(node: LogicalExpressionNode): R;
-  visitNullExpression?(node: NullExpressionNode): R;
-  visitInExpression?(node: InExpressionNode): R;
-  visitExistsExpression?(node: ExistsExpressionNode): R;
-  visitBetweenExpression?(node: BetweenExpressionNode): R;
-  visitArithmeticExpression?(node: ArithmeticExpressionNode): R;
-  visitBitwiseExpression?(node: BitwiseExpressionNode): R;
-  visitOperand?(node: OperandNode): R;
-  visitSelectQuery?(node: SelectQueryNode): R;
-  otherwise?(node: ExpressionNode): R;
-}
-
-/**
- * Visitor for operand nodes
- */
-export interface OperandVisitor<R> {
-  visitColumn?(node: ColumnNode): R;
-  visitLiteral?(node: LiteralNode): R;
-  visitParam?(node: ParamNode): R;
-  visitFunction?(node: FunctionNode): R;
-  visitJsonPath?(node: JsonPathNode): R;
-  visitScalarSubquery?(node: ScalarSubqueryNode): R;
-  visitCaseExpression?(node: CaseExpressionNode): R;
-  visitCast?(node: CastExpressionNode): R;
-  visitWindowFunction?(node: WindowFunctionNode): R;
-  visitArithmeticExpression?(node: ArithmeticExpressionNode): R;
-  visitBitwiseExpression?(node: BitwiseExpressionNode): R;
-  visitExpression?(node: ExpressionNode): R;
-  visitSelectQuery?(node: SelectQueryNode): R;
-  visitCollate?(node: CollateExpressionNode): R;
-  visitAliasRef?(node: AliasRefNode): R;
-  otherwise?(node: OperandNode): R;
-}
-
-type ExpressionDispatch = <R>(node: ExpressionNode, visitor: ExpressionVisitor<R>) => R;
-type OperandDispatch = <R>(node: OperandNode, visitor: OperandVisitor<R>) => R;
-
-/**
- * Registry class for managing dispatchers in an immutable way
- */
-class DispatcherRegistry<T> {
-  private readonly dispatchers: ReadonlyMap<string, T>;
-
-  constructor(dispatchers: Map<string, T> = new Map()) {
-    this.dispatchers = dispatchers;
-  }
-
-  /**
-   * Registers a new dispatcher and returns a new registry instance
-   */
-  register(type: string, dispatcher: T): DispatcherRegistry<T> {
-    const newMap = new Map(this.dispatchers);
-    newMap.set(type, dispatcher);
-    return new DispatcherRegistry(newMap);
-  }
-
-  /**
-   * Gets a dispatcher for the given type
-   */
-  get(type: string): T | undefined {
-    return this.dispatchers.get(type);
-  }
-
-  /**
-   * Returns a new empty registry
-   */
-  clear(): DispatcherRegistry<T> {
-    return new DispatcherRegistry();
-  }
-}
-
-let expressionRegistry = new DispatcherRegistry<ExpressionDispatch>();
-let operandRegistry = new DispatcherRegistry<OperandDispatch>();
-
-/**
- * Registers a dispatcher for a custom expression node type.
- * Allows new node kinds without modifying the core switch.
- */
-export const registerExpressionDispatcher = (type: string, dispatcher: ExpressionDispatch): void => {
-  expressionRegistry = expressionRegistry.register(type, dispatcher);
-};
-
-/**
- * Registers a dispatcher for a custom operand node type.
- * Allows new node kinds without modifying the core switch.
- */
-export const registerOperandDispatcher = (type: string, dispatcher: OperandDispatch): void => {
-  operandRegistry = operandRegistry.register(type, dispatcher);
-};
-
-export const hasExpressionDispatcher = (type: string): boolean =>
-  expressionRegistry.get(type) !== undefined;
-
-export const hasOperandDispatcher = (type: string): boolean =>
-  operandRegistry.get(type) !== undefined;
-
-/**
- * Clears all registered dispatchers. Primarily for tests.
- */
-export const clearExpressionDispatchers = (): void => {
-  expressionRegistry = expressionRegistry.clear();
-};
-
-export const clearOperandDispatchers = (): void => {
-  operandRegistry = operandRegistry.clear();
-};
-
-const getNodeType = (node: { type?: string } | null | undefined): string | undefined => {
-  if (typeof node !== 'object' || node === null) return undefined;
-  const descriptor = Object.getOwnPropertyDescriptor(node, 'type');
-  if (descriptor && typeof descriptor.value === 'string') {
-    return descriptor.value;
-  }
-  const type = node.type;
-  return typeof type === 'string' ? type : undefined;
-};
-
-const unsupportedExpression = (node: ExpressionNode): never => {
-  throw new Error(`Unsupported expression type "${getNodeType(node) ?? 'unknown'}"`);
-};
-
-const unsupportedOperand = (node: OperandNode): never => {
-  throw new Error(`Unsupported operand type "${getNodeType(node) ?? 'unknown'}"`);
-};
-/**
- * Dispatches an expression node to the visitor
- * @param node - Expression node to visit
- * @param visitor - Visitor implementation
- */
-export const visitExpression = <R>(node: ExpressionNode, visitor: ExpressionVisitor<R>): R => {
-  const type = getNodeType(node);
-  const dynamic = type ? expressionRegistry.get(type) : undefined;
-  if (dynamic) return dynamic(node, visitor);
-
-  switch (type) {
-    case 'BinaryExpression':
-      if (visitor.visitBinaryExpression) return visitor.visitBinaryExpression(node as BinaryExpressionNode);
-      break;
-    case 'LogicalExpression':
-      if (visitor.visitLogicalExpression) return visitor.visitLogicalExpression(node as LogicalExpressionNode);
-      break;
-    case 'NullExpression':
-      if (visitor.visitNullExpression) return visitor.visitNullExpression(node as NullExpressionNode);
-      break;
-    case 'InExpression':
-      if (visitor.visitInExpression) return visitor.visitInExpression(node as InExpressionNode);
-      break;
-    case 'ExistsExpression':
-      if (visitor.visitExistsExpression) return visitor.visitExistsExpression(node as ExistsExpressionNode);
-      break;
-    case 'BetweenExpression':
-      if (visitor.visitBetweenExpression) return visitor.visitBetweenExpression(node as BetweenExpressionNode);
-      break;
-    case 'ArithmeticExpression':
-      if (visitor.visitArithmeticExpression) return visitor.visitArithmeticExpression(node as ArithmeticExpressionNode);
-      break;
-    case 'BitwiseExpression':
-      if (visitor.visitBitwiseExpression) return visitor.visitBitwiseExpression(node as BitwiseExpressionNode);
-      break;
-    default:
-      break;
-  }
-  if (visitor.otherwise) return visitor.otherwise(node);
-  return unsupportedExpression(node);
-};
-
-/**
- * Dispatches an operand node to the visitor
- * @param node - Operand node to visit
- * @param visitor - Visitor implementation
- */
-export const visitOperand = <R>(node: OperandNode, visitor: OperandVisitor<R>): R => {
-  const type = getNodeType(node);
-  const dynamic = type ? operandRegistry.get(type) : undefined;
-  if (dynamic) return dynamic(node, visitor);
-
-  switch (type) {
-    case 'Column':
-      if (visitor.visitColumn) return visitor.visitColumn(node as ColumnNode);
-      break;
-    case 'Literal':
-      if (visitor.visitLiteral) return visitor.visitLiteral(node as LiteralNode);
-      break;
-    case 'Param':
-      if (visitor.visitParam) return visitor.visitParam(node as ParamNode);
-      break;
-    case 'Function':
-      if (visitor.visitFunction) return visitor.visitFunction(node as FunctionNode);
-      break;
-    case 'JsonPath':
-      if (visitor.visitJsonPath) return visitor.visitJsonPath(node as JsonPathNode);
-      break;
-    case 'ScalarSubquery':
-      if (visitor.visitScalarSubquery) return visitor.visitScalarSubquery(node as ScalarSubqueryNode);
-      break;
-    case 'CaseExpression':
-      if (visitor.visitCaseExpression) return visitor.visitCaseExpression(node as CaseExpressionNode);
-      break;
-    case 'WindowFunction':
-      if (visitor.visitWindowFunction) return visitor.visitWindowFunction(node as WindowFunctionNode);
-      break;
-    case 'AliasRef':
-      if (visitor.visitAliasRef) return visitor.visitAliasRef(node as AliasRefNode);
-      break;
-    case 'Cast':
-      if (visitor.visitCast) return visitor.visitCast(node as CastExpressionNode);
-      break;
-    case 'Collate':
-      if (visitor.visitCollate) return visitor.visitCollate(node as CollateExpressionNode);
-      break;
-    case 'ArithmeticExpression':
-      if (visitor.visitArithmeticExpression) return visitor.visitArithmeticExpression(node as ArithmeticExpressionNode);
-      break;
-    case 'BitwiseExpression':
-      if (visitor.visitBitwiseExpression) return visitor.visitBitwiseExpression(node as BitwiseExpressionNode);
-      break;
-    default:
-      break;
-  }
-  if (visitor.otherwise) return visitor.otherwise(node);
-  return unsupportedOperand(node);
-};
+import {
+  BinaryExpressionNode,
+  LogicalExpressionNode,
+  NullExpressionNode,
+  InExpressionNode,
+  ExistsExpressionNode,
+  BetweenExpressionNode,
+  ExpressionNode,
+  OperandNode,
+  ArithmeticExpressionNode,
+  ColumnNode,
+  LiteralNode,
+  FunctionNode,
+  JsonPathNode,
+  ScalarSubqueryNode,
+  CaseExpressionNode,
+  CastExpressionNode,
+  WindowFunctionNode,
+  CollateExpressionNode,
+  AliasRefNode,
+  BitwiseExpressionNode
+} from './expression-nodes.js';
+
+/**
+ * Visitor for expression nodes
+ */
+export interface ExpressionVisitor<R> {
+  visitBinaryExpression?(node: BinaryExpressionNode): R;
+  visitLogicalExpression?(node: LogicalExpressionNode): R;
+  visitNullExpression?(node: NullExpressionNode): R;
+  visitInExpression?(node: InExpressionNode): R;
+  visitExistsExpression?(node: ExistsExpressionNode): R;
+  visitBetweenExpression?(node: BetweenExpressionNode): R;
+  visitArithmeticExpression?(node: ArithmeticExpressionNode): R;
+  visitBitwiseExpression?(node: BitwiseExpressionNode): R;
+  otherwise?(node: ExpressionNode): R;
+}
+
+/**
+ * Visitor for operand nodes
+ */
+export interface OperandVisitor<R> {
+  visitColumn?(node: ColumnNode): R;
+  visitLiteral?(node: LiteralNode): R;
+  visitFunction?(node: FunctionNode): R;
+  visitJsonPath?(node: JsonPathNode): R;
+  visitScalarSubquery?(node: ScalarSubqueryNode): R;
+  visitCaseExpression?(node: CaseExpressionNode): R;
+  visitCast?(node: CastExpressionNode): R;
+  visitWindowFunction?(node: WindowFunctionNode): R;
+  visitCollate?(node: CollateExpressionNode): R;
+  visitAliasRef?(node: AliasRefNode): R;
+  otherwise?(node: OperandNode): R;
+}
+
+type ExpressionDispatch = <R>(node: ExpressionNode, visitor: ExpressionVisitor<R>) => R;
+type OperandDispatch = <R>(node: OperandNode, visitor: OperandVisitor<R>) => R;
+
+/**
+ * Registry class for managing dispatchers in an immutable way
+ */
+class DispatcherRegistry<T> {
+  private readonly dispatchers: ReadonlyMap<string, T>;
+
+  constructor(dispatchers: Map<string, T> = new Map()) {
+    this.dispatchers = dispatchers;
+  }
+
+  /**
+   * Registers a new dispatcher and returns a new registry instance
+   */
+  register(type: string, dispatcher: T): DispatcherRegistry<T> {
+    const newMap = new Map(this.dispatchers);
+    newMap.set(type, dispatcher);
+    return new DispatcherRegistry(newMap);
+  }
+
+  /**
+   * Gets a dispatcher for the given type
+   */
+  get(type: string): T | undefined {
+    return this.dispatchers.get(type);
+  }
+
+  /**
+   * Returns a new empty registry
+   */
+  clear(): DispatcherRegistry<T> {
+    return new DispatcherRegistry();
+  }
+}
+
+let expressionRegistry = new DispatcherRegistry<ExpressionDispatch>();
+let operandRegistry = new DispatcherRegistry<OperandDispatch>();
+
+/**
+ * Registers a dispatcher for a custom expression node type.
+ * Allows new node kinds without modifying the core switch.
+ */
+export const registerExpressionDispatcher = (type: string, dispatcher: ExpressionDispatch): void => {
+  expressionRegistry = expressionRegistry.register(type, dispatcher);
+};
+
+/**
+ * Registers a dispatcher for a custom operand node type.
+ * Allows new node kinds without modifying the core switch.
+ */
+export const registerOperandDispatcher = (type: string, dispatcher: OperandDispatch): void => {
+  operandRegistry = operandRegistry.register(type, dispatcher);
+};
+
+/**
+ * Clears all registered dispatchers. Primarily for tests.
+ */
+export const clearExpressionDispatchers = (): void => {
+  expressionRegistry = expressionRegistry.clear();
+};
+
+export const clearOperandDispatchers = (): void => {
+  operandRegistry = operandRegistry.clear();
+};
+
+const getNodeType = (node: { type?: string } | null | undefined): string | undefined =>
+  typeof node === 'object' && node !== null && typeof node.type === 'string' ? node.type : undefined;
+
+const unsupportedExpression = (node: ExpressionNode): never => {
+  throw new Error(`Unsupported expression type "${getNodeType(node) ?? 'unknown'}"`);
+};
+
+const unsupportedOperand = (node: OperandNode): never => {
+  throw new Error(`Unsupported operand type "${getNodeType(node) ?? 'unknown'}"`);
+};
+/**
+ * Dispatches an expression node to the visitor
+ * @param node - Expression node to visit
+ * @param visitor - Visitor implementation
+ */
+export const visitExpression = <R>(node: ExpressionNode, visitor: ExpressionVisitor<R>): R => {
+  const dynamic = expressionRegistry.get(node.type);
+  if (dynamic) return dynamic(node, visitor);
+
+  switch (node.type) {
+    case 'BinaryExpression':
+      if (visitor.visitBinaryExpression) return visitor.visitBinaryExpression(node);
+      break;
+    case 'LogicalExpression':
+      if (visitor.visitLogicalExpression) return visitor.visitLogicalExpression(node);
+      break;
+    case 'NullExpression':
+      if (visitor.visitNullExpression) return visitor.visitNullExpression(node);
+      break;
+    case 'InExpression':
+      if (visitor.visitInExpression) return visitor.visitInExpression(node);
+      break;
+    case 'ExistsExpression':
+      if (visitor.visitExistsExpression) return visitor.visitExistsExpression(node);
+      break;
+    case 'BetweenExpression':
+      if (visitor.visitBetweenExpression) return visitor.visitBetweenExpression(node);
+      break;
+    case 'ArithmeticExpression':
+      if (visitor.visitArithmeticExpression) return visitor.visitArithmeticExpression(node);
+      break;
+    case 'BitwiseExpression':
+      if (visitor.visitBitwiseExpression) return visitor.visitBitwiseExpression(node);
+      break;
+    default:
+      break;
+  }
+  if (visitor.otherwise) return visitor.otherwise(node);
+  return unsupportedExpression(node);
+};
+
+/**
+ * Dispatches an operand node to the visitor
+ * @param node - Operand node to visit
+ * @param visitor - Visitor implementation
+ */
+export const visitOperand = <R>(node: OperandNode, visitor: OperandVisitor<R>): R => {
+  const dynamic = operandRegistry.get(node.type);
+  if (dynamic) return dynamic(node, visitor);
+
+  switch (node.type) {
+    case 'Column':
+      if (visitor.visitColumn) return visitor.visitColumn(node);
+      break;
+    case 'Literal':
+      if (visitor.visitLiteral) return visitor.visitLiteral(node);
+      break;
+    case 'Function':
+      if (visitor.visitFunction) return visitor.visitFunction(node);
+      break;
+    case 'JsonPath':
+      if (visitor.visitJsonPath) return visitor.visitJsonPath(node);
+      break;
+    case 'ScalarSubquery':
+      if (visitor.visitScalarSubquery) return visitor.visitScalarSubquery(node);
+      break;
+    case 'CaseExpression':
+      if (visitor.visitCaseExpression) return visitor.visitCaseExpression(node);
+      break;
+    case 'WindowFunction':
+      if (visitor.visitWindowFunction) return visitor.visitWindowFunction(node);
+      break;
+    case 'AliasRef':
+      if (visitor.visitAliasRef) return visitor.visitAliasRef(node);
+      break;
+    case 'Cast':
+      if (visitor.visitCast) return visitor.visitCast(node);
+      break;
+    case 'Collate':
+      if (visitor.visitCollate) return visitor.visitCollate(node);
+      break;
+    default:
+      break;
+  }
+  if (visitor.otherwise) return visitor.otherwise(node);
+  return unsupportedOperand(node);
+};

package/src/core/ast/expression.ts

@@ -1,21 +1,20 @@
-/**
- * Expression AST nodes and builders.
- * Re-exports components for building and visiting SQL expression trees.
- */
-import type { CaseExpressionNode, FunctionNode, WindowFunctionNode } from './expression-nodes.js';
-
-export * from './expression-nodes.js';
-export * from './expression-builders.js';
-export * from './window-functions.js';
-export * from './aggregate-functions.js';
-export * from './expression-visitor.js';
-export * from './param-proxy.js';
-export type { ColumnRef, TableRef as AstTableRef } from './types.js';
-export * from './adapters.js';
-
-export type TypedExpression<T> =
-  (FunctionNode | CaseExpressionNode | WindowFunctionNode) & { __tsType: T };
-
-export const asType = <T>(
-  expr: FunctionNode | CaseExpressionNode | WindowFunctionNode
-): TypedExpression<T> => expr as TypedExpression<T>;
+/**
+ * Expression AST nodes and builders.
+ * Re-exports components for building and visiting SQL expression trees.
+ */
+import type { CaseExpressionNode, FunctionNode, WindowFunctionNode } from './expression-nodes.js';
+
+export * from './expression-nodes.js';
+export * from './expression-builders.js';
+export * from './window-functions.js';
+export * from './aggregate-functions.js';
+export * from './expression-visitor.js';
+export type { ColumnRef, TableRef as AstTableRef } from './types.js';
+export * from './adapters.js';
+
+export type TypedExpression<T> =
+  (FunctionNode | CaseExpressionNode | WindowFunctionNode) & { __tsType: T };
+
+export const asType = <T>(
+  expr: FunctionNode | CaseExpressionNode | WindowFunctionNode
+): TypedExpression<T> => expr as TypedExpression<T>;