@claudebernard/node-fhir-mapper 2.1.2 → 2.1.3

package/README.md

@@ -211,6 +211,17 @@ back by the other.
 | `lstPathologiesCIM10` | `Condition` | `http://hl7.org/fhir/sid/icd-10` |
 | `lstIdComposantAllergie` / `allergies` | `AllergyIntolerance` | `.../CodeSystem/products-ingredients` |
 
+#### Codifications and mappers
+
+Pathologies and allergies already coded in a Claude Bernard code system are read as is, their
+`display` being used as the label : `amm-pathologies` and ICD-10 `Condition` resources, and
+`products-ingredients` `AllergyIntolerance` resources. The optional `allergiesMapper` and
+`snomedPathologiesMapper` are only needed for codings expressed in another system, SNOMED CT
+typically ; an error is reported when such a coding is found and the matching mapper is missing.
+
+The wanted coding is looked up by system, not by position, so a `Condition` or an
+`AllergyIntolerance` may carry several codings without the mapping picking the wrong one.
+
 #### Hepatic insufficiency
 
 The Child-Pugh `Observation` carries the numeric score in `valueQuantity` and the class as a
@@ -387,7 +398,20 @@ The medication mapper provides utilities for creating and extracting medication
 function createMedicationsFromBcbCodes(codes: string[]): MappingResponse<Bundle> {}
 ```
 
-Creates a FHIR Bundle containing Medication resources from BCB codes.
+Creates a FHIR Bundle containing Medication resources from BCB codes. Each Medication is paired with a MedicationRequest that references it. Those MedicationRequest resources are blank : they carry no `dosageInstruction`, only the mandatory `status`, `intent`, `medication` and `subject` fields.
+
+Both resources get a UUID v4 as `id`, so their ids differ from one call to the next. Only the Bundle `id` stays deterministic, derived from the codes it contains. Each Bundle entry carries a `fullUrl` built as `<ResourceType>/<id>` :
+
+```json
+{
+  "fullUrl": "Medication/d813a438-a3ea-4608-ba50-d19a69e59569",
+  "resource": {
+    "resourceType": "Medication",
+    "id": "d813a438-a3ea-4608-ba50-d19a69e59569",
+    "code": { "coding": [{ "system": "https://platform.claudebernard.fr/fhir/CodeSystem/bcb-code", "code": "BCB001" }] }
+  }
+}
+```
 
 ##### Usage
 
@@ -398,8 +422,8 @@ const bcbCodes = ['BCB001', 'BCB002', 'BCB003'];
 const response = medicationMapper.createMedicationsFromBcbCodes(bcbCodes);
 
 if (response.result) {
-    // Bundle with Medication resources
-    console.log(response.result.entry?.length); // 3 medications
+    // Bundle with the Medication resources first, then their MedicationRequest resources
+    console.log(response.result.entry?.length); // 6 : 3 medications + 3 medication requests
 }
 ```
 
