@claudebernard/node-fhir-mapper 2.1.2 → 2.1.4

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,46 @@ 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.
+
+#### - createMedicationsFromProducts / createMedicationFromProduct
+
+```ts
+function createMedicationsFromProducts(products: Product[]): MappingResponse<Bundle> {}
+function createMedicationFromProduct(product: Product): Medication | undefined {}
+```
+
+Same as `createMedicationsFromBcbCodes`, but starting from the `Product` objects returned by the BCB APIs (`@claudebernard/types`), so the medication labels are kept along with the codes. Each Medication carries one Coding per code the Product holds — `code` for the bcb-code, `properties.codes.cip13` (or `code13`) for the cip13-code, `properties.codes.cis` for the cis-code — each with the product label as `display`, and the same label as the CodeableConcept `text` :
+
+```json
+{
+  "resourceType": "Medication",
+  "id": "95175bcb-f3cf-4eb8-83be-7956554cd0b8",
+  "code": {
+    "coding": [
+      { "system": "https://platform.claudebernard.fr/fhir/CodeSystem/bcb-code", "code": "76461", "display": "JANUMET 50 mg/1000 mg, comprimé pelliculé" },
+      { "system": "http://terminology.hl7.org/CodeSystem/cip13-code", "code": "3400957312114", "display": "JANUMET 50 mg/1000 mg, comprimé pelliculé" },
+      { "system": "http://terminology.hl7.org/CodeSystem/cis-code", "code": "66010671", "display": "JANUMET 50 mg/1000 mg, comprimé pelliculé" }
+    ],
+    "text": "JANUMET 50 mg/1000 mg, comprimé pelliculé"
+  }
+}
+```
+
+The label is read from `labels.label`, falling back on `labels.longLabel` then `labels.shortLabel`, depending on which fields the API in use fills ; the HTML flavoured fields (`labelHtml` & co) are never used. Unlike the other creation functions, the Bundle `id` is a UUID v4 as well, so it differs from one call to the next. A Product carrying none of the three codes is skipped and reported in the `errors` field of the response ; `createMedicationFromProduct` returns `undefined` for it.
+
+##### Usage
+
+```ts
+import { medicationMapper } from '@claudebernard/fhir-mapper';
+
+const response = medicationMapper.createMedicationsFromProducts(products);
+
+if (response.result) {
+    // Bundle with the Medication resources first, then their MedicationRequest resources
+    console.log(response.result.entry?.length);
+}
+```
 
 #### - extractBcbCodesFromMedications / extractCIP13CodesFromMedications / extractCISCodesFromMedications
 

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { Dosage, Bundle } from 'fhir/r5';
-import { CBPatient } from '@claudebernard/types';
+import { Dosage, Bundle, Medication } from 'fhir/r5';
+import { CBPatient, Product } from '@claudebernard/types';
 
 interface BCBPosologieStructuree2 {
     adequationUP?: number | null;
@@ -191,6 +191,9 @@ declare namespace patientMapper_d {
   };
 }
 
+declare const BCB_CODE_SYSTEM = "https://platform.claudebernard.fr/fhir/CodeSystem/bcb-code";
+declare const CIP13_CODE_SYSTEM = "http://terminology.hl7.org/CodeSystem/cip13-code";
+declare const CIS_CODE_SYSTEM = "http://terminology.hl7.org/CodeSystem/cis-code";
 /**
  * Generate a hash-based ID for a medication based on its codes
  */
@@ -204,64 +207,107 @@ declare const generateMedicationId: (codes: string[], system: string) => string;
 declare function extractCodesFromMedications(bundle: Bundle, system: string): string[];
 /**
  * Extracts a list of bcb-code strings from a Bundle containing Medication resources.
- * Only codes with system "https://platform.claudebernard.fr/fhir/CodeSystem/bcb-code" are included.
+ * Only codes with system BCB_CODE_SYSTEM are included.
  * @param bundle Bundle containing Medication resources
  * @returns List of BCB codes
  */
 declare function extractBcbCodesFromMedications(bundle: Bundle): string[];
 /**
  * Extracts a list of cip13-code strings from a Bundle containing Medication resources.
- * Only codes with system "http://terminology.hl7.org/CodeSystem/cip13-code" are included.
+ * Only codes with system CIP13_CODE_SYSTEM are included.
  * @param bundle Bundle containing Medication resources
  * @returns List of CIP13 codes
  */
 declare function extractCIP13CodesFromMedications(bundle: Bundle): string[];
 /**
  * Extracts a list of cis-code strings from a Bundle containing Medication resources.
- * Only codes with system "http://terminology.hl7.org/CodeSystem/cis-code" are included.
+ * Only codes with system CIS_CODE_SYSTEM are included.
  * @param bundle Bundle containing Medication resources
  * @returns List of CIS codes
  */
 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>;
