fhirpath-ts 0.0.0-bootstrap.0

package/src/functions/existence.ts

@@ -0,0 +1,107 @@
+import { pairEquals } from '../engine/operators/equality.ts'
+import { FhirPathTypeError } from '../errors.ts'
+import { booleanSingleton, wrapBoolean } from '../values/collection.ts'
+import { SYSTEM_BOOLEAN, SYSTEM_INTEGER, systemTypeOf, type TypedValue } from '../values/typed-value.ts'
+import { perItem } from './iteration.ts'
+import { argAt, registerFunction } from './registry.ts'
+
+registerFunction('empty', {
+  minArity: 0,
+  maxArity: 0,
+  evaluate: (_context, input) => wrapBoolean(input.length === 0),
+})
+
+registerFunction('exists', {
+  minArity: 0,
+  maxArity: 1,
+  evaluate: (context, input, args, evaluateNode) => {
+    if (args.length === 0) {
+      return wrapBoolean(input.length > 0)
+    }
+    let found = false
+    perItem(context, input, argAt(args, 0), evaluateNode, (_item, result) => {
+      found = found || booleanSingleton(result) === true
+    })
+    return wrapBoolean(found)
+  },
+})
+
+registerFunction('all', {
+  minArity: 1,
+  maxArity: 1,
+  evaluate: (context, input, args, evaluateNode) => {
+    let all = true
+    perItem(context, input, argAt(args, 0), evaluateNode, (_item, result) => {
+      all = all && booleanSingleton(result) === true
+    })
+    return wrapBoolean(all)
+  },
+})
+
+function booleanAggregate(name: string, fold: (values: boolean[]) => boolean) {
+  registerFunction(name, {
+    minArity: 0,
+    maxArity: 0,
+    evaluate: (_context, input) => {
+      const values = input.map(item => {
+        if (systemTypeOf(item) !== SYSTEM_BOOLEAN) {
+          throw new FhirPathTypeError(`${name}() expects a collection of booleans, found ${item.type}`)
+        }
+        return item.value as boolean
+      })
+      return wrapBoolean(fold(values))
+    },
+  })
+}
+
+booleanAggregate('allTrue', values => values.every(value => value))
+booleanAggregate('anyTrue', values => values.some(value => value))
+booleanAggregate('allFalse', values => values.every(value => !value))
+booleanAggregate('anyFalse', values => values.some(value => !value))
+
+registerFunction('count', {
+  minArity: 0,
+  maxArity: 0,
+  evaluate: (_context, input) => [{ type: SYSTEM_INTEGER, value: input.length }],
+})
+
+/** Duplicate elimination with `=` semantics; shared with the `|` operator and isDistinct(). */
+export function distinctItems(input: TypedValue[]): TypedValue[] {
+  const result: TypedValue[] = []
+  for (const item of input) {
+    if (!result.some(existing => pairEquals(existing, item) === true)) {
+      result.push(item)
+    }
+  }
+  return result
+}
+
+registerFunction('distinct', {
+  minArity: 0,
+  maxArity: 0,
+  evaluate: (_context, input) => distinctItems(input),
+})
+
+registerFunction('isDistinct', {
+  minArity: 0,
+  maxArity: 0,
+  evaluate: (_context, input) => wrapBoolean(distinctItems(input).length === input.length),
+})
+
+registerFunction('subsetOf', {
+  minArity: 1,
+  maxArity: 1,
+  evaluate: (context, input, args, evaluateNode) => {
+    const other = evaluateNode(argAt(args, 0), context, input)
+    return wrapBoolean(input.every(item => other.some(candidate => pairEquals(item, candidate) === true)))
+  },
+})
+
+registerFunction('supersetOf', {
+  minArity: 1,
+  maxArity: 1,
+  evaluate: (context, input, args, evaluateNode) => {
+    const other = evaluateNode(argAt(args, 0), context, input)
+    return wrapBoolean(other.every(item => input.some(candidate => pairEquals(item, candidate) === true)))
+  },
+})

package/src/functions/fhir.ts

