metal-orm 1.0.83 → 1.0.85

package/package.json

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

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

@@ -1,188 +1,14 @@
-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;
-};
+import { visitSelectQuery } from './query-visitor.js';
 
 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;
-      }
-    }
-  });
+  let hasParams = false;
 
-  ast.orderBy?.forEach(ord => {
-    if (ord.term) {
-      if (hasParamOperandsInOperand(ord.term as OperandNode)) {
-        return true;
-      }
+  visitSelectQuery(ast, {
+    visitParam: () => {
+      hasParams = 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;
+  return hasParams;
 };

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

@@ -183,31 +183,41 @@ const operandTypes = new Set<OperandNode['type']>([
   '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';
+  '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';
 export const isExpressionSelectionNode = (
   node: ColumnRef | FunctionNode | CaseExpressionNode | CastExpressionNode | WindowFunctionNode
 ): node is FunctionNode | CaseExpressionNode | CastExpressionNode | WindowFunctionNode =>

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

@@ -122,8 +122,15 @@ 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 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'}"`);
@@ -138,33 +145,34 @@ const unsupportedOperand = (node: OperandNode): never => {
  * @param visitor - Visitor implementation
  */
 export const visitExpression = <R>(node: ExpressionNode, visitor: ExpressionVisitor<R>): R => {
-  const dynamic = expressionRegistry.get(node.type);
+  const type = getNodeType(node);
+  const dynamic = type ? expressionRegistry.get(type) : undefined;
   if (dynamic) return dynamic(node, visitor);
 
-  switch (node.type) {
+  switch (type) {
     case 'BinaryExpression':
-      if (visitor.visitBinaryExpression) return visitor.visitBinaryExpression(node);
+      if (visitor.visitBinaryExpression) return visitor.visitBinaryExpression(node as BinaryExpressionNode);
       break;
     case 'LogicalExpression':
-      if (visitor.visitLogicalExpression) return visitor.visitLogicalExpression(node);
+      if (visitor.visitLogicalExpression) return visitor.visitLogicalExpression(node as LogicalExpressionNode);
       break;
     case 'NullExpression':
-      if (visitor.visitNullExpression) return visitor.visitNullExpression(node);
+      if (visitor.visitNullExpression) return visitor.visitNullExpression(node as NullExpressionNode);
       break;
     case 'InExpression':
-      if (visitor.visitInExpression) return visitor.visitInExpression(node);
+      if (visitor.visitInExpression) return visitor.visitInExpression(node as InExpressionNode);
       break;
     case 'ExistsExpression':
-      if (visitor.visitExistsExpression) return visitor.visitExistsExpression(node);
+      if (visitor.visitExistsExpression) return visitor.visitExistsExpression(node as ExistsExpressionNode);
       break;
     case 'BetweenExpression':
-      if (visitor.visitBetweenExpression) return visitor.visitBetweenExpression(node);
+      if (visitor.visitBetweenExpression) return visitor.visitBetweenExpression(node as BetweenExpressionNode);
       break;
     case 'ArithmeticExpression':
-      if (visitor.visitArithmeticExpression) return visitor.visitArithmeticExpression(node);
+      if (visitor.visitArithmeticExpression) return visitor.visitArithmeticExpression(node as ArithmeticExpressionNode);
       break;
     case 'BitwiseExpression':
-      if (visitor.visitBitwiseExpression) return visitor.visitBitwiseExpression(node);
+      if (visitor.visitBitwiseExpression) return visitor.visitBitwiseExpression(node as BitwiseExpressionNode);
       break;
     default:
       break;
@@ -179,42 +187,43 @@ export const visitExpression = <R>(node: ExpressionNode, visitor: ExpressionVisi
  * @param visitor - Visitor implementation
  */
 export const visitOperand = <R>(node: OperandNode, visitor: OperandVisitor<R>): R => {
-  const dynamic = operandRegistry.get(node.type);
+  const type = getNodeType(node);
+  const dynamic = type ? operandRegistry.get(type) : undefined;
   if (dynamic) return dynamic(node, visitor);
 
-  switch (node.type) {
+  switch (type) {
     case 'Column':
-      if (visitor.visitColumn) return visitor.visitColumn(node);
+      if (visitor.visitColumn) return visitor.visitColumn(node as ColumnNode);
       break;
     case 'Literal':
-      if (visitor.visitLiteral) return visitor.visitLiteral(node);
+      if (visitor.visitLiteral) return visitor.visitLiteral(node as LiteralNode);
       break;
     case 'Param':
-      if (visitor.visitParam) return visitor.visitParam(node);
+      if (visitor.visitParam) return visitor.visitParam(node as ParamNode);
       break;
     case 'Function':
-      if (visitor.visitFunction) return visitor.visitFunction(node);
+      if (visitor.visitFunction) return visitor.visitFunction(node as FunctionNode);
       break;
     case 'JsonPath':
-      if (visitor.visitJsonPath) return visitor.visitJsonPath(node);
+      if (visitor.visitJsonPath) return visitor.visitJsonPath(node as JsonPathNode);
       break;
     case 'ScalarSubquery':
-      if (visitor.visitScalarSubquery) return visitor.visitScalarSubquery(node);
+      if (visitor.visitScalarSubquery) return visitor.visitScalarSubquery(node as ScalarSubqueryNode);
       break;
     case 'CaseExpression':
-      if (visitor.visitCaseExpression) return visitor.visitCaseExpression(node);
+      if (visitor.visitCaseExpression) return visitor.visitCaseExpression(node as CaseExpressionNode);
       break;
     case 'WindowFunction':
-      if (visitor.visitWindowFunction) return visitor.visitWindowFunction(node);
+      if (visitor.visitWindowFunction) return visitor.visitWindowFunction(node as WindowFunctionNode);
       break;
     case 'AliasRef':
-      if (visitor.visitAliasRef) return visitor.visitAliasRef(node);
+      if (visitor.visitAliasRef) return visitor.visitAliasRef(node as AliasRefNode);
       break;
     case 'Cast':
-      if (visitor.visitCast) return visitor.visitCast(node);
+      if (visitor.visitCast) return visitor.visitCast(node as CastExpressionNode);
       break;
     case 'Collate':
-      if (visitor.visitCollate) return visitor.visitCollate(node);
+      if (visitor.visitCollate) return visitor.visitCollate(node as CollateExpressionNode);
       break;
     default:
       break;

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

@@ -0,0 +1,227 @@
+import type {
+  CommonTableExpressionNode,
+  DerivedTableNode,
+  FunctionTableNode,
+  OrderByNode,
+  OrderingTerm,
+  SelectQueryNode,
+  SetOperationNode,
+  TableSourceNode
+} from './query.js';
+import type { JoinNode } from './join.js';
+import type {
+  ExpressionNode,
+  OperandNode,
+  ParamNode
+} from './expression-nodes.js';
+import { isOperandNode } from './expression-nodes.js';
+
+export interface SelectQueryVisitor {
+  visitSelectQuery?(node: SelectQueryNode): void;
+  visitTableSource?(node: TableSourceNode): void;
+  visitDerivedTable?(node: DerivedTableNode): void;
+  visitFunctionTable?(node: FunctionTableNode): void;
+  visitJoin?(node: JoinNode): void;
+  visitCte?(node: CommonTableExpressionNode): void;
+  visitSetOperation?(node: SetOperationNode): void;
+  visitOrderBy?(node: OrderByNode): void;
+  visitExpression?(node: ExpressionNode): void;
+  visitOperand?(node: OperandNode): void;
+  visitParam?(node: ParamNode): void;
+}
+
+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;
+};
+
+const visitOrderingTerm = (term: OrderingTerm, visitor: SelectQueryVisitor): void => {
+  if (isOperandNode(term)) {
+    visitOperandNode(term, visitor);
+    return;
+  }
+  visitExpressionNode(term as ExpressionNode, visitor);
+};
+
+const visitOrderByNode = (node: OrderByNode, visitor: SelectQueryVisitor): void => {
+  visitor.visitOrderBy?.(node);
+  visitOrderingTerm(node.term, visitor);
+};
+
+const visitTableSource = (source: TableSourceNode, visitor: SelectQueryVisitor): void => {
+  visitor.visitTableSource?.(source);
+  if (source.type === 'DerivedTable') {
+    visitor.visitDerivedTable?.(source);
+    visitSelectQuery(source.query, visitor);
+    return;
+  }
+  if (source.type === 'FunctionTable') {
+    visitor.visitFunctionTable?.(source);
+    source.args?.forEach(arg => visitOperandNode(arg, visitor));
+  }
+};
+
+const visitExpressionNode = (node: ExpressionNode, visitor: SelectQueryVisitor): void => {
+  visitor.visitExpression?.(node);
+  const type = getNodeType(node);
+  if (!type) return;
+  switch (type) {
+    case 'BinaryExpression':
+      visitOperandNode(node.left, visitor);
+      visitOperandNode(node.right, visitor);
+      if (node.escape) {
+        visitOperandNode(node.escape, visitor);
+      }
+      return;
+    case 'LogicalExpression':
+      node.operands.forEach(operand => visitExpressionNode(operand, visitor));
+      return;
+    case 'NullExpression':
+      visitOperandNode(node.left, visitor);
+      return;
+    case 'InExpression':
+      visitOperandNode(node.left, visitor);
+      if (Array.isArray(node.right)) {
+        node.right.forEach(operand => visitOperandNode(operand, visitor));
+      } else {
+        visitOperandNode(node.right, visitor);
+      }
+      return;
+    case 'ExistsExpression':
+      visitSelectQuery(node.subquery, visitor);
+      return;
+    case 'BetweenExpression':
+      visitOperandNode(node.left, visitor);
+      visitOperandNode(node.lower, visitor);
+      visitOperandNode(node.upper, visitor);
+      return;
+    case 'ArithmeticExpression':
+      visitOperandNode(node.left, visitor);
+      visitOperandNode(node.right, visitor);
+      return;
+    case 'BitwiseExpression':
+      visitOperandNode(node.left, visitor);
+      visitOperandNode(node.right, visitor);
+      return;
+    default: {
+      return;
+    }
+  }
+};
+
+const visitOperandNode = (node: OperandNode, visitor: SelectQueryVisitor): void => {
+  visitor.visitOperand?.(node);
+  const type = getNodeType(node);
+  if (type === 'Param') {
+    visitor.visitParam?.(node);
+  }
+  if (!type) return;
+  switch (type) {
+    case 'Column':
+    case 'Literal':
+    case 'Param':
+    case 'AliasRef':
+      return;
+    case 'Function':
+      node.args?.forEach(arg => visitOperandNode(arg, visitor));
+      node.orderBy?.forEach(order => visitOrderByNode(order, visitor));
+      if (node.separator) {
+        visitOperandNode(node.separator, visitor);
+      }
+      return;
+    case 'JsonPath':
+      visitOperandNode(node.column, visitor);
+      return;
+    case 'ScalarSubquery':
+      visitSelectQuery(node.query, visitor);
+      return;
+    case 'CaseExpression':
+      node.conditions.forEach(cond => {
+        visitExpressionNode(cond.when, visitor);
+        visitOperandNode(cond.then, visitor);
+      });
+      if (node.else) {
+        visitOperandNode(node.else, visitor);
+      }
+      return;
+    case 'Cast':
+      visitOperandNode(node.expression, visitor);
+      return;
+    case 'WindowFunction':
+      node.args?.forEach(arg => visitOperandNode(arg, visitor));
+      node.partitionBy?.forEach(term => visitOperandNode(term, visitor));
+      node.orderBy?.forEach(order => visitOrderByNode(order, visitor));
+      return;
+    case 'ArithmeticExpression':
+      visitOperandNode(node.left, visitor);
+      visitOperandNode(node.right, visitor);
+      return;
+    case 'BitwiseExpression':
+      visitOperandNode(node.left, visitor);
+      visitOperandNode(node.right, visitor);
+      return;
+    case 'Collate':
+      visitOperandNode(node.expression, visitor);
+      return;
+    default: {
+      const _exhaustive: never = node;
+      return _exhaustive;
+    }
+  }
+};
+
+export const visitSelectQuery = (ast: SelectQueryNode, visitor: SelectQueryVisitor): void => {
+  visitor.visitSelectQuery?.(ast);
+
+  if (ast.ctes) {
+    for (const cte of ast.ctes) {
+      visitor.visitCte?.(cte);
+      visitSelectQuery(cte.query, visitor);
+    }
+  }
+
+  visitTableSource(ast.from, visitor);
+
+  ast.columns?.forEach(col => {
+    visitOperandNode(col as OperandNode, visitor);
+  });
+
+  ast.joins?.forEach(join => {
+    visitor.visitJoin?.(join);
+    visitTableSource(join.table, visitor);
+    visitExpressionNode(join.condition, visitor);
+  });
+
+  if (ast.where) {
+    visitExpressionNode(ast.where, visitor);
+  }
+
+  ast.groupBy?.forEach(term => {
+    visitOrderingTerm(term, visitor);
+  });
+
+  if (ast.having) {
+    visitExpressionNode(ast.having, visitor);
+  }
+
+  ast.orderBy?.forEach(order => {
+    visitOrderByNode(order, visitor);
+  });
+
+  ast.distinct?.forEach(col => {
+    visitOperandNode(col, visitor);
+  });
+
+  ast.setOps?.forEach(op => {
+    visitor.visitSetOperation?.(op);
+    visitSelectQuery(op.query, visitor);
+  });
+};

package/src/core/dialect/abstract.ts

@@ -387,13 +387,17 @@ export abstract class Dialect
    * @param ctx - Compiler context
    * @returns Compiled SQL operand
    */
-  protected compileOperand(node: OperandNode, ctx: CompilerContext): string {
-    const compiler = this.operandCompilers.get(node.type);
-    if (!compiler) {
-      throw new Error(`Unsupported operand node type "${node.type}" for ${this.constructor.name}`);
-    }
-    return compiler(node, ctx);
-  }
+  protected compileOperand(node: OperandNode, ctx: CompilerContext): string {
+    const descriptor = Object.getOwnPropertyDescriptor(node, 'type');
+    const nodeType = typeof descriptor?.value === 'string'
+      ? descriptor.value
+      : (typeof node.type === 'string' ? node.type : undefined);
+    const compiler = nodeType ? this.operandCompilers.get(nodeType) : undefined;
+    if (!compiler) {
+      throw new Error(`Unsupported operand node type "${nodeType ?? 'unknown'}" for ${this.constructor.name}`);
+    }
+    return compiler(node, ctx);
+  }
 
   /**
    * Compiles an ordering term (operand, expression, or alias reference).

package/src/query-builder/query-ast-service.ts

@@ -18,6 +18,7 @@ import {
   CastExpressionNode,
   WindowFunctionNode,
   ScalarSubqueryNode,
+  ParamNode,
   and,
   isExpressionSelectionNode,
   isOperandNode
@@ -258,6 +259,10 @@ export class QueryAstService {
    * @returns Normalized ordering term
    */
   private normalizeOrderingTerm(term: ColumnDef | OrderingTerm): OrderingTerm {
+    const paramNode = this.toParamNode(term);
+    if (paramNode) {
+      return paramNode;
+    }
     const from = this.state.ast.from;
     const tableRef = from.type === 'Table' && from.alias ? { ...this.table, alias: from.alias } : this.table;
     const termType = (term as { type?: string }).type;
@@ -284,4 +289,12 @@ export class QueryAstService {
     return buildColumnNode(tableRef, term as ColumnDef);
   }
 
+  private 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 };
+  }
 }