fhir-runtime 0.2.0

package/dist/lib/validator/slicing-validator.d.ts

@@ -0,0 +1,119 @@
+/**
+ * fhir-validator — Slicing Validation
+ *
+ * Implements slicing validation logic for FHIR array elements:
+ * - {@link validateSlicing} — orchestrates slice matching, cardinality, rules, and ordering
+ * - {@link findMatchingSlice} — matches a value to a named slice via discriminators
+ * - {@link matchesDiscriminator} — checks a single discriminator against a value
+ * - {@link isSliceOrderValid} — validates ordered slicing constraints
+ * - {@link extractValueAtPath} — extracts a nested value from an object using a dot path
+ * - {@link getSliceDiscriminatorValue} — retrieves the expected discriminator value from a slice element
+ *
+ * @module fhir-validator
+ */
+import type { CanonicalElement, SlicingDiscriminatorDef } from '../model/canonical-profile.js';
+import type { ValidationIssue } from './types.js';
+/**
+ * Extract a value from an object using a simple dot-separated path.
+ *
+ * This is a lightweight path extractor for discriminator evaluation.
+ * Unlike the full `extractValues` in path-extractor.ts, this operates
+ * on plain objects (not full FHIR resources) and returns a single value.
+ *
+ * Handles:
+ * - Simple dot paths: `"system"`, `"coding.system"`
+ * - `$this` (returns the value itself)
+ * - `resolve()` is ignored (returns the value at the preceding path)
+ *
+ * @param value - The object to extract from.
+ * @param path - Dot-separated path (e.g., `"coding.system"`).
+ * @returns The extracted value, or `undefined` if not found.
+ */
+export declare function extractValueAtPath(value: unknown, path: string): unknown;
+/**
+ * Get the expected discriminator value from a slice element definition.
+ *
+ * For a "value" discriminator, the expected value comes from the slice's
+ * `fixed` or `pattern` constraint. The discriminator path is used to
+ * navigate into the fixed/pattern value if it's a complex object.
+ *
+ * @param slice - The slice element definition.
+ * @param discriminatorPath - The discriminator path (e.g., `"system"`).
+ * @returns The expected value for this discriminator, or `undefined`.
+ */
+export declare function getSliceDiscriminatorValue(slice: CanonicalElement, discriminatorPath: string): unknown;
+/**
+ * Get the expected type codes from a slice element definition.
+ *
+ * For a "type" discriminator, the expected types come from the slice's
+ * `types` array.
+ *
+ * @param slice - The slice element definition.
+ * @param _discriminatorPath - The discriminator path (currently unused).
+ * @returns Array of expected type code strings.
+ */
+export declare function getSliceTypes(slice: CanonicalElement, _discriminatorPath: string): string[];
+/**
+ * Check if a value matches a single discriminator for a slice.
+ *
+ * Supports 4 discriminator types:
+ * - `value`: The value at the discriminator path must deeply equal the
+ *   slice's fixed/pattern value at the same path.
+ * - `pattern`: The value at the discriminator path must match the
+ *   slice's pattern (partial/subset match).
+ * - `type`: The inferred FHIR type of the value at the discriminator
+ *   path must match one of the slice's allowed types.
+ * - `exists`: The discriminator path must exist (have a non-undefined value)
+ *   in the value.
+ * - `profile`: Always returns `true` (placeholder — full profile conformance
+ *   checking requires context resolution not available here).
+ *
+ * @param value - The actual value to check.
+ * @param slice - The slice element definition.
+ * @param discriminator - The discriminator definition.
+ * @returns `true` if the value matches this discriminator.
+ */
+export declare function matchesDiscriminator(value: unknown, slice: CanonicalElement, discriminator: SlicingDiscriminatorDef): boolean;
+/**
+ * Find which named slice a value matches based on discriminators.
+ *
+ * Iterates through the slice elements and checks each discriminator.
+ * A value matches a slice if ALL discriminators match.
+ *
+ * @param value - The actual value to match.
+ * @param slices - Array of slice element definitions (must have `sliceName`).
+ * @param discriminators - The discriminator definitions from the slicing root.
+ * @returns The matching slice element, or `undefined` if no match.
+ */
+export declare function findMatchingSlice(value: unknown, slices: CanonicalElement[], discriminators: SlicingDiscriminatorDef[]): CanonicalElement | undefined;
+/**
+ * Check if values appear in the correct order according to slice definitions.
+ *
+ * For ordered slicing, values must appear in the same order as the slice
+ * definitions. Values matching slice A must all appear before values
+ * matching slice B if slice A is defined before slice B.
+ *
+ * @param values - The actual values in the array.
+ * @param slices - The slice element definitions (in definition order).
+ * @param discriminators - The discriminator definitions.
+ * @returns `true` if the values are in valid order.
+ */
+export declare function isSliceOrderValid(values: unknown[], slices: CanonicalElement[], discriminators: SlicingDiscriminatorDef[]): boolean;
+/**
+ * Validate slicing constraints for an array element.
+ *
+ * Performs the following checks:
+ * 1. **Slice matching** — each value is matched to a named slice via discriminators.
+ * 2. **Slice cardinality** — each slice's min/max is checked against matched values.
+ * 3. **Slicing rules** — for `closed` slicing, unmatched values produce errors.
+ *    For `openAtEnd`, unmatched values must appear after all matched values.
+ * 4. **Ordering** — for `ordered` slicing, matched values must appear in
+ *    slice definition order.
+ *
+ * @param slicingRoot - The element with the slicing definition.
+ * @param sliceElements - The named slice element definitions.
+ * @param values - The actual values in the array.
+ * @param issues - Mutable array to push validation issues into.
+ */
+export declare function validateSlicing(slicingRoot: CanonicalElement, sliceElements: CanonicalElement[], values: unknown[], issues: ValidationIssue[]): void;
+//# sourceMappingURL=slicing-validator.d.ts.map