@@ -0,0 +1,247 @@
+import { FhirPathRuntimeError, FhirPathTypeError } from '../errors.ts'
+import { validateNarrative } from '../fhir/html-checks.ts'
+import { singleton, wrapBoolean } from '../values/collection.ts'
+import { calendarToUcumLoose, compareQuantities, promoteQuantity } from '../values/quantity.ts'
+import { SYSTEM_QUANTITY, SYSTEM_STRING, systemTypeOf, toTypedValue, type TypedValue } from '../values/typed-value.ts'
+import { argAt, registerFunction } from './registry.ts'
+
+/** extension(url): extensions of each item, including primitive `_field` extensions. */
+registerFunction('extension', {
+  minArity: 1,
+  maxArity: 1,
+  evaluate: (context, input, args, evaluateNode) => {
+    const urlValue = singleton(evaluateNode(argAt(args, 0), context, input))
+    if (urlValue === undefined) {
+      return []
+    }
+    if (systemTypeOf(urlValue) !== SYSTEM_STRING) {
+      throw new FhirPathTypeError('extension() expects a String url argument')
+    }
+    const url = urlValue.value as string
+    const result: TypedValue[] = []
+    for (const item of input) {
+      for (const extension of extensionsOf(item)) {
+        if ((extension as { url?: unknown }).url === url) {
+          result.push({ type: 'FHIR.Extension', value: extension })
+        }
+      }
+    }
+    return result
+  },
+})
+
+function extensionsOf(item: TypedValue): unknown[] {
+  const containers: unknown[] = [item.value, item.primitiveElement]
+  const result: unknown[] = []
+  for (const container of containers) {
+    if (typeof container === 'object' && container !== null) {
+      const extensions = (container as { extension?: unknown }).extension
+      if (Array.isArray(extensions)) {
+        result.push(...extensions)
+      }
+    }
+  }
+  return result
+}
+
+/**
+ * True when the input holds a single primitive with an actual value; a multi-item
+ * input is "not a single value" (FHIR spec wording), so false — not an error.
+ */
+registerFunction('hasValue', {
+  minArity: 0,
+  maxArity: 0,
+  evaluate: (_context, input) => {
+    if (input.length === 0) {
+      return []
+    }
+    if (input.length > 1) {
+      return wrapBoolean(false)
+    }
+    const item = input[0] as TypedValue
+    return wrapBoolean(
+      systemTypeOf(item) !== undefined &&
+        item.type !== SYSTEM_QUANTITY &&
+        item.value !== undefined &&
+        item.value !== null
+    )
+  },
+})
+
+registerFunction('getValue', {
+  minArity: 0,
+  maxArity: 0,
+  evaluate: (_context, input) => {
+    if (input.length !== 1) {
+      return []
+    }
+    const item = input[0] as TypedValue
+    if (systemTypeOf(item) === undefined || item.value === undefined) {
+      return []
+    }
+    return [{ type: systemTypeOf(item) as string, value: item.value }]
+  },
+})
+
+/**
+ * Resolves contained references and Bundle entries against the evaluation root.
+ * External references return empty. A contained reference inside a Bundle entry
+ * also returns empty because resolution does not change root for each entry.
+ */
+registerFunction('resolve', {
+  minArity: 0,
+  maxArity: 0,
+  evaluate: (context, input) => {
+    const result: TypedValue[] = []
+    const scope = context.root[0]?.value as ResolveScope | undefined
+    for (const item of input) {
+      const reference = referenceStringOf(item)
+      if (reference === undefined) {
+        continue
+      }
+      const resolved = resolveReference(reference, scope)
+      if (resolved !== undefined) {
+        result.push(toTypedValue(resolved))
+      }
+    }
+    return result
+  },
+})
+
+function referenceStringOf(item: TypedValue): string | undefined {
+  if (typeof item.value === 'string') {
+    return item.value
+  }
+  if (typeof item.value === 'object' && item.value !== null) {
+    const reference = (item.value as { reference?: unknown }).reference
+    return typeof reference === 'string' ? reference : undefined
+  }
+  return undefined
+}
+
+interface BundleEntry {
+  fullUrl?: unknown
+  resource?: { resourceType?: unknown; id?: unknown }
+}
+
+interface ResolveScope {
+  resourceType?: unknown
+  contained?: unknown
+  entry?: unknown
+}
+
+function resolveReference(reference: string, scope: ResolveScope | undefined): unknown {
+  if (!scope) {
+    return undefined
+  }
+  if (reference.startsWith('#')) {
+    const id = reference.slice(1)
+    if (id === '') {
+      return scope
+    }
+    if (Array.isArray(scope.contained)) {
+      return scope.contained.find(resource => (resource as { id?: unknown } | null)?.id === id)
+    }
+    return undefined
+  }
+  if (scope.resourceType === 'Bundle' && Array.isArray(scope.entry)) {
+    const isAbsolute = reference.includes('://') || reference.startsWith('urn:')
+    for (const entry of scope.entry) {
+      if (!isObject(entry)) {
+        continue
+      }
+      const { fullUrl, resource } = entry as BundleEntry
+      // Absolute references match a fullUrl exactly. Relative references
+      // (Type/id) match a resource's own type/id — a fullUrl suffix match alone
+      // would wrongly resolve Patient/123 against a different base whose resource
+      // id is not 123, so the resource must confirm the type/id.
+      if (isAbsolute && fullUrl === reference) {
+        return resource
+      }
+      if (resource && `${String(resource.resourceType)}/${String(resource.id)}` === reference) {
+        return resource
+      }
+    }
+  }
+  return undefined
+}
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null
+}
+
+/** Validate narrative xhtml against the FHIR rules (real implementation, not a stub). */
+registerFunction('htmlChecks', {
+  minArity: 0,
+  maxArity: 0,
+  evaluate: (_context, input) => {
+    const item = singleton(input)
+    if (item === undefined) {
+      return []
+    }
+    return wrapBoolean(typeof item.value === 'string' && validateNarrative(item.value))
+  },
+})
+
+/** Quantities are comparable when their units share a dimension (FHIR R5 addition). */
+registerFunction('comparable', {
+  minArity: 1,
+  maxArity: 1,
+  evaluate: (context, input, args, evaluateNode) => {
+    const left = singleton(input)
+    const right = singleton(evaluateNode(argAt(args, 0), context, input))
+    if (left === undefined || right === undefined) {
+      return []
+    }
+    const a = promoteQuantity(left)
+    const b = promoteQuantity(right)
+    if (!(a && b)) {
+      throw new FhirPathTypeError('comparable() expects Quantity operands')
+    }
+    // Dimensions decide comparability, so calendar durations count as their
+    // loose UCUM twins: 1 year.comparable(1 second) is true.
+    return wrapBoolean(compareQuantities(calendarToUcumLoose(a), calendarToUcumLoose(b)) !== undefined)
+  },
+})
+
+/**
+ * Base-StructureDefinition conformance only: the url must name a core resource type.
+ * Real profile validation is a deferred feature (README register).
+ */
+registerFunction('conformsTo', {
+  minArity: 1,
+  maxArity: 1,
+  evaluate: (context, input, args, evaluateNode) => {
+    const item = singleton(input)
+    if (item === undefined) {
+      return []
+    }
+    const urlValue = singleton(evaluateNode(argAt(args, 0), context, input))
+    const url = typeof urlValue?.value === 'string' ? urlValue.value : ''
+    const match = /^http:\/\/hl7\.org\/fhir\/StructureDefinition\/([A-Za-z]+)$/.exec(url)
+    if (!match) {
+      throw new FhirPathRuntimeError(`conformsTo() only supports base StructureDefinition urls, got '${url}'`)
+    }
+    const resourceType = (item.value as { resourceType?: unknown } | undefined)?.resourceType
+    return wrapBoolean(resourceType === match[1])
+  },
+})
+
+/** Deferred features (see the README register): registered so they fail with a clear message. */
+function unsupported(name: string, minArity: number, maxArity: number, reason: string): void {
+  registerFunction(name, {
+    minArity,
+    maxArity,
+    evaluate: () => {
+      throw new FhirPathRuntimeError(`${name}() is not supported in v1: ${reason}`)
+    },
+  })
+}
+
+unsupported('memberOf', 1, 1, 'terminology functions need a terminology service')
+unsupported('subsumes', 1, 1, 'terminology functions need a terminology service')
+unsupported('subsumedBy', 1, 1, 'terminology functions need a terminology service')
+unsupported('slice', 2, 2, 'profile slicing needs profile definitions')
+unsupported('elementDefinition', 0, 0, 'element definitions need profile definitions')
+unsupported('checkModifiers', 0, 1, 'modifier checking needs profile definitions')
+unsupported('weight', 0, 0, 'item weights need code-system lookups')

