@peerbits/fhir-validator 1.0.0 → 1.0.1

package/README.md

@@ -49,7 +49,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/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[];

package/dist/base-definitions/coverage.js

@@ -0,0 +1,109 @@
+import { validateCodeableConcept } from "../coding.js";
+import { validateReference } from "../reference-rules.js";
+const VALID_COVERAGE_STATUSES = ["active", "cancelled", "draft", "entered-in-error"];
+/**
+ * Validates base structural rules for FHIR R4 Coverage resource.
+ */
+export function validateCoverage(resource, path = "Coverage") {
+    const issues = [];
+    if (resource.resourceType !== "Coverage") {
+        issues.push({
+            severity: "error",
+            path: `${path}.resourceType`,
+            code: "invalid-resource-type",
+            message: `Expected resourceType 'Coverage', 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_COVERAGE_STATUSES.includes(resource.status)) {
+        issues.push({
+            severity: "error",
+            path: `${path}.status`,
+            code: "invalid-value",
+            message: `Invalid Coverage status '${String(resource.status)}'. Allowed values: ${VALID_COVERAGE_STATUSES.join(", ")}.`,
+        });
+    }
+    // beneficiary (Required Reference: Patient)
+    if (resource.beneficiary === undefined || resource.beneficiary === null) {
+        issues.push({
+            severity: "error",
+            path: `${path}.beneficiary`,
+            code: "required",
+            message: `Missing required 'beneficiary' in '${path}'.`,
+        });
+    }
+    else {
+        issues.push(...validateReference(resource.beneficiary, `${path}.beneficiary`, ["Patient"]));
+    }
+    // payor (Required Reference[]: Organization | Patient | RelatedPerson, min 1)
+    if (resource.payor === undefined || resource.payor === null) {
+        issues.push({
+            severity: "error",
+            path: `${path}.payor`,
+            code: "required",
+            message: `Missing required 'payor' in '${path}'.`,
+        });
+    }
+    else if (!Array.isArray(resource.payor)) {
+        issues.push({
+            severity: "error",
+            path: `${path}.payor`,
+            code: "invalid-type",
+            message: `Expected '${path}.payor' to be an array, got ${typeof resource.payor}.`,
+        });
+    }
+    else if (resource.payor.length === 0) {
+        issues.push({
+            severity: "error",
+            path: `${path}.payor`,
+            code: "cardinality",
+            message: `Expected at least 1 payor in '${path}.payor', found 0.`,
+        });
+    }
+    else {
+        resource.payor.forEach((p, idx) => {
+            issues.push(...validateReference(p, `${path}.payor[${idx}]`, ["Organization", "Patient", "RelatedPerson"]));
+        });
+    }
+    // subscriber (Reference: Patient | RelatedPerson)
+    if (resource.subscriber !== undefined) {
+        issues.push(...validateReference(resource.subscriber, `${path}.subscriber`, ["Patient", "RelatedPerson"]));
+    }
+    // subscriberId (string)
+    if (resource.subscriberId !== undefined && typeof resource.subscriberId !== "string") {
+        issues.push({
+            severity: "error",
+            path: `${path}.subscriberId`,
+            code: "invalid-type",
+            message: `Expected '${path}.subscriberId' to be a string.`,
+        });
+    }
+    // type (CodeableConcept)
+    if (resource.type !== undefined) {
+        issues.push(...validateCodeableConcept(resource.type, `${path}.type`));
+    }
+    // relationship (CodeableConcept)
+    if (resource.relationship !== undefined) {
+        issues.push(...validateCodeableConcept(resource.relationship, `${path}.relationship`));
+    }
+    // period (Period)
+    if (resource.period !== undefined) {
+        if (typeof resource.period !== "object" || resource.period === null || Array.isArray(resource.period)) {
+            issues.push({
+                severity: "error",
+                path: `${path}.period`,
+                code: "invalid-structure",
+                message: `Expected '${path}.period' to be an object.`,
+            });
+        }
+    }
+    return issues;
+}

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

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