@peerbits/fhir-validator 1.0.0 → 1.0.1

package/dist/base-definitions/encounter.js

@@ -0,0 +1,137 @@
+import { validateCodeableConcept, validateCoding } from "../coding.js";
+import { validateReference } from "../reference-rules.js";
+const VALID_ENCOUNTER_STATUSES = [
+    "planned",
+    "arrived",
+    "triaged",
+    "in-progress",
+    "onleave",
+    "finished",
+    "cancelled",
+    "entered-in-error",
+    "unknown",
+];
+/**
+ * Validates base structural rules for FHIR R4 Encounter resource.
+ */
+export function validateEncounter(resource, path = "Encounter") {
+    const issues = [];
+    if (resource.resourceType !== "Encounter") {
+        issues.push({
+            severity: "error",
+            path: `${path}.resourceType`,
+            code: "invalid-resource-type",
+            message: `Expected resourceType 'Encounter', 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_ENCOUNTER_STATUSES.includes(resource.status)) {
+        issues.push({
+            severity: "error",
+            path: `${path}.status`,
+            code: "invalid-value",
+            message: `Invalid Encounter status '${String(resource.status)}'. Allowed values: ${VALID_ENCOUNTER_STATUSES.join(", ")}.`,
+        });
+    }
+    // class (Required Coding / Coding-like object)
+    if (resource.class === undefined || resource.class === null) {
+        issues.push({
+            severity: "error",
+            path: `${path}.class`,
+            code: "required",
+            message: `Missing required 'class' in '${path}'.`,
+        });
+    }
+    else {
+        // In FHIR R4, Encounter.class is a Coding
+        issues.push(...validateCoding(resource.class, `${path}.class`));
+    }
+    // subject (Reference: Patient | Group)
+    if (resource.subject !== undefined) {
+        issues.push(...validateReference(resource.subject, `${path}.subject`, ["Patient", "Group"]));
+    }
+    // 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.`,
+            });
+        }
+        else {
+            const p = resource.period;
+            if (p.start !== undefined && typeof p.start !== "string") {
+                issues.push({
+                    severity: "error",
+                    path: `${path}.period.start`,
+                    code: "invalid-type",
+                    message: `Expected '${path}.period.start' to be a string.`,
+                });
+            }
+            if (p.end !== undefined && typeof p.end !== "string") {
+                issues.push({
+                    severity: "error",
+                    path: `${path}.period.end`,
+                    code: "invalid-type",
+                    message: `Expected '${path}.period.end' to be a string.`,
+                });
+            }
+        }
+    }
+    // participant
+    if (resource.participant !== undefined) {
+        if (!Array.isArray(resource.participant)) {
+            issues.push({
+                severity: "error",
+                path: `${path}.participant`,
+                code: "invalid-type",
+                message: `Expected '${path}.participant' to be an array.`,
+            });
+        }
+        else {
+            resource.participant.forEach((part, idx) => {
+                const partPath = `${path}.participant[${idx}]`;
+                if (typeof part !== "object" || part === null || Array.isArray(part)) {
+                    issues.push({
+                        severity: "error",
+                        path: partPath,
+                        code: "invalid-structure",
+                        message: `Expected '${partPath}' to be an object.`,
+                    });
+                }
+                else {
+                    const p = part;
+                    if (p.individual !== undefined) {
+                        issues.push(...validateReference(p.individual, `${partPath}.individual`, ["Practitioner", "PractitionerRole", "RelatedPerson"]));
+                    }
+                    if (p.type !== undefined && Array.isArray(p.type)) {
+                        p.type.forEach((t, tIdx) => {
+                            issues.push(...validateCodeableConcept(t, `${partPath}.type[${tIdx}]`));
+                        });
+                    }
+                }
+            });
+        }
+    }
+    // serviceProvider (Reference: Organization)
+    if (resource.serviceProvider !== undefined) {
+        issues.push(...validateReference(resource.serviceProvider, `${path}.serviceProvider`, ["Organization"]));
+    }
+    // type (CodeableConcept[])
+    if (resource.type !== undefined && Array.isArray(resource.type)) {
+        resource.type.forEach((t, idx) => {
+            issues.push(...validateCodeableConcept(t, `${path}.type[${idx}]`));
+        });
+    }
+    return issues;
+}

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

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

package/dist/base-definitions/observation.js

