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

package/src/registry/types.ts

@@ -0,0 +1,161 @@
+import type { TokenType } from '../lexer/token';
+import type { TypeRef, ModelProvider } from '../analyzer/types';
+import type { EvaluationResult } from '../interpreter/types';
+import type { RuntimeContext } from '../runtime/context';
+
+// Type information returned by analyze
+export interface TypeInfo {
+  type: TypeRef;
+  isSingleton: boolean;
+}
+
+// Base interface for all operations
+export interface BaseOperation {
+  name: string;
+  
+  // Common lifecycle methods
+  analyze: (analyzer: Analyzer, input: TypeInfo, args: TypeInfo[]) => TypeInfo;
+  evaluate: (interpreter: Interpreter, context: RuntimeContext, input: any[], ...args: any[]) => EvaluationResult;
+  compile: (compiler: Compiler, input: CompiledExpression, args: CompiledExpression[]) => CompiledExpression;
+}
+
+// Operator-specific interface
+export interface Operator extends BaseOperation {
+  kind: 'operator';
+  
+  syntax: {
+    form: 'prefix' | 'infix' | 'postfix';
+    token: TokenType;
+    precedence: number;
+    associativity?: 'left' | 'right';  // For infix operators
+    notation: string;  // e.g., "a + b", "not a"
+    special?: boolean;  // For special forms like . and []
+    endToken?: TokenType;  // For bracketed operators like []
+  };
+  
+  signature: {
+    parameters: [OperatorParameter] | [OperatorParameter, OperatorParameter];  // Unary or binary
+    output: {
+      type: TypeInferenceRule;
+      cardinality: CardinalityInferenceRule;
+    };
+    propagatesEmpty?: boolean;
+  };
+}
+
+// Function-specific interface
+export interface Function extends BaseOperation {
+  kind: 'function';
+  
+  syntax: {
+    notation: string;  // e.g., "substring(start [, length])"
+  };
+  
+  signature: {
+    input?: {
+      types?: TypeConstraint;
+      cardinality?: 'singleton' | 'collection' | 'any';
+    };
+    parameters: FunctionParameter[];
+    output: {
+      type: TypeInferenceRule;
+      cardinality: CardinalityInferenceRule;
+    };
+    propagatesEmpty?: boolean;
+    deterministic?: boolean;
+  };
+}
+
+// Literal-specific interface
+export interface Literal extends BaseOperation {
+  kind: 'literal';
+  
+  syntax: {
+    pattern?: RegExp;      // For complex literals like dates
+    keywords?: string[];   // For keyword literals like 'true', 'false'
+    notation: string;      // Example: "123", "@2023-01-01"
+  };
+  
+  // Literals have fixed output type
+  signature: {
+    output: {
+      type: string;  // Always a specific type
+      cardinality: 'singleton';  // Literals are always singleton
+    };
+  };
+  
+  // Parse the literal value from source text
+  parse: (value: string) => any;
+}
+
+// Union type for registry
+export type Operation = Operator | Function | Literal;
+
+// Specialized parameter types
+export interface OperatorParameter {
+  name: 'left' | 'right' | 'operand';
+  types?: TypeConstraint;
+  cardinality?: 'singleton' | 'collection' | 'any';  // Required cardinality for this parameter
+}
+
+export interface FunctionParameter {
+  name: string;
+  kind: 'value' | 'expression' | 'type-specifier';
+  types?: TypeConstraint;
+  cardinality?: 'singleton' | 'collection' | 'any';
+  optional?: boolean;
+  default?: any;
+}
+
+export interface TypeConstraint {
+  kind: 'primitive' | 'class' | 'union' | 'any';
+  types?: string[];  // ['Integer', 'Decimal'] for numeric, ['Resource'] for FHIR types
+}
+
+export type TypeInferenceRule = 
+  | string  // Fixed type like 'Boolean'
+  | 'preserve-input'  // Returns input type
+  | 'promote-numeric'  // Integer + Decimal = Decimal
+  | ((input: TypeRef, args: TypeRef[], provider: ModelProvider) => TypeRef);
+
+export type CardinalityInferenceRule = 
+  | 'singleton' | 'collection'
+  | 'preserve-input'  // Same as input
+  | 'all-singleton'  // Singleton only if all inputs are singleton
+  | ((input: boolean, args: boolean[]) => boolean);
+
+// Closure-based compiled expression
+export interface CompiledExpression {
+  // The compiled function
+  fn: (context: RuntimeContext) => any[];
+  
+  // Type information for optimization
+  type: TypeRef;
+  isSingleton: boolean;
+  
+  // For debugging/tracing
+  source?: string;
+}
+
+
+// Interfaces for components that use the registry
+export interface Analyzer {
+  error(message: string): void;
+  warning(message: string): void;
+  resolveType(typeName: string): TypeRef;
+}
+
+export interface Interpreter {
+  evaluate(node: any, input: any[], context: RuntimeContext): EvaluationResult;
+}
+
+export interface Compiler {
+  compile(node: any, input: CompiledExpression): CompiledExpression;
+  resolveType(typeName: string): TypeRef;
+}
+
+// Re-export TypeRef from analyzer
+export type { TypeRef } from '../analyzer/types';
+
+// Re-export RuntimeContext for use in other modules
+export type { RuntimeContext } from '../runtime/context';