package/src/functions/filtering.ts

@@ -0,0 +1,120 @@
+import { pairEquals } from '../engine/operators/equality.ts'
+import { isKnownTypeName, itemMatchesType } from '../engine/type-matching.ts'
+import { FhirPathRuntimeError } from '../errors.ts'
+import { booleanSingleton, singleton, wrapBoolean } from '../values/collection.ts'
+import type { TypedValue } from '../values/typed-value.ts'
+import { perItem } from './iteration.ts'
+import { argAt, registerFunction } from './registry.ts'
+import { typePartsFromArgument } from './type-specifier.ts'
+
+registerFunction('where', {
+  minArity: 1,
+  maxArity: 1,
+  evaluate: (context, input, args, evaluateNode) => {
+    const result: TypedValue[] = []
+    perItem(context, input, argAt(args, 0), evaluateNode, (item, criteria) => {
+      if (booleanSingleton(criteria) === true) {
+        result.push(item)
+      }
+    })
+    return result
+  },
+})
+
+registerFunction('select', {
+  minArity: 1,
+  maxArity: 1,
+  evaluate: (context, input, args, evaluateNode) => {
+    const result: TypedValue[] = []
+    perItem(context, input, argAt(args, 0), evaluateNode, (_item, projected) => {
+      result.push(...projected)
+    })
+    return result
+  },
+})
+
+registerFunction('repeat', {
+  minArity: 1,
+  maxArity: 1,
+  evaluate: (context, input, args, evaluateNode) => {
+    const expression = argAt(args, 0)
+    const collected: TypedValue[] = []
+    let current = input
+    while (current.length > 0) {
+      const produced: TypedValue[] = []
+      perItem(context, current, expression, evaluateNode, (_item, projected) => {
+        produced.push(...projected)
+      })
+      // Only never-seen items continue the loop (including duplicates produced in
+      // the same round), so cyclic data terminates and results stay distinct.
+      const fresh: typeof produced = []
+      for (const item of produced) {
+        if (!collected.some(existing => existing.value === item.value || pairEquals(existing, item) === true)) {
+          collected.push(item)
+          fresh.push(item)
+        }
+      }
+      current = fresh
+    }
+    return collected
+  },
+})
+
+/** coalesce(...) — ballot STU: the first argument that evaluates non-empty. */
+registerFunction('coalesce', {
+  minArity: 0,
+  maxArity: 99,
+  evaluate: (context, input, args, evaluateNode) => {
+    for (const arg of args) {
+      const value = evaluateNode(arg, context, input)
+      if (value.length > 0) {
+        return value
+      }
+    }
+    return []
+  },
+})
+
+registerFunction('ofType', {
+  minArity: 1,
+  maxArity: 1,
+  evaluate: (context, input, args) => {
+    const parts = typePartsFromArgument('ofType', argAt(args, 0))
+    requireKnownType(context, 'ofType', parts)
+    return input.filter(item => itemMatchesType(context, item, parts, { exact: true }))
+  },
+})
+
+function requireKnownType(context: Parameters<typeof isKnownTypeName>[0], name: string, parts: string[]): void {
+  // Without a model there is no authority on type names; stay lenient.
+  if (context.model && !isKnownTypeName(context, parts)) {
+    throw new FhirPathRuntimeError(`${name}() received an unknown type name '${parts.join('.')}'`)
+  }
+}
+
+// Deprecated function forms of the `is` and `as` operators (spec §6.3).
+registerFunction('is', {
+  minArity: 1,
+  maxArity: 1,
+  evaluate: (context, input, args) => {
+    const item = singleton(input)
+    if (item === undefined) {
+      return []
+    }
+    return wrapBoolean(itemMatchesType(context, item, typePartsFromArgument('is', argAt(args, 0))))
+  },
+})
+
+registerFunction('as', {
+  minArity: 1,
+  maxArity: 1,
+  evaluate: (context, input, args) => {
+    const parts = typePartsFromArgument('as', argAt(args, 0))
+    requireKnownType(context, 'as', parts)
+    const item = singleton(input)
+    if (item === undefined) {
+      return []
+    }
+    return itemMatchesType(context, item, parts, { exact: true }) ? [item] : []
+  },
+})