package/dist/lib/validator/slicing-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slicing-validator.d.ts","sourceRoot":"","sources":["../../../src/validator/slicing-validator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAC/F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAQlD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAwCxE;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,gBAAgB,EACvB,iBAAiB,EAAE,MAAM,GACxB,OAAO,CAkBT;AAMD;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,gBAAgB,EACvB,kBAAkB,EAAE,MAAM,GACzB,MAAM,EAAE,CAEV;AAMD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,gBAAgB,EACvB,aAAa,EAAE,uBAAuB,GACrC,OAAO,CAgDT;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,gBAAgB,EAAE,EAC1B,cAAc,EAAE,uBAAuB,EAAE,GACxC,gBAAgB,GAAG,SAAS,CAgB9B;AAMD;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,OAAO,EAAE,EACjB,MAAM,EAAE,gBAAgB,EAAE,EAC1B,cAAc,EAAE,uBAAuB,EAAE,GACxC,OAAO,CA4BT;AAMD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC7B,WAAW,EAAE,gBAAgB,EAC7B,aAAa,EAAE,gBAAgB,EAAE,EACjC,MAAM,EAAE,OAAO,EAAE,EACjB,MAAM,EAAE,eAAe,EAAE,GACxB,IAAI,CAsFN"}

package/dist/lib/validator/structure-validator.d.ts

