@atomic-ehr/fhirpath 0.0.1-canary.35b105d.20250724165800

package/src/parser/pprint.ts

@@ -0,0 +1,169 @@
+import type { 
+  ASTNode, 
+  IdentifierNode, 
+  TypeOrIdentifierNode, 
+  VariableNode,
+  TypeReferenceNode,
+  BinaryNode,
+  UnaryNode,
+  UnionNode,
+  FunctionNode,
+  CollectionNode,
+  MembershipTestNode,
+  TypeCastNode,
+  IndexNode,
+  LiteralNode
+} from './ast';
+import { NodeType } from './ast';
+import { TokenType } from '../lexer/token';
+
+/**
+ * Pretty print an AST node as an S-expression (without position information)
+ */
+export function pprint(node: ASTNode, multiline: boolean = false, indent: number = 0): string {
+  const spaces = multiline ? ' '.repeat(indent) : '';
+  const nl = multiline ? '\n' : '';
+  const childIndent = indent + 2;
+  
+  switch (node.type) {
+    case NodeType.Literal:
+      const lit = node as LiteralNode;
+      return `${spaces}(${pprintLiteralValue(lit)}:${lit.valueType})`;
+    
+    case NodeType.Identifier:
+      return `${spaces}(${(node as IdentifierNode).name}:id)`;
+    
+    case NodeType.TypeOrIdentifier:
+      return `${spaces}(${(node as TypeOrIdentifierNode).name}:type-or-id)`;
+    
+    case NodeType.Variable:
+      const varNode = node as VariableNode;
+      const varName = varNode.name.startsWith('$') ? varNode.name : `%${varNode.name}`;
+      return `${spaces}(${varName}:var)`;
+    
+    case NodeType.TypeReference:
+      return `${spaces}(${(node as TypeReferenceNode).typeName}:type-ref)`;
+    
+    case NodeType.Binary:
+      const binary = node as BinaryNode;
+      const op = tokenToOp(binary.operator);
+      if (multiline) {
+        return `${spaces}(${op}${nl}${pprint(binary.left, multiline, childIndent)}${nl}${pprint(binary.right, multiline, childIndent)})`;
+      } else {
+        return `(${op} ${pprint(binary.left)} ${pprint(binary.right)})`;
+      }
+    
+    case NodeType.Unary:
+      const unary = node as UnaryNode;
+      const unaryOp = tokenToOp(unary.operator);
+      if (multiline) {
+        return `${spaces}(${unaryOp}:unary${nl}${pprint(unary.operand, multiline, childIndent)})`;
+      } else {
+        return `(${unaryOp}:unary ${pprint(unary.operand)})`;
+      }
+    
+    case NodeType.Union:
+      const union = node as UnionNode;
+      if (multiline) {
+        const operands = union.operands.map(op => pprint(op, multiline, childIndent)).join(nl);
+        return `${spaces}(|${nl}${operands})`;
+      } else {
+        return `(| ${union.operands.map(op => pprint(op)).join(' ')})`;
+      }
+    
+    case NodeType.Function:
+      const func = node as FunctionNode;
+      const funcName = (func.name as IdentifierNode).name;
+      if (multiline && func.arguments.length > 0) {
+        const args = func.arguments.map(arg => pprint(arg, multiline, childIndent)).join(nl);
+        return `${spaces}(${funcName}:fn${nl}${args})`;
+      } else {
+        const args = func.arguments.map(arg => pprint(arg)).join(' ');
+        return args ? `${spaces}(${funcName}:fn ${args})` : `${spaces}(${funcName}:fn)`;
+      }
+    
+    case NodeType.Collection:
+      const coll = node as CollectionNode;
+      if (multiline && coll.elements.length > 0) {
+        const elements = coll.elements.map(el => pprint(el, multiline, childIndent)).join(nl);
+        return `${spaces}({}:collection${nl}${elements})`;
+      } else {
+        const elements = coll.elements.map(el => pprint(el)).join(' ');
+        return elements ? `${spaces}({}:collection ${elements})` : `${spaces}({}:collection)`;
+      }
+    
+    case NodeType.MembershipTest:
+      const memberTest = node as MembershipTestNode;
+      if (multiline) {
+        return `${spaces}(is${nl}${pprint(memberTest.expression, multiline, childIndent)}${nl}${' '.repeat(childIndent)}${memberTest.targetType})`;
+      } else {
+        return `(is ${pprint(memberTest.expression)} ${memberTest.targetType})`;
+      }
+    
+    case NodeType.TypeCast:
+      const typeCast = node as TypeCastNode;
+      if (multiline) {
+        return `${spaces}(as${nl}${pprint(typeCast.expression, multiline, childIndent)}${nl}${' '.repeat(childIndent)}${typeCast.targetType})`;
+      } else {
+        return `(as ${pprint(typeCast.expression)} ${typeCast.targetType})`;
+      }
+    
+    case NodeType.Index:
+      const index = node as IndexNode;
+      if (multiline) {
+        return `${spaces}([]${nl}${pprint(index.expression, multiline, childIndent)}${nl}${pprint(index.index, multiline, childIndent)})`;
+      } else {
+        return `([] ${pprint(index.expression)} ${pprint(index.index)})`;
+      }
+    
+    default:
+      return `${spaces}(unknown:${node.type})`;
+  }
+}
+
+function pprintLiteralValue(node: LiteralNode): string {
+  const value = node.value;
+  const valueType = node.valueType;
+  
+  switch (valueType) {
+    case 'string':
+      return `'${value}'`;
+    case 'number':
+      return String(value);
+    case 'boolean':
+      return String(value);
+    case 'null':
+      return '{}';
+    case 'date':
+    case 'time':
+    case 'datetime':
+      return `@${value}`;
+    default:
+      return String(value);
+  }
+}
+
+function tokenToOp(token: TokenType): string {
+  switch (token) {
+    case TokenType.PLUS: return '+';
+    case TokenType.MINUS: return '-';
+    case TokenType.STAR: return '*';
+    case TokenType.DIV: return 'div';
+    case TokenType.MOD: return 'mod';
+    case TokenType.GT: return '>';
+    case TokenType.LT: return '<';
+    case TokenType.GTE: return '>=';
+    case TokenType.LTE: return '<=';
+    case TokenType.EQ: return '=';
+    case TokenType.NEQ: return '!=';
+    case TokenType.AND: return 'and';
+    case TokenType.OR: return 'or';
+    case TokenType.XOR: return 'xor';
+    case TokenType.IMPLIES: return 'implies';
+    case TokenType.NOT: return 'not';
+    case TokenType.DOT: return '.';
+    case TokenType.CONTAINS: return 'contains';
+    case TokenType.IN: return 'in';
+    default: return token;
+  }
+}