@@ -0,0 +1,213 @@
+import { validateCodeableConcept } from "../coding.js";
+import { validateReference } from "../reference-rules.js";
+const VALID_OBSERVATION_STATUSES = [
+    "registered",
+    "preliminary",
+    "final",
+    "amended",
+    "corrected",
+    "cancelled",
+    "entered-in-error",
+    "unknown",
+];
+/**
+ * Validates base structural rules for FHIR R4 Observation resource.
+ */
+export function validateObservation(resource, path = "Observation") {
+    const issues = [];
+    if (resource.resourceType !== "Observation") {
+        issues.push({
+            severity: "error",
+            path: `${path}.resourceType`,
+            code: "invalid-resource-type",
+            message: `Expected resourceType 'Observation', 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_OBSERVATION_STATUSES.includes(resource.status)) {
+        issues.push({
+            severity: "error",
+            path: `${path}.status`,
+            code: "invalid-value",
+            message: `Invalid Observation status '${String(resource.status)}'. Allowed values: ${VALID_OBSERVATION_STATUSES.join(", ")}.`,
+        });
+    }
+    // code (Required CodeableConcept)
+    if (resource.code === undefined || resource.code === null) {
+        issues.push({
+            severity: "error",
+            path: `${path}.code`,
+            code: "required",
+            message: `Missing required 'code' in '${path}'.`,
+        });
+    }
+    else {
+        issues.push(...validateCodeableConcept(resource.code, `${path}.code`, { requireCoding: true }));
+    }
+    // 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}]`));
+            });
+        }
+    }
+    // subject (Reference: Patient | Group | Device | Location)
+    if (resource.subject !== undefined) {
+        issues.push(...validateReference(resource.subject, `${path}.subject`, ["Patient", "Group", "Device", "Location"]));
+    }
+    // encounter (Reference: Encounter)
+    if (resource.encounter !== undefined) {
+        issues.push(...validateReference(resource.encounter, `${path}.encounter`, ["Encounter"]));
+    }
+    // performer (Reference[])
+    if (resource.performer !== undefined) {
+        if (!Array.isArray(resource.performer)) {
+            issues.push({
+                severity: "error",
+                path: `${path}.performer`,
+                code: "invalid-type",
+                message: `Expected '${path}.performer' to be an array, got ${typeof resource.performer}.`,
+            });
+        }
+        else {
+            resource.performer.forEach((perf, idx) => {
+                issues.push(...validateReference(perf, `${path}.performer[${idx}]`, ["Practitioner", "PractitionerRole", "Organization", "CareTeam", "Patient", "RelatedPerson"]));
+            });
+        }
+    }
+    // valueQuantity
+    if (resource.valueQuantity !== undefined) {
+        if (typeof resource.valueQuantity !== "object" || resource.valueQuantity === null || Array.isArray(resource.valueQuantity)) {
+            issues.push({
+                severity: "error",
+                path: `${path}.valueQuantity`,
+                code: "invalid-structure",
+                message: `Expected '${path}.valueQuantity' to be an object.`,
+            });
+        }
+        else {
+            const q = resource.valueQuantity;
+            if (q.value !== undefined && typeof q.value !== "number") {
+                issues.push({
+                    severity: "error",
+                    path: `${path}.valueQuantity.value`,
+                    code: "invalid-type",
+                    message: `Expected '${path}.valueQuantity.value' to be a number, got ${typeof q.value}.`,
+                });
+            }
+            if (q.unit !== undefined && typeof q.unit !== "string") {
+                issues.push({
+                    severity: "error",
+                    path: `${path}.valueQuantity.unit`,
+                    code: "invalid-type",
+                    message: `Expected '${path}.valueQuantity.unit' to be a string.`,
+                });
+            }
+            if (q.system !== undefined && typeof q.system !== "string") {
+                issues.push({
+                    severity: "error",
+                    path: `${path}.valueQuantity.system`,
+                    code: "invalid-type",
+                    message: `Expected '${path}.valueQuantity.system' to be a string.`,
+                });
+            }
+            if (q.code !== undefined && typeof q.code !== "string") {
+                issues.push({
+                    severity: "error",
+                    path: `${path}.valueQuantity.code`,
+                    code: "invalid-type",
+                    message: `Expected '${path}.valueQuantity.code' to be a string.`,
+                });
+            }
+        }
+    }
+    // valueCodeableConcept
+    if (resource.valueCodeableConcept !== undefined) {
+        issues.push(...validateCodeableConcept(resource.valueCodeableConcept, `${path}.valueCodeableConcept`));
+    }
+    // component (Array of components)
+    if (resource.component !== undefined) {
+        if (!Array.isArray(resource.component)) {
+            issues.push({
+                severity: "error",
+                path: `${path}.component`,
+                code: "invalid-type",
+                message: `Expected '${path}.component' to be an array, got ${typeof resource.component}.`,
+            });
+        }
+        else {
+            resource.component.forEach((comp, idx) => {
+                const compPath = `${path}.component[${idx}]`;
+                if (typeof comp !== "object" || comp === null || Array.isArray(comp)) {
+                    issues.push({
+                        severity: "error",
+                        path: compPath,
+                        code: "invalid-structure",
+                        message: `Expected '${compPath}' to be an object.`,
+                    });
+                }
+                else {
+                    const c = comp;
+                    if (c.code === undefined || c.code === null) {
+                        issues.push({
+                            severity: "error",
+                            path: `${compPath}.code`,
+                            code: "required",
+                            message: `Missing required 'code' in '${compPath}'.`,
+                        });
+                    }
+                    else {
+                        issues.push(...validateCodeableConcept(c.code, `${compPath}.code`, { requireCoding: true }));
+                    }
+                    if (c.valueQuantity !== undefined) {
+                        const q = c.valueQuantity;
+                        if (q && typeof q.value !== "number" && q.value !== undefined) {
+                            issues.push({
+                                severity: "error",
+                                path: `${compPath}.valueQuantity.value`,
+                                code: "invalid-type",
+                                message: `Expected '${compPath}.valueQuantity.value' to be a number.`,
+                            });
+                        }
+                    }
+                    if (c.valueCodeableConcept !== undefined) {
+                        issues.push(...validateCodeableConcept(c.valueCodeableConcept, `${compPath}.valueCodeableConcept`));
+                    }
+                }
+            });
+        }
+    }
+    // hasMember / derivedFrom
+    if (resource.hasMember !== undefined) {
+        if (Array.isArray(resource.hasMember)) {
+            resource.hasMember.forEach((hm, idx) => {
+                issues.push(...validateReference(hm, `${path}.hasMember[${idx}]`, ["Observation", "QuestionnaireResponse", "MolecularSequence"]));
+            });
+        }
+    }
+    if (resource.derivedFrom !== undefined) {
+        if (Array.isArray(resource.derivedFrom)) {
+            resource.derivedFrom.forEach((df, idx) => {
+                issues.push(...validateReference(df, `${path}.derivedFrom[${idx}]`, ["DocumentReference", "ImagingStudy", "Media", "QuestionnaireResponse", "Observation", "MolecularSequence"]));
+            });
+        }
+    }
+    return issues;
+}

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

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