@@ -0,0 +1,74 @@
+/**
+ * fhir-validator — Structure Validator (Orchestrator)
+ *
+ * Main validator class that coordinates all validation rules to validate
+ * a FHIR resource instance against a {@link CanonicalProfile}.
+ *
+ * Integrates:
+ * - Path extraction ({@link extractValues})
+ * - Cardinality validation ({@link validateCardinality})
+ * - Type validation ({@link validateType})
+ * - Fixed/pattern validation ({@link validateFixed}, {@link validatePattern})
+ * - Reference validation ({@link validateReference})
+ * - Slicing validation ({@link validateSlicing})
+ *
+ * Exported:
+ * - {@link StructureValidator} — main validator class
+ *
+ * @module fhir-validator
+ */
+import type { CanonicalProfile, Resource } from '../model/index.js';
+import type { ValidationOptions, ValidationResult } from './types.js';
+/**
+ * Main validator class for structural validation of FHIR resources.
+ *
+ * Validates a resource instance against a {@link CanonicalProfile} by
+ * orchestrating all individual validation rules (cardinality, type,
+ * fixed/pattern, reference, slicing).
+ *
+ * @example
+ * ```typescript
+ * const validator = new StructureValidator();
+ *
+ * // Validate with an explicit profile
+ * const result = validator.validate(patient, patientProfile);
+ *
+ * if (!result.valid) {
+ *   for (const issue of result.issues) {
+ *     console.error(`${issue.severity}: ${issue.message}`);
+ *   }
+ * }
+ * ```
+ */
+export declare class StructureValidator {
+    private readonly options;
+    constructor(options?: ValidationOptions);
+    /**
+     * Validate a resource instance against a CanonicalProfile.
+     *
+     * @param resource - The FHIR resource to validate.
+     * @param profile - The CanonicalProfile to validate against.
+     * @param options - Optional per-call overrides for validation options.
+     * @returns The validation result with all issues.
+     * @throws {@link ProfileNotFoundError} if profile is undefined.
+     * @throws {@link ValidationFailedError} if failFast is enabled and an error is found.
+     */
+    validate(resource: Resource, profile: CanonicalProfile, options?: ValidationOptions): ValidationResult;
+    /**
+     * Check that the resource type matches the profile type.
+     */
+    private validateResourceType;
+    /**
+     * Validate all elements in the profile against the resource.
+     */
+    private validateElements;
+    /**
+     * Get all named slice elements for a slicing root path.
+     */
+    private getSliceElements;
+    /**
+     * Check if failFast is enabled and there are errors; if so, throw.
+     */
+    private checkFailFast;
+}
+//# sourceMappingURL=structure-validator.d.ts.map

package/dist/lib/validator/structure-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structure-validator.d.ts","sourceRoot":"","sources":["../../../src/validator/structure-validator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAoB,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AACtF,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAmB,MAAM,YAAY,CAAC;AAkBvF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA8B;gBAE1C,OAAO,CAAC,EAAE,iBAAiB;IAQvC;;;;;;;;;OASG;IACH,QAAQ,CACN,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,gBAAgB,EACzB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,gBAAgB;IA8BnB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAqC5B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IA4ExB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAexB;;OAEG;IACH,OAAO,CAAC,aAAa;CAWtB"}

package/dist/lib/validator/types.d.ts

