@ovok/core 0.4.49-dev.497 → 0.4.49-dev.499

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.49-dev.497+7201066",
+        version: "0.4.49-dev.499+db0e927",
     },
     fhirVersion: "4.0.1",
     format: ["json"],

package/dist/next/index.d.ts

@@ -17,6 +17,7 @@ export type { HealthCheck } from "./resources/health-resource";
 export type { PatientRegistration, PractitionerRegistration, RegisterResult } from "./resources/auth/registration";
 export type { SocialCredentials, SocialProvider } from "./resources/auth/social-login";
 export type { LastObservationsQuery, LatestObservationsParams, MeasurementCodeTypes, SaveObservationsOptions, SaveObservationsResult, } from "./resources/measurements/measurements-resource";
+export type { OfflineMeasurementFailure, OfflineMeasurementFlushOptions, OfflineMeasurementFlushResult, OfflineMeasurementQueueApi, } from "./resources/measurements/offline-measurement-queue";
 export type { BuildObservationsParams } from "./resources/measurements/observation-builder";
 export type { SignalsDeliveryRepair, SignalsDeliveryRepairResult, SignalsUndeliverable, SignalsUndeliverableResident, } from "./resources/signals/undeliverable-resource";
 export type { ProjectListQuery } from "./resources/projects/projects-resource";

package/dist/next/ovok.js

@@ -24,6 +24,7 @@ const invites_resource_1 = require("./resources/invites/invites-resource");
 const locales_resource_1 = require("./resources/localization/locales-resource");
 const localizations_resource_1 = require("./resources/localization/localizations-resource");
 const measurements_resource_1 = require("./resources/measurements/measurements-resource");
+const offline_measurement_queue_1 = require("./resources/measurements/offline-measurement-queue");
 const patient_resource_1 = require("./resources/patient/patient-resource");
 const projects_resource_1 = require("./resources/projects/projects-resource");
 const questionnaires_resource_1 = require("./resources/questionnaires/questionnaires-resource");
