@ovok/core 0.4.40 → 0.4.41

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

@@ -1,4 +1,4 @@
-import type { OvokClient, SaveObservationsResult } from "../../ovok-client";
+import type { OvokClient, SaveObservationsOptions, SaveObservationsResult } from "../../ovok-client";
 import { GenerateObservationBodyParams } from "../types/generate-observation-body/GenerateObservationBodyParams";
 /** Framework-free save helper for apps that do not use React hooks. */
-export declare const saveMeasurement: (client: OvokClient, params: GenerateObservationBodyParams) => Promise<SaveObservationsResult>;
+export declare const saveMeasurement: (client: OvokClient, params: GenerateObservationBodyParams, options?: SaveObservationsOptions) => Promise<SaveObservationsResult>;

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

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.saveMeasurement = void 0;
 /** Framework-free save helper for apps that do not use React hooks. */
-const saveMeasurement = (client, params) => client.saveMeasurement(params);
+const saveMeasurement = (client, params, options) => client.saveMeasurement(params, options);
 exports.saveMeasurement = saveMeasurement;

package/dist/client/observation/observation-bundle-utils.d.ts

@@ -4,3 +4,8 @@ export declare const MAX_CONDITIONAL_OBSERVATION_ENTRIES = 8;
 export declare const linkObservationMembers: (observations: Observation[]) => Observation[];
 export declare const splitObservationBundleEntries: (bundle: Bundle) => BundleEntry[][] | undefined;
 export declare const executeObservationBundle: (bundle: Bundle, executeBatch: (bundle: Bundle) => Promise<Bundle>) => Promise<Bundle>;
+/**
+ * Readings' entries packed into as few requests as fit `MAX_OBSERVATION_BUNDLE_BYTES`, each reading whole. A reading
+ * too big for one request is a request by itself, which `executeObservationBundle` splits.
+ */
+export declare const packObservationGroups: (groups: BundleEntry[][]) => BundleEntry[][][];

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeObservationBundle = exports.splitObservationBundleEntries = exports.linkObservationMembers = exports.MAX_CONDITIONAL_OBSERVATION_ENTRIES = exports.MAX_OBSERVATION_BUNDLE_BYTES = void 0;
+exports.packObservationGroups = exports.executeObservationBundle = exports.splitObservationBundleEntries = exports.linkObservationMembers = exports.MAX_CONDITIONAL_OBSERVATION_ENTRIES = exports.MAX_OBSERVATION_BUNDLE_BYTES = void 0;
 const offline_1 = require("../offline");
 exports.MAX_OBSERVATION_BUNDLE_BYTES = 900000;
 exports.MAX_CONDITIONAL_OBSERVATION_ENTRIES = 8;
@@ -78,7 +78,7 @@ const splitObservationBundleEntries = (bundle) => {
 };
 exports.splitObservationBundleEntries = splitObservationBundleEntries;
 const executeObservationBundle = async (bundle, executeBatch) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
     const entries = (_a = bundle.entry) !== null && _a !== void 0 ? _a : [];
     if (bundle.type === "transaction" &&
         entries.length > exports.MAX_CONDITIONAL_OBSERVATION_ENTRIES) {
@@ -129,13 +129,40 @@ const executeObservationBundle = async (bundle, executeBatch) => {
         };
     }
     const response = await executeBatch(bundle);
-    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");
-    })) {
+    if (((_o = (_m = response.entry) === null || _m === void 0 ? void 0 : _m.length) !== null && _o !== void 0 ? _o : 0) !== entries.length ||
+        ((_p = response.entry) === null || _p === void 0 ? void 0 : _p.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");
+        }))) {
         throw response;
     }
     return response;
 };
 exports.executeObservationBundle = executeObservationBundle;
