@ovok/core 0.3.16 → 0.3.17

package/dist/client/observation/methods/observationsToMeasurements.d.ts

@@ -2,9 +2,16 @@ import { Observation } from "@medplum/fhirtypes";
 import { BloodGlucoseMeasurement, BloodPressureMeasurement, BodyTemperatureMeasurement, BodyWeightMeasurement, EcgMeasurement, HeartRateMeasurement, HeartRateVariabilityMeasurement, Measurement, MeasurementTypeKey, PulseOximeterMeasurement, RespiratoryRateMeasurement, RestingHeartRateMeasurement, StepCountMeasurement, UrineAnalyzeMeasurement, Vo2MaxMeasurement, WalkingHeartRateAverageMeasurement } from "../../../types";
 export type SupportedMeasurement = BloodGlucoseMeasurement | BloodPressureMeasurement | BodyTemperatureMeasurement | BodyWeightMeasurement | EcgMeasurement | HeartRateMeasurement | HeartRateVariabilityMeasurement | PulseOximeterMeasurement | RespiratoryRateMeasurement | RestingHeartRateMeasurement | StepCountMeasurement | UrineAnalyzeMeasurement | Vo2MaxMeasurement | WalkingHeartRateAverageMeasurement | Measurement;
 type SupportedType = Exclude<MeasurementTypeKey, MeasurementTypeKey.symptomQuestionnaire>;
+export type ObservationGrouping = "hasMember" | "time" | ((observation: Observation, index: number, observations: readonly Observation[]) => string);
+export interface ObservationsToMeasurementsOptions {
+    /** How related Observation resources should be reconstructed into measurements. */
+    groupBy?: ObservationGrouping;
+    /** Maximum timestamp difference used by the time-based fallback. */
+    timeToleranceMs?: number;
+}
 export declare const observationCodesForTypes: (types: readonly SupportedType[]) => string;
 /** Converts FHIR observations back into SDK measurements without patient/app assumptions. */
-export declare const observationsToMeasurements: <T extends readonly SupportedType[]>(observations: readonly Observation[], types: T) => Array<Extract<SupportedMeasurement, {
+export declare const observationsToMeasurements: <T extends readonly SupportedType[]>(observations: readonly Observation[], types: T, options?: ObservationsToMeasurementsOptions) => Array<Extract<SupportedMeasurement, {
     measurementTypeKey: T[number];
 }>>;
 export {};

package/dist/client/observation/methods/observationsToMeasurements.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.observationsToMeasurements = exports.observationCodesForTypes = void 0;
 const types_1 = require("../../../types");
+const DEFAULT_OBSERVATION_TIME_TOLERANCE_MS = 1000;
 const codeOf = (observation) => {
     var _a, _b, _c, _d, _e, _f, _g;
     return (_d = (_c = (_b = (_a = observation.code) === null || _a === void 0 ? void 0 : _a.coding) === null || _b === void 0 ? void 0 : _b.find((coding) => coding.system === "http://loinc.org")) === null || _c === void 0 ? void 0 : _c.code) !== null && _d !== void 0 ? _d : (_g = (_f = (_e = observation.code) === null || _e === void 0 ? void 0 : _e.coding) === null || _f === void 0 ? void 0 : _f[0]) === null || _g === void 0 ? void 0 : _g.code;
@@ -50,28 +51,138 @@ const ecgGroupKey = (observation, observations) => {
     });
     return root ? groupKey(root) : groupKey(observation);
 };
