@atomic-ehr/fhirpath 0.0.1-canary.8687028.20250724113707

package/src/registry/operations/utility.ts

@@ -0,0 +1,510 @@
+import type { Function } from '../types';
+import { defaultFunctionAnalyze } from '../default-analyzers';
+import { defaultFunctionCompile } from '../default-compilers';
+import { ContextManager } from '../../interpreter/context';
+import { isTruthy } from '../utils';
+
+export const aggregateFunction: Function = {
+  name: 'aggregate',
+  kind: 'function',
+  
+  syntax: {
+    notation: 'aggregate(aggregator, init)'
+  },
+  
+  signature: {
+    input: {
+      types: { kind: 'any' },
+      cardinality: 'collection'
+    },
+    parameters: [
+      {
+        name: 'aggregator',
+        kind: 'expression',
+        types: { kind: 'any' },
+        cardinality: 'collection',
+        optional: false
+      },
+      {
+        name: 'init',
+        kind: 'value',
+        types: { kind: 'any' },
+        cardinality: 'collection',
+        optional: true
+      }
+    ],
+    output: {
+      type: 'any',
+      cardinality: 'collection'
+    },
+    propagatesEmpty: false,
+    deterministic: true
+  },
+  
+  analyze: defaultFunctionAnalyze,
+  
+  evaluate: (interpreter, context, input, aggregatorExpr, init) => {
+    if (!aggregatorExpr) {
+      throw new Error('aggregate() requires an aggregator expression');
+    }
+    
+    let total = init !== undefined ? init : [];
+    
+    for (let i = 0; i < input.length; i++) {
+      const item = input[i];
+      const iterContext = {
+        ...ContextManager.setIteratorContext(context, item, i),
+        env: {
+          ...context.env,
+          $this: [item],
+          $index: i,
+          $total: total
+        }
+      };
+      
+      const result = interpreter.evaluate(aggregatorExpr, [item], iterContext);
+      total = result.value;
+    }
+    
+    return { value: total, context };
+  },
+  
+  compile: defaultFunctionCompile
+};
+
+export const childrenFunction: Function = {
+  name: 'children',
+  kind: 'function',
+  
+  syntax: {
+    notation: 'children()'
+  },
+  
+  signature: {
+    input: {
+      types: { kind: 'any' },
+      cardinality: 'collection'
+    },
+    parameters: [],
+    output: {
+      type: 'preserve-input',
+      cardinality: 'collection'
+    },
+    propagatesEmpty: true,
+    deterministic: true
+  },
+  
+  analyze: defaultFunctionAnalyze,
+  
+  evaluate: (interpreter, context, input) => {
+    const results: any[] = [];
+    
+    for (const item of input) {
+      if (item && typeof item === 'object') {
+        for (const key of Object.keys(item)) {
+          if (!key.startsWith('_')) {
+            const value = item[key];
+            if (Array.isArray(value)) {
+              results.push(...value);
+            } else if (value !== null && value !== undefined) {
+              results.push(value);
+            }
+          }
+        }
+      }
+    }
+    
+    return { value: results, context };
+  },
+  
+  compile: defaultFunctionCompile
+};
+
+export const descendantsFunction: Function = {
+  name: 'descendants',
+  kind: 'function',
+  
+  syntax: {
+    notation: 'descendants()'
+  },
+  
+  signature: {
+    input: {
+      types: { kind: 'any' },
+      cardinality: 'collection'
+    },
+    parameters: [],
+    output: {
+      type: 'preserve-input',
+      cardinality: 'collection'
+    },
+    propagatesEmpty: true,
+    deterministic: true
+  },
+  
+  analyze: defaultFunctionAnalyze,
+  
+  evaluate: (interpreter, context, input) => {
+    const results: any[] = [];
+    const seen = new Set();
+    
+    function collectDescendants(items: any[]) {
+      for (const item of items) {
+        if (item && typeof item === 'object') {
+          const key = JSON.stringify(item);
+          if (!seen.has(key)) {
+            seen.add(key);
+            results.push(item);
+            
+            const children: any[] = [];
+            for (const prop of Object.keys(item)) {
+              if (!prop.startsWith('_')) {
+                const value = item[prop];
+                if (Array.isArray(value)) {
+                  children.push(...value);
+                } else if (value !== null && value !== undefined && typeof value === 'object') {
+                  children.push(value);
+                }
+              }
+            }
+            collectDescendants(children);
+          }
+        }
+      }
+    }
+    
+    const children: any[] = [];
+    for (const item of input) {
+      if (item && typeof item === 'object') {
+        for (const key of Object.keys(item)) {
+          if (!key.startsWith('_')) {
+            const value = item[key];
+            if (Array.isArray(value)) {
+              children.push(...value);
+            } else if (value !== null && value !== undefined) {
+              children.push(value);
+            }
+          }
+        }
+      }
+    }
+    
+    collectDescendants(children);
+    return { value: results, context };
+  },
+  
+  compile: defaultFunctionCompile
+};
+
+export const iifFunction: Function = {
+  name: 'iif',
+  kind: 'function',
+  
+  syntax: {
+    notation: 'iif(condition, then, else)'
+  },
+  
+  signature: {
+    input: {
+      types: { kind: 'any' },
+      cardinality: 'collection'
+    },
+    parameters: [
+      {
+        name: 'condition',
+        kind: 'expression',
+        types: { kind: 'any' },
+        cardinality: 'collection',
+        optional: false
+      },
+      {
+        name: 'then',
+        kind: 'expression',
+        types: { kind: 'any' },
+        cardinality: 'collection',
+        optional: false
+      },
+      {
+        name: 'else',
+        kind: 'expression',
+        types: { kind: 'any' },
+        cardinality: 'collection',
+        optional: false
+      }
+    ],
+    output: {
+      type: 'any',
+      cardinality: 'collection'
+    },
+    propagatesEmpty: false,
+    deterministic: true
+  },
+  
+  analyze: defaultFunctionAnalyze,
+  
+  evaluate: (interpreter, context, input, condition, thenBranch, elseBranch) => {
+    const condResult = interpreter.evaluate(condition, input, context);
+    
+    if (isTruthy(condResult.value)) {
+      return interpreter.evaluate(thenBranch, input, condResult.context);
+    } else {
+      return interpreter.evaluate(elseBranch, input, condResult.context);
+    }
+  },
+  
+  compile: (compiler, input, args) => {
+    const [condExpr, thenExpr, elseExpr] = args;
+    
+    if (!condExpr || !thenExpr || !elseExpr) {
+      throw new Error('iif() requires condition, then, and else expressions');
+    }
+    
+    return {
+      fn: (ctx) => {
+        const inputVal = input.fn(ctx);
+        const condCtx = { ...ctx, input: inputVal, focus: inputVal };
+        const condResult = condExpr.fn(condCtx);
+        
+        if (isTruthy(condResult)) {
+          const thenCtx = { ...ctx, input: inputVal, focus: inputVal };
+          return thenExpr.fn(thenCtx);
+        } else {
+          const elseCtx = { ...ctx, input: inputVal, focus: inputVal };
+          return elseExpr.fn(elseCtx);
+        }
+      },
+      type: compiler.resolveType('Any'),
+      isSingleton: false,
+      source: `${input.source || ''}.iif(${condExpr.source || ''}, ${thenExpr.source || ''}, ${elseExpr.source || ''})`
+    };
+  }
+};
+
+export const defineVariableFunction: Function = {
+  name: 'defineVariable',
+  kind: 'function',
+  
+  syntax: {
+    notation: 'defineVariable(name, value)'
+  },
+  
+  signature: {
+    input: {
+      types: { kind: 'any' },
+      cardinality: 'collection'
+    },
+    parameters: [
+      {
+        name: 'name',
+        kind: 'value',
+        types: { kind: 'primitive', types: ['String'] },
+        cardinality: 'singleton',
+        optional: false
+      },
+      {
+        name: 'value',
+        kind: 'expression',
+        types: { kind: 'any' },
+        cardinality: 'collection',
+        optional: false
+      }
+    ],
+    output: {
+      type: 'preserve-input',
+      cardinality: 'collection'
+    },
+    propagatesEmpty: false,
+    deterministic: true
+  },
+  
+  analyze: defaultFunctionAnalyze,
+  
+  evaluate: (interpreter, context, input, nameValue, valueExpr) => {
+    // Extract the string value from the name parameter
+    let varName: string;
+    
+    // nameValue comes as evaluated value (array) when param.kind !== 'expression'
+    if (Array.isArray(nameValue) && nameValue.length === 1 && typeof nameValue[0] === 'string') {
+      varName = nameValue[0];
+    } else if (typeof nameValue === 'string') {
+      varName = nameValue;
+    } else {
+      throw new Error('defineVariable() requires a string literal as the first parameter');
+    }
+    
+    // Create a new context where $this refers to the input
+    const valueContext = ContextManager.copy(context);
+    valueContext.env = { ...valueContext.env, $this: input };
+    
+    const result = interpreter.evaluate(valueExpr, input, valueContext);
+    const newContext = ContextManager.setVariable(result.context, varName, result.value);
+    return { value: input, context: newContext };
+  },
+  
+  compile: (compiler, input, args) => {
+    const [nameExpr, valueExpr] = args;
+    
+    if (!valueExpr) {
+      throw new Error('defineVariable() requires name and value parameters');
+    }
+    
+    // For defineVariable, the name should be a literal string
+    // Try to extract it at compile time
+    let varName: string | undefined;
+    
+    // The name parameter should evaluate to a constant string
+    try {
+      const nameResult = nameExpr?.fn({ input: [], focus: [], env: {} }) || [];
+      if (nameResult.length === 1 && typeof nameResult[0] === 'string') {
+        varName = nameResult[0];
+      }
+    } catch (e) {
+      // If we can't evaluate it at compile time, it might be invalid
+      throw new Error('defineVariable() requires a string literal as the first parameter');
+    }
+    
+    if (!varName) {
+      throw new Error('defineVariable() requires a string literal as the first parameter');
+    }
+    
+    // Return a compiled expression that modifies the context
+    return {
+      fn: (ctx) => {
+        // Evaluate the input expression
+        const inputVal = input.fn(ctx);
+        
+        // Create context for evaluating the value expression
+        // Set $this to the input value
+        const valueCtx = { 
+          ...ctx, 
+          input: inputVal, 
+          focus: inputVal,
+          env: { ...ctx.env, $this: inputVal }
+        };
+        
+        // Evaluate the value expression
+        const value = valueExpr.fn(valueCtx);
+        
+        // IMPORTANT: We need to modify the context object that was passed in
+        // so that subsequent operations can see the variable
+        // This is done by modifying the env object in place
+        ctx.env[varName] = value;
+        
+        // Return the original input (not the value)
+        return inputVal;
+      },
+      type: input.type,
+      isSingleton: input.isSingleton,
+      source: `${input.source || ''}.defineVariable('${varName}', ${valueExpr.source || ''})`
+    };
+  }
+};
+
+export const traceFunction: Function = {
+  name: 'trace',
+  kind: 'function',
+  
+  syntax: {
+    notation: 'trace(name, selector)'
+  },
+  
+  signature: {
+    input: {
+      types: { kind: 'any' },
+      cardinality: 'collection'
+    },
+    parameters: [
+      {
+        name: 'name',
+        kind: 'value',
+        types: { kind: 'primitive', types: ['String'] },
+        cardinality: 'singleton',
+        optional: true
+      },
+      {
+        name: 'selector',
+        kind: 'expression',
+        types: { kind: 'any' },
+        cardinality: 'collection',
+        optional: true
+      }
+    ],
+    output: {
+      type: 'preserve-input',
+      cardinality: 'collection'
+    },
+    propagatesEmpty: false,
+    deterministic: false
+  },
+  
+  analyze: defaultFunctionAnalyze,
+  
+  evaluate: (interpreter, context, input, nameExpr, selectorExpr) => {
+    let values = input;
+    
+    if (selectorExpr) {
+      const result = interpreter.evaluate(selectorExpr, input, context);
+      values = result.value;
+    }
+    
+    console.log(`[TRACE] ${nameExpr || 'trace'}:`, values);
+    
+    return { value: input, context };
+  },
+  
+  compile: defaultFunctionCompile
+};
+
+export const checkFunction: Function = {
+  name: 'check',
+  kind: 'function',
+  
+  syntax: {
+    notation: 'check(error, condition)'
+  },
+  
+  signature: {
+    input: {
+      types: { kind: 'any' },
+      cardinality: 'collection'
+    },
+    parameters: [
+      {
+        name: 'error',
+        kind: 'expression',
+        types: { kind: 'any' },
+        cardinality: 'collection',
+        optional: false
+      },
+      {
+        name: 'condition',
+        kind: 'expression',
+        types: { kind: 'any' },
+        cardinality: 'collection',
+        optional: false
+      }
+    ],
+    output: {
+      type: 'preserve-input',
+      cardinality: 'collection'
+    },
+    propagatesEmpty: false,
+    deterministic: true
+  },
+  
+  analyze: defaultFunctionAnalyze,
+  
+  evaluate: (interpreter, context, input, errorExpr, conditionExpr) => {
+    const condResult = interpreter.evaluate(conditionExpr, input, context);
+    
+    if (!isTruthy(condResult.value)) {
+      const errorResult = interpreter.evaluate(errorExpr, input, condResult.context);
+      const errorMessage = errorResult.value.join('');
+      throw new Error(`Check failed: ${errorMessage}`);
+    }
+    
+    return { value: input, context: condResult.context };
+  },
+  
+  compile: defaultFunctionCompile
+};

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