@@ -410,7 +434,7 @@ function createMedicationsFromCIP13Codes(codes: string[]): MappingResponse<Bundl
 function createMedicationsFromCISCodes(codes: string[]): MappingResponse<Bundle> {}
 ```
 
-Similar functions for creating medications from CIP13 and CIS codes respectively.
+Similar functions for creating medications from CIP13 and CIS codes respectively. They also add a blank MedicationRequest per Medication.
 
 #### - extractBcbCodesFromMedications / extractCIP13CodesFromMedications / extractCISCodesFromMedications
 

package/dist/index.d.ts

@@ -225,23 +225,26 @@ declare function extractCIP13CodesFromMedications(bundle: Bundle): string[];
 declare function extractCISCodesFromMedications(bundle: Bundle): string[];
 /**
  * Creates a Bundle containing Medication resources from a list of bcb-code strings.
- * Each Medication will have a CodeableConcept with a Coding for the bcb-code system.
+ * Each Medication will have a CodeableConcept with a Coding for the bcb-code system,
+ * and is paired with a MedicationRequest referencing it (without dosage instruction).
  * @param bcbCodes List of BCB codes to convert to Medication resources
- * @returns MappingResponse containing a Bundle with Medication resources
+ * @returns MappingResponse containing a Bundle with Medication and MedicationRequest resources
  */
 declare function createMedicationsFromBcbCodes(bcbCodes: string[]): MappingResponse<Bundle>;
 /**
  * Creates a Bundle containing Medication resources from a list of CIP13 codes.
- * Each Medication will have a CodeableConcept with a Coding for the CIP13 system.
+ * Each Medication will have a CodeableConcept with a Coding for the CIP13 system,
+ * and is paired with a MedicationRequest referencing it (without dosage instruction).
  * @param cip13Codes List of CIP13 codes to convert to Medication resources
- * @returns MappingResponse containing a Bundle with Medication resources
+ * @returns MappingResponse containing a Bundle with Medication and MedicationRequest resources
  */
 declare function createMedicationsFromCIP13Codes(cip13Codes: string[]): MappingResponse<Bundle>;
 /**
  * Creates a Bundle containing Medication resources from a list of CIS codes.
- * Each Medication will have a CodeableConcept with a Coding for the CIS system.
+ * Each Medication will have a CodeableConcept with a Coding for the CIS system,
+ * and is paired with a MedicationRequest referencing it (without dosage instruction).
  * @param cisCodes List of CIS codes to convert to Medication resources
- * @returns MappingResponse containing a Bundle with Medication resources
+ * @returns MappingResponse containing a Bundle with Medication and MedicationRequest resources
  */
 declare function createMedicationsFromCISCodes(cisCodes: string[]): MappingResponse<Bundle>;
 
@@ -323,5 +326,12 @@ declare const simpleHash: (str: string) => string;
  */
 declare const generateHash: (data: any) => string;
 
-export { dosageMapper_d as dosageMapper, generateHash, medicationMapper_d as medicationMapper, medicationRequestMapper_d as medicationRequestMapper, patientMapper_d as patientMapper, simpleHash };
+/**
+ * UUID v4 generation compatible with both Node.js and browser environments
+ * Like the hash utils, this avoids importing the Node.js crypto module to keep
+ * the package usable in a browser bundle
+ */
+declare const generateUuidV4: () => string;
+
+export { dosageMapper_d as dosageMapper, generateHash, generateUuidV4, medicationMapper_d as medicationMapper, medicationRequestMapper_d as medicationRequestMapper, patientMapper_d as patientMapper, simpleHash };
 export type { CodificationFunction, Coding, MappingError, MappingResponse, SimpleCodification };

package/dist/index.js

@@ -670,6 +670,23 @@ const LEGACY_HEPATIC_ICD10_CODES = Object.keys(hepaticInsufficiencyReverseMap);
 const isAcceptedLoincCode = (code, acceptedCodes) => !!code && acceptedCodes.includes(code);
 /** True when any coding of the concept carries one of the accepted codes. */
 const hasAcceptedCode = (concept, acceptedCodes) => !!concept?.coding?.some(coding => isAcceptedLoincCode(coding.code, acceptedCodes));
+/**
+ * Find the coding of a concept belonging to a given system.
+ *
+ * A concept often carries several codings, so the wanted one is not necessarily the first: reading
+ * `coding[0]` blindly would mix up the code and the label of two different code systems.
+ */
+const findCodingBySystem = (concept, system) => concept?.coding?.find(coding => coding.system === system);
+/** Read a coding as a codification, the label being carried by its display. */
+const codingToCodification = (coding) => ({
+    code: coding.code ?? '',
+    label: coding.display ?? ''
+});
+/** Codifications of every condition coded in the given system, labels included. */
+const conditionsToCodifications = (conditions, system) => conditions.flatMap(condition => {
+    const coding = findCodingBySystem(condition?.code, system);
+    return coding ? [codingToCodification(coding)] : [];
+});
 /**
  * Body Surface Area, Du Bois formula.
  *
@@ -789,6 +806,21 @@ const sortEntries = async (target, entries, allergiesMapper, snomedPathologiesMa
     let lstIdComposantAllergie = [];
     let errorField = target === 'bcb' ? 'lstIdComposantAllergie' : 'allergies';
     for (const allergyEntry of allergyIntoleranceEntries) {
+        // An allergy already coded in the BCB ingredients system needs no mapper, its code is the
+        // idComposant expected on the BCB / CB side. This mirrors how AMM conditions are read.
+        const ingredientCoding = findCodingBySystem(allergyEntry?.code, INGREDIENTS_SYSTEM_URL);
+        if (ingredientCoding) {
+            if (ingredientCoding.code && !Number.isNaN(Number(ingredientCoding.code))) {
+                lstIdComposantAllergie.push(codingToCodification(ingredientCoding));
+            }
+            else {
+                errors.push({
+                    field: errorField,
+                    message: `Invalid ingredient code for allergy ${ingredientCoding.code ?? ''}`
+                });
+            }
+            continue;
+        }
         if (allergiesMapper) {
             const mappingResult = await allergiesMapper(allergyEntry?.code?.coding?.[0]);
             if (Array.isArray(mappingResult)) {
@@ -821,17 +853,18 @@ const sortEntries = async (target, entries, allergiesMapper, snomedPathologiesMa
     }
     // The legacy hepatic Condition is already consumed as the hepatic status, keep it out of the
     // ICD-10 pathologies so it is not reported twice.
-    const cim10PathologiesEntries = conditionEntries.filter(entry => entry !== legacyHepaticCondition && entry?.code?.coding?.some(coding => coding.system === ICD10_SYSTEM_URL)).map(pathology => ({ code: pathology?.code?.coding?.[0]?.code || '', label: '' }));
+    const cim10PathologiesEntries = conditionsToCodifications(conditionEntries.filter(entry => entry !== legacyHepaticCondition), ICD10_SYSTEM_URL);
     const snomedPathologiesEntries = conditionEntries.filter(entry => entry?.code?.coding?.some(coding => coding.system === SNOMED_SYSTEM_URL));
-    const ammPathologiesEntries = conditionEntries.filter(entry => entry?.code?.coding?.some(coding => coding.system === AMM_SYSTEM_URL)).map(pathology => ({ code: pathology?.code?.coding?.[0]?.code || '', label: '' }));
+    const ammPathologiesEntries = conditionsToCodifications(conditionEntries, AMM_SYSTEM_URL);
     let lstPathologies = [];
     lstPathologies.push(...ammPathologiesEntries);
     let lstCim10Pathologies = [];
     lstCim10Pathologies.push(...cim10PathologiesEntries);
     errorField = target === 'bcb' ? 'lstPathologiesAMM' : 'ammPathologies';
     for (const pathology of snomedPathologiesEntries) {
+        const snomedCoding = findCodingBySystem(pathology?.code, SNOMED_SYSTEM_URL);
         if (snomedPathologiesMapper) {
-            const mappingResult = await snomedPathologiesMapper(pathology?.code?.coding?.[0]);
+            const mappingResult = await snomedPathologiesMapper(snomedCoding);
             if (Array.isArray(mappingResult)) {
                 if (mappingResult.length > 0) {
                     lstPathologies.push(...mappingResult);
@@ -839,7 +872,7 @@ const sortEntries = async (target, entries, allergiesMapper, snomedPathologiesMa
                 else {
                     errors.push({
                         field: errorField,
-                        message: `No mapping found for snomed code ${pathology?.code?.coding?.[0]?.code}`
+                        message: `No mapping found for snomed code ${snomedCoding?.code}`
                     });
                 }
             }
@@ -849,7 +882,7 @@ const sortEntries = async (target, entries, allergiesMapper, snomedPathologiesMa
             else {
                 errors.push({
                     field: errorField,
-                    message: `No mapping found for snomed code ${pathology?.code?.coding?.[0]?.code}`
+                    message: `No mapping found for snomed code ${snomedCoding?.code}`
                 });
             }
         }
@@ -1373,6 +1406,39 @@ var patientMapper = /*#__PURE__*/Object.freeze({
     fhirToCb: fhirToCb
 });
 
+/**
+ * UUID v4 generation compatible with both Node.js and browser environments
+ * Like the hash utils, this avoids importing the Node.js crypto module to keep
+ * the package usable in a browser bundle
+ */
+const generateUuidV4 = () => {
+    const webCrypto = globalThis.crypto;
+    if (typeof webCrypto?.randomUUID === 'function') {
+        return webCrypto.randomUUID();
+    }
+    const bytes = new Uint8Array(16);
+    if (typeof webCrypto?.getRandomValues === 'function') {
+        // Available in browsers even outside of a secure context, where randomUUID is not
+        webCrypto.getRandomValues(bytes);
+    }
+    else {
+        for (let i = 0; i < bytes.length; i++) {
+            bytes[i] = Math.floor(Math.random() * 256);
+        }
+    }
+    // Force the version (4) and variant (10xx) bits required by RFC 4122
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = Array.from(bytes, byte => byte.toString(16).padStart(2, '0')).join('');
+    return [
+        hex.substring(0, 8),
+        hex.substring(8, 12),
+        hex.substring(12, 16),
+        hex.substring(16, 20),
+        hex.substring(20)
+    ].join('-');
+};
+
 /**
  * Generate a hash-based ID for a medication based on its codes
  */
@@ -1445,13 +1511,24 @@ function extractCISCodesFromMedications(bundle) {
     return extractCodesFromMedications(bundle, "http://terminology.hl7.org/CodeSystem/cis-code");
 }
 /**
- * Creates a Bundle containing Medication resources from a list of bcb-code strings.
- * Each Medication will have a CodeableConcept with a Coding for the bcb-code system.
- * @param bcbCodes List of BCB codes to convert to Medication resources
- * @returns MappingResponse containing a Bundle with Medication resources
+ * Wraps a resource into a Bundle entry, carrying its fullUrl as "<ResourceType>/<id>"
  */
-function createMedicationsFromBcbCodes(bcbCodes) {
-    if (!bcbCodes || bcbCodes.length === 0) {
+const toBundleEntry = (resource) => ({
+    fullUrl: `${resource.resourceType}/${resource.id}`,
+    resource: resource
+});
+/**
+ * Creates a Bundle containing a Medication and its associated MedicationRequest for each code.
+ * Each Medication holds a CodeableConcept with a Coding for the given system, and each
+ * MedicationRequest references its Medication without any dosage instruction.
+ * Resource ids are UUID v4, so they differ from one call to the next, and every entry
+ * carries a fullUrl built as "<ResourceType>/<id>".
+ * @param codes List of codes to convert to Medication / MedicationRequest resources
+ * @param system The coding system the codes belong to
+ * @returns MappingResponse containing a Bundle with Medication and MedicationRequest resources
+ */
+const createMedicationsFromCodes = (codes, system) => {
+    if (!codes || codes.length === 0) {
         return {
             result: {
                 resourceType: "Bundle",
@@ -1462,116 +1539,74 @@ function createMedicationsFromBcbCodes(bcbCodes) {
             errors: []
         };
     }
-    const bundleId = generateMedicationId(bcbCodes, "https://platform.claudebernard.fr/fhir/CodeSystem/bcb-code");
-    const medications = bcbCodes.map((code, index) => {
-        const medicationId = `${bundleId}-med-${index}`;
-        return {
-            resourceType: 'Medication',
-            id: medicationId,
-            code: {
-                coding: [{
-                        system: "https://platform.claudebernard.fr/fhir/CodeSystem/bcb-code",
-                        code: code
-                    }]
+    const bundleId = generateMedicationId(codes, system);
+    const medications = codes.map(code => ({
+        resourceType: 'Medication',
+        id: generateUuidV4(),
+        code: {
+            coding: [{
+                    system: system,
+                    code: code
+                }]
+        }
+    }));
+    const medicationRequests = medications.map(medication => ({
+        resourceType: 'MedicationRequest',
+        id: generateUuidV4(),
+        status: 'active',
+        intent: 'order',
+        medication: {
+            reference: {
+                reference: `Medication/${medication.id}`
             }
-        };
-    });
+        },
+        subject: {
+            reference: 'Patient/unknown'
+        }
+    }));
     const bundle = {
         resourceType: "Bundle",
         id: `medications-bundle-${bundleId}`,
         type: "collection",
-        entry: medications.map(medication => ({ resource: medication }))
+        entry: [
+            ...medications.map(medication => toBundleEntry(medication)),
+            ...medicationRequests.map(medicationRequest => toBundleEntry(medicationRequest))
+        ]
     };
     return {
         result: bundle,
         errors: []
     };
+};
+/**
+ * Creates a Bundle containing Medication resources from a list of bcb-code strings.
+ * Each Medication will have a CodeableConcept with a Coding for the bcb-code system,
+ * and is paired with a MedicationRequest referencing it (without dosage instruction).
+ * @param bcbCodes List of BCB codes to convert to Medication resources
+ * @returns MappingResponse containing a Bundle with Medication and MedicationRequest resources
+ */
+function createMedicationsFromBcbCodes(bcbCodes) {
+    return createMedicationsFromCodes(bcbCodes, "https://platform.claudebernard.fr/fhir/CodeSystem/bcb-code");
 }
 /**
  * Creates a Bundle containing Medication resources from a list of CIP13 codes.
- * Each Medication will have a CodeableConcept with a Coding for the CIP13 system.
+ * Each Medication will have a CodeableConcept with a Coding for the CIP13 system,
+ * and is paired with a MedicationRequest referencing it (without dosage instruction).
  * @param cip13Codes List of CIP13 codes to convert to Medication resources
- * @returns MappingResponse containing a Bundle with Medication resources
+ * @returns MappingResponse containing a Bundle with Medication and MedicationRequest resources
  */
 function createMedicationsFromCIP13Codes(cip13Codes) {
-    if (!cip13Codes || cip13Codes.length === 0) {
-        return {
-            result: {
-                resourceType: "Bundle",
-                id: "empty-medications-bundle",
-                type: "collection",
-                entry: []
-            },
-            errors: []
-        };
-    }
-    const bundleId = generateMedicationId(cip13Codes, "http://terminology.hl7.org/CodeSystem/cip13-code");
-    const medications = cip13Codes.map((code, index) => {
-        const medicationId = `${bundleId}-med-${index}`;
-        return {
-            resourceType: 'Medication',
-            id: medicationId,
-            code: {
-                coding: [{
-                        system: "http://terminology.hl7.org/CodeSystem/cip13-code",
-                        code: code
-                    }]
-            }
-        };
-    });
-    const bundle = {
-        resourceType: "Bundle",
-        id: `medications-bundle-${bundleId}`,
-        type: "collection",
-        entry: medications.map(medication => ({ resource: medication }))
-    };
-    return {
-        result: bundle,
-        errors: []
-    };
+    return createMedicationsFromCodes(cip13Codes, "http://terminology.hl7.org/CodeSystem/cip13-code");
 }
 /**
  * Creates a Bundle containing Medication resources from a list of CIS codes.
- * Each Medication will have a CodeableConcept with a Coding for the CIS system.
+ * Each Medication will have a CodeableConcept with a Coding for the CIS system,
+ * and is paired with a MedicationRequest referencing it (without dosage instruction).
  * @param cisCodes List of CIS codes to convert to Medication resources
- * @returns MappingResponse containing a Bundle with Medication resources
+ * @returns MappingResponse containing a Bundle with Medication and MedicationRequest resources
  */
 function createMedicationsFromCISCodes(cisCodes) {
-    if (!cisCodes || cisCodes.length === 0) {
-        return {
-            result: {
-                resourceType: "Bundle",
-                id: "empty-medications-bundle",
-                type: "collection",
-                entry: []
-            },
-            errors: []
-        };
-    }
-    const bundleId = generateMedicationId(cisCodes, "http://terminology.hl7.org/CodeSystem/cis-code");
-    const medications = cisCodes.map((code, index) => {
-        const medicationId = `${bundleId}-med-${index}`;
-        return {
-            resourceType: 'Medication',
-            id: medicationId,
-            code: {
-                coding: [{
-                        system: "http://terminology.hl7.org/CodeSystem/cis-code",
-                        code: code
-                    }]
-            }
-        };
-    });
-    const bundle = {
-        resourceType: "Bundle",
-        id: `medications-bundle-${bundleId}`,
-        type: "collection",
-        entry: medications.map(medication => ({ resource: medication }))
-    };
-    return {
-        result: bundle,
-        errors: []
-    };
+    return createMedicationsFromCodes(cisCodes, "http://terminology.hl7.org/CodeSystem/cis-code");
 }
 
 var medicationMapper = /*#__PURE__*/Object.freeze({
@@ -1747,5 +1782,5 @@ var medicationRequestMapper = /*#__PURE__*/Object.freeze({
     generateMedicationRequestId: generateMedicationRequestId
 });
 
-export { dosageMapper, generateHash, medicationMapper, medicationRequestMapper, patientMapper, simpleHash };
+export { dosageMapper, generateHash, generateUuidV4, medicationMapper, medicationRequestMapper, patientMapper, simpleHash };
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claudebernard/node-fhir-mapper",
-  "version": "2.1.2",
+  "version": "2.1.3",
   "description": "A simple FHIR / BCB resource mapper to help stay interoperable while still using the Claude Bernard intelligence",
   "type": "module",
   "main": "dist/index.js",