@claudebernard/node-fhir-mapper 2.2.0 → 2.3.1

package/README.md

@@ -51,6 +51,7 @@ Below the list of all mappers currently comprised in this library :
 - A [**Patient**](https://www.hl7.org/fhir/patient.html#Patient) mapper exported as _patientMapper_.
 - A [**Medication**](https://www.hl7.org/fhir/medication.html#Medication) mapper exported as _medicationMapper_.
 - A [**MedicationRequest**](https://www.hl7.org/fhir/medicationrequest.html#MedicationRequest) mapper exported as _medicationRequestMapper_.
+- A [**MedicationStatement**](https://www.hl7.org/fhir/medicationstatement.html#MedicationStatement) mapper exported as _medicationStatementMapper_ (read-only, FHIR → BCB direction only).
 
 ## Mappers details
 
@@ -546,6 +547,68 @@ if (response.result) {
 }
 ```
 
+### MedicationStatement mapper : functions
+
+The medication statement mapper handles conversion of dosage from FHIR MedicationStatement resources to BCB format, focusing purely on dosage conversion.
+
+**Read-only.** Unlike the MedicationRequest mapper, this mapper only supports the FHIR → BCB
+reading direction. `MedicationStatement` represents patient-reported automédication (medication
+the patient reports taking on their own initiative, as opposed to a prescriber's order) : this
+library only ever receives such data from an incoming FHIR Bundle, it never constructs a
+`MedicationStatement` as output. There is therefore no `bcbToFhir`, `fhirToCb`, or `cbToFhir`
+function on this mapper.
+
+Also note the field name difference from MedicationRequest : FHIR R5 keeps the dosage instructions
+of a MedicationStatement in its **`dosage`** field, not `dosageInstruction`.
+
+#### - fhirToBcb
+
+```ts
+async function fhirToBcb(
+    bundle: Bundle,
+    indicationMapper?: CodificationFunction,
+    routeMapper?: CodificationFunction,
+    intakeMapper?: CodificationFunction
+): Promise<MappingResponse<BCBPosologieStructuree2>[]> {}
+```
+
+Extracts and converts the `dosage` field of MedicationStatement resources in a Bundle to BCB format using the dosage-mapper. The 3 optional **CodificationFunction** parameters are forwarded unchanged to the dosage-mapper, exactly as they are for `medicationRequestMapper.fhirToBcb`.
+
+##### Usage
+
+```ts
+import { medicationStatementMapper } from '@claudebernard/fhir-mapper';
+
+const bundle = /* FHIR Bundle with MedicationStatement resources */;
+const bcbDosages = await medicationStatementMapper.fhirToBcb(bundle);
+
+// Array of BCB dosage mapping responses
+bcbDosages.forEach(response => {
+    if (response.result) {
+        console.log(response.result.libellePosologie);
+    }
+});
+```
+
+#### - extractMedicationCodes / extractSubjectReferences
+
+```ts
+function extractMedicationCodes(bundle: Bundle): string[] {}
+function extractSubjectReferences(bundle: Bundle): string[] {}
+```
+
+Extract, respectively, the medication codes and the subject references carried by the MedicationStatement resources of a Bundle.
+
+##### Usage
+
+```ts
+import { medicationStatementMapper } from '@claudebernard/fhir-mapper';
+
+const bundle = /* FHIR Bundle with MedicationStatement resources */;
+const medicationCodes = medicationStatementMapper.extractMedicationCodes(bundle);
+const subjectReferences = medicationStatementMapper.extractSubjectReferences(bundle);
+```
+
 ## Browser support
 - [x] Chrome
 - [x] Firefox

package/dist/index.d.ts

@@ -124,7 +124,7 @@ type Coding = {
 };
 type CodificationFunction = ((coding: Coding | undefined) => SimpleCodification[] | Promise<SimpleCodification[]>) | undefined;
 
-declare function fhirToBcb$2(dosageInstructions: Dosage[], indicationMapper?: CodificationFunction, routeMapper?: CodificationFunction, intakeMapper?: CodificationFunction): Promise<MappingResponse<BCBPosologieStructuree2>[]>;
+declare function fhirToBcb$3(dosageInstructions: Dosage[], indicationMapper?: CodificationFunction, routeMapper?: CodificationFunction, intakeMapper?: CodificationFunction): Promise<MappingResponse<BCBPosologieStructuree2>[]>;
 declare function mapToBcb(dosageInstructions: Dosage[], indicationMapper?: CodificationFunction, routeMapper?: CodificationFunction, intakeMapper?: CodificationFunction): Promise<MappingResponse<BCBPosologieStructuree2>[]>;
 declare function bcbToFhir$2(bcbDosages: BCBPosologieStructuree2[]): MappingResponse<Dosage>[];
 declare function mapToFhir(bcbDosages: BCBPosologieStructuree2[]): MappingResponse<Dosage>[];
@@ -152,7 +152,7 @@ declare namespace dosageMapper_d {
   export {
     bcbToFhir$2 as bcbToFhir,
     cbToFhir$1 as cbToFhir,
-    fhirToBcb$2 as fhirToBcb,
+    fhirToBcb$3 as fhirToBcb,
     fhirToCb$1 as fhirToCb,
     dosageMapper_d_mapToBcb as mapToBcb,
     dosageMapper_d_mapToFhir as mapToFhir,
@@ -176,7 +176,7 @@ interface BCBPatient {
 }
 
 declare function bcbToFhir$1(bcbPatient: BCBPatient): MappingResponse<Bundle>;
-declare function fhirToBcb$1(fhirBundle: Bundle, allergiesMapper?: CodificationFunction, snomedPathologiesMapper?: CodificationFunction): Promise<MappingResponse<BCBPatient>>;
+declare function fhirToBcb$2(fhirBundle: Bundle, allergiesMapper?: CodificationFunction, snomedPathologiesMapper?: CodificationFunction): Promise<MappingResponse<BCBPatient>>;
 declare function cbToFhir(cbPatient: CBPatient): MappingResponse<Bundle>;
 declare function fhirToCb(fhirBundle: Bundle, allergiesMapper?: CodificationFunction, snomedPathologiesMapper?: CodificationFunction): Promise<MappingResponse<CBPatient>>;
 
@@ -186,7 +186,7 @@ declare namespace patientMapper_d {
   export {
     bcbToFhir$1 as bcbToFhir,
     patientMapper_d_cbToFhir as cbToFhir,
-    fhirToBcb$1 as fhirToBcb,
+    fhirToBcb$2 as fhirToBcb,
     patientMapper_d_fhirToCb as fhirToCb,
   };
 }
@@ -322,7 +322,7 @@ declare const generateMedicationRequestId: (medicationCode?: string, patientId?:
  * @param bundle Bundle containing MedicationRequest resources
  * @returns Array of BCB dosage instructions from all MedicationRequest resources
  */
-declare function fhirToBcb(bundle: Bundle): Promise<MappingResponse<BCBPosologieStructuree2>[]>;
+declare function fhirToBcb$1(bundle: Bundle): Promise<MappingResponse<BCBPosologieStructuree2>[]>;
 /**
  * Creates a Bundle containing MedicationRequest resources from BCB dosage data.
  * Uses the dosage-mapper for converting BCB dosage to FHIR dosage instructions.
@@ -335,7 +335,7 @@ declare function bcbToFhir(bcbDosages: BCBPosologieStructuree2[]): MappingRespon
  * @param bundle Bundle containing MedicationRequest resources
  * @returns Array of medication codes
  */
-declare function extractMedicationCodes(bundle: Bundle): string[];
+declare function extractMedicationCodes$1(bundle: Bundle): string[];
 /**
  * Extracts patient references from MedicationRequest resources in a Bundle.
  * @param bundle Bundle containing MedicationRequest resources
@@ -344,20 +344,57 @@ declare function extractMedicationCodes(bundle: Bundle): string[];
 declare function extractPatientReferences(bundle: Bundle): string[];
 
 declare const medicationRequestMapper_d_bcbToFhir: typeof bcbToFhir;
-declare const medicationRequestMapper_d_extractMedicationCodes: typeof extractMedicationCodes;
 declare const medicationRequestMapper_d_extractPatientReferences: typeof extractPatientReferences;
-declare const medicationRequestMapper_d_fhirToBcb: typeof fhirToBcb;
 declare const medicationRequestMapper_d_generateMedicationRequestId: typeof generateMedicationRequestId;
 declare namespace medicationRequestMapper_d {
   export {
     medicationRequestMapper_d_bcbToFhir as bcbToFhir,
-    medicationRequestMapper_d_extractMedicationCodes as extractMedicationCodes,
+    extractMedicationCodes$1 as extractMedicationCodes,
     medicationRequestMapper_d_extractPatientReferences as extractPatientReferences,
-    medicationRequestMapper_d_fhirToBcb as fhirToBcb,
+    fhirToBcb$1 as fhirToBcb,
     medicationRequestMapper_d_generateMedicationRequestId as generateMedicationRequestId,
   };
 }
 
+/**
+ * Converts dosage instructions from MedicationStatement resources in a Bundle to BCB format.
+ * Uses the dosage-mapper for `dosage` field conversion (the FHIR R5 field name on
+ * MedicationStatement, distinct from MedicationRequest.dosageInstruction).
+ *
+ * Read-only: MedicationStatement represents patient-reported automédication, which this
+ * library only ever receives, never constructs. There is intentionally no `bcbToFhir`,
+ * `fhirToCb`, or `cbToFhir` counterpart in this module.
+ * @param bundle Bundle containing MedicationStatement resources
+ * @param indicationMapper Optional codification mapper for the dosage's indication field
+ * @param routeMapper Optional codification mapper for the dosage's route field
+ * @param intakeMapper Optional codification mapper for the dosage's intake unit field
+ * @returns Array of BCB dosage instructions from all MedicationStatement resources
+ */
+declare function fhirToBcb(bundle: Bundle, indicationMapper?: CodificationFunction, routeMapper?: CodificationFunction, intakeMapper?: CodificationFunction): Promise<MappingResponse<BCBPosologieStructuree2>[]>;
+/**
+ * Extracts medication codes from MedicationStatement resources in a Bundle.
+ * @param bundle Bundle containing MedicationStatement resources
+ * @returns Array of medication codes
+ */
+declare function extractMedicationCodes(bundle: Bundle): string[];
+/**
+ * Extracts subject references from MedicationStatement resources in a Bundle.
+ * @param bundle Bundle containing MedicationStatement resources
+ * @returns Array of subject references
+ */
+declare function extractSubjectReferences(bundle: Bundle): string[];
+
+declare const medicationStatementMapper_d_extractMedicationCodes: typeof extractMedicationCodes;
+declare const medicationStatementMapper_d_extractSubjectReferences: typeof extractSubjectReferences;
+declare const medicationStatementMapper_d_fhirToBcb: typeof fhirToBcb;
+declare namespace medicationStatementMapper_d {
+  export {
+    medicationStatementMapper_d_extractMedicationCodes as extractMedicationCodes,
+    medicationStatementMapper_d_extractSubjectReferences as extractSubjectReferences,
+    medicationStatementMapper_d_fhirToBcb as fhirToBcb,
+  };
+}
+
 /**
  * Simple hash function compatible with both Node.js and browser environments
  * This replaces the Node.js crypto module to avoid browser compatibility issues
@@ -376,5 +413,5 @@ declare const generateHash: (data: any) => string;
  */
 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 { dosageMapper_d as dosageMapper, generateHash, generateUuidV4, medicationMapper_d as medicationMapper, medicationRequestMapper_d as medicationRequestMapper, medicationStatementMapper_d as medicationStatementMapper, patientMapper_d as patientMapper, simpleHash };
 export type { CodificationFunction, Coding, MappingError, MappingResponse, SimpleCodification };

package/dist/index.js

@@ -309,7 +309,7 @@ async function handleCodifications(dosage, indicationMapper, routeMapper, intake
 }
 
 // adding this function to support new naming convention without breaking changes
-async function fhirToBcb$2(dosageInstructions, indicationMapper, routeMapper, intakeMapper) {
+async function fhirToBcb$3(dosageInstructions, indicationMapper, routeMapper, intakeMapper) {
     return await mapToBcb(dosageInstructions, indicationMapper, routeMapper, intakeMapper);
 }
 async function mapToBcb(dosageInstructions, indicationMapper, routeMapper, intakeMapper) {
@@ -474,7 +474,7 @@ function wrapMaybeAsync$1(fn) {
  */
 async function fhirToCb$1(dosageInstructions, indicationMapper, routeMapper, intakeMapper) {
     // First convert FHIR to BCB using existing function
-    const bcbResults = await fhirToBcb$2(dosageInstructions, indicationMapper, routeMapper, intakeMapper);
+    const bcbResults = await fhirToBcb$3(dosageInstructions, indicationMapper, routeMapper, intakeMapper);
     // Convert each BCB result to CB format
     const cbResults = [];
     for (const bcbResult of bcbResults) {
@@ -545,7 +545,7 @@ var dosageMapper = /*#__PURE__*/Object.freeze({
     __proto__: null,
     bcbToFhir: bcbToFhir$2,
     cbToFhir: cbToFhir$1,
-    fhirToBcb: fhirToBcb$2,
+    fhirToBcb: fhirToBcb$3,
     fhirToCb: fhirToCb$1,
     mapToBcb: mapToBcb,
     mapToFhir: mapToFhir
@@ -1306,7 +1306,7 @@ const patientToFhir = (patientData) => {
 function bcbToFhir$1(bcbPatient) {
     return patientToFhir(convertPatient(bcbPatient));
 }
-async function fhirToBcb$1(fhirBundle, allergiesMapper, snomedPathologiesMapper) {
+async function fhirToBcb$2(fhirBundle, allergiesMapper, snomedPathologiesMapper) {
     if (!fhirBundle || !fhirBundle.entry || fhirBundle.entry.length === 0) {
         return {
             result: undefined,
@@ -1402,7 +1402,7 @@ var patientMapper = /*#__PURE__*/Object.freeze({
     __proto__: null,
     bcbToFhir: bcbToFhir$1,
     cbToFhir: cbToFhir,
-    fhirToBcb: fhirToBcb$1,
+    fhirToBcb: fhirToBcb$2,
     fhirToCb: fhirToCb
 });
 
@@ -1760,7 +1760,7 @@ const generateMedicationRequestId = (medicationCode, patientId) => {
  * @param bundle Bundle containing MedicationRequest resources
  * @returns Array of BCB dosage instructions from all MedicationRequest resources
  */
-async function fhirToBcb(bundle) {
+async function fhirToBcb$1(bundle) {
     const results = [];
     if (!bundle.entry) {
         return [{
@@ -1774,7 +1774,7 @@ async function fhirToBcb(bundle) {
             // Convert dosage instructions using the dosage-mapper
             if (medicationRequest.dosageInstruction && medicationRequest.dosageInstruction.length > 0) {
                 try {
-                    const dosageResults = await fhirToBcb$2(medicationRequest.dosageInstruction);
+                    const dosageResults = await fhirToBcb$3(medicationRequest.dosageInstruction);
                     results.push(...dosageResults);
                 }
                 catch (error) {
@@ -1858,7 +1858,7 @@ function bcbToFhir(bcbDosages) {
  * @param bundle Bundle containing MedicationRequest resources
  * @returns Array of medication codes
  */
-function extractMedicationCodes(bundle) {
+function extractMedicationCodes$1(bundle) {
     const codes = [];
     if (!bundle.entry) {
         return codes;
@@ -1899,11 +1899,106 @@ function extractPatientReferences(bundle) {
 var medicationRequestMapper = /*#__PURE__*/Object.freeze({
     __proto__: null,
     bcbToFhir: bcbToFhir,
-    extractMedicationCodes: extractMedicationCodes,
+    extractMedicationCodes: extractMedicationCodes$1,
     extractPatientReferences: extractPatientReferences,
-    fhirToBcb: fhirToBcb,
+    fhirToBcb: fhirToBcb$1,
     generateMedicationRequestId: generateMedicationRequestId
 });
 
-export { dosageMapper, generateHash, generateUuidV4, medicationMapper, medicationRequestMapper, patientMapper, simpleHash };
+/**
+ * Converts dosage instructions from MedicationStatement resources in a Bundle to BCB format.
+ * Uses the dosage-mapper for `dosage` field conversion (the FHIR R5 field name on
+ * MedicationStatement, distinct from MedicationRequest.dosageInstruction).
+ *
+ * Read-only: MedicationStatement represents patient-reported automédication, which this
+ * library only ever receives, never constructs. There is intentionally no `bcbToFhir`,
+ * `fhirToCb`, or `cbToFhir` counterpart in this module.
+ * @param bundle Bundle containing MedicationStatement resources
+ * @param indicationMapper Optional codification mapper for the dosage's indication field
+ * @param routeMapper Optional codification mapper for the dosage's route field
+ * @param intakeMapper Optional codification mapper for the dosage's intake unit field
+ * @returns Array of BCB dosage instructions from all MedicationStatement resources
+ */
+async function fhirToBcb(bundle, indicationMapper, routeMapper, intakeMapper) {
+    const results = [];
+    if (!bundle.entry) {
+        return [{
+                result: undefined,
+                errors: [{ field: 'bundle.entry', message: 'Bundle has no entries' }]
+            }];
+    }
+    for (const entry of bundle.entry) {
+        if (entry.resource?.resourceType === 'MedicationStatement') {
+            const medicationStatement = entry.resource;
+            // Convert dosage using the dosage-mapper
+            if (medicationStatement.dosage && medicationStatement.dosage.length > 0) {
+                try {
+                    const dosageResults = await fhirToBcb$3(medicationStatement.dosage, indicationMapper, routeMapper, intakeMapper);
+                    results.push(...dosageResults);
+                }
+                catch (error) {
+                    results.push({
+                        result: undefined,
+                        errors: [{
+                                field: 'dosage',
+                                message: `Error converting dosage: ${error}`
+                            }]
+                    });
+                }
+            }
+        }
+    }
+    return results;
+}
+/**
+ * Extracts medication codes from MedicationStatement resources in a Bundle.
+ * @param bundle Bundle containing MedicationStatement resources
+ * @returns Array of medication codes
+ */
+function extractMedicationCodes(bundle) {
+    const codes = [];
+    if (!bundle.entry) {
+        return codes;
+    }
+    for (const entry of bundle.entry) {
+        if (entry.resource?.resourceType === 'MedicationStatement') {
+            const medicationStatement = entry.resource;
+            const medicationCode = medicationStatement.medication?.concept?.coding?.[0]?.code;
+            if (medicationCode) {
+                codes.push(medicationCode);
+            }
+        }
+    }
+    return codes;
+}
+/**
+ * Extracts subject references from MedicationStatement resources in a Bundle.
+ * @param bundle Bundle containing MedicationStatement resources
+ * @returns Array of subject references
+ */
+function extractSubjectReferences(bundle) {
+    const references = [];
+    if (!bundle.entry) {
+        return references;
+    }
+    for (const entry of bundle.entry) {
+        if (entry.resource?.resourceType === 'MedicationStatement') {
+            const medicationStatement = entry.resource;
+            const subjectReference = medicationStatement.subject?.reference;
+            if (subjectReference) {
+                references.push(subjectReference);
+            }
+        }
+    }
+    return references;
+}
+
+var medicationStatementMapper = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    extractMedicationCodes: extractMedicationCodes,
+    extractSubjectReferences: extractSubjectReferences,
+    fhirToBcb: fhirToBcb
+});
+
+export { dosageMapper, generateHash, generateUuidV4, medicationMapper, medicationRequestMapper, medicationStatementMapper, patientMapper, simpleHash };
 //# sourceMappingURL=index.js.map

package/package.json

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