@@ -36,6 +37,7 @@ const wearables_resource_1 = require("./resources/wearables/wearables-resource")
 /** One client per tenant; each namespace mirrors an area of the Ovok API. */
 class Ovok {
     constructor(config) {
+        var _a, _b;
         const settings = (0, settings_1.readSettings)(config, (0, settings_1.currentEnvironment)());
         const credentials = credentialsFor(settings);
         const http = new http_client_1.HttpClient({ settings, credentials, retryPolicy: new retry_policy_1.RetryPolicy(settings.maxNetworkRetries) });
@@ -46,7 +48,11 @@ class Ovok {
         this.fhir = fhir;
         this.health = new health_resource_1.HealthResource(http.anonymous());
         this.patient = new patient_resource_1.PatientResource(http, fhir);
-        this.measurements = new measurements_resource_1.MeasurementsResource(http, fhir, session);
+        this.measurements = new measurements_resource_1.MeasurementsResource(http, fhir, session, {
+            storage: settings.storage,
+            queueKey: (0, offline_measurement_queue_1.offlineMeasurementStorageKey)(settings.tenantCode, settings.baseUrl),
+            machineClientId: (_b = (_a = settings.machineClient) === null || _a === void 0 ? void 0 : _a.clientId) !== null && _b !== void 0 ? _b : null,
+        });
         this.questionnaires = new questionnaires_resource_1.QuestionnairesResource(http);
         this.questionnaireResponses = new questionnaires_resource_1.QuestionnaireResponsesResource(http, fhir);
         this.consent = new consent_resource_1.ConsentResource(http);

package/dist/next/react/context.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import type { Ovok } from "../ovok";
+export declare const OvokContext: React.Context<Ovok | null>;
+export declare const useOvok: () => Ovok;

package/dist/next/react/context.js

@@ -0,0 +1,46 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOvok = exports.OvokContext = void 0;
+const React = __importStar(require("react"));
+exports.OvokContext = React.createContext(null);
+const useOvok = () => {
+    const client = React.useContext(exports.OvokContext);
+    if (client === null) {
+        throw new Error("useOvok must be used inside an OvokProvider.");
+    }
+    return client;
+};
+exports.useOvok = useOvok;

package/dist/next/react/index.d.ts

@@ -0,0 +1,14 @@
+import * as React from "react";
+import type { Session } from "../auth/session";
+import type { Ovok } from "../ovok";
+import type { OvokQueryState } from "./query-hooks";
+import { useOvok } from "./context";
+export type OvokProviderProps = React.PropsWithChildren<{
+    client: Ovok;
+}>;
+export declare const OvokProvider: ({ client, children }: OvokProviderProps) => React.ReactElement;
+export declare const useSession: () => OvokQueryState<Session | null>;
+export declare const useProfile: () => OvokQueryState<Session["profile"] | null>;
+export { useOvokMutation, useOvokQuery, useResource, useSearch, useSubscription } from "./query-hooks";
+export { useOvok };
+export type { OvokMutationState, OvokQueryOptions, OvokQueryState } from "./query-hooks";

package/dist/next/react/index.js

@@ -0,0 +1,68 @@
+"use strict";
+"use client";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOvok = exports.useSubscription = exports.useSearch = exports.useResource = exports.useOvokQuery = exports.useOvokMutation = exports.useProfile = exports.useSession = exports.OvokProvider = void 0;
+const React = __importStar(require("react"));
+const context_1 = require("./context");
+Object.defineProperty(exports, "useOvok", { enumerable: true, get: function () { return context_1.useOvok; } });
+const query_hooks_1 = require("./query-hooks");
+const OvokProvider = ({ client, children }) => (React.createElement(context_1.OvokContext.Provider, { value: client }, children));
+exports.OvokProvider = OvokProvider;
+const useSession = () => {
+    const client = (0, context_1.useOvok)();
+    const subscribe = React.useCallback((listener) => client.session.onChange(listener), [client]);
+    const changedSession = (0, query_hooks_1.useSubscription)(subscribe);
+    const state = (0, query_hooks_1.useOvokQuery)((ovok) => ovok.session.current(), { queryKey: ["session"] });
+    return changedSession === undefined
+        ? state
+        : { ...state, data: changedSession, loading: false, isRefreshing: false, isStale: false, error: undefined };
+};
+exports.useSession = useSession;
+const useProfile = () => {
+    var _a, _b;
+    const session = (0, exports.useSession)();
+    return {
+        ...session,
+        data: session.data === undefined ? undefined : (_b = (_a = session.data) === null || _a === void 0 ? void 0 : _a.profile) !== null && _b !== void 0 ? _b : null,
+    };
+};
+exports.useProfile = useProfile;
+var query_hooks_2 = require("./query-hooks");
+Object.defineProperty(exports, "useOvokMutation", { enumerable: true, get: function () { return query_hooks_2.useOvokMutation; } });
+Object.defineProperty(exports, "useOvokQuery", { enumerable: true, get: function () { return query_hooks_2.useOvokQuery; } });
+Object.defineProperty(exports, "useResource", { enumerable: true, get: function () { return query_hooks_2.useResource; } });
+Object.defineProperty(exports, "useSearch", { enumerable: true, get: function () { return query_hooks_2.useSearch; } });
+Object.defineProperty(exports, "useSubscription", { enumerable: true, get: function () { return query_hooks_2.useSubscription; } });

package/dist/next/react/query-hooks.d.ts

@@ -0,0 +1,31 @@
+import type { QueryParams } from "../http/url";
+import type { Ovok } from "../ovok";
+import type { Page } from "../paging/page";
+import type { ExtractResource, ResourceType } from "@medplum/fhirtypes";
+export type OvokQueryOptions = {
+    queryKey: readonly unknown[];
+    enabled?: boolean;
+};
+export type OvokQueryState<T> = {
+    data: T | undefined;
+    loading: boolean;
+    isRefreshing: boolean;
+    isStale: boolean;
+    error: Error | undefined;
+    refetch: () => void;
+};
+export type OvokMutationState<TVariables, TResult> = {
+    data: TResult | undefined;
+    loading: boolean;
+    error: Error | undefined;
+    mutate: (variables: TVariables) => Promise<TResult>;
+    reset: () => void;
+};
+type OvokQuery<T> = (client: Ovok, signal: AbortSignal) => Promise<T>;
+type OvokMutation<TVariables, TResult> = (client: Ovok, variables: TVariables) => Promise<TResult>;
+export declare const useOvokQuery: <T>(query: OvokQuery<T>, options: OvokQueryOptions) => OvokQueryState<T>;
+export declare const useOvokMutation: <TVariables, TResult>(mutation: OvokMutation<TVariables, TResult>) => OvokMutationState<TVariables, TResult>;
+export declare const useResource: <K extends ResourceType>(type: K, id: string | undefined, options?: Pick<OvokQueryOptions, "enabled">) => OvokQueryState<ExtractResource<K>>;
+export declare const useSearch: <K extends ResourceType>(type: K, params?: QueryParams, options?: Pick<OvokQueryOptions, "enabled">) => OvokQueryState<Page<ExtractResource<K>>>;
+export declare const useSubscription: <T>(subscribe: (listener: (value: T) => void) => () => void) => T | undefined;
+export {};

package/dist/next/react/query-hooks.js

@@ -0,0 +1,160 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSubscription = exports.useSearch = exports.useResource = exports.useOvokMutation = exports.useOvokQuery = void 0;
+const React = __importStar(require("react"));
+const context_1 = require("./context");
+const useOvokQuery = (query, options) => {
+    var _a, _b;
+    const client = (0, context_1.useOvok)();
+    const key = (_a = JSON.stringify(options.queryKey)) !== null && _a !== void 0 ? _a : "[]";
+    const enabled = (_b = options.enabled) !== null && _b !== void 0 ? _b : true;
+    const queryRef = React.useRef(query);
+    const previousQuery = React.useRef(null);
+    const [data, setData] = React.useState();
+    const [loading, setLoading] = React.useState(enabled);
+    const [error, setError] = React.useState();
+    const [revision, setRevision] = React.useState(0);
+    queryRef.current = query;
+    React.useEffect(() => {
+        const previous = previousQuery.current;
+        const changed = previous === null || previous.client !== client || previous.key !== key;
+        previousQuery.current = { client, key };
+        if (changed) {
+            setData(undefined);
+        }
+        if (!enabled) {
+            setError(undefined);
+            setLoading(false);
+            return undefined;
+        }
+        const controller = new AbortController();
+        let disposed = false;
+        setLoading(true);
+        setError(undefined);
+        void Promise.resolve()
+            .then(() => queryRef.current(client, controller.signal))
+            .then((result) => {
+            if (!disposed) {
+                setData(result);
+                setLoading(false);
+            }
+        })
+            .catch((reason) => {
+            if (!disposed) {
+                setError(toError(reason));
+                setLoading(false);
+            }
+        });
+        return () => {
+            disposed = true;
+            controller.abort();
+        };
+    }, [client, enabled, key, revision]);
+    const refetch = React.useCallback(() => setRevision((value) => value + 1), []);
+    return {
+        data,
+        loading,
+        isRefreshing: data !== undefined && loading,
+        isStale: data !== undefined && (loading || error !== undefined),
+        error,
+        refetch,
+    };
+};
+exports.useOvokQuery = useOvokQuery;
+const useOvokMutation = (mutation) => {
+    const client = (0, context_1.useOvok)();
+    const mutationRef = React.useRef(mutation);
+    const pendingCount = React.useRef(0);
+    const [data, setData] = React.useState();
+    const [loading, setLoading] = React.useState(false);
+    const [error, setError] = React.useState();
+    mutationRef.current = mutation;
+    const mutate = React.useCallback(async (variables) => {
+        pendingCount.current += 1;
+        setLoading(true);
+        setError(undefined);
+        try {
+            const result = await mutationRef.current(client, variables);
+            setData(result);
+            return result;
+        }
+        catch (reason) {
+            const mutationError = toError(reason);
+            setError(mutationError);
+            throw mutationError;
+        }
+        finally {
+            pendingCount.current -= 1;
+            setLoading(pendingCount.current > 0);
+        }
+    }, [client]);
+    const reset = React.useCallback(() => {
+        setData(undefined);
+        setError(undefined);
+    }, []);
+    return { data, loading, error, mutate, reset };
+};
+exports.useOvokMutation = useOvokMutation;
+const useResource = (type, id, options = {}) => {
+    var _a;
+    return (0, exports.useOvokQuery)((client, signal) => {
+        if (!id) {
+            return Promise.reject(new Error("A resource id is required."));
+        }
+        return client.fhir.read(type, id, { signal });
+    }, { queryKey: [type, id], enabled: (_a = options.enabled) !== null && _a !== void 0 ? _a : Boolean(id) });
+};
+exports.useResource = useResource;
+const useSearch = (type, params = {}, options = {}) => (0, exports.useOvokQuery)((client, signal) => client.fhir.search(type, params, { signal }), { queryKey: [type, params], enabled: options.enabled });
+exports.useSearch = useSearch;
+const useSubscription = (subscribe) => {
+    const [subscription, setSubscription] = React.useState();
+    React.useEffect(() => {
+        let active = true;
+        const unsubscribe = subscribe((value) => {
+            if (active) {
+                setSubscription({ subscribe, value });
+            }
+        });
+        return () => {
+            active = false;
+            unsubscribe();
+        };
+    }, [subscribe]);
+    return (subscription === null || subscription === void 0 ? void 0 : subscription.subscribe) === subscribe ? subscription.value : undefined;
+};
+exports.useSubscription = useSubscription;
+const toError = (reason) => (reason instanceof Error ? reason : new Error(String(reason)));

package/dist/next/resources/measurements/measurements-resource.d.ts

@@ -1,4 +1,6 @@
+import type { OfflineMeasurementQueueApi } from "./offline-measurement-queue";
 import type { GetLatestObservationsByCodeParams } from "../../../client/observation/types/GetLatestObservationsByCodeParams";
+import type { OvokStorage } from "../../storage/ovok-storage";
 import type { Bundle, Observation } from "@medplum/fhirtypes";
 import { observationCodesForTypes } from "../../../client/observation/methods/observationsToMeasurements";
 import { HttpClient } from "../../http/http-client";
@@ -15,6 +17,14 @@ export type SaveObservationsOptions = RequestOptions & {
 export type SaveObservationsResult = {
     status: "saved";
     response: Bundle;
+} | {
+    status: "queued";
+    queueId: string;
+};
+type MeasurementStorage = {
+    storage: OvokStorage;
+    queueKey: string;
+    machineClientId: string | null;
 };
 export type LatestObservationsParams = GetLatestObservationsByCodeParams;
 export type LastObservationsQuery = {
@@ -26,7 +36,11 @@ export declare class MeasurementsResource {
     private readonly http;
     private readonly fhir;
     private readonly account;
-    constructor(http: HttpClient, fhir: FhirResource, session: SessionSource | null);
+    private readonly offlineMeasurementQueue;
+    private readonly machineClientId;
+    private readonly session;
+    readonly offlineQueue: OfflineMeasurementQueueApi;
+    constructor(http: HttpClient, fhir: FhirResource, session: SessionSource | null, storageOptions: MeasurementStorage);
     save(params: BuildObservationsParams, options?: SaveObservationsOptions): Promise<SaveObservationsResult>;
     /** One reading, main observation first, created conditionally so a retry cannot duplicate it. */
     saveObservations(observations: Observation[], options?: SaveObservationsOptions): Promise<SaveObservationsResult>;
@@ -38,5 +52,7 @@ export declare class MeasurementsResource {
     private latestPatientId;
     /** A reading split over several requests stops once another account signs in, so none of it lands elsewhere. */
     private send;
+    private currentOwnerKey;
     private requireOwner;
 }
+export {};

package/dist/next/resources/measurements/measurements-resource.js

@@ -8,15 +8,22 @@ const query_string_1 = require("../../../client/query-string");
 const ovok_errors_1 = require("../../errors/ovok-errors");
 const url_1 = require("../../http/url");
 const observation_builder_1 = require("./observation-builder");
+const offline_measurement_queue_2 = require("./offline-measurement-queue");
 const save_error_1 = require("./save-error");
 const signed_in_account_1 = require("./signed-in-account");
 const LATEST_OBSERVATIONS_PATH = "fhir/Observation/$lastn";
 const LATEST_PER_CODE = 1;
 class MeasurementsResource {
-    constructor(http, fhir, session) {
+    constructor(http, fhir, session, storageOptions) {
         this.http = http;
         this.fhir = fhir;
+        this.session = session;
+        this.machineClientId = storageOptions.machineClientId;
         this.account = new signed_in_account_1.SignedInAccount(session);
+        this.offlineMeasurementQueue = new offline_measurement_queue_2.OfflineMeasurementQueue(storageOptions.storage, storageOptions.queueKey, () => this.currentOwnerKey(), (bundle, ownerKey, requestOptions) => this.send(bundle, requestOptions, ownerKey));
+        this.offlineQueue = {
+            flush: (options, requestOptions) => this.offlineMeasurementQueue.flush(options, requestOptions),
+        };
     }
     async save(params, options) {
         return this.saveObservations(await this.build(params), options);
@@ -25,8 +32,16 @@ class MeasurementsResource {
     async saveObservations(observations, options = {}) {
         const { identifierSystems, replace, ...requestOptions } = options;
         const entry = (0, observation_bundle_utils_1.linkObservationMembers)(observations).map((observation) => (0, offline_measurement_queue_1.entryForObservation)(observation, { identifierSystems, replace }));
-        const response = await this.send({ resourceType: "Bundle", type: "transaction", entry }, requestOptions);
-        return { status: "saved", response };
+        const ownerKey = await this.currentOwnerKey();
+        if (entry.length === 0 || ownerKey === null) {
+            const response = await this.send({ resourceType: "Bundle", type: "transaction", entry }, requestOptions, ownerKey);
+            return { status: "saved", response };
+        }
+        const queued = await this.offlineMeasurementQueue.enqueueAndFlush(entry, ownerKey, requestOptions);
+        const response = queued.flush.responses[queued.id];
+        return response
+            ? { status: "saved", response }
+            : { status: "queued", queueId: queued.id };
     }
     async build(params) {
         const subject = params.patientId ? `Patient/${params.patientId}` : await this.account.profileReference();
@@ -55,8 +70,7 @@ class MeasurementsResource {
         return params.patientId;
     }
     /** A reading split over several requests stops once another account signs in, so none of it lands elsewhere. */
-    async send(bundle, options) {
-        const owner = await this.account.key();
+    async send(bundle, options, owner) {
         try {
             return await (0, observation_bundle_utils_1.executeObservationBundle)(bundle, async (request) => {
                 await this.requireOwner(owner);
@@ -67,8 +81,15 @@ class MeasurementsResource {
             throw (0, save_error_1.isBundle)(error) ? (0, save_error_1.saveErrorFrom)(error) : error;
         }
     }
+    async currentOwnerKey() {
+        const accountKey = await this.account.key();
+        if (accountKey) {
+            return `user:${accountKey}`;
+        }
+        return this.session === null && this.machineClientId ? `machine:${this.machineClientId}` : null;
+    }
     async requireOwner(owner) {
-        if (owner !== (await this.account.key())) {
+        if (owner !== (await this.currentOwnerKey())) {
             throw new ovok_errors_1.OvokConflictError((0, ovok_errors_1.detailsFor)("The signed-in account changed during the save; the rest was not sent."));
         }
     }

package/dist/next/resources/measurements/offline-measurement-queue-types.d.ts

@@ -0,0 +1,22 @@
+import type { RequestOptions } from "../../http/transmit";
+import type { Bundle } from "@medplum/fhirtypes";
+export type OfflineMeasurementFlushOptions = {
+    includeExhausted?: boolean;
+    resetExhausted?: boolean;
+};
+export type OfflineMeasurementFailure = {
+    name: string;
+    code?: string;
+    status?: number;
+};
+export type OfflineMeasurementFlushResult = {
+    attempted: number;
+    saved: number;
+    queued: number;
+    exhausted: number;
+    responses: Record<string, Bundle>;
+    failures: Record<string, OfflineMeasurementFailure>;
+};
+export type OfflineMeasurementQueueApi = {
+    flush: (options?: OfflineMeasurementFlushOptions, requestOptions?: RequestOptions) => Promise<OfflineMeasurementFlushResult>;
+};

package/dist/next/resources/measurements/offline-measurement-queue-types.js

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

package/dist/next/resources/measurements/offline-measurement-queue.d.ts

@@ -0,0 +1,25 @@
+import type { OfflineMeasurementFlushOptions, OfflineMeasurementFlushResult } from "./offline-measurement-queue-types";
+import type { RequestOptions } from "../../http/transmit";
+import type { OvokStorage } from "../../storage/ovok-storage";
+import type { Bundle, BundleEntry, Observation } from "@medplum/fhirtypes";
+export type { OfflineMeasurementFailure, OfflineMeasurementFlushOptions, OfflineMeasurementFlushResult, OfflineMeasurementQueueApi, } from "./offline-measurement-queue-types";
+type MeasurementTransport = (bundle: Bundle, ownerKey: string, requestOptions?: RequestOptions) => Promise<Bundle>;
+type OwnerKey = () => Promise<string | null>;
+export declare const offlineMeasurementStorageKey: (tenantCode: string, baseUrl: string) => string;
+export declare class OfflineMeasurementQueue {
+    private readonly storage;
+    private readonly storageKey;
+    private readonly getOwnerKey;
+    private readonly transport;
+    private operation;
+    constructor(storage: OvokStorage, storageKey: string, getOwnerKey: OwnerKey, transport: MeasurementTransport);
+    enqueueAndFlush: (entries: BundleEntry<Observation>[], ownerKey: string, requestOptions?: RequestOptions) => Promise<{
+        id: string;
+        flush: OfflineMeasurementFlushResult;
+    }>;
+    flush: (options?: OfflineMeasurementFlushOptions, requestOptions?: RequestOptions) => Promise<OfflineMeasurementFlushResult>;
+    private runExclusive;
+    private readQueue;
+    private writeQueue;
+    private flushQueue;
+}

package/dist/next/resources/measurements/offline-measurement-queue.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OfflineMeasurementQueue = exports.offlineMeasurementStorageKey = void 0;
+const ovok_errors_1 = require("../../errors/ovok-errors");
+const MAX_RETRIES = 8;
+const RETRY_BACKOFF_MS = 5000;
+const MAX_RETRY_BACKOFF_MS = 60 * 60 * 1000;
+const offlineMeasurementStorageKey = (tenantCode, baseUrl) => {
+    const base = new URL(baseUrl);
+    const path = base.pathname.replace(/\/+$/g, "");
+    return `ovok:${tenantCode}:${base.origin}${path}:offline-measurements`;
+};
+exports.offlineMeasurementStorageKey = offlineMeasurementStorageKey;
+const queueItemId = (entries) => entries.map(({ fullUrl }) => fullUrl !== null && fullUrl !== void 0 ? fullUrl : "").join("|");
+const retryable = (error) => error instanceof ovok_errors_1.OvokConnectionError ||
+    error instanceof ovok_errors_1.OvokRateLimitError ||
+    error instanceof ovok_errors_1.OvokServiceError;
+const summarizeFailure = (error) => {
+    const failure = error;
+    return {
+        name: typeof (failure === null || failure === void 0 ? void 0 : failure.name) === "string" ? failure.name : "Error",
+        ...(typeof (failure === null || failure === void 0 ? void 0 : failure.code) === "string" ? { code: failure.code } : {}),
+        ...(typeof (failure === null || failure === void 0 ? void 0 : failure.status) === "number" ? { status: failure.status } : {}),
+    };
+};
+class OfflineMeasurementQueue {
+    constructor(storage, storageKey, getOwnerKey, transport) {
+        this.storage = storage;
+        this.storageKey = storageKey;
+        this.getOwnerKey = getOwnerKey;
+        this.transport = transport;
+        this.operation = Promise.resolve();
+        this.enqueueAndFlush = (entries, ownerKey, requestOptions) => this.runExclusive(async () => {
+            const queue = await this.readQueue();
+            const id = queueItemId(entries);
+            const exists = queue.some((item) => item.id === id && item.ownerKey === ownerKey);
+            if (!exists) {
+                queue.push({
+                    id,
+                    ownerKey,
+                    queuedAt: new Date().toISOString(),
+                    attempt: 0,
+                    nextAttemptAt: 0,
+                    entries,
+                });
+                await this.writeQueue(queue);
+            }
+            return {
+                id,
+                flush: await this.flushQueue(queue, {}, requestOptions, true),
+            };
+        });
+        this.flush = (options = {}, requestOptions) => this.runExclusive(async () => this.flushQueue(await this.readQueue(), options, requestOptions, false));
+        this.runExclusive = (operation) => {
+            const next = this.operation.then(operation, operation);
+            this.operation = next.catch(() => undefined);
+            return next;
+        };
+        this.readQueue = async () => {
+            const serialized = await this.storage.getItem(this.storageKey);
+            if (serialized === null || serialized === "") {
+                return [];
+            }
+            const queue = JSON.parse(serialized);
+            if (!Array.isArray(queue)) {
+                throw new Error("Offline measurement queue is not an array.");
+            }
+            return queue;
+        };
+        this.writeQueue = async (queue) => {
+            if (queue.length === 0) {
+                await this.storage.removeItem(this.storageKey);
+                return;
+            }
+            const serialized = JSON.stringify(queue);
+            await this.storage.setItem(this.storageKey, serialized);
+            if ((await this.storage.getItem(this.storageKey)) !== serialized) {
+                throw new Error("Offline measurement queue could not be persisted.");
+            }
+        };
+        this.flushQueue = async (queue, options, requestOptions, throwNonRetryable) => {
+            const result = {
+                attempted: 0,
+                saved: 0,
+                queued: 0,
+                exhausted: 0,
+                responses: {},
+                failures: {},
+            };
+            let changed = false;
+            const now = Date.now();
+            for (const item of [...queue]) {
+                const ownerKey = await this.getOwnerKey();
+                if (!ownerKey || item.ownerKey !== ownerKey) {
+                    result.queued++;
+                    continue;
+                }
+                if (item.lastFailure) {
+                    result.failures[item.id] = item.lastFailure;
+                }
+                if (item.exhausted && options.resetExhausted) {
+                    item.attempt = 0;
+                    item.exhausted = false;
+                    item.nextAttemptAt = 0;
+                    changed = true;
+                }
+                if ((item.exhausted && !options.includeExhausted) || item.nextAttemptAt > now) {
+                    if (item.exhausted) {
+                        result.exhausted++;
+                    }
+                    else {
+                        result.queued++;
+                    }
+                    continue;
+                }
+                result.attempted++;
+                try {
+                    const response = await this.transport({ resourceType: "Bundle", type: "transaction", entry: item.entries }, item.ownerKey, requestOptions);
+                    queue.splice(queue.indexOf(item), 1);
+                    result.saved++;
+                    result.responses[item.id] = response;
+                    delete result.failures[item.id];
+                    changed = true;
+                }
+                catch (error) {
+                    if (throwNonRetryable && !retryable(error)) {
+                        queue.splice(queue.indexOf(item), 1);
+                        await this.writeQueue(queue);
+                        throw error;
+                    }
+                    item.attempt++;
+                    item.exhausted = item.attempt >= MAX_RETRIES;
+                    item.nextAttemptAt = item.exhausted
+                        ? Number.MAX_SAFE_INTEGER
+                        : Date.now() + Math.min(MAX_RETRY_BACKOFF_MS, RETRY_BACKOFF_MS * 2 ** (item.attempt - 1));
+                    item.lastFailure = summarizeFailure(error);
+                    result.failures[item.id] = item.lastFailure;
+                    if (item.exhausted) {
+                        result.exhausted++;
+                    }
+                    else {
+                        result.queued++;
+                    }
+                    changed = true;
+                }
+            }
+            if (changed) {
+                await this.writeQueue(queue);
+            }
+            return result;
+        };
+    }
+}
+exports.OfflineMeasurementQueue = OfflineMeasurementQueue;

package/dist/next/resources/session/session-resource.d.ts

@@ -7,5 +7,6 @@ export declare class SessionResource {
     readonly savedAccounts: SavedAccountsResource;
     constructor(http: HttpClient, session: UserSession | null);
     onChange(listener: SessionChangeListener): () => void;
+    current(): Promise<Session | null>;
 }
 export type { Session };

package/dist/next/resources/session/session-resource.js

@@ -11,5 +11,9 @@ class SessionResource {
         var _a, _b;
         return (_b = (_a = this.session) === null || _a === void 0 ? void 0 : _a.onChange(listener)) !== null && _b !== void 0 ? _b : (() => undefined);
     }
+    current() {
+        var _a, _b;
+        return (_b = (_a = this.session) === null || _a === void 0 ? void 0 : _a.current()) !== null && _b !== void 0 ? _b : Promise.resolve(null);
+    }
 }
 exports.SessionResource = SessionResource;

package/next/react/index.d.ts

@@ -0,0 +1 @@
+export * from "../../dist/next/react";

package/next/react/index.js

@@ -0,0 +1 @@
+module.exports = require("../../dist/next/react/index.js");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ovok/core",
-  "version": "0.4.49-dev.497+7201066",
+  "version": "0.4.49-dev.499+db0e927",
   "private": false,
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -59,5 +59,16 @@
     "@medplum/fhirtypes": ">=3.2.22",
     "@medplum/react-hooks": ">=3.2.19",
     "react": "*"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "@medplum/core": {
+      "optional": true
+    },
+    "@medplum/react-hooks": {
+      "optional": true
+    }
   }
 }