package/src/functions/install.ts

@@ -0,0 +1,19 @@
+// Importing this module registers the function library into the registry table.
+// The evaluator imports it for its side effects; later phases append more modules.
+import './aggregate.ts'
+import './boundary.ts'
+import './combining.ts'
+import './conversion.ts'
+import './date-components.ts'
+import './control.ts'
+import './existence.ts'
+import './fhir.ts'
+import './filtering.ts'
+import './math.ts'
+import './reflection.ts'
+import './sort.ts'
+import './string.ts'
+import './subsetting.ts'
+import './tree.ts'
+import './variables.ts'
+import './utility.ts'

package/src/functions/iteration.ts

@@ -0,0 +1,21 @@
+import { type EvaluationContext, withFrame } from '../engine/context.ts'
+import type { AstNode } from '../parser/ast.ts'
+import type { TypedValue } from '../values/typed-value.ts'
+
+export type NodeEvaluator = (node: AstNode, context: EvaluationContext, input: TypedValue[]) => TypedValue[]
+
+/** Evaluate `expression` once per item with `$this` and `$index` bound. */
+export function perItem(
+  context: EvaluationContext,
+  input: TypedValue[],
+  expression: AstNode,
+  evaluateNode: NodeEvaluator,
+  each: (item: TypedValue, result: TypedValue[], index: number) => void
+): void {
+  input.forEach((item, index) => {
+    const result = withFrame(context, { thisValue: [item], index }, frameContext =>
+      evaluateNode(expression, frameContext, [item])
+    )
+    each(item, result, index)
+  })
+}

