@atomic-ehr/fhirpath 0.0.3 → 0.0.4

package/src/{index.ts → index.common.ts}

@@ -1,36 +1,39 @@
 import { Parser } from './parser';
 import { Interpreter } from './interpreter';
 import { Analyzer } from './analyzer';
-import type { AnalysisResult } from './types';
-import { DiagnosticSeverity } from './types';
-import { FHIRPathError, Errors, ErrorCodes } from './errors';
+import type { AnalysisResult, EvaluationResult, ModelProvider, TypeInfo } from './types';
+
+declare const __VERSION__: string;
 
 export interface EvaluateOptions {
   input?: unknown;
   variables?: Record<string, unknown>;
-  modelProvider?: import('./types').ModelProvider;
-  inputType?: import('./types').TypeInfo;
+  modelProvider?: ModelProvider;
+  inputType?: TypeInfo;
+  includeMetadata?: boolean;
 }
 
-export async function evaluate(
+export async function evaluate<T = any>(
   expression: string,
   options: EvaluateOptions = {}
-): Promise<any[]> {
+): Promise<EvaluationResult<T>['value']> {
   const interpreter = new Interpreter(undefined, options.modelProvider);
   return interpreter.evaluateExpression(expression, {
     input: options.input,
     variables: options.variables,
     inputType: options.inputType,
     modelProvider: options.modelProvider,
+    includeMetadata: options.includeMetadata
   });
 }
 
+
 export async function analyze(
   expression: string,
   options: { 
     variables?: Record<string, unknown>;
-    modelProvider?: import('./types').ModelProvider;
-    inputType?: import('./types').TypeInfo;
+    modelProvider?: ModelProvider;
+    inputType?: TypeInfo;
     errorRecovery?: boolean;
   } = {}
 ): Promise<AnalysisResult> {
@@ -43,6 +46,10 @@ export async function analyze(
   return analysisResult;
 }
 
+export function getVersion(): string {
+  return __VERSION__;
+}
+
 // Export key types and classes
 export { Parser } from './parser';
 export { Interpreter } from './interpreter';
@@ -59,13 +66,10 @@ export type {
   TypeName,
   ModelProvider as ModelTypeProvider,
   OperatorDefinition,
-  FunctionDefinition
+  FunctionDefinition,
+  EvaluationResult
 } from './types';
 
-// Export FHIR ModelProvider
-export { FHIRModelProvider } from './model-provider';
-export type { FHIRModelContext, FHIRModelProviderConfig } from './model-provider';
-
 // Export inspect API
 export { inspect } from './inspect';
 export type { InspectOptions, InspectResult, ASTMetadata } from './inspect';

package/src/index.node.ts

@@ -0,0 +1,4 @@
+export * from './index.common';
+
+export { FHIRModelProvider } from './model-provider.node.js';
+export type { FHIRModelContext, FHIRModelProviderConfig } from './model-provider.node.js';

package/src/interpreter/navigator.ts

@@ -79,6 +79,18 @@ async function detectChoiceValues(
     } else {
       choiceType = { ...choiceType, singleton: !Array.isArray(value) };
     }
+    
+    // For FHIR value[x] polymorphic properties, ensure FHIR namespace and lowercase name
+    if (choiceProp.startsWith('value') && modelProvider) {
+      // Convert type name to lowercase for FHIR primitive types
+      // valueString -> FHIR.string, valueInteger -> FHIR.integer, etc.
+      const lowerTypeName = choiceName.charAt(0).toLowerCase() + choiceName.slice(1);
+      choiceType = {
+        ...choiceType,
+        namespace: 'FHIR',
+        name: lowerTypeName
+      };
+    }
     if (Array.isArray(value)) {
       for (const v of value) {
         hits.push({ value: v, typeInfo: { ...choiceType, singleton: true }, primitiveElement });

package/src/interpreter/runtime-context.ts

@@ -33,6 +33,12 @@ export class RuntimeContextManager {
     context.variables['%resource'] = input;
     context.variables['%rootResource'] = input;
 
+    // Set FHIR-specific system variables (standard URLs for code systems)
+    context.variables['%sct'] = 'http://snomed.info/sct';
+    context.variables['%loinc'] = 'http://loinc.org';
+    context.variables['%ucum'] = 'http://unitsofmeasure.org';
+    context.variables['%vs-administrative-gender'] = 'http://hl7.org/fhir/ValueSet/administrative-gender';
+
     // Add any initial variables (with % prefix for user-defined)
     if (initialVariables) {
       for (const [key, value] of Object.entries(initialVariables)) {
@@ -91,7 +97,7 @@ export class RuntimeContextManager {
   static setVariable(context: RuntimeContext, name: string, value: any, allowRedefinition: boolean = false): RuntimeContext {
     // Ensure value is array for consistency (except for special variables like $index)
     const arrayValue = (name === '$index' || name === '$total') ? value :
-                      Array.isArray(value) ? value : [value];
+      Array.isArray(value) ? value : [value];
 
     // Determine variable key based on prefix
     let varKey = name;
@@ -100,12 +106,20 @@ export class RuntimeContextManager {
       varKey = `%${name}`;
     }
 
-    // Check for system variables (with or without % prefix)
-    const systemVariables = ['context', 'resource', 'rootResource', 'ucum', 'sct', 'loinc'];
-    const baseVarName = varKey.startsWith('%') ? varKey.substring(1) : varKey;
-    if (systemVariables.includes(baseVarName)) {
-      // Throw error when trying to override system variables
-      throw Errors.invalidOperation(`Cannot override system variable: ${baseVarName}`);
+    // Check for system variable override attempts
+    const systemVariables = new Set([
+      'context', '%context',
+      'resource', '%resource',
+      'rootResource', '%rootResource',
+      'sct', '%sct',
+      'loinc', '%loinc',
+      'ucum', '%ucum',
+      'vs-administrative-gender', '%vs-administrative-gender'
+    ]);
+
+    if (!allowRedefinition && (systemVariables.has(name) || systemVariables.has(varKey))) {
+      // Cannot override system variables
+      throw Errors.systemVariableOverride(name);
     }
 
     // Check if variable already exists (unless redefinition is allowed)
@@ -149,12 +163,33 @@ export class RuntimeContextManager {
     if (name === 'rootResource' || name === '%rootResource') {
       return context.variables['%rootResource'];
     }
+    if (name === 'sct' || name === '%sct') {
+      return context.variables['%sct'];
+    }
+    if (name === 'loinc' || name === '%loinc') {
+      return context.variables['%loinc'];
+    }
+    if (name === 'ucum' || name === '%ucum') {
+      return context.variables['%ucum'];
+    }
+    if (name === 'vs-administrative-gender' || name === '%vs-administrative-gender' || name === '%`vs-administrative-gender`') {
+      return context.variables['%vs-administrative-gender'];
+    }
+
+    // Handle user-defined variables
+    // Strip backticks from environment variable syntax %`variable`
+    let cleanName = name;
+    if (name.startsWith('%`') && name.endsWith('`')) {
+      // Remove %` from start and ` from end
+      cleanName = '%' + name.slice(2, -1);
+    } else if (!name.startsWith('%')) {
+      // Add % prefix if not present
+      cleanName = '%' + name;
+    }
 
-    // Handle user-defined variables (add % prefix if not present)
-    const varKey = name.startsWith('%') ? name : `%${name}`;
     // Use 'in' operator to check prototype chain for inherited variables
-    if (varKey in context.variables) {
-      return context.variables[varKey];
+    if (cleanName in context.variables) {
+      return context.variables[cleanName];
     }
     return undefined;
   }
@@ -250,21 +285,21 @@ export class RuntimeContextManager {
         const values = Array.isArray(rawVal) ? rawVal : [rawVal];
         const maybeBoxed = modelProvider
           ? await Promise.all(
-              values.map(async (v) => {
-                if (
-                  v &&
-                  typeof v === 'object' &&
-                  'resourceType' in (v as any) &&
-                  typeof (v as any).resourceType === 'string'
-                ) {
-                  const ti = await modelProvider.getType((v as any).resourceType);
-                  return ti ? box(v, ti) : v;
-                }
-                return v;
-              })
-            )
+            values.map(async (v) => {
+              if (
+                v &&
+                typeof v === 'object' &&
+                'resourceType' in (v as any) &&
+                typeof (v as any).resourceType === 'string'
+              ) {
+                const ti = await modelProvider.getType((v as any).resourceType);
+                return ti ? box(v, ti) : v;
+              }
+              return v;
+            })
+          )
           : values;
-        context = RuntimeContextManager.setVariable(context, key, maybeBoxed);
+        context = RuntimeContextManager.setVariable(context, key, maybeBoxed, true);
       }
     }
 

package/src/interpreter.ts

@@ -10,7 +10,8 @@ import type {
   IndexNode,
   MembershipTestNode,
   TypeCastNode,
-  QuantityNode
+  QuantityNode,
+  ModelProvider
 } from './types';
 import { NodeType } from './types';
 import { Registry } from './registry';
@@ -44,7 +45,7 @@ export class Interpreter {
     this.modelProvider = modelProvider;
     this.operationEvaluators = new Map();
     this.functionEvaluators = new Map();
-    
+
     // Initialize node evaluators using object dispatch pattern
     this.nodeEvaluators = {
       [NodeType.Literal]: this.evaluateLiteral.bind(this),
@@ -136,10 +137,11 @@ export class Interpreter {
       input?: unknown;
       variables?: Record<string, unknown>;
       inputType?: TypeInfo;
-      modelProvider?: import('./types').ModelProvider;
+      modelProvider?: ModelProvider;
       now?: Date;
+      includeMetadata?: boolean;
     } = {}
-  ): Promise<any[]> {
+  ): Promise<EvaluationResult['value']> {
     // Analyze expression first (ensures type info and diagnostics)
     const analysis = await Analyzer.analyzeExpression(expression, {
       variables: options.variables,
@@ -168,13 +170,24 @@ export class Interpreter {
     // Unbox and format temporal outputs for API parity
     return result.value.map((boxedValue) => {
       const value = unbox(boxedValue);
+      let overridedValue: any = undefined;
       if (value && typeof value === 'object' && 'kind' in value) {
         if ((value as any).kind === 'FHIRDate' || (value as any).kind === 'FHIRDateTime') {
-          return '@' + toTemporalString(value as any);
+          if (options.includeMetadata) {
+            overridedValue = '@' + toTemporalString(value as any);
+          } else {
+            return '@' + toTemporalString(value as any);
+          }
         } else if ((value as any).kind === 'FHIRTime') {
-          return '@T' + toTemporalString(value as any);
+          if (options.includeMetadata) {
+            overridedValue = '@T' + toTemporalString(value as any);
+          } else {
+            return '@T' + toTemporalString(value as any);
+          }
         }
       }
+      // return options.includeMetadata ? box(overridedValue ?? value, boxedValue.typeInfo, boxedValue.primitiveElement) : value;
+      // return box(overridedValue ?? value, boxedValue.typeInfo, boxedValue.primitiveElement);
       return value;
     });
   }
@@ -201,10 +214,10 @@ export class Interpreter {
   // TemporalLiteral node evaluator
   private async evaluateTemporalLiteral(node: ASTNode, input: FHIRPathValue[], context: RuntimeContext): Promise<EvaluationResult> {
     const temporal = node as import('./types').TemporalLiteralNode;
-    
+
     // The value is already parsed in the parser
     let typeInfo: import('./types').TypeInfo;
-    
+
     if (temporal.valueType === 'date') {
       typeInfo = { type: 'Date', singleton: true };
     } else if (temporal.valueType === 'datetime') {
@@ -212,7 +225,7 @@ export class Interpreter {
     } else {
       typeInfo = { type: 'Time', singleton: true };
     }
-    
+
     return {
       value: [box(temporal.value, typeInfo)],
       context
@@ -222,18 +235,18 @@ export class Interpreter {
   // Literal node evaluator
   private async evaluateLiteral(node: ASTNode, input: FHIRPathValue[], context: RuntimeContext): Promise<EvaluationResult> {
     const literal = node as LiteralNode;
-    
+
     // Box the literal value with appropriate type info
     let typeInfo: import('./types').TypeInfo | undefined;
     let value: any = literal.value;
-    
+
     // Handle temporal literals (backwards compatibility - should not reach here with new parser)
     if (literal.valueType === 'date' || literal.valueType === 'datetime' || literal.valueType === 'time') {
       // Import temporal parsing function
       const { parseTemporalLiteral } = await import('./complex-types/temporal');
       // Parse the temporal literal (add @ back since it was stripped by parser)
       const temporalValue = parseTemporalLiteral('@' + literal.value);
-      
+
       // Set appropriate type info
       if (literal.valueType === 'date') {
         typeInfo = { type: 'Date', singleton: true };
@@ -242,18 +255,20 @@ export class Interpreter {
       } else if (literal.valueType === 'time') {
         typeInfo = { type: 'Time', singleton: true };
       }
-      
+
       value = temporalValue;
     } else if (typeof value === 'string') {
       typeInfo = { type: 'String', singleton: true };
     } else if (typeof value === 'number') {
-      typeInfo = Number.isInteger(value) ? 
-        { type: 'Integer', singleton: true } : 
-        { type: 'Decimal', singleton: true };
+      // Use the valueType from the literal node to determine if it's integer or decimal
+      // This preserves the distinction between 1.0 (decimal) and 1 (integer)
+      typeInfo = literal.valueType === 'decimal' ?
+        { type: 'Decimal', singleton: true } :
+        { type: 'Integer', singleton: true };
     } else if (typeof value === 'boolean') {
       typeInfo = { type: 'Boolean', singleton: true };
     }
-    
+
     return {
       value: [box(value, typeInfo)],
       context
@@ -262,7 +277,7 @@ export class Interpreter {
 
   // Helper: Handle extension elements
   private handleExtension(
-    boxedItem: FHIRPathValue, 
+    boxedItem: FHIRPathValue,
     nodeTypeInfo?: TypeInfo
   ): FHIRPathValue[] {
     const results: FHIRPathValue[] = [];
@@ -326,15 +341,31 @@ export class Interpreter {
     item: object,
     name: string,
     nodeTypeInfo: TypeInfo | undefined,
-    context: RuntimeContext
+    context: RuntimeContext,
+    parentTypeInfo?: TypeInfo
   ): Promise<FHIRPathValue[]> {
     const results: FHIRPathValue[] = [];
     if (name in (item as any)) {
       const value = (item as any)[name];
       const primitiveElement = getPrimitiveElement(item as Record<string, unknown>, name);
 
+      // Determine if this is a FHIR primitive - if parent is a FHIR resource and value is primitive
+      const isFHIRPrimitive = parentTypeInfo &&
+        parentTypeInfo.type &&
+        parentTypeInfo.type !== 'Any' &&
+        !parentTypeInfo.type.startsWith('System.') &&
+        (typeof value === 'boolean' || typeof value === 'string' || typeof value === 'number');
+
       if (Array.isArray(value)) {
-        const elementTypeInfo = nodeTypeInfo ? { ...nodeTypeInfo, singleton: true } : undefined;
+        let elementTypeInfo = nodeTypeInfo ? { ...nodeTypeInfo, singleton: true } : undefined;
+
+        // For FHIR primitives, use FHIR namespace
+        if (isFHIRPrimitive && elementTypeInfo) {
+          if (elementTypeInfo.type === 'Boolean') {
+            elementTypeInfo = { ...elementTypeInfo, type: 'boolean' as any };
+          }
+        }
+
         for (const v of value) {
           if (
             v && typeof v === 'object' && 'resourceType' in (v as any) && typeof (v as any).resourceType === 'string'
@@ -355,8 +386,16 @@ export class Interpreter {
           const boxed = await reboxResource(value, true, context.modelProvider);
           results.push(boxed);
         } else {
-          const val = await maybeParseTemporal(value, nodeTypeInfo, context.modelProvider);
-          results.push(box(val, nodeTypeInfo, primitiveElement));
+          // For FHIR primitives, use FHIR namespace
+          let typeInfo = nodeTypeInfo;
+          if (isFHIRPrimitive && typeInfo) {
+            if (typeInfo.type === 'Boolean') {
+              typeInfo = { ...typeInfo, type: 'boolean' as any };
+            }
+          }
+
+          const val = await maybeParseTemporal(value, typeInfo, context.modelProvider);
+          results.push(box(val, typeInfo, primitiveElement));
         }
       }
     }
@@ -393,7 +432,7 @@ export class Interpreter {
         results.push(...unionResults);
 
         // 4. Handle standard property access
-        const propertyResults = await this.handleStandardProperty(item, name, nodeTypeInfo, context);
+        const propertyResults = await this.handleStandardProperty(item, name, nodeTypeInfo, context, boxedItem.typeInfo);
         results.push(...propertyResults);
       }
     }
@@ -431,9 +470,29 @@ export class Interpreter {
 
     // Special handling for dot operator (sequential pipeline)
     if (operator === '.') {
+      // Check if this is actually a namespaced type in an 'is' expression
+      // Parser incorrectly creates: (true is System).Boolean instead of: true is System.Boolean
+      if (binary.left.type === NodeType.MembershipTest && binary.right.type === NodeType.Identifier) {
+        const membershipTest = binary.left as MembershipTestNode;
+        const rightIdent = binary.right as IdentifierNode;
+
+        // Extract the expression from the membership test
+        const expr = membershipTest.expression;
+        const typeName = `${membershipTest.targetType}.${rightIdent.name}`;
+
+        // Evaluate the expression
+        const exprResult = await this.evaluate(expr, input, context);
+
+        // Now apply the is operator with the full type name
+        const evaluator = this.operationEvaluators.get('is');
+        if (evaluator) {
+          return await evaluator(input, context, exprResult.value, [typeName]);
+        }
+      }
+
       // Evaluate left with current input/context
       const leftResult = await this.evaluate(binary.left, input, context);
-      
+
       // Use left's output as right's input, and left's context flows to right
       return await this.evaluate(binary.right, leftResult.value, leftResult.context);
     }
@@ -447,7 +506,7 @@ export class Interpreter {
         this.evaluate(binary.left, input, context),
         this.evaluate(binary.right, input, context)
       ]);
-      
+
       // Merge the results
       const unionEvaluator = this.operationEvaluators.get('|');
       if (unionEvaluator) {
@@ -457,6 +516,32 @@ export class Interpreter {
       throw Errors.noEvaluatorFound('binary operator', '|');
     }
 
+    // Special handling for 'is' and 'as' operators - right side is a type identifier, not an expression
+    if (operator === 'is' || operator === 'as') {
+      const leftResult = await this.evaluate(binary.left, input, context);
+
+      // Extract type name from right side WITHOUT evaluating it
+      let typeName: string;
+      if (binary.right.type === NodeType.Identifier) {
+        typeName = (binary.right as any).name;
+      } else if (binary.right.type === NodeType.Binary && (binary.right as any).operator === '.') {
+        // Handle namespaced types like System.Boolean or FHIR.Patient
+        const rightBinary = binary.right as any;
+        if (rightBinary.left.type === NodeType.Identifier && rightBinary.right.type === NodeType.Identifier) {
+          typeName = `${rightBinary.left.name}.${rightBinary.right.name}`;
+        } else {
+          throw new Error('is operator requires a type name as right operand');
+        }
+      } else {
+        throw new Error('is operator requires a type name as right operand');
+      }
+
+      const evaluator = this.operationEvaluators.get('is');
+      if (evaluator) {
+        return await evaluator(input, context, leftResult.value, [typeName]);
+      }
+    }
+
     // Get operation evaluator
     const evaluator = this.operationEvaluators.get(operator);
     if (evaluator) {
@@ -541,7 +626,7 @@ export class Interpreter {
   private async evaluateUnary(node: ASTNode, input: FHIRPathValue[], context: RuntimeContext): Promise<EvaluationResult> {
     const unary = node as UnaryNode;
     const operator = unary.operator;
-    
+
     const operandResult = await this.evaluate(unary.operand, input, context);
 
     // Check for unary operation evaluators
@@ -566,7 +651,7 @@ export class Interpreter {
     const name = variable.name;
 
     const value = RuntimeContextManager.getVariable(context, name);
-    
+
     if (value !== undefined) {
       // Ensure value is always an array
       const arrayValue = Array.isArray(value) ? value : [value];
@@ -599,7 +684,7 @@ export class Interpreter {
 
     // Get the function definition to check if it propagates empty
     const functionDef = this.registry.getFunction(funcName);
-    
+
     // Check if function is registered with an evaluator
     const functionEvaluator = this.functionEvaluators.get(funcName);
     if (!functionEvaluator) {
@@ -702,13 +787,13 @@ export class Interpreter {
   private async evaluateMembershipTest(node: ASTNode, input: FHIRPathValue[], context: RuntimeContext): Promise<EvaluationResult> {
     const test = node as MembershipTestNode;
     const exprResult = await this.evaluate(test.expression, input, context);
-    
+
     // Use the is-operator implementation for consistency
     const isOperator = this.operationEvaluators.get('is');
     if (isOperator) {
       return isOperator(input, context, exprResult.value, [test.targetType]);
     }
-    
+
     // Fallback - shouldn't reach here normally
     return { value: [], context };
   }
@@ -717,17 +802,17 @@ export class Interpreter {
   private async evaluateTypeCast(node: ASTNode, input: FHIRPathValue[], context: RuntimeContext): Promise<EvaluationResult> {
     const cast = node as TypeCastNode;
     const exprResult = await this.evaluate(cast.expression, input, context);
-    
+
     // Use the as-operator implementation for consistency
     const asOperator = this.operationEvaluators.get('as');
     if (asOperator) {
       return asOperator(input, context, exprResult.value, [cast.targetType]);
     }
-    
+
     // Fallback implementation (shouldn't normally reach here)
     return { value: [], context };
   }
-  
+
   private async evaluateQuantity(node: ASTNode, input: FHIRPathValue[], context: RuntimeContext): Promise<EvaluationResult> {
     const quantity = node as QuantityNode;
     const quantityValue = createQuantity(quantity.value, quantity.unit);

package/src/lexer.ts

@@ -674,10 +674,13 @@ export class Lexer {
       if (this.current() === '*' && this.peek() === '/') {
         this.advance(); // Skip *
         this.advance(); // Skip /
-        break;
+        return;
       }
       this.advance();
     }
+    
+    // If we reached the end without finding */, it's an error
+    throw this.error('Unclosed multi-line comment');
   }
   
   private advance(): void {

package/src/model-provider.browser.ts

@@ -0,0 +1,35 @@
+export * from './model-provider.common'
+import { FHIRModelProviderBase, type Resource } from './model-provider.common';
+
+export type Resolver = (canonicalUrl: string) => Promise<Resource | null>;
+export type Searcher = (kind: 'primitive-type' | 'complex-type' | 'resource') => Promise<Resource[]>
+
+export type Options = {
+  resolve: Resolver,
+  search: Searcher
+}
+
+export class FHIRModelProvider extends FHIRModelProviderBase {
+  private _resolve: Resolver;
+  private _search: Searcher;
+
+
+  override async resolve(canonicalUrl: string): Promise<Resource | null> {
+    return await this._resolve(canonicalUrl);
+  }
+
+  override async search(params: { kind: 'primitive-type' | 'complex-type' | 'resource' }): Promise<Resource[]> {
+    return await this._search(params.kind);
+  }
+
+  reconfigure(options: Options) {
+    this._resolve = options.resolve;
+    this._search = options.search;
+  }
+
+  constructor(options: Options) {
+    super();
+    this._resolve = options.resolve;
+    this._search = options.search;
+  }
+}