package/src/registry/utils/evaluation-helpers.ts

@@ -0,0 +1,93 @@
+import { CollectionUtils } from '../../interpreter/types';
+
+/**
+ * Convert collection to singleton value
+ */
+export function toSingleton(collection: any[]): any {
+  return CollectionUtils.toSingleton(collection);
+}
+
+/**
+ * Convert value to boolean according to FHIRPath rules
+ */
+export function toBoolean(value: any): boolean {
+  // Handle direct boolean
+  if (typeof value === 'boolean') {
+    return value;
+  }
+  
+  // Handle null/undefined as false
+  if (value == null) {
+    return false;
+  }
+  
+  // Handle empty string as false
+  if (value === '') {
+    return false;
+  }
+  
+  // Handle zero as false
+  if (value === 0) {
+    return false;
+  }
+  
+  // Everything else is true
+  return true;
+}
+
+/**
+ * Determines if a value is truthy according to FHIRPath rules
+ */
+export function isTruthy(value: any[]): boolean {
+  if (value.length === 0) {
+    return false;
+  }
+  
+  // Convert to singleton
+  const singleton = toSingleton(value);
+  
+  // Rule: true if singleton is true, false if singleton is false
+  if (typeof singleton === 'boolean') {
+    return singleton;
+  }
+  
+  // Rule: singleton exists and is not false = true
+  return singleton !== undefined;
+}
+
+/**
+ * Checks if two values are equivalent for FHIRPath comparison
+ */
+export function isEquivalent(a: any, b: any): boolean {
+  // Handle null/undefined
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  
+  // Handle different types
+  if (typeof a !== typeof b) return false;
+  
+  // Handle primitives
+  if (typeof a !== 'object') return a === b;
+  
+  // Handle arrays
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!isEquivalent(a[i], b[i])) return false;
+    }
+    return true;
+  }
+  
+  // Handle objects (deep comparison)
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  
+  if (keysA.length !== keysB.length) return false;
+  
+  for (const key of keysA) {
+    if (!keysB.includes(key)) return false;
+    if (!isEquivalent(a[key], b[key])) return false;
+  }
+  
+  return true;
+}

package/src/registry/utils/index.ts

@@ -0,0 +1,3 @@
+export { TypeSystem } from './type-system';
+export { isTruthy, isEquivalent, toSingleton, toBoolean } from './evaluation-helpers';
+export type { TypeInfo, PrimitiveType } from './type-system';

package/src/registry/utils/type-system.ts

