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

package/src/registry/operations/filtering.ts

@@ -0,0 +1,358 @@
+import type { Function } from '../types';
+import { defaultFunctionAnalyze } from '../default-analyzers';
+import { defaultFunctionCompile } from '../default-compilers';
+import { RuntimeContextManager } from '../../runtime/context';
+import { isTruthy } from '../utils';
+
+export const whereFunction: Function = {
+  name: 'where',
+  kind: 'function',
+  
+  syntax: {
+    notation: 'where(criteria)'
+  },
+  
+  signature: {
+    input: {
+      types: { kind: 'any' },
+      cardinality: 'any'
+    },
+    parameters: [
+      {
+        name: 'criteria',
+        kind: 'expression',
+        types: { kind: 'any' },
+        cardinality: 'any',
+        optional: false
+      }
+    ],
+    output: {
+      type: 'preserve-input',
+      cardinality: 'collection'
+    },
+    propagatesEmpty: true,
+    deterministic: true
+  },
+  
+  analyze: defaultFunctionAnalyze,
+  
+  evaluate: (interpreter, context, input, criteria) => {
+    const results: any[] = [];
+    if (!criteria) {
+      throw new Error('where() requires a predicate expression');
+    }
+
+    for (let i = 0; i < input.length; i++) {
+      const item = input[i];
+      const iterContext = RuntimeContextManager.withIterator(context, item, i);
+      const result = interpreter.evaluate(criteria, [item], iterContext);
+      
+      if (isTruthy(result.value)) {
+        results.push(item);
+      }
+    }
+
+    return { value: results, context };
+  },
+  
+  compile: (compiler, input, args) => {
+    const criteria = args[0];
+    if (!criteria) {
+      throw new Error('where() requires a predicate expression');
+    }
+    
+    return {
+      fn: (ctx) => {
+        const inputValue = input.fn(ctx);
+        const results: any[] = [];
+        
+        for (let i = 0; i < inputValue.length; i++) {
+          const item = inputValue[i];
+          const iterCtx = RuntimeContextManager.withIterator(ctx, item, i);
+          const predicateResult = criteria.fn(iterCtx);
+          
+          if (isTruthy(predicateResult)) {
+            results.push(item);
+          }
+        }
+        
+        return results;
+      },
+      type: input.type,
+      isSingleton: false,
+      source: `${input.source || ''}.where(${criteria.source || ''})`
+    };
+  }
+};
+
+export const selectFunction: Function = {
+  name: 'select',
+  kind: 'function',
+  
+  syntax: {
+    notation: 'select(expression)'
+  },
+  
+  signature: {
+    input: {
+      types: { kind: 'any' },
+      cardinality: 'any'
+    },
+    parameters: [
+      {
+        name: 'expression',
+        kind: 'expression',
+        types: { kind: 'any' },
+        cardinality: 'any',
+        optional: false
+      }
+    ],
+    output: {
+      type: 'any',
+      cardinality: 'collection'
+    },
+    propagatesEmpty: true,
+    deterministic: true
+  },
+  
+  analyze: function(analyzer, input, args) {
+    // First run default validation
+    defaultFunctionAnalyze.call(this, analyzer, input, args);
+    
+    // For select(), the output type is determined by the expression result
+    const expressionInfo = args[0];
+    if (!expressionInfo) {
+      return { type: analyzer.resolveType('Any'), isSingleton: false };
+    }
+    
+    // select() always returns a collection
+    return { type: expressionInfo.type, isSingleton: false };
+  },
+  
+  evaluate: (interpreter, context, input, expression) => {
+    const results: any[] = [];
+    if (!expression) {
+      throw new Error('select() requires an expression');
+    }
+
+    for (let i = 0; i < input.length; i++) {
+      const item = input[i];
+      const iterContext = RuntimeContextManager.withIterator(context, item, i);
+      const result = interpreter.evaluate(expression, [item], iterContext);
+      results.push(...result.value);
+    }
+
+    return { value: results, context };
+  },
+  
+  compile: (compiler, input, args) => {
+    const expression = args[0];
+    if (!expression) {
+      throw new Error('select() requires an expression');
+    }
+    
+    return {
+      fn: (ctx) => {
+        const inputValue = input.fn(ctx);
+        const results: any[] = [];
+        
+        for (let i = 0; i < inputValue.length; i++) {
+          const item = inputValue[i];
+          const iterCtx = RuntimeContextManager.withIterator(ctx, item, i);
+          const exprResult = expression.fn(iterCtx);
+          results.push(...exprResult);
+        }
+        
+        return results;
+      },
+      type: expression.type,
+      isSingleton: false,
+      source: `${input.source || ''}.select(${expression.source || ''})`
+    };
+  }
+};
+
+export const ofTypeFunction: Function = {
+  name: 'ofType',
+  kind: 'function',
+  
+  syntax: {
+    notation: 'ofType(type)'
+  },
+  
+  signature: {
+    input: {
+      types: { kind: 'any' },
+      cardinality: 'any'
+    },
+    parameters: [
+      {
+        name: 'type',
+        kind: 'expression',
+        types: { kind: 'any' },
+        cardinality: 'any',
+        optional: false
+      }
+    ],
+    output: {
+      type: 'preserve-input',
+      cardinality: 'collection'
+    },
+    propagatesEmpty: true,
+    deterministic: true
+  },
+  
+  analyze: defaultFunctionAnalyze,
+  
+  evaluate: (interpreter, context, input, typeNode) => {
+    const results: any[] = [];
+    
+    // Extract type name from AST node
+    let typeName: string;
+    if (typeNode && typeNode.type === 11) { // TypeReference (correct enum value)
+      typeName = typeNode.typeName;
+    } else if (typeNode && typeNode.type === 1) { // TypeOrIdentifier
+      typeName = typeNode.name;
+    } else {
+      throw new Error('ofType() requires a type reference');
+    }
+    
+    for (const item of input) {
+      if (isOfType(item, typeName)) {
+        results.push(item);
+      }
+    }
+    
+    return { value: results, context };
+  },
+  
+  compile: (compiler, input, args) => {
+    // The TypeSystem module with isOfType helper
+    const { TypeSystem } = require('../utils/type-system');
+    
+    // The argument should be a TypeReference node compiled to return the type name
+    const typeArg = args[0];
+    if (!typeArg) {
+      throw new Error('ofType() requires a type reference');
+    }
+    
+    return {
+      fn: (ctx) => {
+        const inputValue = input.fn(ctx);
+        const results: any[] = [];
+        
+        // Get the type name
+        let typeName: string;
+        try {
+          const typeResult = typeArg.fn(ctx);
+          if (typeResult.length === 1 && typeof typeResult[0] === 'string') {
+            typeName = typeResult[0];
+          } else {
+            throw new Error('Type reference must evaluate to a string');
+          }
+        } catch (e: any) {
+          // If it's a type reference that cannot be evaluated, extract from source
+          if (typeArg.source && /^[A-Z]/.test(typeArg.source)) {
+            typeName = typeArg.source;
+          } else {
+            throw new Error(`Cannot determine type name: ${e.message}`);
+          }
+        }
+        
+        // Filter by type
+        for (const item of inputValue) {
+          if (TypeSystem.isType(item, typeName)) {
+            results.push(item);
+          }
+        }
+        
+        return results;
+      },
+      type: input.type,
+      isSingleton: false,
+      source: `${input.source || ''}.ofType(${typeArg.source || ''})`
+    };
+  }
+};
+
+export const repeatFunction: Function = {
+  name: 'repeat',
+  kind: 'function',
+  
+  syntax: {
+    notation: 'repeat(expression)'
+  },
+  
+  signature: {
+    input: {
+      types: { kind: 'any' },
+      cardinality: 'any'
+    },
+    parameters: [
+      {
+        name: 'expression',
+        kind: 'expression',
+        types: { kind: 'any' },
+        cardinality: 'any',
+        optional: false
+      }
+    ],
+    output: {
+      type: 'preserve-input',
+      cardinality: 'collection'
+    },
+    propagatesEmpty: true,
+    deterministic: true
+  },
+  
+  analyze: defaultFunctionAnalyze,
+  
+  evaluate: (interpreter, context, input, expression) => {
+    let current = input;
+    const seen = new Set();
+    
+    while (current.length > 0) {
+      const nextResults: any[] = [];
+      
+      for (let i = 0; i < current.length; i++) {
+        const item = current[i];
+        const itemKey = JSON.stringify(item);
+        
+        if (!seen.has(itemKey)) {
+          seen.add(itemKey);
+          const iterContext = RuntimeContextManager.withIterator(context, item, i);
+          const result = interpreter.evaluate(expression, [item], iterContext);
+          nextResults.push(...result.value);
+        }
+      }
+      
+      current = nextResults;
+    }
+    
+    return { value: Array.from(seen).map(key => JSON.parse(key as string)), context };
+  },
+  
+  compile: defaultFunctionCompile
+};
+
+// Helper function for type checking
+function isOfType(item: any, typeName: string): boolean {
+  // Handle FHIR resource types
+  if (item && typeof item === 'object' && item.resourceType === typeName) {
+    return true;
+  }
+  
+  // Handle primitive types
+  switch (typeName) {
+    case 'String':
+      return typeof item === 'string';
+    case 'Boolean':
+      return typeof item === 'boolean';
+    case 'Integer':
+      return typeof item === 'number' && Number.isInteger(item);
+    case 'Decimal':
+      return typeof item === 'number';
+    default:
+      return false;
+  }
+}

