@peerbits/fhir-validator 1.0.0 → 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)
@@ -49,7 +51,9 @@ npm install @peerbits/fhir-validator
 
 ---
 
-## Quick Start
+## Demo and Quick Start
+
+[Peerbits HealthTech - Fhir Validator Demo](https://healthcare.peerbits.com/demo/fhir-validator)
 
 ### 1. Validating a Resource
 

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/claim-response.d.ts

@@ -0,0 +1,5 @@
+import { ValidationIssue } from "../types.js";
+/**
+ * Validates base structural rules for FHIR R4 ClaimResponse resource.
+ */
+export declare function validateClaimResponse(resource: Record<string, unknown>, path?: string): ValidationIssue[];

package/dist/base-definitions/claim-response.js

@@ -0,0 +1,186 @@
+import { validateCodeableConcept } from "../coding.js";
+import { validateReference } from "../reference-rules.js";
+const VALID_CLAIM_RESPONSE_STATUSES = ["active", "cancelled", "draft", "entered-in-error"];
+const VALID_CLAIM_RESPONSE_USES = ["claim", "preauthorization", "predetermination"];
+const VALID_CLAIM_RESPONSE_OUTCOMES = ["queued", "complete", "error", "partial"];
+/**
+ * Validates base structural rules for FHIR R4 ClaimResponse resource.
+ */
+export function validateClaimResponse(resource, path = "ClaimResponse") {
+    const issues = [];
+    if (resource.resourceType !== "ClaimResponse") {
+        issues.push({
+            severity: "error",
+            path: `${path}.resourceType`,
+            code: "invalid-resource-type",
+            message: `Expected resourceType 'ClaimResponse', found '${String(resource.resourceType)}'.`,
+        });
+    }
+    // status (Required)
+    if (resource.status === undefined || resource.status === null || resource.status === "") {
+        issues.push({
+            severity: "error",
+            path: `${path}.status`,
+            code: "required",
+            message: `Missing required 'status' in '${path}'.`,
+        });
+    }
+    else if (typeof resource.status !== "string" || !VALID_CLAIM_RESPONSE_STATUSES.includes(resource.status)) {
+        issues.push({
+            severity: "error",
+            path: `${path}.status`,
+            code: "invalid-value",
+            message: `Invalid ClaimResponse status '${String(resource.status)}'. Allowed values: ${VALID_CLAIM_RESPONSE_STATUSES.join(", ")}.`,
+        });
+    }
+    // type (Required CodeableConcept)
+    if (resource.type === undefined || resource.type === null) {
+        issues.push({
+            severity: "error",
+            path: `${path}.type`,
+            code: "required",
+            message: `Missing required 'type' in '${path}'.`,
+        });
+    }
+    else {
+        issues.push(...validateCodeableConcept(resource.type, `${path}.type`));
+    }
+    // use (Required enum: claim | preauthorization | predetermination)
+    if (resource.use === undefined || resource.use === null || resource.use === "") {
+        issues.push({
+            severity: "error",
+            path: `${path}.use`,
+            code: "required",
+            message: `Missing required 'use' in '${path}'.`,
+        });
+    }
+    else if (typeof resource.use !== "string" || !VALID_CLAIM_RESPONSE_USES.includes(resource.use)) {
+        issues.push({
+            severity: "error",
+            path: `${path}.use`,
+            code: "invalid-value",
+            message: `Invalid ClaimResponse use '${String(resource.use)}'. Allowed values: ${VALID_CLAIM_RESPONSE_USES.join(", ")}.`,
+        });
+    }
+    // patient (Required Reference: Patient)
+    if (resource.patient === undefined || resource.patient === null) {
+        issues.push({
+            severity: "error",
+            path: `${path}.patient`,
+            code: "required",
+            message: `Missing required 'patient' in '${path}'.`,
+        });
+    }
+    else {
+        issues.push(...validateReference(resource.patient, `${path}.patient`, ["Patient"]));
+    }
+    // created (Required string dateTime)
+    if (resource.created === undefined || resource.created === null || resource.created === "") {
+        issues.push({
+            severity: "error",
+            path: `${path}.created`,
+            code: "required",
+            message: `Missing required 'created' in '${path}'.`,
+        });
+    }
+    else if (typeof resource.created !== "string") {
+        issues.push({
+            severity: "error",
+            path: `${path}.created`,
+            code: "invalid-type",
+            message: `Expected '${path}.created' to be a string dateTime.`,
+        });
+    }
+    // insurer (Required Reference: Organization)
+    if (resource.insurer === undefined || resource.insurer === null) {
+        issues.push({
+            severity: "error",
+            path: `${path}.insurer`,
+            code: "required",
+            message: `Missing required 'insurer' in '${path}'.`,
+        });
+    }
+    else {
+        issues.push(...validateReference(resource.insurer, `${path}.insurer`, ["Organization"]));
+    }
+    // outcome (Required enum: queued | complete | error | partial)
+    if (resource.outcome === undefined || resource.outcome === null || resource.outcome === "") {
+        issues.push({
+            severity: "error",
+            path: `${path}.outcome`,
+            code: "required",
+            message: `Missing required 'outcome' in '${path}'.`,
+        });
+    }
+    else if (typeof resource.outcome !== "string" || !VALID_CLAIM_RESPONSE_OUTCOMES.includes(resource.outcome)) {
+        issues.push({
+            severity: "error",
+            path: `${path}.outcome`,
+            code: "invalid-value",
+            message: `Invalid ClaimResponse outcome '${String(resource.outcome)}'. Allowed values: ${VALID_CLAIM_RESPONSE_OUTCOMES.join(", ")}.`,
+        });
+    }
+    // request (Reference: Claim)
+    if (resource.request !== undefined) {
+        issues.push(...validateReference(resource.request, `${path}.request`, ["Claim"]));
+    }
+    // requestor (Reference: Practitioner | PractitionerRole | Organization)
+    if (resource.requestor !== undefined) {
+        issues.push(...validateReference(resource.requestor, `${path}.requestor`, ["Practitioner", "PractitionerRole", "Organization"]));
+    }
+    // insurance (Array)
+    if (resource.insurance !== undefined) {
+        if (!Array.isArray(resource.insurance)) {
+            issues.push({
+                severity: "error",
+                path: `${path}.insurance`,
+                code: "invalid-type",
+                message: `Expected '${path}.insurance' to be an array.`,
+            });
+        }
+        else {
+            resource.insurance.forEach((ins, idx) => {
+                const insPath = `${path}.insurance[${idx}]`;
+                if (typeof ins !== "object" || ins === null || Array.isArray(ins)) {
+                    issues.push({
+                        severity: "error",
+                        path: insPath,
+                        code: "invalid-structure",
+                        message: `Expected '${insPath}' to be an object.`,
+                    });
+                }
+                else {
+                    const obj = ins;
+                    if (typeof obj.sequence !== "number") {
+                        issues.push({
+                            severity: "error",
+                            path: `${insPath}.sequence`,
+                            code: "required",
+                            message: `Missing or invalid 'sequence' number in '${insPath}'.`,
+                        });
+                    }
+                    if (typeof obj.focal !== "boolean") {
+                        issues.push({
+                            severity: "error",
+                            path: `${insPath}.focal`,
+                            code: "required",
+                            message: `Missing or invalid 'focal' boolean in '${insPath}'.`,
+                        });
+                    }
+                    if (obj.coverage === undefined || obj.coverage === null) {
+                        issues.push({
+                            severity: "error",
+                            path: `${insPath}.coverage`,
+                            code: "required",
+                            message: `Missing required 'coverage' reference in '${insPath}'.`,
+                        });
+                    }
+                    else {
+                        issues.push(...validateReference(obj.coverage, `${insPath}.coverage`, ["Coverage"]));
+                    }
+                }
+            });
+        }
+    }
+    return issues;
+}

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

@@ -0,0 +1,5 @@
+import { ValidationIssue } from "../types.js";
+/**
+ * Validates base structural rules for FHIR R4 Claim resource.
+ */
+export declare function validateClaim(resource: Record<string, unknown>, path?: string): ValidationIssue[];

package/dist/base-definitions/claim.js

@@ -0,0 +1,240 @@
+import { validateCodeableConcept } from "../coding.js";
+import { validateReference } from "../reference-rules.js";
+const VALID_CLAIM_STATUSES = ["active", "cancelled", "draft", "entered-in-error"];
+const VALID_CLAIM_USES = ["claim", "preauthorization", "predetermination"];
+/**
+ * Validates base structural rules for FHIR R4 Claim resource.
+ */
+export function validateClaim(resource, path = "Claim") {
+    const issues = [];
+    if (resource.resourceType !== "Claim") {
+        issues.push({
+            severity: "error",
+            path: `${path}.resourceType`,
+            code: "invalid-resource-type",
+            message: `Expected resourceType 'Claim', found '${String(resource.resourceType)}'.`,
+        });
+    }
+    // status (Required)
+    if (resource.status === undefined || resource.status === null || resource.status === "") {
+        issues.push({
+            severity: "error",
+            path: `${path}.status`,
+            code: "required",
+            message: `Missing required 'status' in '${path}'.`,
+        });
+    }
+    else if (typeof resource.status !== "string" || !VALID_CLAIM_STATUSES.includes(resource.status)) {
+        issues.push({
+            severity: "error",
+            path: `${path}.status`,
+            code: "invalid-value",
+            message: `Invalid Claim status '${String(resource.status)}'. Allowed values: ${VALID_CLAIM_STATUSES.join(", ")}.`,
+        });
+    }
+    // type (Required CodeableConcept)
+    if (resource.type === undefined || resource.type === null) {
+        issues.push({
+            severity: "error",
+            path: `${path}.type`,
+            code: "required",
+            message: `Missing required 'type' in '${path}'.`,
+        });
+    }
+    else {
+        issues.push(...validateCodeableConcept(resource.type, `${path}.type`));
+    }
+    // use (Required enum: claim | preauthorization | predetermination)
+    if (resource.use === undefined || resource.use === null || resource.use === "") {
+        issues.push({
+            severity: "error",
+            path: `${path}.use`,
+            code: "required",
+            message: `Missing required 'use' in '${path}'.`,
+        });
+    }
+    else if (typeof resource.use !== "string" || !VALID_CLAIM_USES.includes(resource.use)) {
+        issues.push({
+            severity: "error",
+            path: `${path}.use`,
+            code: "invalid-value",
+            message: `Invalid Claim use '${String(resource.use)}'. Allowed values: ${VALID_CLAIM_USES.join(", ")}.`,
+        });
+    }
+    // patient (Required Reference: Patient)
+    if (resource.patient === undefined || resource.patient === null) {
+        issues.push({
+            severity: "error",
+            path: `${path}.patient`,
+            code: "required",
+            message: `Missing required 'patient' in '${path}'.`,
+        });
+    }
+    else {
+        issues.push(...validateReference(resource.patient, `${path}.patient`, ["Patient"]));
+    }
+    // created (Required string dateTime)
+    if (resource.created === undefined || resource.created === null || resource.created === "") {
+        issues.push({
+            severity: "error",
+            path: `${path}.created`,
+            code: "required",
+            message: `Missing required 'created' in '${path}'.`,
+        });
+    }
+    else if (typeof resource.created !== "string") {
+        issues.push({
+            severity: "error",
+            path: `${path}.created`,
+            code: "invalid-type",
+            message: `Expected '${path}.created' to be a string dateTime.`,
+        });
+    }
+    // provider (Required Reference: Practitioner | PractitionerRole | Organization)
+    if (resource.provider === undefined || resource.provider === null) {
+        issues.push({
+            severity: "error",
+            path: `${path}.provider`,
+            code: "required",
+            message: `Missing required 'provider' in '${path}'.`,
+        });
+    }
+    else {
+        issues.push(...validateReference(resource.provider, `${path}.provider`, ["Practitioner", "PractitionerRole", "Organization"]));
+    }
+    // priority (Required CodeableConcept)
+    if (resource.priority === undefined || resource.priority === null) {
+        issues.push({
+            severity: "error",
+            path: `${path}.priority`,
+            code: "required",
+            message: `Missing required 'priority' in '${path}'.`,
+        });
+    }
+    else {
+        issues.push(...validateCodeableConcept(resource.priority, `${path}.priority`));
+    }
+    // insurer (Reference: Organization)
+    if (resource.insurer !== undefined) {
+        issues.push(...validateReference(resource.insurer, `${path}.insurer`, ["Organization"]));
+    }
+    // facility (Reference: Location)
+    if (resource.facility !== undefined) {
+        issues.push(...validateReference(resource.facility, `${path}.facility`, ["Location"]));
+    }
+    // insurance (Required array, min 1)
+    if (resource.insurance === undefined || resource.insurance === null) {
+        issues.push({
+            severity: "error",
+            path: `${path}.insurance`,
+            code: "required",
+            message: `Missing required 'insurance' in '${path}'.`,
+        });
+    }
+    else if (!Array.isArray(resource.insurance)) {
+        issues.push({
+            severity: "error",
+            path: `${path}.insurance`,
+            code: "invalid-type",
+            message: `Expected '${path}.insurance' to be an array, got ${typeof resource.insurance}.`,
+        });
+    }
+    else if (resource.insurance.length === 0) {
+        issues.push({
+            severity: "error",
+            path: `${path}.insurance`,
+            code: "cardinality",
+            message: `Expected at least 1 insurance element in '${path}.insurance', found 0.`,
+        });
+    }
+    else {
+        resource.insurance.forEach((ins, idx) => {
+            const insPath = `${path}.insurance[${idx}]`;
+            if (typeof ins !== "object" || ins === null || Array.isArray(ins)) {
+                issues.push({
+                    severity: "error",
+                    path: insPath,
+                    code: "invalid-structure",
+                    message: `Expected '${insPath}' to be an object.`,
+                });
+            }
+            else {
+                const obj = ins;
+                if (typeof obj.sequence !== "number") {
+                    issues.push({
+                        severity: "error",
+                        path: `${insPath}.sequence`,
+                        code: "required",
+                        message: `Missing or invalid 'sequence' number in '${insPath}'.`,
+                    });
+                }
+                if (typeof obj.focal !== "boolean") {
+                    issues.push({
+                        severity: "error",
+                        path: `${insPath}.focal`,
+                        code: "required",
+                        message: `Missing or invalid 'focal' boolean in '${insPath}'.`,
+                    });
+                }
+                if (obj.coverage === undefined || obj.coverage === null) {
+                    issues.push({
+                        severity: "error",
+                        path: `${insPath}.coverage`,
+                        code: "required",
+                        message: `Missing required 'coverage' reference in '${insPath}'.`,
+                    });
+                }
+                else {
+                    issues.push(...validateReference(obj.coverage, `${insPath}.coverage`, ["Coverage"]));
+                }
+            }
+        });
+    }
+    // item (Array)
+    if (resource.item !== undefined) {
+        if (!Array.isArray(resource.item)) {
+            issues.push({
+                severity: "error",
+                path: `${path}.item`,
+                code: "invalid-type",
+                message: `Expected '${path}.item' to be an array, got ${typeof resource.item}.`,
+            });
+        }
+        else {
+            resource.item.forEach((it, idx) => {
+                const itPath = `${path}.item[${idx}]`;
+                if (typeof it !== "object" || it === null || Array.isArray(it)) {
+                    issues.push({
+                        severity: "error",
+                        path: itPath,
+                        code: "invalid-structure",
+                        message: `Expected '${itPath}' to be an object.`,
+                    });
+                }
+                else {
+                    const itemObj = it;
+                    if (typeof itemObj.sequence !== "number") {
+                        issues.push({
+                            severity: "error",
+                            path: `${itPath}.sequence`,
+                            code: "required",
+                            message: `Missing or invalid 'sequence' number in '${itPath}'.`,
+                        });
+                    }
+                    if (itemObj.productOrService === undefined || itemObj.productOrService === null) {
+                        issues.push({
+                            severity: "error",
+                            path: `${itPath}.productOrService`,
+                            code: "required",
+                            message: `Missing required 'productOrService' in '${itPath}'.`,
+                        });
+                    }
+                    else {
+                        issues.push(...validateCodeableConcept(itemObj.productOrService, `${itPath}.productOrService`));
+                    }
+                }
+            });
+        }
+    }
+    return issues;
+}

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

@@ -0,0 +1,5 @@
+import { ValidationIssue } from "../types.js";
+/**
+ * Validates base structural rules for FHIR R4 Condition resource.
+ */
+export declare function validateCondition(resource: Record<string, unknown>, path?: string): ValidationIssue[];

package/dist/base-definitions/condition.js

@@ -0,0 +1,78 @@
+import { validateCodeableConcept } from "../coding.js";
+import { validateReference } from "../reference-rules.js";
+/**
+ * Validates base structural rules for FHIR R4 Condition resource.
+ */
+export function validateCondition(resource, path = "Condition") {
+    const issues = [];
+    if (resource.resourceType !== "Condition") {
+        issues.push({
+            severity: "error",
+            path: `${path}.resourceType`,
+            code: "invalid-resource-type",
+            message: `Expected resourceType 'Condition', found '${String(resource.resourceType)}'.`,
+        });
+    }
+    // subject (Required Reference: Patient | Group)
+    if (resource.subject === undefined || resource.subject === null) {
+        issues.push({
+            severity: "error",
+            path: `${path}.subject`,
+            code: "required",
+            message: `Missing required 'subject' in '${path}'.`,
+        });
+    }
+    else {
+        issues.push(...validateReference(resource.subject, `${path}.subject`, ["Patient", "Group"]));
+    }
+    // clinicalStatus (CodeableConcept)
+    if (resource.clinicalStatus !== undefined) {
+        issues.push(...validateCodeableConcept(resource.clinicalStatus, `${path}.clinicalStatus`));
+    }
+    // verificationStatus (CodeableConcept)
+    if (resource.verificationStatus !== undefined) {
+        issues.push(...validateCodeableConcept(resource.verificationStatus, `${path}.verificationStatus`));
+    }
+    // category (CodeableConcept[])
+    if (resource.category !== undefined) {
+        if (!Array.isArray(resource.category)) {
+            issues.push({
+                severity: "error",
+                path: `${path}.category`,
+                code: "invalid-type",
+                message: `Expected '${path}.category' to be an array, got ${typeof resource.category}.`,
+            });
+        }
+        else {
+            resource.category.forEach((cat, idx) => {
+                issues.push(...validateCodeableConcept(cat, `${path}.category[${idx}]`));
+            });
+        }
+    }
+    // code (CodeableConcept)
+    if (resource.code !== undefined) {
+        issues.push(...validateCodeableConcept(resource.code, `${path}.code`));
+    }
+    // encounter (Reference: Encounter)
+    if (resource.encounter !== undefined) {
+        issues.push(...validateReference(resource.encounter, `${path}.encounter`, ["Encounter"]));
+    }
+    // recorder (Reference)
+    if (resource.recorder !== undefined) {
+        issues.push(...validateReference(resource.recorder, `${path}.recorder`, ["Practitioner", "PractitionerRole", "Patient", "RelatedPerson"]));
+    }
+    // asserter (Reference)
+    if (resource.asserter !== undefined) {
+        issues.push(...validateReference(resource.asserter, `${path}.asserter`, ["Practitioner", "PractitionerRole", "Patient", "RelatedPerson"]));
+    }
+    // recordedDate
+    if (resource.recordedDate !== undefined && typeof resource.recordedDate !== "string") {
+        issues.push({
+            severity: "error",
+            path: `${path}.recordedDate`,
+            code: "invalid-type",
+            message: `Expected '${path}.recordedDate' to be a string.`,
+        });
+    }
+    return issues;
+}

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

@@ -0,0 +1,5 @@
+import { ValidationIssue } from "../types.js";
+/**
+ * Validates base structural rules for FHIR R4 Coverage resource.
+ */
+export declare function validateCoverage(resource: Record<string, unknown>, path?: string): ValidationIssue[];