+/**
+ * Readings' entries packed into as few requests as fit `MAX_OBSERVATION_BUNDLE_BYTES`, each reading whole. A reading
+ * too big for one request is a request by itself, which `executeObservationBundle` splits.
+ */
+const packObservationGroups = (groups) => {
+    const envelope = JSON.stringify({ resourceType: "Bundle", type: "batch", entry: [] }).length;
+    const requests = [];
+    let request = [];
+    let size = envelope;
+    for (const group of groups) {
+        // Each entry adds its JSON and a separating comma.
+        const groupSize = group.reduce((total, entry) => total + JSON.stringify(entry).length + 1, 0);
+        if (request.length > 0 && size + groupSize > exports.MAX_OBSERVATION_BUNDLE_BYTES) {
+            requests.push(request);
+            request = [];
+            size = envelope;
+        }
+        request.push(group);
+        size += groupSize;
+    }
+    if (request.length > 0) {
+        requests.push(request);
+    }
+    return requests;
+};
+exports.packObservationGroups = packObservationGroups;

package/dist/client/observation/series.d.ts

@@ -0,0 +1,33 @@
+import { Observation } from "@medplum/fhirtypes";
+import { MeasurementDevice } from "./types/measurement/MeasurementDevice";
+import { MeasurementSeries } from "./types/measurement/MeasurementSeries";
+export type SeriesObservationParams = {
+    series: MeasurementSeries;
+    patientId: string;
+    device?: MeasurementDevice;
+    /** `preliminary` for values a device's own recording may still replace. */
+    status?: Observation["status"];
+};
+/** The values of a series observation, one per slot from `start`. */
+export type ReadSeries = {
+    start: Date;
+    periodMs: number;
+    values: Array<number | null>;
+};
+export type SeriesSummary = {
+    min: number;
+    max: number;
+    mean: number;
+    count: number;
+};
+/**
+ * A series as observations: one per measured property, in `MEASUREMENT_FIELDS` order with the main one first, each
+ * holding its values as `valueSampledData` across the series' `effectivePeriod`. They carry the same codes as a
+ * single reading of that kind. Save them with `saveObservations`, which links the rest to the first. ECG recordings
+ * keep their own path, `generateObservationBodiesByMeasurement`.
+ */
+export declare const seriesObservations: ({ series, patientId, device, status, }: SeriesObservationParams) => Observation[];
+/** The values of a series observation (`valueSampledData` with one dimension), or `undefined` for any other. */
+export declare const readSeries: (observation: Observation) => ReadSeries | undefined;
+/** The lowest, highest and mean of a series' values, or `undefined` when it holds none. */
+export declare const summarizeSeries: (values: ReadonlyArray<number | null>) => SeriesSummary | undefined;