package/src/functions/math.ts

@@ -0,0 +1,167 @@
+import { FhirPathTypeError } from '../errors.ts'
+import { singleton } from '../values/collection.ts'
+import { Decimal } from '../values/decimal.ts'
+import { asNumeric, wrapNumeric } from '../values/numeric.ts'
+import {
+  type QuantityValue,
+  SYSTEM_DECIMAL,
+  SYSTEM_INTEGER,
+  SYSTEM_QUANTITY,
+  type TypedValue,
+} from '../values/typed-value.ts'
+import { argAt, registerFunction } from './registry.ts'
+
+function numericInput(name: string, input: TypedValue[]): { item: TypedValue; value: Decimal } | undefined {
+  const item = singleton(input)
+  if (item === undefined) {
+    return undefined
+  }
+  const numeric = asNumeric(item)
+  if (!numeric) {
+    throw new FhirPathTypeError(`${name}() is not defined for ${item.type}`)
+  }
+  return { item, value: numeric.value }
+}
+
+registerFunction('abs', {
+  minArity: 0,
+  maxArity: 0,
+  evaluate: (_context, input) => {
+    const item = singleton(input)
+    if (item === undefined) {
+      return []
+    }
+    if (item.type === SYSTEM_QUANTITY) {
+      const quantity = item.value as QuantityValue
+      return [{ type: SYSTEM_QUANTITY, value: { ...quantity, value: quantity.value.abs() } }]
+    }
+    const numeric = asNumeric(item)
+    if (!numeric) {
+      throw new FhirPathTypeError(`abs() is not defined for ${item.type}`)
+    }
+    return [wrapNumeric(numeric.value.abs(), numeric.kind)]
+  },
+})
+
+registerFunction('ceiling', {
+  minArity: 0,
+  maxArity: 0,
+  evaluate: (_context, input) => {
+    const numeric = numericInput('ceiling', input)
+    if (!numeric) {
+      return []
+    }
+    return [wrapNumeric(numeric.value.ceiling(), 'Integer')]
+  },
+})
+
+registerFunction('floor', {
+  minArity: 0,
+  maxArity: 0,
+  evaluate: (_context, input) => {
+    const numeric = numericInput('floor', input)
+    if (!numeric) {
+      return []
+    }
+    return [wrapNumeric(numeric.value.floor(), 'Integer')]
+  },
+})
+
+registerFunction('truncate', {
+  minArity: 0,
+  maxArity: 0,
+  evaluate: (_context, input) => {
+    const numeric = numericInput('truncate', input)
+    if (!numeric) {
+      return []
+    }
+    return [wrapNumeric(numeric.value.truncate(), 'Integer')]
+  },
+})
+
+registerFunction('round', {
+  minArity: 0,
+  maxArity: 1,
+  evaluate: (context, input, args, evaluateNode) => {
+    const numeric = numericInput('round', input)
+    if (!numeric) {
+      return []
+    }
+    let precision = 0
+    if (args.length === 1) {
+      const argument = singleton(evaluateNode(argAt(args, 0), context, input), SYSTEM_INTEGER)
+      if (argument === undefined || typeof argument.value !== 'number' || argument.value < 0) {
+        throw new FhirPathTypeError('round() expects a non-negative integer precision')
+      }
+      precision = argument.value
+    }
+    return [{ type: SYSTEM_DECIMAL, value: numeric.value.round(precision) }]
+  },
+})
+
+/** Number-backed transcendental; empty when the JS result is not finite (domain errors). */
+function transcendental(name: string, compute: (value: number) => number): void {
+  registerFunction(name, {
+    minArity: 0,
+    maxArity: 0,
+    evaluate: (_context, input) => {
+      const numeric = numericInput(name, input)
+      if (!numeric) {
+        return []
+      }
+      const result = compute(numeric.value.toNumber())
+      const decimal = Decimal.fromNumber(result)
+      return decimal === undefined ? [] : [{ type: SYSTEM_DECIMAL, value: decimal }]
+    },
+  })
+}
+
+transcendental('exp', Math.exp)
+transcendental('ln', Math.log)
+transcendental('sqrt', Math.sqrt)
+
+registerFunction('log', {
+  minArity: 1,
+  maxArity: 1,
+  evaluate: (context, input, args, evaluateNode) => {
+    const numeric = numericInput('log', input)
+    if (!numeric) {
+      return []
+    }
+    const baseInput = singleton(evaluateNode(argAt(args, 0), context, input))
+    const base = baseInput === undefined ? undefined : asNumeric(baseInput)
+    if (!base) {
+      return []
+    }
+    const result = Math.log(numeric.value.toNumber()) / Math.log(base.value.toNumber())
+    const decimal = Decimal.fromNumber(result)
+    // NaN and infinities (log of a non-positive value, base 1) become empty.
+    return decimal === undefined ? [] : [{ type: SYSTEM_DECIMAL, value: decimal }]
+  },
+})
+
+registerFunction('power', {
+  minArity: 1,
+  maxArity: 1,
+  evaluate: (context, input, args, evaluateNode) => {
+    const numeric = numericInput('power', input)
+    if (!numeric) {
+      return []
+    }
+    const exponentInput = singleton(evaluateNode(argAt(args, 0), context, input))
+    const exponent = exponentInput === undefined ? undefined : asNumeric(exponentInput)
+    if (!exponent) {
+      return []
+    }
+    const result = numeric.value.toNumber() ** exponent.value.toNumber()
+    const decimal = Decimal.fromNumber(result)
+    if (decimal === undefined) {
+      return []
+    }
+    // Integer ^ Integer stays an Integer when the result is whole (spec §5.7.7).
+    if (numeric.item.type === SYSTEM_INTEGER && exponentInput?.type === SYSTEM_INTEGER && decimal.isInteger()) {
+      return [wrapNumeric(decimal, 'Integer')]
+    }
+    return [{ type: SYSTEM_DECIMAL, value: decimal }]
+  },
+})