package/dist/base-definitions/patient.js

@@ -0,0 +1,163 @@
+import { validateCodeableConcept } from "../coding.js";
+import { validateReference } from "../reference-rules.js";
+const VALID_GENDERS = ["male", "female", "other", "unknown"];
+const DATE_REGEX = /^\d{4}(-\d{2}(-\d{2})?)?$/;
+/**
+ * Validates base structural rules for FHIR R4 Patient resource.
+ */
+export function validatePatient(resource, path = "Patient") {
+    const issues = [];
+    if (resource.resourceType !== "Patient") {
+        issues.push({
+            severity: "error",
+            path: `${path}.resourceType`,
+            code: "invalid-resource-type",
+            message: `Expected resourceType 'Patient', found '${String(resource.resourceType)}'.`,
+        });
+    }
+    // active
+    if (resource.active !== undefined && typeof resource.active !== "boolean") {
+        issues.push({
+            severity: "error",
+            path: `${path}.active`,
+            code: "invalid-type",
+            message: `Expected '${path}.active' to be a boolean, got ${typeof resource.active}.`,
+        });
+    }
+    // gender
+    if (resource.gender !== undefined) {
+        if (typeof resource.gender !== "string" || !VALID_GENDERS.includes(resource.gender)) {
+            issues.push({
+                severity: "error",
+                path: `${path}.gender`,
+                code: "invalid-value",
+                message: `Invalid gender '${String(resource.gender)}'. Allowed values: ${VALID_GENDERS.join(", ")}.`,
+            });
+        }
+    }
+    // birthDate
+    if (resource.birthDate !== undefined) {
+        if (typeof resource.birthDate !== "string" || !DATE_REGEX.test(resource.birthDate)) {
+            issues.push({
+                severity: "error",
+                path: `${path}.birthDate`,
+                code: "invalid-format",
+                message: `Expected '${path}.birthDate' to match YYYY, YYYY-MM, or YYYY-MM-DD format.`,
+            });
+        }
+    }
+    // name (HumanName[])
+    if (resource.name !== undefined) {
+        if (!Array.isArray(resource.name)) {
+            issues.push({
+                severity: "error",
+                path: `${path}.name`,
+                code: "invalid-type",
+                message: `Expected '${path}.name' to be an array, got ${typeof resource.name}.`,
+            });
+        }
+        else {
+            resource.name.forEach((n, idx) => {
+                const namePath = `${path}.name[${idx}]`;
+                if (typeof n !== "object" || n === null) {
+                    issues.push({
+                        severity: "error",
+                        path: namePath,
+                        code: "invalid-structure",
+                        message: `Expected '${namePath}' to be a HumanName object.`,
+                    });
+                }
+                else {
+                    const hn = n;
+                    if (hn.family !== undefined && typeof hn.family !== "string") {
+                        issues.push({
+                            severity: "error",
+                            path: `${namePath}.family`,
+                            code: "invalid-type",
+                            message: `Expected '${namePath}.family' to be a string.`,
+                        });
+                    }
+                    if (hn.given !== undefined && (!Array.isArray(hn.given) || hn.given.some((g) => typeof g !== "string"))) {
+                        issues.push({
+                            severity: "error",
+                            path: `${namePath}.given`,
+                            code: "invalid-type",
+                            message: `Expected '${namePath}.given' to be an array of strings.`,
+                        });
+                    }
+                }
+            });
+        }
+    }
+    // identifier (Identifier[])
+    if (resource.identifier !== undefined) {
+        if (!Array.isArray(resource.identifier)) {
+            issues.push({
+                severity: "error",
+                path: `${path}.identifier`,
+                code: "invalid-type",
+                message: `Expected '${path}.identifier' to be an array, got ${typeof resource.identifier}.`,
+            });
+        }
+        else {
+            resource.identifier.forEach((ident, idx) => {
+                const idPath = `${path}.identifier[${idx}]`;
+                if (typeof ident !== "object" || ident === null) {
+                    issues.push({
+                        severity: "error",
+                        path: idPath,
+                        code: "invalid-structure",
+                        message: `Expected '${idPath}' to be an Identifier object.`,
+                    });
+                }
+                else {
+                    const idObj = ident;
+                    if (idObj.system !== undefined && typeof idObj.system !== "string") {
+                        issues.push({
+                            severity: "error",
+                            path: `${idPath}.system`,
+                            code: "invalid-type",
+                            message: `Expected '${idPath}.system' to be a string.`,
+                        });
+                    }
+                    if (idObj.value !== undefined && typeof idObj.value !== "string") {
+                        issues.push({
+                            severity: "error",
+                            path: `${idPath}.value`,
+                            code: "invalid-type",
+                            message: `Expected '${idPath}.value' to be a string.`,
+                        });
+                    }
+                    if (idObj.type !== undefined) {
+                        issues.push(...validateCodeableConcept(idObj.type, `${idPath}.type`));
+                    }
+                }
+            });
+        }
+    }
+    // generalPractitioner (Reference[])
+    if (resource.generalPractitioner !== undefined) {
+        if (!Array.isArray(resource.generalPractitioner)) {
+            issues.push({
+                severity: "error",
+                path: `${path}.generalPractitioner`,
+                code: "invalid-type",
+                message: `Expected '${path}.generalPractitioner' to be an array.`,
+            });
+        }
+        else {
+            resource.generalPractitioner.forEach((gp, idx) => {
+                issues.push(...validateReference(gp, `${path}.generalPractitioner[${idx}]`, ["Organization", "Practitioner", "PractitionerRole"]));
+            });
+        }
+    }
+    // managingOrganization (Reference)
+    if (resource.managingOrganization !== undefined) {
+        issues.push(...validateReference(resource.managingOrganization, `${path}.managingOrganization`, ["Organization"]));
+    }
+    // maritalStatus (CodeableConcept)
+    if (resource.maritalStatus !== undefined) {
+        issues.push(...validateCodeableConcept(resource.maritalStatus, `${path}.maritalStatus`));
+    }
+    return issues;
+}

