@peerbits/fhir-validator 1.0.1 → 1.1.0

package/README.md

@@ -1,5 +1,7 @@
 # @peerbits/fhir-validator
 
+Version 1.1 validates Bundle structure and recursively validates bundled resources, including transaction/batch request details. Observation checks now cover periods, components, finite quantities, UCUM codes, and FHIR choice-field cardinality.
+
 > Fast, lightweight structural, cardinality, and reference validation for FHIR R4 resources.
 
 [![CI](https://github.com/PeerbitsSolution/fhir-validator/actions/workflows/ci.yml/badge.svg)](https://github.com/PeerbitsSolution/fhir-validator/actions)

package/dist/base-definitions/bundle.d.ts

@@ -0,0 +1,2 @@
+import type { ValidationIssue } from '../types.js';
+export declare function validateBundle(resource: Record<string, unknown>, path?: string): ValidationIssue[];

package/dist/base-definitions/bundle.js

@@ -0,0 +1,41 @@
+const BUNDLE_TYPES = ['document', 'message', 'transaction', 'transaction-response', 'batch', 'batch-response', 'history', 'searchset', 'collection'];
+export function validateBundle(resource, path = 'Bundle') {
+    const issues = [];
+    if (resource.resourceType !== 'Bundle')
+        issues.push({ severity: 'error', path: `${path}.resourceType`, code: 'invalid-resource-type', message: "Expected resourceType 'Bundle'." });
+    if (typeof resource.type !== 'string' || !BUNDLE_TYPES.includes(resource.type)) {
+        issues.push({ severity: 'error', path: `${path}.type`, code: 'invalid-value', message: `Bundle.type must be one of: ${BUNDLE_TYPES.join(', ')}.` });
+    }
+    if (resource.entry !== undefined && !Array.isArray(resource.entry)) {
+        issues.push({ severity: 'error', path: `${path}.entry`, code: 'invalid-type', message: 'Bundle.entry must be an array.' });
+    }
+    if (Array.isArray(resource.entry)) {
+        resource.entry.forEach((entry, index) => {
+            const entryPath = `${path}.entry[${index}]`;
+            if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+                issues.push({ severity: 'error', path: entryPath, code: 'invalid-structure', message: 'Bundle entry must be an object.' });
+                return;
+            }
+            const value = entry;
+            if (!value.resource || typeof value.resource !== 'object' || Array.isArray(value.resource)) {
+                issues.push({ severity: 'error', path: `${entryPath}.resource`, code: 'required', message: 'Bundle entry requires a resource object.' });
+            }
+            if (resource.type === 'transaction' || resource.type === 'batch') {
+                if (!value.request || typeof value.request !== 'object' || Array.isArray(value.request)) {
+                    issues.push({ severity: 'error', path: `${entryPath}.request`, code: 'required', message: `${resource.type} Bundle entry requires request.` });
+                }
+                else {
+                    const request = value.request;
+                    const methods = ['GET', 'HEAD', 'POST', 'PUT', 'DELETE', 'PATCH'];
+                    if (typeof request.method !== 'string' || !methods.includes(request.method)) {
+                        issues.push({ severity: 'error', path: `${entryPath}.request.method`, code: 'invalid-value', message: `Bundle request.method must be one of: ${methods.join(', ')}.` });
+                    }
+                    if (typeof request.url !== 'string' || !request.url.trim()) {
+                        issues.push({ severity: 'error', path: `${entryPath}.request.url`, code: 'required', message: 'Bundle request.url must be a non-empty string.' });
+                    }
+                }
+            }
+        });
+    }
+    return issues;
+}

package/dist/base-definitions/observation.js

@@ -15,6 +15,12 @@ const VALID_OBSERVATION_STATUSES = [
  */
 export function validateObservation(resource, path = "Observation") {
     const issues = [];
+    const effectiveFields = ["effectiveDateTime", "effectivePeriod", "effectiveTiming", "effectiveInstant"].filter((field) => resource[field] !== undefined);
+    if (effectiveFields.length > 1)
+        issues.push({ severity: "error", path: `${path}.effective[x]`, code: "cardinality", message: "Observation may contain only one effective[x] value." });
+    const valueFields = ["valueQuantity", "valueCodeableConcept", "valueString", "valueBoolean", "valueInteger", "valueRange", "valueRatio", "valueSampledData", "valueTime", "valueDateTime", "valuePeriod"].filter((field) => resource[field] !== undefined);
+    if (valueFields.length > 1)
+        issues.push({ severity: "error", path: `${path}.value[x]`, code: "cardinality", message: "Observation may contain only one value[x] value." });
     if (resource.resourceType !== "Observation") {
         issues.push({
             severity: "error",
@@ -104,7 +110,7 @@ export function validateObservation(resource, path = "Observation") {
         }
         else {
             const q = resource.valueQuantity;
-            if (q.value !== undefined && typeof q.value !== "number") {
+            if (q.value !== undefined && (typeof q.value !== "number" || !Number.isFinite(q.value))) {
                 issues.push({
                     severity: "error",
                     path: `${path}.valueQuantity.value`,
@@ -136,6 +142,24 @@ export function validateObservation(resource, path = "Observation") {
                     message: `Expected '${path}.valueQuantity.code' to be a string.`,
                 });
             }
+            if (q.system !== undefined && q.system === "http://unitsofmeasure.org" && (typeof q.code !== "string" || !q.code.trim())) {
+                issues.push({ severity: "error", path: `${path}.valueQuantity.code`, code: "required", message: "UCUM Quantity requires a non-empty code." });
+            }
+        }
+    }
+    if (resource.effectiveDateTime !== undefined && (typeof resource.effectiveDateTime !== "string" || Number.isNaN(Date.parse(resource.effectiveDateTime)))) {
+        issues.push({ severity: "error", path: `${path}.effectiveDateTime`, code: "invalid-value", message: "effectiveDateTime must be a valid date-time string." });
+    }
+    if (resource.effectivePeriod !== undefined) {
+        if (!resource.effectivePeriod || typeof resource.effectivePeriod !== "object" || Array.isArray(resource.effectivePeriod)) {
+            issues.push({ severity: "error", path: `${path}.effectivePeriod`, code: "invalid-structure", message: "effectivePeriod must be an object." });
+        }
+        else {
+            const period = resource.effectivePeriod;
+            const start = typeof period.start === "string" ? Date.parse(period.start) : NaN;
+            const end = typeof period.end === "string" ? Date.parse(period.end) : NaN;
+            if (Number.isNaN(start) || Number.isNaN(end) || start > end)
+                issues.push({ severity: "error", path: `${path}.effectivePeriod`, code: "invalid-value", message: "effectivePeriod requires valid start and end values in chronological order." });
         }
     }
     // valueCodeableConcept
@@ -178,7 +202,10 @@ export function validateObservation(resource, path = "Observation") {
                     }
                     if (c.valueQuantity !== undefined) {
                         const q = c.valueQuantity;
-                        if (q && typeof q.value !== "number" && q.value !== undefined) {
+                        if (!q || Array.isArray(q)) {
+                            issues.push({ severity: "error", path: `${compPath}.valueQuantity`, code: "invalid-structure", message: `Expected '${compPath}.valueQuantity' to be an object.` });
+                        }
+                        else if (typeof q.value !== "number" || !Number.isFinite(q.value)) {
                             issues.push({
                                 severity: "error",
                                 path: `${compPath}.valueQuantity.value`,

package/dist/index.d.ts

@@ -3,7 +3,7 @@
  * FHIR R4 resources. Explicitly NOT a full conformance engine — see
  * docs/KNOWN_LIMITATIONS.md and developer handover spec.
  */
-export declare const VERSION = "1.0.1";
+export declare const VERSION = "1.1.0";
 export { validate, getNestedValue, validateProfileConstraints, hasCircularReference } from "./validate.js";
 export type { ValidationIssue, ValidationResult, ValidationSeverity, ProfileConstraints, BindingStrength, ValidateOptions, } from "./types.js";
 export { validateCoding, validateCodeableConcept } from "./coding.js";

package/dist/index.js

@@ -3,7 +3,7 @@
  * FHIR R4 resources. Explicitly NOT a full conformance engine — see
  * docs/KNOWN_LIMITATIONS.md and developer handover spec.
  */
-export const VERSION = "1.0.1";
+export const VERSION = "1.1.0";
 // Main API
 export { validate, getNestedValue, validateProfileConstraints, hasCircularReference } from "./validate.js";
 // Coding & Reference Helpers

package/dist/validate.js

@@ -5,6 +5,7 @@ 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,
@@ -13,6 +14,7 @@ const BASE_VALIDATORS = {
     Coverage: validateCoverage,
     Claim: validateClaim,
     ClaimResponse: validateClaimResponse,
+    Bundle: validateBundle,
 };
 /**
  * Detects whether an object contains a circular reference.
@@ -188,6 +190,17 @@ export function validate(resource, options) {
     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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peerbits/fhir-validator",
-  "version": "1.0.1",
+  "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": {
@@ -24,7 +24,8 @@
     "lint": "eslint .",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
-    "prepublishOnly": "npm run build"
+    "prepack": "npm run build && npm run typecheck && npm test",
+    "prepublishOnly": "npm run lint && npm run prepack"
   },
   "repository": {
     "type": "git",
@@ -42,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"
   }
 }