@atomic-ehr/fhirpath 0.0.1-canary.0c6931e.20250727185306

package/src/registry/registry.ts

@@ -0,0 +1,146 @@
+import { TokenType } from '../lexer/token';
+import type { Operation, Operator, Function, Literal } from './types';
+
+export class Registry {
+  private static operations = new Map<string, Operation>();
+  private static tokenToOperation = new Map<TokenType, Operation>();
+  private static prefixOperators = new Map<TokenType, Operator>();
+  private static infixOperators = new Map<TokenType, Operator>();
+  private static postfixOperators = new Map<TokenType, Operator>();
+  private static precedenceTable = new Map<TokenType, number>();
+  private static literals: Literal[] = [];
+  private static keywords = new Set<string>();
+  
+  static register(op: Operation) {
+    this.operations.set(op.name, op);
+    
+    // Type-based registration
+    switch (op.kind) {
+      case 'operator':
+        // Register by form to handle operators with same token but different forms
+        if (op.syntax.form === 'prefix') {
+          this.prefixOperators.set(op.syntax.token, op);
+        } else if (op.syntax.form === 'infix') {
+          this.infixOperators.set(op.syntax.token, op);
+        } else if (op.syntax.form === 'postfix') {
+          this.postfixOperators.set(op.syntax.token, op);
+        }
+        
+        // For backward compatibility, store in tokenToOperation (prioritize infix)
+        if (op.syntax.form === 'infix' || !this.tokenToOperation.has(op.syntax.token)) {
+          this.tokenToOperation.set(op.syntax.token, op);
+        }
+        
+        // Only set precedence for infix operators in the precedence table
+        // Prefix and postfix operators have their own precedence but don't affect the infix precedence table
+        if (op.syntax.form === 'infix') {
+          this.precedenceTable.set(op.syntax.token, op.syntax.precedence);
+        }
+        // Register keyword operators (and, or, not, etc.)
+        if (/^[a-z]+$/.test(op.name)) {
+          this.keywords.add(op.name);
+        }
+        break;
+        
+      case 'literal':
+        this.literals.push(op);
+        // Register keyword literals
+        if (op.syntax.keywords) {
+          op.syntax.keywords.forEach(kw => this.keywords.add(kw));
+        }
+        break;
+        
+      case 'function':
+        // Functions don't need special registration
+        break;
+    }
+  }
+  
+  static get(name: string): Operation | undefined {
+    return this.operations.get(name);
+  }
+  
+  static getByToken(token: TokenType, form?: 'prefix' | 'infix' | 'postfix'): Operation | undefined {
+    if (form === 'prefix') {
+      return this.prefixOperators.get(token);
+    } else if (form === 'infix') {
+      return this.infixOperators.get(token);
+    } else if (form === 'postfix') {
+      return this.postfixOperators.get(token);
+    }
+    // Default fallback
+    return this.tokenToOperation.get(token);
+  }
+  
+  static getPrecedence(token: TokenType): number {
+    return this.precedenceTable.get(token) ?? 0;
+  }
+  
+  static isKeyword(word: string): boolean {
+    return this.keywords.has(word);
+  }
+  
+  static getLiterals(): Literal[] {
+    return this.literals;
+  }
+  
+  static matchLiteral(text: string): { operation: Literal; value: any } | null {
+    for (const literal of this.literals) {
+      if (literal.syntax.pattern && literal.syntax.pattern.test(text)) {
+        return {
+          operation: literal,
+          value: literal.parse(text)
+        };
+      }
+      if (literal.syntax.keywords && literal.syntax.keywords.includes(text)) {
+        return {
+          operation: literal,
+          value: literal.parse(text)
+        };
+      }
+    }
+    return null;
+  }
+  
+  // For special forms
+  static getSpecialForms(): Operator[] {
+    return Array.from(this.operations.values())
+      .filter((op): op is Operator => op.kind === 'operator' && op.syntax.special === true);
+  }
+  
+  // Check if token starts a composite operator
+  static isCompositeOperatorStart(token: TokenType): boolean {
+    // Used by lexer to know when to look ahead
+    return [TokenType.LT, TokenType.GT, TokenType.NEQ, TokenType.NEQUIV]
+      .includes(token);
+  }
+  
+  // Clear registry (useful for testing)
+  static clear() {
+    this.operations.clear();
+    this.tokenToOperation.clear();
+    this.prefixOperators.clear();
+    this.infixOperators.clear();
+    this.postfixOperators.clear();
+    this.precedenceTable.clear();
+    this.literals = [];
+    this.keywords.clear();
+  }
+  
+  // Get all registered operations
+  static getAllOperations(): Operation[] {
+    return Array.from(this.operations.values());
+  }
+  
+  // Get operators by form
+  static getOperatorsByForm(form: 'prefix' | 'infix' | 'postfix'): Operator[] {
+    return Array.from(this.operations.values())
+      .filter((op): op is Operator => op.kind === 'operator' && op.syntax.form === form);
+  }
+  
+  // Get all functions
+  static getAllFunctions(): Function[] {
+    return Array.from(this.operations.values())
+      .filter((op): op is Function => op.kind === 'function');
+  }
+}

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 };
+  }
+}