package/dist/coding.d.ts

@@ -0,0 +1,17 @@
+import { ValidationIssue } from "./types.js";
+/**
+ * Validates the structural shape of a FHIR Coding element.
+ * Checks for non-empty string code and valid URI system format.
+ */
+export declare function validateCoding(coding: unknown, path: string, options?: {
+    requireSystem?: boolean;
+    requireCode?: boolean;
+}): ValidationIssue[];
+/**
+ * Validates the structural shape of a FHIR CodeableConcept element.
+ * Checks for coding array structure and validates individual Coding elements.
+ */
+export declare function validateCodeableConcept(concept: unknown, path: string, options?: {
+    requireCoding?: boolean;
+    minCodings?: number;
+}): ValidationIssue[];

package/dist/coding.js

@@ -0,0 +1,139 @@
+/**
+ * Validates the structural shape of a FHIR Coding element.
+ * Checks for non-empty string code and valid URI system format.
+ */
+export function validateCoding(coding, path, options) {
+    const issues = [];
+    if (!coding || typeof coding !== "object" || Array.isArray(coding)) {
+        issues.push({
+            severity: "error",
+            path,
+            code: "invalid-structure",
+            message: `Expected '${path}' to be a Coding object, got ${Array.isArray(coding) ? "array" : typeof coding}.`,
+        });
+        return issues;
+    }
+    const c = coding;
+    const requireSystem = options?.requireSystem ?? true;
+    const requireCode = options?.requireCode ?? true;
+    if (requireCode) {
+        if (c.code === undefined || c.code === null || c.code === "") {
+            issues.push({
+                severity: "error",
+                path: `${path}.code`,
+                code: "required",
+                message: `Missing required 'code' in '${path}'.`,
+            });
+        }
+        else if (typeof c.code !== "string") {
+            issues.push({
+                severity: "error",
+                path: `${path}.code`,
+                code: "invalid-type",
+                message: `Expected 'code' in '${path}' to be a string, got ${typeof c.code}.`,
+            });
+        }
+    }
+    else if (c.code !== undefined && typeof c.code !== "string") {
+        issues.push({
+            severity: "error",
+            path: `${path}.code`,
+            code: "invalid-type",
+            message: `Expected 'code' in '${path}' to be a string, got ${typeof c.code}.`,
+        });
+    }
+    if (requireSystem) {
+        if (c.system === undefined || c.system === null || c.system === "") {
+            issues.push({
+                severity: "error",
+                path: `${path}.system`,
+                code: "required",
+                message: `Missing required 'system' URI in '${path}'.`,
+            });
+        }
+        else if (typeof c.system !== "string") {
+            issues.push({
+                severity: "error",
+                path: `${path}.system`,
+                code: "invalid-type",
+                message: `Expected 'system' in '${path}' to be a string URI, got ${typeof c.system}.`,
+            });
+        }
+    }
+    else if (c.system !== undefined && typeof c.system !== "string") {
+        issues.push({
+            severity: "error",
+            path: `${path}.system`,
+            code: "invalid-type",
+            message: `Expected 'system' in '${path}' to be a string URI, got ${typeof c.system}.`,
+        });
+    }
+    if (c.display !== undefined && typeof c.display !== "string") {
+        issues.push({
+            severity: "error",
+            path: `${path}.display`,
+            code: "invalid-type",
+            message: `Expected 'display' in '${path}' to be a string, got ${typeof c.display}.`,
+        });
+    }
+    return issues;
+}
+/**
+ * Validates the structural shape of a FHIR CodeableConcept element.
+ * Checks for coding array structure and validates individual Coding elements.
+ */
+export function validateCodeableConcept(concept, path, options) {
+    const issues = [];
+    if (!concept || typeof concept !== "object" || Array.isArray(concept)) {
+        issues.push({
+            severity: "error",
+            path,
+            code: "invalid-structure",
+            message: `Expected '${path}' to be a CodeableConcept object, got ${Array.isArray(concept) ? "array" : typeof concept}.`,
+        });
+        return issues;
+    }
+    const cc = concept;
+    const requireCoding = options?.requireCoding ?? false;
+    const minCodings = options?.minCodings ?? (requireCoding ? 1 : 0);
+    if (cc.coding !== undefined) {
+        if (!Array.isArray(cc.coding)) {
+            issues.push({
+                severity: "error",
+                path: `${path}.coding`,
+                code: "invalid-type",
+                message: `Expected '${path}.coding' to be an array, got ${typeof cc.coding}.`,
+            });
+        }
+        else {
+            if (cc.coding.length < minCodings) {
+                issues.push({
+                    severity: "error",
+                    path: `${path}.coding`,
+                    code: "cardinality",
+                    message: `Expected at least ${minCodings} coding(s) in '${path}.coding', found ${cc.coding.length}.`,
+                });
+            }
+            cc.coding.forEach((item, idx) => {
+                issues.push(...validateCoding(item, `${path}.coding[${idx}]`));
+            });
+        }
+    }
+    else if (requireCoding || minCodings > 0) {
+        issues.push({
+            severity: "error",
+            path: `${path}.coding`,
+            code: "required",
+            message: `Missing required 'coding' array in '${path}'.`,
+        });
+    }
+    if (cc.text !== undefined && typeof cc.text !== "string") {
+        issues.push({
+            severity: "error",
+            path: `${path}.text`,
+            code: "invalid-type",
+            message: `Expected 'text' in '${path}' to be a string, got ${typeof cc.text}.`,
+        });
+    }
+    return issues;
+}