package/src/registry/default-analyzers.ts

@@ -0,0 +1,257 @@
+import type { 
+  Analyzer, 
+  TypeInfo, 
+  TypeRef,
+  Operator, 
+  Function, 
+  Literal,
+  TypeConstraint,
+  TypeInferenceRule,
+  CardinalityInferenceRule
+} from './types';
+import type { ModelProvider } from '../analyzer/types';
+
+// Helper to check if type matches constraint
+export function matchesConstraint(type: TypeRef, constraint: TypeConstraint): boolean {
+  if (constraint.kind === 'any') return true;
+  
+  if (!constraint.types) return true;
+  
+  // For now, simple type name matching
+  // TODO: Handle inheritance and complex types
+  let typeName = typeof type === 'string' ? type : (type as any).type || (type as any).name || 'unknown';
+  
+  // Normalize case - constraint types are capitalized, but actual types might be lowercase
+  const normalizedTypeName = typeName.charAt(0).toUpperCase() + typeName.slice(1);
+  
+  return constraint.types.includes(normalizedTypeName) || constraint.types.includes(typeName);
+}
+
+// Helper to format constraint for error messages
+export function formatConstraint(constraint: TypeConstraint): string {
+  if (constraint.kind === 'any') return 'any type';
+  if (!constraint.types || constraint.types.length === 0) return 'any type';
+  if (constraint.types.length === 1) return constraint.types[0]!;
+  return constraint.types.join(' or ');
+}
+
+// Helper to resolve type inference rule
+export function resolveTypeInferenceRule(
+  rule: TypeInferenceRule,
+  input: TypeRef,
+  args: TypeRef[],
+  analyzer: Analyzer
+): TypeRef {
+  if (typeof rule === 'string') {
+    if (rule === 'preserve-input') return input;
+    if (rule === 'promote-numeric') {
+      // Check if we have numeric types
+      const types = [input, ...args].map(t => {
+        const rawType = typeof t === 'string' ? t : (t as any).type || (t as any).name || 'unknown';
+        // Normalize to uppercase first letter
+        return rawType.charAt(0).toUpperCase() + rawType.slice(1);
+      });
+      if (types.includes('Decimal')) return analyzer.resolveType('Decimal');
+      if (types.includes('Integer')) return analyzer.resolveType('Integer');
+      return input; // fallback
+    }
+    return analyzer.resolveType(rule); // Fixed type name - resolve through analyzer
+  }
+  
+  if (typeof rule === 'function') {
+    // TODO: We need to pass ModelProvider to the rule function
+    // For now, just return input
+    return input;
+  }
+  
+  return input; // fallback
+}
+
+// Helper to resolve cardinality inference rule
+export function resolveCardinalityInferenceRule(
+  rule: CardinalityInferenceRule,
+  inputIsSingleton: boolean,
+  argsAreSingleton: boolean[]
+): boolean {
+  if (rule === 'singleton') return true;
+  if (rule === 'collection') return false;
+  if (rule === 'preserve-input') return inputIsSingleton;
+  if (rule === 'all-singleton') return inputIsSingleton && argsAreSingleton.every(s => s);
+  
+  if (typeof rule === 'function') {
+    return rule(inputIsSingleton, argsAreSingleton);
+  }
+  
+  return inputIsSingleton; // fallback
+}
+
+// Default analyzer for operators
+export function defaultOperatorAnalyze(
+  this: Operator,
+  analyzer: Analyzer, 
+  input: TypeInfo, 
+  args: TypeInfo[]
+): TypeInfo {
+  const { signature } = this;
+  
+  // Validate parameter count
+  const expectedParams = signature.parameters.length;
+  if (args.length !== expectedParams) {
+    analyzer.error(`Operator '${this.name}' expects ${expectedParams} parameter(s) but got ${args.length}`);
+  }
+  
+  // Validate parameter types and cardinality
+  signature.parameters.forEach((param, i) => {
+    const arg = args[i];
+    if (!arg) return;
+    
+    // Check type constraint
+    if (param.types && !matchesConstraint(arg.type, param.types)) {
+      const argTypeName = typeof arg.type === 'string' 
+        ? arg.type 
+        : (arg.type as any).type || (arg.type as any).name || 'unknown';
+      analyzer.error(
+        `Operator '${this.name}' parameter '${param.name}' expects ${formatConstraint(param.types)} but got ${argTypeName}`
+      );
+    }
+    
+    // Check cardinality constraint
+    if (param.cardinality) {
+      if (param.cardinality === 'singleton' && !arg.isSingleton) {
+        analyzer.error(
+          `Operator '${this.name}' parameter '${param.name}' requires singleton value but got collection`
+        );
+      } else if (param.cardinality === 'collection' && arg.isSingleton) {
+        analyzer.error(
+          `Operator '${this.name}' parameter '${param.name}' requires collection but got singleton`
+        );
+      }
+      // 'any' accepts both
+    }
+  });
+  
+  // Determine output type
+  const outputType = resolveTypeInferenceRule(
+    signature.output.type,
+    input.type,
+    args.map(a => a.type),
+    analyzer
+  );
+  
+  // Determine output cardinality
+  const isSingleton = resolveCardinalityInferenceRule(
+    signature.output.cardinality,
+    input.isSingleton,
+    args.map(a => a.isSingleton)
+  );
+  
+  return { type: outputType, isSingleton };
+}
+
+// Default analyzer for functions
+export function defaultFunctionAnalyze(
+  this: Function,
+  analyzer: Analyzer, 
+  input: TypeInfo, 
+  args: TypeInfo[]
+): TypeInfo {
+  const { signature } = this;
+  
+  // Check input constraints if specified
+  if (signature.input) {
+    if (signature.input.types && !matchesConstraint(input.type, signature.input.types)) {
+      const inputTypeName = typeof input.type === 'string' 
+        ? input.type 
+        : (input.type as any).type || (input.type as any).name || 'unknown';
+      analyzer.error(
+        `Function '${this.name}' expects input of type ${formatConstraint(signature.input.types)} but got ${inputTypeName}`
+      );
+    }
+    
+    if (signature.input.cardinality) {
+      if (signature.input.cardinality === 'singleton' && !input.isSingleton) {
+        analyzer.error(`Function '${this.name}' requires singleton input but got collection`);
+      } else if (signature.input.cardinality === 'collection' && input.isSingleton) {
+        analyzer.error(`Function '${this.name}' requires collection input but got singleton`);
+      }
+    }
+  }
+  
+  // Validate parameters
+  const requiredParams = signature.parameters.filter(p => !p.optional);
+  if (args.length < requiredParams.length) {
+    analyzer.error(
+      `Function '${this.name}' requires at least ${requiredParams.length} parameter(s) but got ${args.length}`
+    );
+  }
+  
+  if (args.length > signature.parameters.length) {
+    analyzer.error(
+      `Function '${this.name}' expects at most ${signature.parameters.length} parameter(s) but got ${args.length}`
+    );
+  }
+  
+  // Check each parameter
+  signature.parameters.forEach((param, i) => {
+    const arg = args[i];
+    if (!arg && !param.optional) {
+      analyzer.error(`Function '${this.name}' parameter '${param.name}' is required`);
+      return;
+    }
+    if (!arg) return; // Optional parameter not provided
+    
+    // Check type constraint
+    if (param.types && !matchesConstraint(arg.type, param.types)) {
+      const argTypeName = typeof arg.type === 'string' 
+        ? arg.type 
+        : (arg.type as any).type || (arg.type as any).name || 'unknown';
+      analyzer.error(
+        `Function '${this.name}' parameter '${param.name}' expects ${formatConstraint(param.types)} but got ${argTypeName}`
+      );
+    }
+    
+    // Check cardinality constraint
+    if (param.cardinality) {
+      if (param.cardinality === 'singleton' && !arg.isSingleton) {
+        analyzer.error(
+          `Function '${this.name}' parameter '${param.name}' requires singleton value but got collection`
+        );
+      } else if (param.cardinality === 'collection' && arg.isSingleton) {
+        analyzer.error(
+          `Function '${this.name}' parameter '${param.name}' requires collection but got singleton`
+        );
+      }
+    }
+  });
+  
+  // Determine output type
+  const outputType = resolveTypeInferenceRule(
+    signature.output.type,
+    input.type,
+    args.map(a => a.type),
+    analyzer
+  );
+  
+  // Determine output cardinality
+  const isSingleton = resolveCardinalityInferenceRule(
+    signature.output.cardinality,
+    input.isSingleton,
+    args.map(a => a.isSingleton)
+  );
+  
+  return { type: outputType, isSingleton };
+}
+
+// Default analyzer for literals
+export function defaultLiteralAnalyze(
+  this: Literal,
+  analyzer: Analyzer, 
+  input: TypeInfo, 
+  args: TypeInfo[]
+): TypeInfo {
+  // Literals have fixed output type and cardinality
+  return {
+    type: analyzer.resolveType(this.signature.output.type),
+    isSingleton: true
+  };
+}