@@ -0,0 +1,173 @@
+/**
+ * FHIRPath Type System
+ * 
+ * Handles type checking and casting for FHIRPath expressions.
+ * Supports primitive types and FHIR resource types.
+ */
+
+export enum PrimitiveType {
+  Boolean = 'Boolean',
+  String = 'String',
+  Integer = 'Integer',
+  Decimal = 'Decimal',
+  Date = 'Date',
+  DateTime = 'DateTime',
+  Time = 'Time',
+  Quantity = 'Quantity'
+}
+
+/**
+ * Type information for a value
+ */
+export interface TypeInfo {
+  name: string;
+  isPrimitive: boolean;
+  isResource?: boolean;
+  isList?: boolean;
+}
+
+/**
+ * Type registry for checking and casting
+ */
+export class TypeSystem {
+  private static primitiveTypes = new Set<string>(Object.values(PrimitiveType));
+  
+  /**
+   * Check if a value is of a specific type
+   */
+  static isType(value: any, typeName: string): boolean {
+    // Handle primitive types
+    if (this.primitiveTypes.has(typeName)) {
+      return this.isPrimitiveType(value, typeName as PrimitiveType);
+    }
+    
+    // Handle FHIR resource types
+    // For now, check if the object has a resourceType property matching the type name
+    if (typeof value === 'object' && value !== null) {
+      return value.resourceType === typeName;
+    }
+    
+    return false;
+  }
+  
+  /**
+   * Check if a value is a primitive type
+   */
+  private static isPrimitiveType(value: any, type: PrimitiveType): boolean {
+    switch (type) {
+      case PrimitiveType.Boolean:
+        return typeof value === 'boolean';
+        
+      case PrimitiveType.String:
+        return typeof value === 'string';
+        
+      case PrimitiveType.Integer:
+        return typeof value === 'number' && Number.isInteger(value);
+        
+      case PrimitiveType.Decimal:
+        return typeof value === 'number';
+        
+      case PrimitiveType.Date:
+        // Check if it's a date string in FHIR format (YYYY-MM-DD)
+        if (typeof value === 'string') {
+          return /^\d{4}(-\d{2}(-\d{2})?)?$/.test(value);
+        }
+        return false;
+        
+      case PrimitiveType.DateTime:
+        // Check if it's a datetime string in FHIR format
+        if (typeof value === 'string') {
+          return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?(Z|[+-]\d{2}:\d{2})?$/.test(value);
+        }
+        return false;
+        
+      case PrimitiveType.Time:
+        // Check if it's a time string in FHIR format (HH:MM:SS)
+        if (typeof value === 'string') {
+          return /^\d{2}:\d{2}:\d{2}(\.\d{3})?$/.test(value);
+        }
+        return false;
+        
+      case PrimitiveType.Quantity:
+        // Check if it's a quantity object with value and optional unit
+        if (typeof value === 'object' && value !== null) {
+          return typeof value.value === 'number' && 
+                 (value.unit === undefined || typeof value.unit === 'string');
+        }
+        return false;
+        
+      default:
+        return false;
+    }
+  }
+  
+  /**
+   * Cast a value to a specific type (returns empty if cast fails)
+   */
+  static cast(value: any, typeName: string): any | null {
+    // If already the correct type, return as-is
+    if (this.isType(value, typeName)) {
+      return value;
+    }
+    
+    // Handle FHIR resource casting
+    if (!this.primitiveTypes.has(typeName)) {
+      // Can't cast between different resource types
+      return null;
+    }
+    
+    // Handle primitive type casting
+    return this.castToPrimitive(value, typeName as PrimitiveType);
+  }
+  
+  /**
+   * Cast to primitive type
+   */
+  private static castToPrimitive(value: any, type: PrimitiveType): any | null {
+    // For now, return null for failed casts
+    // Later we can implement actual conversions (e.g., string to number)
+    return null;
+  }
+  
+  /**
+   * Get type information for a value
+   */
+  static getType(value: any): TypeInfo {
+    // Check primitive types
+    if (typeof value === 'boolean') {
+      return { name: PrimitiveType.Boolean, isPrimitive: true };
+    }
+    if (typeof value === 'string') {
+      // Check for specific string formats
+      if (/^\d{4}(-\d{2}(-\d{2})?)?$/.test(value)) {
+        return { name: PrimitiveType.Date, isPrimitive: true };
+      }
+      if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(value)) {
+        return { name: PrimitiveType.DateTime, isPrimitive: true };
+      }
+      if (/^\d{2}:\d{2}:\d{2}/.test(value)) {
+        return { name: PrimitiveType.Time, isPrimitive: true };
+      }
+      return { name: PrimitiveType.String, isPrimitive: true };
+    }
+    if (typeof value === 'number') {
+      return { 
+        name: Number.isInteger(value) ? PrimitiveType.Integer : PrimitiveType.Decimal, 
+        isPrimitive: true 
+      };
+    }
+    
+    // Check for FHIR resources
+    if (typeof value === 'object' && value !== null) {
+      if (value.resourceType) {
+        return { name: value.resourceType, isPrimitive: false, isResource: true };
+      }
+      if (typeof value.value === 'number' && (value.unit || value.code)) {
+        return { name: PrimitiveType.Quantity, isPrimitive: true };
+      }
+    }
+    
+    // Unknown type
+    return { name: 'Unknown', isPrimitive: false };
+  }
+}

package/src/runtime/context.ts