package/src/registry/operations/literals.ts

@@ -0,0 +1,341 @@
+import type { Literal } from '../types';
+import { defaultLiteralAnalyze } from '../default-analyzers';
+
+export const integerLiteral: Literal = {
+  name: 'integer-literal',
+  kind: 'literal',
+  
+  syntax: {
+    pattern: /^-?\d+$/,
+    notation: '123'
+  },
+  
+  signature: {
+    output: {
+      type: 'Integer',
+      cardinality: 'singleton'
+    }
+  },
+  
+  parse: (value: string) => parseInt(value, 10),
+  
+  analyze: defaultLiteralAnalyze,
+  
+  evaluate: (interpreter, context, input, ...args) => {
+    // Value is passed as first argument from parser
+    const value = args[0];
+    return { value: [value], context };
+  },
+  
+  compile: (compiler, input, args) => {
+    // Value is captured from parser
+    const value = (input as any).value || 0; // Parser stores parsed value
+    return {
+      fn: (ctx) => [value],
+      type: compiler.resolveType('Integer'),
+      isSingleton: true,
+      source: value.toString()
+    };
+  }
+};
+
+export const decimalLiteral: Literal = {
+  name: 'decimal-literal',
+  kind: 'literal',
+  
+  syntax: {
+    pattern: /^-?\d+\.\d+$/,
+    notation: '123.45'
+  },
+  
+  signature: {
+    output: {
+      type: 'Decimal',
+      cardinality: 'singleton'
+    }
+  },
+  
+  parse: (value: string) => parseFloat(value),
+  
+  analyze: defaultLiteralAnalyze,
+  
+  evaluate: (interpreter, context, input, ...args) => {
+    const value = args[0];
+    return { value: [value], context };
+  },
+  
+  compile: (compiler, input, args) => {
+    const value = (input as any).value || 0.0;
+    return {
+      fn: (ctx) => [value],
+      type: compiler.resolveType('Decimal'),
+      isSingleton: true,
+      source: value.toString()
+    };
+  }
+};
+
+export const trueLiteral: Literal = {
+  name: 'true',
+  kind: 'literal',
+  
+  syntax: {
+    keywords: ['true'],
+    notation: 'true'
+  },
+  
+  signature: {
+    output: { 
+      type: 'Boolean', 
+      cardinality: 'singleton' 
+    }
+  },
+  
+  parse: () => true,
+  
+  analyze: defaultLiteralAnalyze,
+  
+  evaluate: (interpreter, context) => ({ value: [true], context }),
+  
+  compile: (compiler) => ({
+    fn: (ctx) => [true],
+    type: compiler.resolveType('Boolean'),
+    isSingleton: true,
+    source: 'true'
+  })
+};
+
+export const falseLiteral: Literal = {
+  name: 'false',
+  kind: 'literal',
+  
+  syntax: {
+    keywords: ['false'],
+    notation: 'false'
+  },
+  
+  signature: {
+    output: { 
+      type: 'Boolean', 
+      cardinality: 'singleton' 
+    }
+  },
+  
+  parse: () => false,
+  
+  analyze: defaultLiteralAnalyze,
+  
+  evaluate: (interpreter, context) => ({ value: [false], context }),
+  
+  compile: (compiler) => ({
+    fn: (ctx) => [false],
+    type: compiler.resolveType('Boolean'),
+    isSingleton: true,
+    source: 'false'
+  })
+};
+
+export const stringLiteral: Literal = {
+  name: 'string-literal',
+  kind: 'literal',
+  
+  syntax: {
+    pattern: /^'([^'\\]|\\.)*'$/,
+    notation: "'hello'"
+  },
+  
+  signature: {
+    output: {
+      type: 'String',
+      cardinality: 'singleton'
+    }
+  },
+  
+  parse: (value: string) => {
+    // Remove quotes and unescape
+    const content = value.slice(1, -1);
+    return content
+      .replace(/\\'/g, "'")
+      .replace(/\\\\/g, "\\")
+      .replace(/\\n/g, "\n")
+      .replace(/\\r/g, "\r")
+      .replace(/\\t/g, "\t")
+      .replace(/\\f/g, "\f")
+      .replace(/\\u([0-9a-fA-F]{4})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
+  },
+  
+  analyze: defaultLiteralAnalyze,
+  
+  evaluate: (interpreter, context, input, ...args) => {
+    const value = args[0];
+    return { value: [value], context };
+  },
+  
+  compile: (compiler, input, args) => {
+    const value = (input as any).value || '';
+    return {
+      fn: (ctx) => [value],
+      type: compiler.resolveType('String'),
+      isSingleton: true,
+      source: `'${value.replace(/'/g, "\\'")}'`
+    };
+  }
+};
+
+export const dateTimeLiteral: Literal = {
+  name: 'datetime-literal',
+  kind: 'literal',
+  
+  syntax: {
+    pattern: /@\d{4}(-\d{2}(-\d{2}(T\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:\d{2})?)?)?)?/,
+    notation: '@2023-01-01T12:00:00Z'
+  },
+  
+  signature: {
+    output: { 
+      type: 'DateTime', 
+      cardinality: 'singleton' 
+    }
+  },
+  
+  parse: (value: string) => {
+    // Remove @ prefix
+    const dateStr = value.substring(1);
+    
+    // Parse partial dates by padding with defaults
+    const parts = dateStr.match(/^(\d{4})(?:-(\d{2})(?:-(\d{2})(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d+))?)?(Z|[+-]\d{2}:\d{2})?)?)?)?$/);
+    if (!parts) throw new Error(`Invalid DateTime literal: ${value}`);
+    
+    const [, year, month = '01', day = '01', hour = '00', minute = '00', second = '00', ms = '0', tz = ''] = parts;
+    
+    const isoString = `${year}-${month}-${day}T${hour}:${minute}:${second}.${ms.padEnd(3, '0')}${tz || 'Z'}`;
+    return new Date(isoString);
+  },
+  
+  analyze: defaultLiteralAnalyze,
+  
+  evaluate: (interpreter, context, input, ...args) => {
+    const value = args[0];
+    return { value: [value], context };
+  },
+  
+  compile: (compiler, input, args) => {
+    const value = (input as any).value || new Date();
+    return {
+      fn: (ctx) => [value],
+      type: compiler.resolveType('DateTime'),
+      isSingleton: true,
+      source: `@${value.toISOString()}`
+    };
+  }
+};
+
+export const timeLiteral: Literal = {
+  name: 'time-literal',
+  kind: 'literal',
+  
+  syntax: {
+    pattern: /@T\d{2}:\d{2}(:\d{2}(\.\d+)?)?/,
+    notation: '@T12:00:00'
+  },
+  
+  signature: {
+    output: { 
+      type: 'Time', 
+      cardinality: 'singleton' 
+    }
+  },
+  
+  parse: (value: string) => {
+    // Remove @T prefix
+    const timeStr = value.substring(2);
+    
+    // Parse time components
+    const parts = timeStr.match(/^(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d+))?)?$/);
+    if (!parts) throw new Error(`Invalid Time literal: ${value}`);
+    
+    const [, hour, minute, second = '00', ms = '0'] = parts as string[];
+    
+    // Store as object with time components
+    return {
+      hour: parseInt(hour || '0', 10),
+      minute: parseInt(minute || '0', 10),
+      second: parseInt(second || '0', 10),
+      millisecond: parseInt(ms.padEnd(3, '0'), 10)
+    };
+  },
+  
+  analyze: defaultLiteralAnalyze,
+  
+  evaluate: (interpreter, context, input, ...args) => {
+    const value = args[0];
+    return { value: [value], context };
+  },
+  
+  compile: (compiler, input, args) => {
+    const value = (input as any).value || { hour: 0, minute: 0, second: 0 };
+    return {
+      fn: (ctx) => [value],
+      type: compiler.resolveType('Time'),
+      isSingleton: true,
+      source: `@T${String(value.hour).padStart(2, '0')}:${String(value.minute).padStart(2, '0')}:${String(value.second).padStart(2, '0')}`
+    };
+  }
+};
+
+export const quantityLiteral: Literal = {
+  name: 'quantity-literal',
+  kind: 'literal',
+  
+  syntax: {
+    pattern: /^-?\d+(\.\d+)?\s*'[^']+'$/,
+    notation: "5.4 'mg'"
+  },
+  
+  signature: {
+    output: {
+      type: 'Quantity',
+      cardinality: 'singleton'
+    }
+  },
+  
+  parse: (value: string) => {
+    const match = value.match(/^(-?\d+(?:\.\d+)?)\s*'([^']+)'$/);
+    if (!match) throw new Error(`Invalid Quantity literal: ${value}`);
+    
+    const [, num, unit] = match as [string, string, string];
+    return {
+      value: parseFloat(num || '0'),
+      unit: unit || ''
+    };
+  },
+  
+  analyze: defaultLiteralAnalyze,
+  
+  evaluate: (interpreter, context, input, ...args) => {
+    const value = args[0];
+    return { value: [value], context };
+  },
+  
+  compile: (compiler, input, args) => {
+    const value = (input as any).value || { value: 0, unit: '' };
+    return {
+      fn: (ctx) => [value],
+      type: compiler.resolveType('Quantity'),
+      isSingleton: true,
+      source: `${value.value} '${value.unit}'`
+    };
+  }
+};
+
+// Export all literals
+export const literals = [
+  integerLiteral,
+  decimalLiteral,
+  trueLiteral,
+  falseLiteral,
+  stringLiteral,
+  dateTimeLiteral,
+  timeLiteral,
+  quantityLiteral
+];