package/src/registry/default-compilers.ts

@@ -0,0 +1,31 @@
+import type { Compiler, CompiledExpression } from './types';
+
+export function defaultFunctionCompile(
+  compiler: Compiler,
+  input: CompiledExpression,
+  args: CompiledExpression[]
+): CompiledExpression {
+  // Default implementation returns a simple pass-through
+  return {
+    fn: (ctx) => {
+      throw new Error('Function compile not implemented');
+    },
+    type: compiler.resolveType('Any'),
+    isSingleton: false
+  };
+}
+
+export function defaultOperatorCompile(
+  compiler: Compiler,
+  left: CompiledExpression,
+  right: CompiledExpression[]
+): CompiledExpression {
+  // Default implementation returns a simple pass-through
+  return {
+    fn: (ctx) => {
+      throw new Error('Operator compile not implemented');
+    },
+    type: compiler.resolveType('Any'),
+    isSingleton: false
+  };
+}

package/src/registry/index.ts

@@ -0,0 +1,93 @@
+import { Registry } from './registry';
+import { arithmeticOperators } from './operations/arithmetic';
+import { logicalOperators } from './operations/logical';
+import { comparisonOperators } from './operations/comparison';
+import { membershipOperators } from './operations/membership';
+import { typeOperators } from './operations/type-operators';
+import { literals } from './operations/literals';
+import { existenceFunctions } from './operations/existence';
+import { 
+  aggregateFunction, 
+  childrenFunction, 
+  descendantsFunction, 
+  iifFunction, 
+  defineVariableFunction, 
+  traceFunction, 
+  checkFunction 
+} from './operations/utility';
+import { typeFunction, isFunction, asFunction } from './operations/type-checking';
+import { absFunction, roundFunction, sqrtFunction } from './operations/math';
+import { whereFunction, selectFunction, ofTypeFunction, repeatFunction } from './operations/filtering';
+import { 
+  containsFunction, lengthFunction, substringFunction, startsWithFunction, 
+  endsWithFunction, upperFunction, lowerFunction, indexOfFunction,
+  replaceFunction, splitFunction, joinFunction, trimFunction, toCharsFunction
+} from './operations/string';
+import { 
+  toStringFunction, toIntegerFunction, toDecimalFunction, 
+  toBooleanFunction, toQuantityFunction 
+} from './operations/type-conversion';
+import { tailFunction, skipFunction, takeFunction } from './operations/subsetting';
+import { unionFunction, combineFunction, intersectFunction, excludeFunction, collectionOperators } from './operations/collection';
+
+// Export types
+export * from './types';
+export { Registry } from './registry';
+export * from './default-analyzers';
+
+// Register all operations on module load
+[
+  ...arithmeticOperators,
+  ...logicalOperators,
+  ...comparisonOperators,
+  ...membershipOperators,
+  ...typeOperators,
+  ...collectionOperators,
+  ...literals,
+  ...existenceFunctions,
+  aggregateFunction,
+  childrenFunction,
+  descendantsFunction,
+  iifFunction,
+  defineVariableFunction,
+  traceFunction,
+  checkFunction,
+  typeFunction,
+  isFunction,
+  asFunction,
+  absFunction,
+  roundFunction,
+  sqrtFunction,
+  whereFunction,
+  selectFunction,
+  ofTypeFunction,
+  repeatFunction,
+  containsFunction,
+  lengthFunction,
+  substringFunction,
+  startsWithFunction,
+  endsWithFunction,
+  upperFunction,
+  lowerFunction,
+  indexOfFunction,
+  replaceFunction,
+  splitFunction,
+  joinFunction,
+  trimFunction,
+  toCharsFunction,
+  toStringFunction,
+  toIntegerFunction,
+  toDecimalFunction,
+  toBooleanFunction,
+  toQuantityFunction,
+  tailFunction,
+  skipFunction,
+  takeFunction,
+  unionFunction,
+  combineFunction,
+  intersectFunction,
+  excludeFunction
+].forEach(op => Registry.register(op));
+
+// Export default registry instance
+export default Registry;