@peerbits/fhir-validator 1.0.0 → 1.1.0

package/dist/validate.js

@@ -0,0 +1,214 @@
+import { validatePatient } from "./base-definitions/patient.js";
+import { validateObservation } from "./base-definitions/observation.js";
+import { validateEncounter } from "./base-definitions/encounter.js";
+import { validateCondition } from "./base-definitions/condition.js";
+import { validateCoverage } from "./base-definitions/coverage.js";
+import { validateClaim } from "./base-definitions/claim.js";
+import { validateClaimResponse } from "./base-definitions/claim-response.js";
+import { validateBundle } from "./base-definitions/bundle.js";
+const BASE_VALIDATORS = {
+    Patient: validatePatient,
+    Observation: validateObservation,
+    Encounter: validateEncounter,
+    Condition: validateCondition,
+    Coverage: validateCoverage,
+    Claim: validateClaim,
+    ClaimResponse: validateClaimResponse,
+    Bundle: validateBundle,
+};
+/**
+ * Detects whether an object contains a circular reference.
+ */
+export function hasCircularReference(obj, seen = new WeakSet()) {
+    if (!obj || typeof obj !== "object")
+        return false;
+    if (seen.has(obj))
+        return true;
+    seen.add(obj);
+    for (const key of Object.keys(obj)) {
+        const val = obj[key];
+        if (val && typeof val === "object") {
+            if (hasCircularReference(val, seen))
+                return true;
+        }
+    }
+    seen.delete(obj);
+    return false;
+}
+/**
+ * Resolves a property path (e.g. "name", "category[0].coding[0].system") on an object.
+ */
+export function getNestedValue(obj, path) {
+    if (!obj || typeof obj !== "object")
+        return undefined;
+    // Normalize array access like a[0].b -> a.0.b
+    const normalizedPath = path.replace(/\[(\d+)\]/g, ".$1");
+    const parts = normalizedPath.split(".");
+    let current = obj;
+    for (const part of parts) {
+        if (current === undefined || current === null)
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+/**
+ * Validates profile constraints against a resource.
+ */
+export function validateProfileConstraints(resource, profile, rootPath) {
+    const issues = [];
+    if (profile.resourceType && profile.resourceType !== resource.resourceType) {
+        issues.push({
+            severity: "error",
+            path: `${rootPath}.resourceType`,
+            code: "profile-mismatch",
+            message: `Profile '${profile.name}' applies to '${profile.resourceType}', but resource is '${String(resource.resourceType)}'.`,
+        });
+        return issues;
+    }
+    // Check required elements
+    if (profile.requiredElements) {
+        for (const elem of profile.requiredElements) {
+            const val = getNestedValue(resource, elem);
+            if (val === undefined || val === null || val === "" || (Array.isArray(val) && val.length === 0)) {
+                issues.push({
+                    severity: "error",
+                    path: `${rootPath}.${elem}`,
+                    code: "profile-required-element",
+                    message: `Profile '${profile.name}' requires element '${elem}' to be present.`,
+                });
+            }
+        }
+    }
+    // Check cardinality overrides
+    if (profile.cardinalityOverrides) {
+        for (const [elem, card] of Object.entries(profile.cardinalityOverrides)) {
+            const val = getNestedValue(resource, elem);
+            if (card.min !== undefined && card.min > 0) {
+                if (val === undefined || val === null) {
+                    issues.push({
+                        severity: "error",
+                        path: `${rootPath}.${elem}`,
+                        code: "profile-cardinality",
+                        message: `Profile '${profile.name}' requires at least ${card.min} item(s) for '${elem}', but none found.`,
+                    });
+                }
+                else if (Array.isArray(val) && val.length < card.min) {
+                    issues.push({
+                        severity: "error",
+                        path: `${rootPath}.${elem}`,
+                        code: "profile-cardinality",
+                        message: `Profile '${profile.name}' requires at least ${card.min} item(s) for '${elem}', found ${val.length}.`,
+                    });
+                }
+            }
+            if (card.max !== undefined && Array.isArray(val) && val.length > card.max) {
+                issues.push({
+                    severity: "error",
+                    path: `${rootPath}.${elem}`,
+                    code: "profile-cardinality",
+                    message: `Profile '${profile.name}' allows at most ${card.max} item(s) for '${elem}', found ${val.length}.`,
+                });
+            }
+        }
+    }
+    // Check fixed values
+    if (profile.fixedValues) {
+        for (const [fixedPath, expectedValue] of Object.entries(profile.fixedValues)) {
+            const actualValue = getNestedValue(resource, fixedPath);
+            if (actualValue !== expectedValue) {
+                issues.push({
+                    severity: "error",
+                    path: `${rootPath}.${fixedPath}`,
+                    code: "profile-fixed-value",
+                    message: `Profile '${profile.name}' requires '${fixedPath}' to equal '${String(expectedValue)}', found '${String(actualValue)}'.`,
+                });
+            }
+        }
+    }
+    return issues;
+}
+/**
+ * Validates a FHIR R4 resource against base structural rules and optional profile constraints.
+ *
+ * @param resource The FHIR JSON object to validate.
+ * @param options Optional validation parameters (e.g. custom or illustrative profile).
+ * @returns ValidationResult containing `valid` boolean and list of `issues`.
+ */
+export function validate(resource, options) {
+    const issues = [];
+    if (!resource || typeof resource !== "object" || Array.isArray(resource)) {
+        return {
+            valid: false,
+            issues: [
+                {
+                    severity: "error",
+                    path: "resource",
+                    code: "invalid-structure",
+                    message: `Expected resource to be a JSON object, got ${Array.isArray(resource) ? "array" : typeof resource}.`,
+                },
+            ],
+        };
+    }
+    if (hasCircularReference(resource)) {
+        return {
+            valid: false,
+            issues: [
+                {
+                    severity: "error",
+                    path: "resource",
+                    code: "circular-reference",
+                    message: "Resource contains an invalid circular reference.",
+                },
+            ],
+        };
+    }
+    const res = resource;
+    if (typeof res.resourceType !== "string" || !res.resourceType.trim()) {
+        return {
+            valid: false,
+            issues: [
+                {
+                    severity: "error",
+                    path: "resource.resourceType",
+                    code: "missing-resource-type",
+                    message: "Missing or invalid required 'resourceType' string property.",
+                },
+            ],
+        };
+    }
+    const resourceType = res.resourceType.trim();
+    const baseValidator = BASE_VALIDATORS[resourceType];
+    if (!baseValidator) {
+        issues.push({
+            severity: "error",
+            path: `${resourceType}.resourceType`,
+            code: "unsupported-resource-type",
+            message: `Resource type '${resourceType}' is not supported by fhir-validator v1. Supported types: ${Object.keys(BASE_VALIDATORS).join(", ")}.`,
+        });
+    }
+    else {
+        // 1. Run base structural validation
+        issues.push(...baseValidator(res, resourceType));
+        if (resourceType === "Bundle" && Array.isArray(res.entry)) {
+            res.entry.forEach((entry, index) => {
+                if (!entry || typeof entry !== "object" || Array.isArray(entry))
+                    return;
+                const nested = entry.resource;
+                if (!nested || typeof nested !== "object" || Array.isArray(nested))
+                    return;
+                const nestedResult = validate(nested);
+                nestedResult.issues.forEach((issue) => issues.push({ ...issue, path: `Bundle.entry[${index}].resource.${issue.path}` }));
+            });
+        }
+    }
+    // 2. Run profile constraints if provided
+    if (options?.profile) {
+        issues.push(...validateProfileConstraints(res, options.profile, resourceType));
+    }
+    const hasErrors = issues.some((i) => i.severity === "error");
+    return {
+        valid: !hasErrors,
+        issues,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peerbits/fhir-validator",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Structural, cardinality, and reference validation for FHIR R4 resources — a fast base-spec validator with a pluggable illustrative-profile mechanism (not a full conformance engine)",
   "license": "Apache-2.0",
   "publishConfig": {
@@ -23,7 +23,9 @@
     "build": "tsc -p tsconfig.json",
     "lint": "eslint .",
     "typecheck": "tsc --noEmit",
-    "test": "vitest run"
+    "test": "vitest run",
+    "prepack": "npm run build && npm run typecheck && npm test",
+    "prepublishOnly": "npm run lint && npm run prepack"
   },
   "repository": {
     "type": "git",
@@ -41,9 +43,9 @@
     "@typescript-eslint/parser": "^8.0.0",
     "eslint": "^9.0.0",
     "typescript": "^5.5.0",
-    "vitest": "^2.0.0"
+    "vitest": "^4.0.0"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   }
 }