+/**
+ * Reads the human readable label of a Product, falling back on the other plain text
+ * label fields when the preferred one is not filled by the BCB API in use.
+ * The HTML flavoured fields (labelHtml and friends) are never used.
+ * @param product Product to read the label from
+ * @returns The product label, or undefined when the Product carries none
+ */
+declare const extractProductLabel: (product: Product) => string | undefined;
+/**
+ * Creates a Medication from a Claude Bernard Product, keeping both its codes and its label.
+ * The Medication holds one Coding per code the Product carries (bcb-code, cip13-code, cis-code),
+ * each with the product label as `display`, and the same label as the CodeableConcept `text`.
+ * The Medication id is a UUID v4, so it differs from one call to the next.
+ * @param product Product to convert to a Medication resource
+ * @returns The Medication resource, or undefined when the Product carries no code at all
+ */
+declare function createMedicationFromProduct(product: Product): Medication | undefined;
+/**
+ * Creates a Bundle containing a Medication and its associated MedicationRequest for each Product.
+ * Each Medication keeps the product codes and label (see createMedicationFromProduct), and each
+ * MedicationRequest references its Medication without any dosage instruction.
+ * Products carrying no code at all are skipped and reported in the `errors` field.
+ * Every id, the Bundle one included, is a UUID v4, so they all differ from one call to
+ * the next, and every entry carries a fullUrl built as "<ResourceType>/<id>".
+ * @param products List of Products to convert to Medication / MedicationRequest resources
+ * @returns MappingResponse containing a Bundle with Medication and MedicationRequest resources
+ */
+declare function createMedicationsFromProducts(products: Product[]): MappingResponse<Bundle>;
 
+declare const medicationMapper_d_BCB_CODE_SYSTEM: typeof BCB_CODE_SYSTEM;
+declare const medicationMapper_d_CIP13_CODE_SYSTEM: typeof CIP13_CODE_SYSTEM;
+declare const medicationMapper_d_CIS_CODE_SYSTEM: typeof CIS_CODE_SYSTEM;
+declare const medicationMapper_d_createMedicationFromProduct: typeof createMedicationFromProduct;
 declare const medicationMapper_d_createMedicationsFromBcbCodes: typeof createMedicationsFromBcbCodes;
 declare const medicationMapper_d_createMedicationsFromCIP13Codes: typeof createMedicationsFromCIP13Codes;
 declare const medicationMapper_d_createMedicationsFromCISCodes: typeof createMedicationsFromCISCodes;
+declare const medicationMapper_d_createMedicationsFromProducts: typeof createMedicationsFromProducts;
 declare const medicationMapper_d_extractBcbCodesFromMedications: typeof extractBcbCodesFromMedications;
 declare const medicationMapper_d_extractCIP13CodesFromMedications: typeof extractCIP13CodesFromMedications;
 declare const medicationMapper_d_extractCISCodesFromMedications: typeof extractCISCodesFromMedications;
 declare const medicationMapper_d_extractCodesFromMedications: typeof extractCodesFromMedications;