package/dist/client/observation/series.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarizeSeries = exports.readSeries = exports.seriesObservations = void 0;
+const creator_1 = require("./services/creator");
+const getDeviceObject_1 = require("./utils/getDeviceObject");
+/** FHIR's mark for a slot with no value. */
+const NO_VALUE = "E";
+const sampledData = (values, decimals) => values
+    .map((value) => (value === null || !Number.isFinite(value) ? NO_VALUE : String(Number(value.toFixed(decimals)))))
+    .join(" ");
+/**
+ * A series as observations: one per measured property, in `MEASUREMENT_FIELDS` order with the main one first, each
+ * holding its values as `valueSampledData` across the series' `effectivePeriod`. They carry the same codes as a
+ * single reading of that kind. Save them with `saveObservations`, which links the rest to the first. ECG recordings
+ * keep their own path, `generateObservationBodiesByMeasurement`.
+ */
+const seriesObservations = ({ series, patientId, device, status = "registered", }) => {
+    const service = creator_1.ObservationServiceCreator.getInstance().getService(series.measurementTypeKey);
+    const codes = service.getObservationCodes();
+    const slots = Math.max(0, ...Object.values(series.values).map((values) => { var _a; return (_a = values === null || values === void 0 ? void 0 : values.length) !== null && _a !== void 0 ? _a : 0; }));
+    const effectivePeriod = {
+        start: series.start.toISOString(),
+        end: new Date(series.start.getTime() + slots * series.periodMs).toISOString(),
+    };
+    return service.getFields().flatMap((field, index) => {
+        const values = series.values[field.key];
+        const code = codes[index];
+        if (!code || !(values === null || values === void 0 ? void 0 : values.some((value) => value !== null))) {
+            return [];
+        }
+        return [{
+                resourceType: "Observation",
+                status,
+                subject: { reference: `Patient/${patientId}` },
+                device: (0, getDeviceObject_1.getDeviceObject)(device),
+                code,
+                effectivePeriod,
+                valueSampledData: {
+                    origin: { value: 0, unit: field.unit },
+                    period: series.periodMs,
+                    dimensions: 1,
+                    data: sampledData(values, field.decimals),
+                },
+            }];
+    });
+};
+exports.seriesObservations = seriesObservations;
+/** The values of a series observation (`valueSampledData` with one dimension), or `undefined` for any other. */
+const readSeries = (observation) => {
+    var _a, _b, _c, _d, _e, _f;
+    const sampled = observation.valueSampledData;
+    const start = (_b = (_a = observation.effectivePeriod) === null || _a === void 0 ? void 0 : _a.start) !== null && _b !== void 0 ? _b : observation.effectiveDateTime;
+    if (!(sampled === null || sampled === void 0 ? void 0 : sampled.data) || !sampled.period || !start || ((_c = sampled.dimensions) !== null && _c !== void 0 ? _c : 1) !== 1) {
+        return undefined;
+    }
+    const origin = (_e = (_d = sampled.origin) === null || _d === void 0 ? void 0 : _d.value) !== null && _e !== void 0 ? _e : 0;
+    const factor = (_f = sampled.factor) !== null && _f !== void 0 ? _f : 1;
+    return {
+        start: new Date(start),
+        periodMs: sampled.period,
+        values: sampled.data.trim().split(/\s+/).map((token) => {
+            const value = Number(token);
+            // E, L and U mark a slot without a value.
+            return Number.isFinite(value) ? origin + factor * value : null;
+        }),
+    };
+};
+exports.readSeries = readSeries;
+/** The lowest, highest and mean of a series' values, or `undefined` when it holds none. */
+const summarizeSeries = (values) => {
+    let min = Infinity, max = -Infinity, total = 0, count = 0;
+    // A loop, not Math.min(...values): an ECG holds more values than a call takes arguments.
+    for (const value of values) {
+        if (value !== null) {
+            min = Math.min(min, value);
+            max = Math.max(max, value);
+            total += value;
+            count++;
+        }
+    }
+    return count === 0 ? undefined : { min, max, mean: total / count, count };
+};
+exports.summarizeSeries = summarizeSeries;

package/dist/client/observation/types/measurement/MeasurementSeries.d.ts

@@ -0,0 +1,14 @@
+import { MeasurementTypeKey } from "../MeasurementTypeKey";
+/**
+ * One kind of measurement taken at a fixed interval, such as the heart rate a strap sends every second: one value
+ * per slot for each measured property, and `null` for a slot nothing arrived in.
+ */
+export type MeasurementSeries = {
+    measurementTypeKey: MeasurementTypeKey;
+    /** When the first slot starts. */
+    start: Date;
+    /** Milliseconds from one slot to the next. */
+    periodMs: number;
+    /** By measured property (the keys `MEASUREMENT_FIELDS` lists), one value per slot. */
+    values: Partial<Record<string, ReadonlyArray<number | null>>>;
+};

package/dist/client/observation/types/measurement/MeasurementSeries.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/client/observation/types/measurement/index.d.ts

@@ -18,3 +18,4 @@ export * from "./WalkingHeartRateAverageMeasurement";
 export * from "./LipidPanelMeasurement";
 export * from "./RespiratoryTherapyMeasurement";
 export * from "./BabySleepMeasurement";
+export * from "./MeasurementSeries";

package/dist/client/observation/types/measurement/index.js

@@ -34,3 +34,4 @@ __exportStar(require("./WalkingHeartRateAverageMeasurement"), exports);
 __exportStar(require("./LipidPanelMeasurement"), exports);
 __exportStar(require("./RespiratoryTherapyMeasurement"), exports);
 __exportStar(require("./BabySleepMeasurement"), exports);