@@ -0,0 +1,288 @@
+/**
+ * fhir-validator — Public Interfaces & Types
+ *
+ * Defines the core abstractions for the FHIR validator module:
+ * - {@link ValidationOptions} — validation configuration
+ * - {@link ValidationResult} — validation output
+ * - {@link ValidationIssue} — issue reporting
+ * - {@link ValidationIssueCode} — machine-readable issue codes
+ * - {@link ValidationContext} — internal validation state
+ *
+ * This module implements structural validation of FHIR resource instances
+ * against profile snapshots generated by the fhir-profile module.
+ *
+ * @module fhir-validator
+ */
+import type { CanonicalProfile, Resource } from '../model/index.js';
+/**
+ * Configuration options for structural validation.
+ *
+ * @example
+ * ```typescript
+ * const options: ValidationOptions = {
+ *   profileUrl: 'http://hl7.org/fhir/StructureDefinition/Patient',
+ *   validateSlicing: true,
+ *   validateFixed: true,
+ *   failFast: false,
+ * };
+ * ```
+ */
+export interface ValidationOptions {
+    /**
+     * Profile URL to validate against.
+     *
+     * If not specified, the validator will attempt to extract the profile
+     * from `resource.meta.profile[0]`. If neither is available, the
+     * validator falls back to the base resource type
+     * (e.g., `http://hl7.org/fhir/StructureDefinition/{resourceType}`).
+     */
+    readonly profileUrl?: string;
+    /**
+     * Whether to validate slicing constraints.
+     *
+     * When `true` (default), the validator checks that array elements
+     * match their declared slices and that closed slicing rules are
+     * respected.
+     *
+     * @default true
+     */
+    readonly validateSlicing?: boolean;
+    /**
+     * Whether to validate fixed and pattern value constraints.
+     *
+     * When `true` (default), the validator checks that element values
+     * match any `fixed[x]` or `pattern[x]` constraints declared in
+     * the profile.
+     *
+     * @default true
+     */
+    readonly validateFixed?: boolean;
+    /**
+     * Maximum depth for nested validation.
+     *
+     * Prevents runaway recursion in deeply nested or pathological
+     * resource structures.
+     *
+     * @default 50
+     */
+    readonly maxDepth?: number;
+    /**
+     * Whether to stop on the first error or collect all issues.
+     *
+     * When `true`, the validator throws a {@link ValidationFailedError}
+     * on the first error-severity issue. When `false` (default), all
+     * issues are collected and returned in the result.
+     *
+     * @default false
+     */
+    readonly failFast?: boolean;
+    /**
+     * Whether to skip FHIRPath invariant validation.
+     *
+     * When `true`, constraint expressions from the profile are not
+     * evaluated. Useful for performance or when FHIRPath evaluation
+     * is not needed.
+     *
+     * @default false
+     */
+    readonly skipInvariants?: boolean;
+}
+/**
+ * Result of structural validation.
+ *
+ * Contains the overall validity status, the validated resource, and
+ * all issues encountered during validation.
+ *
+ * @example
+ * ```typescript
+ * const result = await validator.validate(patient);
+ * if (result.valid) {
+ *   console.log('Resource is valid');
+ * } else {
+ *   for (const issue of result.issues) {
+ *     console.error(`${issue.severity}: ${issue.message} (at ${issue.path})`);
+ *   }
+ * }
+ * ```
+ */
+export interface ValidationResult {
+    /**
+     * Whether the resource is valid.
+     *
+     * `true` when no error-severity issues were recorded.
+     * Warnings and informational issues do not affect this flag.
+     */
+    readonly valid: boolean;
+    /** The resource that was validated. */
+    readonly resource: Resource;
+    /** The profile that was validated against. */
+    readonly profileUrl: string;
+    /** The resolved CanonicalProfile used for validation. */
+    readonly profile: CanonicalProfile;
+    /** Issues encountered during validation (errors + warnings + info). */
+    readonly issues: readonly ValidationIssue[];
+}
+/**
+ * A single issue encountered during validation.
+ *
+ * Mirrors the concept of FHIR OperationOutcome.issue but scoped to
+ * structural validation. Issues are collected during validation and
+ * returned in {@link ValidationResult.issues}.
+ *
+ * @example
+ * ```typescript
+ * const issue: ValidationIssue = {
+ *   severity: 'error',
+ *   code: 'CARDINALITY_MIN_VIOLATION',
+ *   message: "Element 'Patient.name' requires at least 1 value(s), but found 0",
+ *   path: 'Patient.name',
+ *   expression: 'Patient.name',
+ * };
+ * ```
+ */
+export interface ValidationIssue {
+    /** Severity level of the issue. */
+    readonly severity: 'error' | 'warning' | 'information';
+    /** Machine-readable issue code. */
+    readonly code: ValidationIssueCode;
+    /** Human-readable description of the issue. */
+    readonly message: string;
+    /**
+     * Element path where the issue occurred (dot-notation).
+     *
+     * @example `'Patient.name'`, `'Observation.value[x]'`
+     */
+    readonly path?: string;
+    /**
+     * FHIRPath expression pointing to the problematic element.
+     *
+     * Typically identical to `path` for structural validation, but may
+     * differ for sliced elements or choice types.
+     *
+     * @example `'Patient.identifier.where(system="urn:oid:1.2.3")'`
+     */
+    readonly expression?: string;
+    /** Additional diagnostic information for debugging. */
+    readonly diagnostics?: string;
+}
+/**
+ * Machine-readable issue codes for structural validation.
+ *
+ * Each code corresponds to a specific category of validation failure.
+ * Codes are designed to be stable across versions for programmatic
+ * consumption.
+ */
+export type ValidationIssueCode = 
+/** Element has fewer values than the minimum cardinality. */
+'CARDINALITY_MIN_VIOLATION'
+/** Element has more values than the maximum cardinality. */
+ | 'CARDINALITY_MAX_VIOLATION'
+/** Value type does not match any of the allowed types. */
+ | 'TYPE_MISMATCH'
+/** Choice type field uses an unsupported type suffix. */
+ | 'INVALID_CHOICE_TYPE'
+/** A required element (min ≥ 1) is missing from the resource. */
+ | 'REQUIRED_ELEMENT_MISSING'
+/** Value does not match the fixed value constraint. */
+ | 'FIXED_VALUE_MISMATCH'
+/** Value does not match the pattern value constraint (partial match). */
+ | 'PATTERN_VALUE_MISMATCH'
+/** Value does not match any slice discriminator in a closed slicing. */
+ | 'SLICING_NO_MATCH'
+/** Slice cardinality violation (too few or too many values in a slice). */
+ | 'SLICING_CARDINALITY_VIOLATION'
+/** Ordered slicing constraint violated (values out of order). */
+ | 'SLICING_ORDER_VIOLATION'
+/** Reference target does not match any of the allowed target profiles. */
+ | 'REFERENCE_TARGET_MISMATCH'
+/** The specified profile could not be found or loaded. */
+ | 'PROFILE_NOT_FOUND'
+/** Resource type does not match the profile's type. */
+ | 'RESOURCE_TYPE_MISMATCH'
+/** Resource contains an element not defined in the profile. */
+ | 'UNKNOWN_ELEMENT'
+/** FHIRPath invariant evaluation is not yet supported (skipped). */
+ | 'INVARIANT_NOT_EVALUATED'
+/** FHIRPath invariant constraint evaluated to false. */
+ | 'INVARIANT_VIOLATION'
+/** FHIRPath invariant expression failed to evaluate (runtime error). */
+ | 'INVARIANT_EVALUATION_ERROR'
+/** Internal validator error (should not happen). */
+ | 'INTERNAL_ERROR';
+/**
+ * Internal state passed through the validation traversal.
+ *
+ * Tracks the current depth, accumulated issues, and options
+ * for the validation run.
+ *
+ * @internal Used by the StructureValidator and validation rules.
+ */
+export interface ValidationContext {
+    /** The CanonicalProfile being validated against. */
+    readonly profile: CanonicalProfile;
+    /** Mutable array of accumulated issues. */
+    readonly issues: ValidationIssue[];
+    /** Resolved validation options. */
+    readonly options: Required<ValidationOptions>;
+    /** Current traversal depth (for maxDepth enforcement). */
+    depth: number;
+}
+/**
+ * Create a {@link ValidationIssue} with the given parameters.
+ *
+ * Convenience factory to reduce boilerplate when recording issues.
+ *
+ * @param severity - Issue severity level.
+ * @param code - Machine-readable issue code.
+ * @param message - Human-readable description.
+ * @param options - Optional path, expression, and diagnostics.
+ * @returns A frozen ValidationIssue object.
+ */
+export declare function createValidationIssue(severity: ValidationIssue['severity'], code: ValidationIssueCode, message: string, options?: {
+    path?: string;
+    expression?: string;
+    diagnostics?: string;
+}): ValidationIssue;
+/**
+ * Create a {@link ValidationContext} with resolved defaults.
+ *
+ * @param profile - The CanonicalProfile to validate against.
+ * @param options - User-provided options (defaults applied for missing fields).
+ * @returns A new ValidationContext ready for traversal.
+ *
+ * @internal
+ */
+export declare function createValidationContext(profile: CanonicalProfile, options?: ValidationOptions): ValidationContext;
+/**
+ * Resolve default validation options.
+ *
+ * Fills in missing fields with sensible defaults.
+ *
+ * @param options - User-provided options (may be partial).
+ * @returns Fully resolved options with all fields populated.
+ */
+export declare function resolveValidationOptions(options?: ValidationOptions): Required<ValidationOptions>;
+/**
+ * Check whether a validation result has any error-severity issues.
+ *
+ * @param issues - The issues to check.
+ * @returns `true` if any issue has severity `'error'`.
+ */
+export declare function hasValidationErrors(issues: readonly ValidationIssue[]): boolean;
+/**
+ * Filter issues by severity.
+ *
+ * @param issues - The issues to filter.
+ * @param severity - The severity to filter by.
+ * @returns Issues matching the specified severity.
+ */
+export declare function filterIssuesBySeverity(issues: readonly ValidationIssue[], severity: ValidationIssue['severity']): ValidationIssue[];
+/**
+ * Filter issues by code.
+ *
+ * @param issues - The issues to filter.
+ * @param code - The issue code to filter by.
+ * @returns Issues matching the specified code.
+ */
+export declare function filterIssuesByCode(issues: readonly ValidationIssue[], code: ValidationIssueCode): ValidationIssue[];
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/validator/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/validator/types.ts"],"names":[],"mappings":"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"}