@@ -0,0 +1,179 @@
+import type { Context } from '../interpreter/types';
+
+/**
+ * Unified runtime context that works with both interpreter and compiler.
+ * Uses prototype-based inheritance for efficient context copying.
+ */
+export interface RuntimeContext {
+  input: any[];
+  focus: any[];
+  env: {
+    $this?: any[];
+    $index?: number;
+    $total?: any[];
+    $context?: any[];
+    $resource?: any[];
+    $rootResource?: any[];
+    [key: string]: any;
+  };
+  variables?: Record<string, any[]>;
+}
+
+/**
+ * Runtime context manager that provides efficient prototype-based context operations
+ * for both interpreter and compiler.
+ */
+export class RuntimeContextManager {
+  /**
+   * Create a new runtime context
+   */
+  static create(input: any[], initialEnv?: Record<string, any>): RuntimeContext {
+    const context = Object.create(null) as RuntimeContext;
+    
+    context.input = input;
+    context.focus = input;
+    
+    // Create env with null prototype to avoid pollution
+    context.env = Object.create(null);
+    if (initialEnv) {
+      Object.assign(context.env, initialEnv);
+    }
+    
+    // Set root context variables
+    context.env.$context = input;
+    context.env.$resource = input;
+    context.env.$rootResource = input;
+    
+    // Create variables object
+    context.variables = Object.create(null);
+    
+    return context;
+  }
+
+  /**
+   * Create a child context using prototype inheritance
+   * O(1) operation - no copying needed
+   */
+  static copy(context: RuntimeContext): RuntimeContext {
+    // Create child context with parent as prototype
+    const newContext = Object.create(context) as RuntimeContext;
+    
+    // Create child env that inherits from parent's env
+    newContext.env = Object.create(context.env);
+    
+    // Create child variables that inherit from parent's variables
+    if (context.variables) {
+      newContext.variables = Object.create(context.variables);
+    }
+    
+    // input and focus are inherited through prototype chain
+    // Only set them if they need to change
+    
+    return newContext;
+  }
+
+  /**
+   * Create a new context with updated input/focus
+   */
+  static withInput(context: RuntimeContext, input: any[], focus?: any[]): RuntimeContext {
+    const newContext = this.copy(context);
+    newContext.input = input;
+    newContext.focus = focus ?? input;
+    return newContext;
+  }
+
+  /**
+   * Set iterator context ($this, $index)
+   */
+  static withIterator(
+    context: RuntimeContext, 
+    item: any, 
+    index: number
+  ): RuntimeContext {
+    const newContext = this.copy(context);
+    newContext.env.$this = [item];
+    newContext.env.$index = index;
+    newContext.input = [item];
+    newContext.focus = [item];
+    return newContext;
+  }
+
+  /**
+   * Set a variable in the context
+   */
+  static setVariable(context: RuntimeContext, name: string, value: any[]): RuntimeContext {
+    const newContext = this.copy(context);
+    if (!newContext.variables) {
+      newContext.variables = Object.create(null);
+    }
+    newContext.variables![name] = value;
+    return newContext;
+  }
+
+  /**
+   * Get a variable from context (handles special variables too)
+   */
+  static getVariable(context: RuntimeContext, name: string): any[] | undefined {
+    // Remove % prefix if present
+    const varName = name.startsWith('%') ? name.substring(1) : name;
+    
+    // Check special variables first
+    switch (varName) {
+      case 'context':
+        return context.env.$context || context.input;
+      case 'resource':
+        return context.env.$resource || context.input;
+      case 'rootResource':
+        return context.env.$rootResource || context.input;
+      default:
+        // Check user-defined variables
+        return context.variables?.[varName];
+    }
+  }
+
+  /**
+   * Convert from interpreter Context to RuntimeContext
+   */
+  static fromContext(context: Context, input: any[]): RuntimeContext {
+    const rtContext = this.create(input);
+    
+    // Copy variables
+    if (context.variables) {
+      rtContext.variables = Object.create(context.variables);
+    }
+    
+    // Copy environment
+    Object.assign(rtContext.env, context.env);
+    
+    // Copy root variables
+    if ((context as any).$context) rtContext.env.$context = (context as any).$context;
+    if ((context as any).$resource) rtContext.env.$resource = (context as any).$resource;
+    if ((context as any).$rootResource) rtContext.env.$rootResource = (context as any).$rootResource;
+    
+    return rtContext;
+  }
+
+  /**
+   * Convert from RuntimeContext to interpreter Context
+   */
+  static toContext(rtContext: RuntimeContext): Context {
+    const context = Object.create(null) as Context;
+    
+    // Copy variables
+    context.variables = rtContext.variables || Object.create(null);
+    
+    // Extract env variables
+    context.env = {
+      $this: rtContext.env.$this,
+      $index: rtContext.env.$index,
+      $total: rtContext.env.$total
+    };
+    
+    // Extract root variables
+    (context as any).$context = rtContext.env.$context;
+    (context as any).$resource = rtContext.env.$resource;
+    (context as any).$rootResource = rtContext.env.$rootResource;
+    
+    return context;
+  }
+}