+__exportStar(require("./MeasurementSeries"), exports);

package/dist/client/offline/offline-measurement-queue.d.ts

@@ -31,7 +31,16 @@ export type OfflineMeasurementFailure = {
 };
 type MeasurementTransport = (bundle: Bundle, requestOptions?: MedplumRequestOptions) => Promise<Bundle>;
 declare const stableMeasurementId: (observation: Observation) => string;
-declare const entryForObservation: (observation: Observation) => BundleEntry<Observation>;
+/** How a save names and writes each observation; `SaveObservationsOptions` describes both. */
+type ObservationEntryOptions = {
+    identifierSystems?: readonly string[];
+    replace?: boolean;
+};
+/**
+ * The bundle entry that saves `observation` once: created only if no observation of its subject has its content id
+ * or one of its reading identifiers, or with `replace`, written over the one saved under its reading identifiers.
+ */
+declare const entryForObservation: (observation: Observation, { identifierSystems, replace }?: ObservationEntryOptions) => BundleEntry<Observation>;
 export declare class OfflineMeasurementQueue {
     private readonly storage;
     private readonly transport;
@@ -42,7 +51,7 @@ export declare class OfflineMeasurementQueue {
     private readonly getOwnerKey?;
     private operation;
     constructor(storage: IClientStorage, transport: MeasurementTransport, options?: OfflineMeasurementQueueOptions);
-    enqueueAndFlush: (observations: Observation[], requestOptions?: MedplumRequestOptions) => Promise<{
+    enqueueAndFlush: (observations: Observation[], requestOptions?: MedplumRequestOptions, entryOptions?: ObservationEntryOptions) => Promise<{
         id: string;
         flush: OfflineMeasurementFlushResult;
     }>;
@@ -52,4 +61,5 @@ export declare class OfflineMeasurementQueue {
     private writeQueue;
     private flushQueue;
 }
+export type { ObservationEntryOptions };
 export { OFFLINE_MEASUREMENT_QUEUE_STORAGE_KEY as DEFAULT_OFFLINE_MEASUREMENT_QUEUE_KEY, IDENTIFIER_SYSTEM as OFFLINE_MEASUREMENT_IDENTIFIER_SYSTEM, entryForObservation, stableMeasurementId, };

package/dist/client/offline/offline-measurement-queue.js

@@ -62,28 +62,55 @@ const stableMeasurementId = (observation) => {
     return stableValueId(legacyObservation);
 };
 exports.stableMeasurementId = stableMeasurementId;
-const entryForObservation = (observation) => {
-    var _a, _b;
+/** The observation's identifiers in `systems`, as `system|value` search tokens. */
+const readingIdentifiers = (observation, systems) => {
+    var _a;
+    return ((_a = observation.identifier) !== null && _a !== void 0 ? _a : [])
+        .filter(({ system, value }) => system && value && systems.includes(system))
+        .map(({ system, value }) => `${system}|${value}`);
+};
+/** A search for an observation of the same subject carrying any of `identifiers`. */
+const searchFor = (observation, identifiers) => {
+    var _a;
+    const subject = (_a = observation.subject) === null || _a === void 0 ? void 0 : _a.reference;
+    return [
+        `identifier=${identifiers.map(encodeURIComponent).join(",")}`,
+        ...(subject ? [`subject=${encodeURIComponent(subject)}`] : []),
+    ].join("&");
+};
+/**
+ * The bundle entry that saves `observation` once: created only if no observation of its subject has its content id
+ * or one of its reading identifiers, or with `replace`, written over the one saved under its reading identifiers.
+ */
+const entryForObservation = (observation, { identifierSystems = [], replace = false } = {}) => {
+    var _a;
     const id = stableMeasurementId(observation);
-    const identifier = {
-        system: IDENTIFIER_SYSTEM,
-        value: id,
+    const fullUrl = `urn:uuid:${id}`;
+    const resource = {
+        ...observation,
+        identifier: [...((_a = observation.identifier) !== null && _a !== void 0 ? _a : []), { system: IDENTIFIER_SYSTEM, value: id }],
     };
-    const sourceIdentifier = (_a = observation.identifier) === null || _a === void 0 ? void 0 : _a.find((item) => item.system === fhir_systems_1.DEVICE_READING_IDENTIFIER_SYSTEM);
-    const ifNoneExist = sourceIdentifier
-        ? `identifier=${encodeURIComponent(`${IDENTIFIER_SYSTEM}|${id}`)},${encodeURIComponent(`${fhir_systems_1.DEVICE_READING_IDENTIFIER_SYSTEM}|${sourceIdentifier.value}`)}`
-        : `identifier=${IDENTIFIER_SYSTEM}|${id}`;
+    const readings = readingIdentifiers(observation, [
+        fhir_systems_1.DEVICE_READING_IDENTIFIER_SYSTEM,
+        ...identifierSystems,
+    ]);
+    if (replace && readings.length > 0) {
+        // Medplum refuses a create-by-update that names an id.
+        delete resource.id;
+        return {
+            fullUrl,
+            request: { method: "PUT", url: `Observation?${searchFor(observation, readings)}` },
+            resource,
+        };
+    }
     return {
-        fullUrl: `urn:uuid:${id}`,
+        fullUrl,
         request: {
             method: "POST",
             url: "Observation",
-            ifNoneExist,
-        },
-        resource: {
-            ...observation,
-            identifier: [...((_b = observation.identifier) !== null && _b !== void 0 ? _b : []), identifier],
+            ifNoneExist: searchFor(observation, [`${IDENTIFIER_SYSTEM}|${id}`, ...readings]),
         },
+        resource,
     };
 };
 exports.entryForObservation = entryForObservation;
@@ -119,14 +146,14 @@ class OfflineMeasurementQueue {
         this.storage = storage;
         this.transport = transport;
         this.operation = Promise.resolve();
-        this.enqueueAndFlush = (observations, requestOptions) => {
+        this.enqueueAndFlush = (observations, requestOptions, entryOptions) => {
             var _a;
             const ownerKey = (_a = this.getOwnerKey) === null || _a === void 0 ? void 0 : _a.call(this);
             return this.runExclusive(async () => {
                 var _a, _b;
                 await ((_b = (_a = this.storage).getInitPromise) === null || _b === void 0 ? void 0 : _b.call(_a));
                 const queue = this.readQueue();
-                const entries = observations.map(entryForObservation);
+                const entries = observations.map((observation) => entryForObservation(observation, entryOptions));
                 if (this.getOwnerKey && !ownerKey) {
                     throw new Error("Offline measurements require an active account to prevent cross-account delivery.");
                 }

package/dist/client/ovok-client.d.ts

@@ -32,6 +32,20 @@ export type SaveObservationsResult = {
     status: "queued";
     queueId: string;
 };
+/** Medplum's request options, and how a save names and writes its observations. */
+export type SaveObservationsOptions = MedplumRequestOptions & {
+    /**
+     * Identifier systems that name a reading for good, such as an app's own reading key. An observation carrying an
+     * identifier in one of them is created only if no observation of its subject has that identifier, so a reading
+     * delivered again, or saved before under that key, is saved once. The SDK's device-reading id always counts.
+     */
+    identifierSystems?: readonly string[];
+    /**
+     * Write over the observation saved under the same reading identifiers instead of keeping it, for a value that
+     * changes, such as a day's step total. Needs a reading identifier; an observation without one is created once.
+     */
+    replace?: boolean;
+};
 export type OvokFhirVersion = "R4" | "R5";
 export type OvokClientOptions = Omit<MedplumClientOptions, "onUnauthenticated"> & {
     onUnauthenticated?: (reason: OvokUnauthenticatedReason) => void;
@@ -81,18 +95,27 @@ export declare class OvokClient extends MedplumClient {
     /** Reauthentication clears the expired marker for the account that signed in. */
     setActiveLogin(login: LoginState): Promise<void>;
     /** Saves a measurement immediately, or durably queues it when the opt-in queue is enabled. */
-    saveMeasurement(params: GenerateObservationBodyParams, requestOptions?: MedplumRequestOptions): Promise<SaveObservationsResult>;
+    saveMeasurement(params: GenerateObservationBodyParams, options?: SaveObservationsOptions): Promise<SaveObservationsResult>;
     /** Reads Ovok's composed FHIR and public-route capability statement. */
     getCapabilityStatement(version?: OvokFhirVersion, requestOptions?: MedplumRequestOptions): Promise<CapabilityStatement>;
     /** Returns the non-FHIR public routes published by the backend statement. */
     getPublicApiEndpoints(version?: OvokFhirVersion, requestOptions?: MedplumRequestOptions): Promise<OvokPublicApiEndpoint[]>;
-    /** Saves observations with conditional creates so a retry cannot create a duplicate. */
-    saveObservations(observations: Observation[], requestOptions?: MedplumRequestOptions): Promise<SaveObservationsResult>;
+    /**
+     * Saves one reading's observations, main first, with conditional creates so a retry cannot create a duplicate.
+     * A reading too big for one request goes over several, and stops if the signed-in account changes in between.
+     */
+    saveObservations(observations: Observation[], options?: SaveObservationsOptions): Promise<SaveObservationsResult>;
+    /**
+     * Saves many readings at once, such as a page of a health import: each group is one reading's observations, main
+     * first, linked and named as `saveObservations` does. Readings share batch requests as far as they fit, each whole;
+     * one too big for a request goes alone and is split. It is never queued offline: an import reads its source again.
+     */
+    saveObservationGroups(groups: Observation[][], options?: SaveObservationsOptions): Promise<Bundle>;
     /** Flushes measurements queued while offline. Call this on connectivity/app-resume events. */
     flushOfflineMeasurementQueue(options?: OfflineMeasurementFlushOptions, requestOptions?: MedplumRequestOptions): Promise<OfflineMeasurementFlushResult>;
     private getOfflineMeasurementQueue;
-    /** Queued measurements belong to one account on one server and project. */
-    private offlineOwnerKey;
+    /** The signed-in account, on its server and project: what queued measurements and a running save belong to. */
+    private accountKey;
     /**
      * Medplum clears its entire client storage after an unrecoverable 401. Keep
      * saved accounts (marking only the active one expired) and queued measurements.
@@ -108,7 +131,10 @@ export declare class OvokClient extends MedplumClient {
     private removeSavedAccount;
     private syncSavedAccountProfile;
     private restoreActiveLogin;
-    private executeConditionalObservationCreates;
+    /**
+     * Sends a save's bundle, over several requests when it must. A later request isn't sent once the signed-in
+     * account differs from `account`: the rest of a reading is never written under someone else's sign-in.
+     */
     private executeObservationBundle;
     private bindMethods;
     /**

package/dist/client/ovok-client.js

@@ -68,6 +68,14 @@ const slimMethods = __importStar(require("./slim/methods"));
 var observation_bundle_utils_2 = require("./observation/observation-bundle-utils");
 Object.defineProperty(exports, "MAX_CONDITIONAL_OBSERVATION_ENTRIES", { enumerable: true, get: function () { return observation_bundle_utils_2.MAX_CONDITIONAL_OBSERVATION_ENTRIES; } });
 Object.defineProperty(exports, "MAX_OBSERVATION_BUNDLE_BYTES", { enumerable: true, get: function () { return observation_bundle_utils_2.MAX_OBSERVATION_BUNDLE_BYTES; } });
+/** A save's own options apart from the request options it passes on. */
+const splitSaveOptions = (options) => {
+    if (!options) {
+        return [{}, undefined];
+    }
+    const { identifierSystems, replace, ...requestOptions } = options;
+    return [{ identifierSystems, replace }, requestOptions];
+};
 const isRetrySafePost = (pathname) => pathname === "/ai/fhir/search";
 /** A failed profile load is tried again after this long, doubling up to the maximum. */
 const PROFILE_RETRY_MS = 2000;
@@ -312,9 +320,9 @@ class OvokClient extends core_1.MedplumClient {
         }
     }
     /** Saves a measurement immediately, or durably queues it when the opt-in queue is enabled. */
-    async saveMeasurement(params, requestOptions) {
+    async saveMeasurement(params, options) {
         const observations = await this.generateObservationBodiesByMeasurement(params);
-        return this.saveObservations(observations, ...(0, request_options_1.optionalArg)(requestOptions));
+        return this.saveObservations(observations, ...(0, request_options_1.optionalArg)(options));
     }
     /** Reads Ovok's composed FHIR and public-route capability statement. */
     async getCapabilityStatement(version = "R4", requestOptions) {
@@ -324,20 +332,51 @@ class OvokClient extends core_1.MedplumClient {
     async getPublicApiEndpoints(version = "R4", requestOptions) {
         return (0, capability_1.getOvokPublicApiEndpoints)(await this.getCapabilityStatement(version, ...(0, request_options_1.optionalArg)(requestOptions)));
     }
-    /** Saves observations with conditional creates so a retry cannot create a duplicate. */
-    async saveObservations(observations, requestOptions) {
+    /**
+     * Saves one reading's observations, main first, with conditional creates so a retry cannot create a duplicate.
+     * A reading too big for one request goes over several, and stops if the signed-in account changes in between.
+     */
+    async saveObservations(observations, options) {
+        const [entryOptions, requestOptions] = splitSaveOptions(options);
         const linkedObservations = (0, observation_bundle_utils_1.linkObservationMembers)(observations);
         const queue = this.getOfflineMeasurementQueue();
         if (queue) {
-            const { id, flush } = await queue.enqueueAndFlush(linkedObservations, ...(0, request_options_1.optionalArg)(requestOptions));
+            const { id, flush } = await queue.enqueueAndFlush(linkedObservations, requestOptions, entryOptions);
             const response = flush.responses[id];
             return response
                 ? { status: "saved", response }
                 : { status: "queued", queueId: id };
         }
-        const response = await this.executeConditionalObservationCreates(linkedObservations, requestOptions);
+        const response = await this.executeObservationBundle({
+            resourceType: "Bundle",
+            type: "transaction",
+            entry: linkedObservations.map((observation) => (0, offline_1.entryForObservation)(observation, entryOptions)),
+        }, ...(0, request_options_1.optionalArg)(requestOptions));
         return { status: "saved", response };
     }
+    /**
+     * Saves many readings at once, such as a page of a health import: each group is one reading's observations, main
+     * first, linked and named as `saveObservations` does. Readings share batch requests as far as they fit, each whole;
+     * one too big for a request goes alone and is split. It is never queued offline: an import reads its source again.
+     */
+    async saveObservationGroups(groups, options) {
+        const [entryOptions, requestOptions] = splitSaveOptions(options);
+        const account = this.accountKey();
+        const entryGroups = groups
+            .filter((group) => group.length > 0)
+            .map((group) => (0, observation_bundle_utils_1.linkObservationMembers)(group).map((observation) => (0, offline_1.entryForObservation)(observation, entryOptions)));
+        const responses = [];
+        for (const request of (0, observation_bundle_utils_1.packObservationGroups)(entryGroups)) {
+            // A reading alone keeps a single save's atomicity; several share a batch.
+            const type = request.length === 1 ? "transaction" : "batch";
+            responses.push(await this.executeObservationBundle({ resourceType: "Bundle", type, entry: request.flat() }, requestOptions, account));
+        }
+        return {
+            resourceType: "Bundle",
+            type: "batch-response",
+            entry: responses.flatMap((response) => { var _a; return (_a = response.entry) !== null && _a !== void 0 ? _a : []; }),
+        };
+    }
     /** Flushes measurements queued while offline. Call this on connectivity/app-resume events. */
     async flushOfflineMeasurementQueue(options = {}, requestOptions) {
         const queue = this.getOfflineMeasurementQueue();
@@ -363,12 +402,12 @@ class OvokClient extends core_1.MedplumClient {
         }
         (_a = this.offlineMeasurementQueue) !== null && _a !== void 0 ? _a : (this.offlineMeasurementQueue = new offline_1.OfflineMeasurementQueue(this.clientStorage, (bundle, requestOptions) => this.executeObservationBundle(bundle, ...(0, request_options_1.optionalArg)(requestOptions)), {
             ...this.offlineQueueOptions,
-            getOwnerKey: () => this.offlineOwnerKey(),
+            getOwnerKey: () => this.accountKey(),
         }));
         return this.offlineMeasurementQueue;
     }
-    /** Queued measurements belong to one account on one server and project. */
-    offlineOwnerKey() {
+    /** The signed-in account, on its server and project: what queued measurements and a running save belong to. */
+    accountKey() {
         var _a, _b, _c;
         const login = this.getActiveLogin();
         const profileReference = (_a = login === null || login === void 0 ? void 0 : login.profile) === null || _a === void 0 ? void 0 : _a.reference;
@@ -474,16 +513,17 @@ class OvokClient extends core_1.MedplumClient {
             // Keep the saved login available for a later retry if restoration is offline.
         }
     }
-    async executeConditionalObservationCreates(observations, requestOptions) {
-        const entries = observations.map(offline_1.entryForObservation);
-        return this.executeObservationBundle({
-            resourceType: "Bundle",
-            type: "transaction",
-            entry: entries,
-        }, ...(0, request_options_1.optionalArg)(requestOptions));
-    }
-    async executeObservationBundle(bundle, requestOptions) {
-        const response = await (0, observation_bundle_utils_1.executeObservationBundle)(bundle, (request) => this.executeBatch(request, ...(0, request_options_1.optionalArg)(requestOptions)));
+    /**
+     * Sends a save's bundle, over several requests when it must. A later request isn't sent once the signed-in
+     * account differs from `account`: the rest of a reading is never written under someone else's sign-in.
+     */
+    async executeObservationBundle(bundle, requestOptions, account = this.accountKey()) {
+        const response = await (0, observation_bundle_utils_1.executeObservationBundle)(bundle, (request) => {
+            if (this.accountKey() !== account) {
+                throw new Error("The signed-in account changed during the save; the rest of it was not sent.");
+            }
+            return this.executeBatch(request, ...(0, request_options_1.optionalArg)(requestOptions));
+        });
         this.invalidateSearches("Observation");
         return response;
     }

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.4.40",
+        version: "0.4.41",
     },
     fhirVersion: "4.0.1",
     format: ["json"],

package/dist/index.d.ts

@@ -934,13 +934,14 @@ export type { OvokSavedAccount } from "./client/auth/types/Account";
 export { LoginError } from "./client/auth/types/LoginError";
 export type { LoginProfile, TenantLoginStart } from "./client/auth/types/LoginError";
 export { MAX_CONDITIONAL_OBSERVATION_ENTRIES, MAX_OBSERVATION_BUNDLE_BYTES, } from "./client/ovok-client";
-export type { SaveObservationsResult } from "./client/ovok-client";
+export type { SaveObservationsOptions, SaveObservationsResult } from "./client/ovok-client";
 export * from "./client/offline";
 export * from "./hooks";
 export * from "./utils";
 export * from "./client/observation/services";
 export * from "./client/observation/methods";
 export * from "./client/observation/measurement-fields";
+export * from "./client/observation/series";
 export { saveMeasurement } from "./client/observation/methods/saveMeasurement";
 export * from "./conformance/capability-requirements";
 export * from "./conformance/api-requirements";

package/dist/index.js

@@ -59,6 +59,7 @@ __exportStar(require("./utils"), exports);
 __exportStar(require("./client/observation/services"), exports);
 __exportStar(require("./client/observation/methods"), exports);
 __exportStar(require("./client/observation/measurement-fields"), exports);
+__exportStar(require("./client/observation/series"), exports);
 var saveMeasurement_1 = require("./client/observation/methods/saveMeasurement");
 Object.defineProperty(exports, "saveMeasurement", { enumerable: true, get: function () { return saveMeasurement_1.saveMeasurement; } });
 __exportStar(require("./conformance/capability-requirements"), exports);

package/package.json

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