-const flattenMembers = (observations) => {
-    const byReference = new Map(observations
-        .filter((observation) => observation.id)
-        .map((observation) => [`Observation/${observation.id}`, observation]));
-    const flattened = [];
-    const add = (observation) => {
+const referenceKeys = (reference) => {
+    const id = reference.replace(/^urn:uuid:/, "").replace(/^Observation\//, "");
+    return [reference, id, `Observation/${id}`, `urn:uuid:${id}`];
+};
+const observationGroups = (observations) => {
+    const byReference = new Map();
+    observations.forEach((observation, index) => {
+        if (observation.id) {
+            referenceKeys(observation.id).forEach((key) => byReference.set(key, index));
+        }
+    });
+    const parent = observations.map((_, index) => index);
+    const find = (index) => {
+        if (parent[index] !== index) {
+            parent[index] = find(parent[index]);
+        }
+        return parent[index];
+    };
+    const union = (left, right) => {
+        const leftRoot = find(left);
+        const rightRoot = find(right);
+        if (leftRoot !== rightRoot) {
+            parent[rightRoot] = leftRoot;
+        }
+    };
+    const linked = new Set();
+    observations.forEach((observation, index) => {
         var _a;
-        flattened.push(observation);
         (_a = observation.hasMember) === null || _a === void 0 ? void 0 : _a.forEach((reference) => {
-            const member = reference.reference ? byReference.get(reference.reference) : undefined;
-            if (member) {
-                add(member);
+            const referenced = reference.reference
+                ? referenceKeys(reference.reference)
+                    .map((key) => byReference.get(key))
+                    .find((candidate) => candidate !== undefined)
+                : undefined;
+            if (referenced !== undefined) {
+                linked.add(index);
+                linked.add(referenced);
+                union(index, referenced);
             }
         });
+    });
+    return {
+        componentOf: new Map(observations.map((_, index) => [index, find(index)])),
+        linked,
     };
-    observations.filter((observation) => { var _a; return !((_a = observation.hasMember) === null || _a === void 0 ? void 0 : _a.length); }).forEach(add);
-    observations.filter((observation) => { var _a; return (_a = observation.hasMember) === null || _a === void 0 ? void 0 : _a.length; }).forEach((observation) => {
-        if (!flattened.includes(observation)) {
-            add(observation);
+};
+const addToGroup = (groups, key, observation, index) => {
+    const group = groups.get(key);
+    if (group) {
+        group.observations.push(observation);
+    }
+    else {
+        groups.set(key, { firstIndex: index, observations: [observation] });
+    }
+};
+const groupByTime = (observations, timeToleranceMs) => {
+    const groups = [];
+    observations.forEach((observation, index) => {
+        var _a;
+        const recordedAt = (_a = recordedAtOf(observation)) === null || _a === void 0 ? void 0 : _a.getTime();
+        const group = recordedAt === undefined
+            ? undefined
+            : groups.find((candidate) => candidate.anchor !== undefined &&
+                Math.abs(candidate.anchor - recordedAt) <= timeToleranceMs);
+        if (group) {
+            group.observations.push(observation);
+            return;
         }
+        groups.push({
+            firstIndex: index,
+            ...(recordedAt !== undefined ? { anchor: recordedAt } : {}),
+            observations: [observation],
+        });
     });
-    return flattened;
+    return groups;
+};
+const groupObservations = (observations, options, legacyKey) => {
+    var _a, _b;
+    const grouping = (_a = options.groupBy) !== null && _a !== void 0 ? _a : "hasMember";
+    const tolerance = Math.max(0, (_b = options.timeToleranceMs) !== null && _b !== void 0 ? _b : DEFAULT_OBSERVATION_TIME_TOLERANCE_MS);
+    if (grouping === "time") {
+        return groupByTime(observations, tolerance);
+    }
+    if (typeof grouping === "function") {
+        const groups = new Map();
+        observations.forEach((observation, index) => {
+            addToGroup(groups, grouping(observation, index, observations), observation, index);
+        });
+        return [...groups.values()].sort((left, right) => left.firstIndex - right.firstIndex);
+    }
+    const { componentOf, linked } = observationGroups(observations);
+    const componentSizes = new Map();
+    componentOf.forEach((root) => {
+        var _a;
+        componentSizes.set(root, ((_a = componentSizes.get(root)) !== null && _a !== void 0 ? _a : 0) + 1);
+    });
+    const groups = new Map();
+    const fallback = observations.filter((_, index) => {
+        var _a;
+        const root = componentOf.get(index);
+        return ((_a = componentSizes.get(root)) !== null && _a !== void 0 ? _a : 0) === 1;
+    });
+    observations.forEach((observation, index) => {
+        var _a;
+        const root = componentOf.get(index);
+        if (((_a = componentSizes.get(root)) !== null && _a !== void 0 ? _a : 0) > 1) {
+            addToGroup(groups, `member:${root}`, observation, index);
+        }
+    });
+    if (fallback.length > 0) {
+        const fallbackIndexes = new Set(fallback.map((observation) => observations.indexOf(observation)));
+        const unlinked = observations.filter((_, index) => fallbackIndexes.has(index) && !linked.has(index));
+        const unresolved = observations.filter((_, index) => fallbackIndexes.has(index) && linked.has(index));
+        groupByTime(unlinked, tolerance).forEach((group) => {
+            const first = group.observations[0];
+            const firstIndex = observations.indexOf(first);
+            const key = legacyKey
+                ? `legacy:${legacyKey(first, firstIndex)}`
+                : `time:${firstIndex}`;
+            addToGroup(groups, key, first, firstIndex);
+            group.observations.slice(1).forEach((observation) => {
+                const index = observations.indexOf(observation);
+                addToGroup(groups, key, observation, index);
+            });
+        });
+        unresolved.forEach((observation) => {
+            var _a;
+            const index = observations.indexOf(observation);
+            addToGroup(groups, `unresolved:${(_a = observation.id) !== null && _a !== void 0 ? _a : index}`, observation, index);
+        });
+    }
+    return [...groups.values()].sort((left, right) => left.firstIndex - right.firstIndex);
 };
 const firstValue = (observations, code) => observations.find((observation) => codeOf(observation) === code)
     ? valueOf(observations.find((observation) => codeOf(observation) === code))
@@ -82,7 +193,11 @@ const baseMeasurement = (measurementTypeKey, observation) => ({
 });
 const inverseGroup = (type, observations) => {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
-    const first = observations[0];
+    const first = [...observations].sort((left, right) => {
+        var _a, _b, _c, _d;
+        return ((_b = (_a = recordedAtOf(left)) === null || _a === void 0 ? void 0 : _a.getTime()) !== null && _b !== void 0 ? _b : Number.MAX_SAFE_INTEGER) -
+            ((_d = (_c = recordedAtOf(right)) === null || _c === void 0 ? void 0 : _c.getTime()) !== null && _d !== void 0 ? _d : Number.MAX_SAFE_INTEGER);
+    })[0];
     const measurement = baseMeasurement(type, first);
     const value = (code) => firstValue(observations, code);
     switch (type) {
@@ -225,22 +340,16 @@ const codesForType = {
 const observationCodesForTypes = (types) => [...new Set(types.flatMap((type) => { var _a; return (_a = codesForType[type]) !== null && _a !== void 0 ? _a : []; }))].join(",");
 exports.observationCodesForTypes = observationCodesForTypes;
 /** Converts FHIR observations back into SDK measurements without patient/app assumptions. */
-const observationsToMeasurements = (observations, types) => {
-    const source = flattenMembers(observations);
+const observationsToMeasurements = (observations, types, options = {}) => {
     const output = [];
     types.forEach((type) => {
         var _a;
         const codes = (_a = codesForType[type]) !== null && _a !== void 0 ? _a : [];
-        const matching = source.filter((observation) => { var _a; return codes.includes((_a = codeOf(observation)) !== null && _a !== void 0 ? _a : ""); });
-        const groups = new Map();
-        matching.forEach((observation) => {
-            var _a, _b, _c;
-            const key = type === types_1.MeasurementTypeKey.ecg
-                ? ecgGroupKey(observation, matching)
-                : (_b = (_a = recordedAtOf(observation)) === null || _a === void 0 ? void 0 : _a.toISOString()) !== null && _b !== void 0 ? _b : "unknown";
-            groups.set(key, [...((_c = groups.get(key)) !== null && _c !== void 0 ? _c : []), observation]);
-        });
-        groups.forEach((group) => output.push(inverseGroup(type, group)));
+        const matching = observations.filter((observation) => { var _a; return codes.includes((_a = codeOf(observation)) !== null && _a !== void 0 ? _a : ""); });
+        const groups = groupObservations(matching, options, type === types_1.MeasurementTypeKey.ecg
+            ? (observation, index) => ecgGroupKey(observation, matching) || `ecg:${index}`
+            : undefined);
+        groups.forEach((group) => output.push(inverseGroup(type, group.observations)));
     });
     return output;
 };

package/dist/client/observation/observation-bundle-utils.js

@@ -24,6 +24,34 @@ const linkObservationMembers = (observations) => {
     });
 };
 exports.linkObservationMembers = linkObservationMembers;
+const createdObservationReference = (response, index) => {
+    var _a, _b, _c, _d;
+    const entry = (_a = response.entry) === null || _a === void 0 ? void 0 : _a[index];
+    const id = ((_b = entry === null || entry === void 0 ? void 0 : entry.resource) === null || _b === void 0 ? void 0 : _b.resourceType) === "Observation"
+        ? entry.resource.id
+        : undefined;
+    if (id) {
+        return `Observation/${id}`;
+    }
+    const location = (_d = (_c = entry === null || entry === void 0 ? void 0 : entry.response) === null || _c === void 0 ? void 0 : _c.location) === null || _d === void 0 ? void 0 : _d.split("?")[0];
+    const match = location === null || location === void 0 ? void 0 : location.match(/(?:^|\/)(Observation\/[^/]+)(?:\/_history\/[^/]+)?$/);
+    return match === null || match === void 0 ? void 0 : match[1];
+};
+const rewriteObservationReference = (entry, from, to) => {
+    var _a;
+    const resource = entry.resource;
+    if ((resource === null || resource === void 0 ? void 0 : resource.resourceType) !== "Observation" || !((_a = resource.hasMember) === null || _a === void 0 ? void 0 : _a.length)) {
+        return entry;
+    }
+    return {
+        ...entry,
+        resource: {
+            ...resource,
+            hasMember: resource.hasMember.map((reference) => reference.reference === from ? { ...reference, reference: to } : reference),
+        },
+    };
+};
+const rewriteObservationReferences = (entries, from, to) => entries.map((entry) => rewriteObservationReference(entry, from, to));
 const splitObservationBundleEntries = (bundle) => {
     var _a;
     const entries = (_a = bundle.entry) !== null && _a !== void 0 ? _a : [];
@@ -50,26 +78,49 @@ const splitObservationBundleEntries = (bundle) => {
 };
 exports.splitObservationBundleEntries = splitObservationBundleEntries;
 const executeObservationBundle = async (bundle, executeBatch) => {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
     const entries = (_a = bundle.entry) !== null && _a !== void 0 ? _a : [];
     if (bundle.type === "transaction" &&
         entries.length > exports.MAX_CONDITIONAL_OBSERVATION_ENTRIES) {
+        const rootReference = (_c = (_b = entries[0]) === null || _b === void 0 ? void 0 : _b.fullUrl) !== null && _c !== void 0 ? _c : (((_e = (_d = entries[0]) === null || _d === void 0 ? void 0 : _d.resource) === null || _e === void 0 ? void 0 : _e.resourceType) === "Observation"
+            ? `urn:uuid:${(0, offline_1.stableMeasurementId)(entries[0].resource)}`
+            : undefined);
         const transactionResponse = await (0, exports.executeObservationBundle)({ ...bundle, entry: entries.slice(0, 1) }, executeBatch);
-        const batchResponse = await (0, exports.executeObservationBundle)({ ...bundle, type: "batch", entry: entries.slice(1) }, executeBatch);
+        const savedRootReference = rootReference
+            ? createdObservationReference(transactionResponse, 0)
+            : undefined;
+        const batchResponse = await (0, exports.executeObservationBundle)({
+            ...bundle,
+            type: "batch",
+            entry: savedRootReference
+                ? rewriteObservationReferences(entries.slice(1), rootReference, savedRootReference)
+                : entries.slice(1),
+        }, executeBatch);
         return {
             resourceType: "Bundle",
             type: "batch-response",
             entry: [
-                ...((_b = transactionResponse.entry) !== null && _b !== void 0 ? _b : []),
-                ...((_c = batchResponse.entry) !== null && _c !== void 0 ? _c : []),
+                ...((_f = transactionResponse.entry) !== null && _f !== void 0 ? _f : []),
+                ...((_g = batchResponse.entry) !== null && _g !== void 0 ? _g : []),
             ],
         };
     }
     const chunks = (0, exports.splitObservationBundleEntries)(bundle);
     if (chunks) {
         const responses = [];
-        for (const entry of chunks) {
-            responses.push(await (0, exports.executeObservationBundle)({ ...bundle, entry }, executeBatch));
+        const rootReference = (_j = (_h = entries[0]) === null || _h === void 0 ? void 0 : _h.fullUrl) !== null && _j !== void 0 ? _j : (((_l = (_k = entries[0]) === null || _k === void 0 ? void 0 : _k.resource) === null || _l === void 0 ? void 0 : _l.resourceType) === "Observation"
+            ? `urn:uuid:${(0, offline_1.stableMeasurementId)(entries[0].resource)}`
+            : undefined);
+        let savedRootReference;
+        for (const [index, entry] of chunks.entries()) {
+            const chunkEntries = index > 0 && rootReference && savedRootReference
+                ? rewriteObservationReferences(entry, rootReference, savedRootReference)
+                : entry;
+            const response = await (0, exports.executeObservationBundle)({ ...bundle, entry: chunkEntries }, executeBatch);
+            if (index === 0 && rootReference) {
+                savedRootReference = createdObservationReference(response, 0);
+            }
+            responses.push(response);
         }
         return {
             resourceType: "Bundle",
@@ -78,7 +129,7 @@ const executeObservationBundle = async (bundle, executeBatch) => {
         };
     }
     const response = await executeBatch(bundle);
-    if ((_d = response.entry) === null || _d === void 0 ? void 0 : _d.some((entry) => {
+    if ((_m = response.entry) === null || _m === void 0 ? void 0 : _m.some((entry) => {
         var _a, _b;
         const status = (_b = (_a = entry.response) === null || _a === void 0 ? void 0 : _a.status) !== null && _b !== void 0 ? _b : "";
         return status.startsWith("4") || status.startsWith("5");

package/dist/conformance/capability-requirements.js

@@ -48,7 +48,7 @@ exports.OVOK_CORE_REQUIREMENTS = {
     description: "The FHIR surface a server must provide for the @ovok/core client library's own methods to function.",
     software: {
         name: "@ovok/core",
-        version: "0.3.16",
+        version: "0.3.17",
     },
     fhirVersion: "4.0.1",
     format: ["json"],

package/dist/hooks/observation-hooks.d.ts

@@ -1,4 +1,5 @@
 import { Observation } from "@medplum/fhirtypes";
+import type { ObservationsToMeasurementsOptions } from "../client/observation/methods/observationsToMeasurements";
 import { observationsToMeasurements, SupportedMeasurement } from "../client/observation/methods/observationsToMeasurements";
 import { GenerateObservationBodyParams } from "../client/observation/types/generate-observation-body/GenerateObservationBodyParams";
 import { OvokClient } from "../client/ovok-client";
@@ -12,10 +13,12 @@ export interface UseObservationsOptions<T extends readonly SupportedType[]> {
     types: T;
     period?: ObservationPeriod;
     patientId?: string;
+    groupBy?: ObservationsToMeasurementsOptions["groupBy"];
+    timeToleranceMs?: number;
 }
 /** Plain inverse mapping for apps that already fetched their Observation resources. */
 export { observationsToMeasurements };
-export declare const useObservations: <T extends readonly SupportedType[]>({ types, period, patientId, }: UseObservationsOptions<T>) => {
+export declare const useObservations: <T extends readonly SupportedType[]>({ types, period, patientId, groupBy, timeToleranceMs, }: UseObservationsOptions<T>) => {
     measurements: Array<Extract<SupportedMeasurement, {
         measurementTypeKey: T[number];
     }>>;

package/dist/hooks/observation-hooks.js

@@ -41,7 +41,7 @@ const observationsToMeasurements_1 = require("../client/observation/methods/obse
 Object.defineProperty(exports, "observationsToMeasurements", { enumerable: true, get: function () { return observationsToMeasurements_1.observationsToMeasurements; } });
 const types_1 = require("../types");
 const index_1 = require("./index");
-const useObservations = ({ types, period, patientId, }) => {
+const useObservations = ({ types, period, patientId, groupBy, timeToleranceMs, }) => {
     var _a, _b, _c;
     // A broad search is intentional: one measurement can expand into several
     // observations, and the inverse mapper performs the type-specific grouping.
@@ -60,7 +60,7 @@ const useObservations = ({ types, period, patientId, }) => {
     }), [codes, patientId, period === null || period === void 0 ? void 0 : period.end, period === null || period === void 0 ? void 0 : period.start]);
     const [resources, loading, outcome] = (0, react_hooks_1.useSearchResources)("Observation", query);
     const observations = resources !== null && resources !== void 0 ? resources : [];
-    const measurements = React.useMemo(() => (0, observationsToMeasurements_1.observationsToMeasurements)(observations, types), [observations, types]);
+    const measurements = React.useMemo(() => (0, observationsToMeasurements_1.observationsToMeasurements)(observations, types, { groupBy, timeToleranceMs }), [groupBy, observations, timeToleranceMs, types]);
     return {
         measurements,
         loading,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ovok/core",
-  "version": "0.3.16",
+  "version": "0.3.17",
   "private": false,
   "main": "dist/index.js",
   "types": "dist/index.d.ts",