+declare const medicationMapper_d_extractProductLabel: typeof extractProductLabel;
 declare const medicationMapper_d_generateMedicationId: typeof generateMedicationId;
 declare namespace medicationMapper_d {
   export {
+    medicationMapper_d_BCB_CODE_SYSTEM as BCB_CODE_SYSTEM,
+    medicationMapper_d_CIP13_CODE_SYSTEM as CIP13_CODE_SYSTEM,
+    medicationMapper_d_CIS_CODE_SYSTEM as CIS_CODE_SYSTEM,
+    medicationMapper_d_createMedicationFromProduct as createMedicationFromProduct,
     medicationMapper_d_createMedicationsFromBcbCodes as createMedicationsFromBcbCodes,
     medicationMapper_d_createMedicationsFromCIP13Codes as createMedicationsFromCIP13Codes,
     medicationMapper_d_createMedicationsFromCISCodes as createMedicationsFromCISCodes,
+    medicationMapper_d_createMedicationsFromProducts as createMedicationsFromProducts,
     medicationMapper_d_extractBcbCodesFromMedications as extractBcbCodesFromMedications,
     medicationMapper_d_extractCIP13CodesFromMedications as extractCIP13CodesFromMedications,
     medicationMapper_d_extractCISCodesFromMedications as extractCISCodesFromMedications,
     medicationMapper_d_extractCodesFromMedications as extractCodesFromMedications,
+    medicationMapper_d_extractProductLabel as extractProductLabel,
     medicationMapper_d_generateMedicationId as generateMedicationId,
   };
 }
@@ -323,5 +369,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,42 @@ 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('-');
+};
+
+const BCB_CODE_SYSTEM = "https://platform.claudebernard.fr/fhir/CodeSystem/bcb-code";
+const CIP13_CODE_SYSTEM = "http://terminology.hl7.org/CodeSystem/cip13-code";
+const CIS_CODE_SYSTEM = "http://terminology.hl7.org/CodeSystem/cis-code";
 /**
  * Generate a hash-based ID for a medication based on its codes
  */
@@ -1419,39 +1488,50 @@ function extractCodesFromMedications(bundle, system) {
 }
 /**
  * Extracts a list of bcb-code strings from a Bundle containing Medication resources.
- * Only codes with system "https://platform.claudebernard.fr/fhir/CodeSystem/bcb-code" are included.
+ * Only codes with system BCB_CODE_SYSTEM are included.
  * @param bundle Bundle containing Medication resources
  * @returns List of BCB codes
  */
 function extractBcbCodesFromMedications(bundle) {
-    return extractCodesFromMedications(bundle, "https://platform.claudebernard.fr/fhir/CodeSystem/bcb-code");
+    return extractCodesFromMedications(bundle, BCB_CODE_SYSTEM);
 }
 /**
  * Extracts a list of cip13-code strings from a Bundle containing Medication resources.
- * Only codes with system "http://terminology.hl7.org/CodeSystem/cip13-code" are included.
+ * Only codes with system CIP13_CODE_SYSTEM are included.
  * @param bundle Bundle containing Medication resources
  * @returns List of CIP13 codes
  */
 function extractCIP13CodesFromMedications(bundle) {
-    return extractCodesFromMedications(bundle, "http://terminology.hl7.org/CodeSystem/cip13-code");
+    return extractCodesFromMedications(bundle, CIP13_CODE_SYSTEM);
 }
 /**
  * Extracts a list of cis-code strings from a Bundle containing Medication resources.
- * Only codes with system "http://terminology.hl7.org/CodeSystem/cis-code" are included.
+ * Only codes with system CIS_CODE_SYSTEM are included.
  * @param bundle Bundle containing Medication resources
  * @returns List of CIS codes
  */
 function extractCISCodesFromMedications(bundle) {
-    return extractCodesFromMedications(bundle, "http://terminology.hl7.org/CodeSystem/cis-code");
+    return extractCodesFromMedications(bundle, CIS_CODE_SYSTEM);
 }
 /**
- * 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,127 +1542,205 @@ 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, BCB_CODE_SYSTEM);
 }
 /**
  * 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, CIP13_CODE_SYSTEM);
 }
 /**
  * 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 createMedicationsFromCodes(cisCodes, CIS_CODE_SYSTEM);
+}
+/**
+ * Reads the human readable label of a Product, falling back on the other plain text
+ * label fields when the preferred one is not filled by the BCB API in use.
+ * The HTML flavoured fields (labelHtml and friends) are never used.
+ * @param product Product to read the label from
+ * @returns The product label, or undefined when the Product carries none
+ */
+const extractProductLabel = (product) => {
+    const label = product.labels?.label
+        ?? product.labels?.longLabel
+        ?? product.labels?.shortLabel;
+    return label?.trim() || undefined;
+};
+/**
+ * Builds one Coding per code the Product carries (bcb-code, cip13-code, cis-code),
+ * each one carrying the product label as its display.
+ */
+const buildProductCodings = (product) => {
+    const display = extractProductLabel(product);
+    const codes = [
+        { system: BCB_CODE_SYSTEM, code: product.code },
+        { system: CIP13_CODE_SYSTEM, code: product.properties?.codes?.cip13 ?? product.code13 },
+        { system: CIS_CODE_SYSTEM, code: product.properties?.codes?.cis }
+    ];
+    return codes
+        .filter(({ code }) => !!code)
+        .map(({ system, code }) => ({ system, code, ...(display ? { display } : {}) }));
+};
+/**
+ * Creates a Medication from a Claude Bernard Product, keeping both its codes and its label.
+ * The Medication holds one Coding per code the Product carries (bcb-code, cip13-code, cis-code),
+ * each with the product label as `display`, and the same label as the CodeableConcept `text`.
+ * The Medication id is a UUID v4, so it differs from one call to the next.
+ * @param product Product to convert to a Medication resource
+ * @returns The Medication resource, or undefined when the Product carries no code at all
+ */
+function createMedicationFromProduct(product) {
+    const coding = buildProductCodings(product);
+    if (coding.length === 0) {
+        return undefined;
+    }
+    const label = extractProductLabel(product);
+    return {
+        resourceType: 'Medication',
+        id: generateUuidV4(),
+        code: {
+            coding,
+            ...(label ? { text: label } : {})
+        }
+    };
+}
+/**
+ * Creates a Bundle containing a Medication and its associated MedicationRequest for each Product.
+ * Each Medication keeps the product codes and label (see createMedicationFromProduct), and each
+ * MedicationRequest references its Medication without any dosage instruction.
+ * Products carrying no code at all are skipped and reported in the `errors` field.
+ * Every id, the Bundle one included, is a UUID v4, so they all differ from one call to
+ * the next, and every entry carries a fullUrl built as "<ResourceType>/<id>".
+ * @param products List of Products to convert to Medication / MedicationRequest resources
+ * @returns MappingResponse containing a Bundle with Medication and MedicationRequest resources
+ */
+function createMedicationsFromProducts(products) {
+    if (!products || products.length === 0) {
         return {
             result: {
                 resourceType: "Bundle",
-                id: "empty-medications-bundle",
+                id: generateUuidV4(),
                 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 errors = [];
+    const medications = [];
+    products.forEach((product, index) => {
+        const medication = createMedicationFromProduct(product);
+        if (!medication) {
+            errors.push({
+                field: `products[${index}]`,
+                message: 'Product carries no bcb-code, cip13-code nor cis-code, no Medication created'
+            });
+            return;
+        }
+        medications.push(medication);
     });
+    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}`,
+        id: generateUuidV4(),
         type: "collection",
-        entry: medications.map(medication => ({ resource: medication }))
+        entry: [
+            ...medications.map(medication => toBundleEntry(medication)),
+            ...medicationRequests.map(medicationRequest => toBundleEntry(medicationRequest))
+        ]
     };
     return {
         result: bundle,
-        errors: []
+        errors
     };
 }
 
 var medicationMapper = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    BCB_CODE_SYSTEM: BCB_CODE_SYSTEM,
+    CIP13_CODE_SYSTEM: CIP13_CODE_SYSTEM,
+    CIS_CODE_SYSTEM: CIS_CODE_SYSTEM,
+    createMedicationFromProduct: createMedicationFromProduct,
     createMedicationsFromBcbCodes: createMedicationsFromBcbCodes,
     createMedicationsFromCIP13Codes: createMedicationsFromCIP13Codes,
     createMedicationsFromCISCodes: createMedicationsFromCISCodes,
+    createMedicationsFromProducts: createMedicationsFromProducts,
     extractBcbCodesFromMedications: extractBcbCodesFromMedications,
     extractCIP13CodesFromMedications: extractCIP13CodesFromMedications,
     extractCISCodesFromMedications: extractCISCodesFromMedications,
     extractCodesFromMedications: extractCodesFromMedications,
+    extractProductLabel: extractProductLabel,
     generateMedicationId: generateMedicationId
 });
 
@@ -1747,5 +1905,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.4",
   "description": "A simple FHIR / BCB resource mapper to help stay interoperable while still using the Claude Bernard intelligence",
   "type": "module",
   "main": "dist/index.js",