@ovok/core 0.4.31 → 0.4.33

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

@@ -1,4 +1,4 @@
-import { IClientStorage, LoginState, MedplumClient, MedplumClientOptions, SubscriptionManager } from "@medplum/core";
+import { IClientStorage, LoginState, MedplumClient, MedplumClientOptions, MedplumRequestOptions, ReadablePromise, SubscriptionManager } from "@medplum/core";
 import { Bundle, CapabilityStatement, Observation } from "@medplum/fhirtypes";
 import { OvokPublicApiEndpoint } from "../conformance/capability";
 import * as aiFhirMethods from "./ai-fhir/methods";
@@ -48,19 +48,28 @@ export type OvokUnauthenticatedReason = {
 export type OvokClientOptions = Omit<MedplumClientOptions, "onUnauthenticated"> & {
     onUnauthenticated?: (reason: OvokUnauthenticatedReason) => void;
     socialLoginClientId?: string;
+    requestTimeoutMs?: number;
     offlineQueue?: OfflineMeasurementQueueOptions;
+    /** Keep the saved login when a refresh cannot reach the server. */
+    keepSessionOnRefreshUnavailable?: boolean;
 };
 export declare class OvokClient extends MedplumClient {
     protected socialLoginClientId: string;
     clientStorage: IClientStorage | undefined;
     private readonly hasExplicitStorageAdapter;
     private readonly offlineQueueOptions;
+    private readonly clientOptions;
+    private readonly keepSessionOnRefreshUnavailable;
+    private readonly refreshState;
     private offlineMeasurementQueue;
     /**
      * @param config - The configuration for the client.
      * @param config.socialLoginClientId - The social login client id to use for the client.
      */
     constructor(config: OvokClientOptions);
+    get<T = unknown>(url: URL | string, options?: MedplumRequestOptions): ReadablePromise<T>;
+    refreshIfExpired(gracePeriod?: number): Promise<void>;
+    post<T = unknown>(url: URL | string, body?: unknown, contentType?: string, options?: MedplumRequestOptions): Promise<T>;
     /** Lists saved accounts without exposing their access or refresh tokens. */
     getSavedAccounts(): OvokSavedAccount[];
     /** Activates a previously saved account without asking for its password again. */
@@ -70,21 +79,21 @@ export declare class OvokClient extends MedplumClient {
      * Accounts with an expired server session are removed locally; network and service
      * failures retain the account so it can be removed after connectivity returns.
      */
-    removeAccount(accountId: string): Promise<void>;
+    removeAccount(accountId: string, requestOptions?: MedplumRequestOptions): Promise<void>;
     /** Removes every saved account and expiry marker from client storage. */
     clearAllAccounts(): void;
     /** 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): Promise<SaveObservationsResult>;
+    saveMeasurement(params: GenerateObservationBodyParams, requestOptions?: MedplumRequestOptions): Promise<SaveObservationsResult>;
     /** Reads Ovok's composed FHIR and public-route capability statement. */
-    getCapabilityStatement(version?: OvokFhirVersion): Promise<CapabilityStatement>;
+    getCapabilityStatement(version?: OvokFhirVersion, requestOptions?: MedplumRequestOptions): Promise<CapabilityStatement>;
     /** Returns the non-FHIR public routes published by the backend statement. */
-    getPublicApiEndpoints(version?: OvokFhirVersion): Promise<OvokPublicApiEndpoint[]>;
+    getPublicApiEndpoints(version?: OvokFhirVersion, requestOptions?: MedplumRequestOptions): Promise<OvokPublicApiEndpoint[]>;
     /** Saves observations with conditional creates so a retry cannot create a duplicate. */
-    saveObservations(observations: Observation[]): Promise<SaveObservationsResult>;
+    saveObservations(observations: Observation[], requestOptions?: MedplumRequestOptions): Promise<SaveObservationsResult>;
     /** Flushes measurements queued while offline. Call this on connectivity/app-resume events. */
-    flushOfflineMeasurementQueue(options?: OfflineMeasurementFlushOptions): Promise<OfflineMeasurementFlushResult>;
+    flushOfflineMeasurementQueue(options?: OfflineMeasurementFlushOptions, requestOptions?: MedplumRequestOptions): Promise<OfflineMeasurementFlushResult>;
     private getOfflineMeasurementQueue;
     /**
      * Medplum clears its entire client storage after an unrecoverable 401. Keep
@@ -94,6 +103,7 @@ export declare class OvokClient extends MedplumClient {
     clear(): void;
     private getLogin;
     private getExpiredAccountIds;
+    private createAccountSessionClient;
     private setAccountExpired;
     private removeSavedAccount;
     private syncSavedAccountProfile;

package/dist/client/ovok-client.js

@@ -39,6 +39,7 @@ const core_1 = require("@medplum/core");
 const capability_1 = require("../conformance/capability");
 const aiFhirMethods = __importStar(require("./ai-fhir/methods"));
 const account_storage_1 = require("./auth/account-storage");
+const errors_1 = require("./auth/errors");
 const authMethods = __importStar(require("./auth/methods"));
 const botMethods = __importStar(require("./bot/methods"));
 const changeHistoryMethods = __importStar(require("./change-history/methods"));
@@ -47,6 +48,7 @@ const cmsMethods = __importStar(require("./cms/methods"));
 const consentMethods = __importStar(require("./consent/methods"));
 const emailMethods = __importStar(require("./email"));
 const ovok_error_1 = require("./errors/ovok-error");
+const ovok_error_utils_1 = require("./errors/ovok-error-utils");
 const rate_limit_error_1 = require("./errors/rate-limit-error");
 const experienceMethods = __importStar(require("./experience/methods"));
 const inviteMethods = __importStar(require("./invites/methods"));
@@ -58,7 +60,7 @@ const patientMethods = __importStar(require("./patient/methods"));
 const patientSharingMethods = __importStar(require("./patient-sharing/methods"));
 const platformMethods = __importStar(require("./platform/methods"));
 const questionnaireResponseMethods = __importStar(require("./questionnaire-response/methods"));
-const errors_1 = require("./signals/errors");
+const errors_2 = require("./signals/errors");
 const signalsMethods = __importStar(require("./signals/methods"));
 const slimMethods = __importStar(require("./slim/methods"));
 exports.MAX_CONDITIONAL_OBSERVATION_ENTRIES = 8;
@@ -77,6 +79,80 @@ const retryAfterMs = (response) => {
     const date = Date.parse(value);
     return Number.isFinite(date) ? Math.max(0, date - Date.now()) : undefined;
 };
+const timeoutError = () => {
+    const error = new Error("The request timed out.");
+    error.name = "TimeoutError";
+    return error;
+};
+const withHttpErrorMetadata = async (response) => {
+    var _a, _b;
+    if (response.ok || typeof response.clone !== "function") {
+        return response;
+    }
+    let bodyText = "";
+    let body;
+    try {
+        bodyText = await response.clone().text();
+        body = JSON.parse(bodyText);
+    }
+    catch (_c) {
+        body = undefined;
+    }
+    const outcome = body && typeof body === "object" && body.resourceType === "OperationOutcome"
+        ? body
+        : undefined;
+    const envelope = body && typeof body === "object" ? body : undefined;
+    const nestedError = (envelope === null || envelope === void 0 ? void 0 : envelope.error) && typeof envelope.error === "object"
+        ? envelope.error
+        : undefined;
+    const safeResponse = envelope
+        ? Object.fromEntries(Object.entries(envelope).filter(([key]) => ["code", "error", "message", "requestId", "retryAfterSec", "status", "statusCode", "errors", "missing"].includes(key)))
+        : { message: typeof body === "string" ? body : response.statusText };
+    const status = response.status;
+    const retryAfter = (_a = retryAfterMs(response)) !== null && _a !== void 0 ? _a : (typeof (envelope === null || envelope === void 0 ? void 0 : envelope.retryAfterSec) === "number" ? envelope.retryAfterSec * 1000 : undefined);
+    const requestId = (_b = response.headers.get("x-request-id")) !== null && _b !== void 0 ? _b : (typeof (envelope === null || envelope === void 0 ? void 0 : envelope.requestId) === "string" ? envelope.requestId : undefined);
+    const message = typeof (envelope === null || envelope === void 0 ? void 0 : envelope.message) === "string"
+        ? envelope.message
+        : typeof (nestedError === null || nestedError === void 0 ? void 0 : nestedError.message) === "string"
+            ? nestedError.message
+            : response.statusText || `HTTP ${status}`;
+    const extensions = [];
+    const addMetadata = (url, value, kind) => {
+        if (value !== undefined) {
+            extensions.push({ url, [`value${kind}`]: value });
+        }
+    };
+    addMetadata("status", status, "Integer");
+    addMetadata("requestId", requestId, "String");
+    addMetadata("retryAfterMs", retryAfter, "Integer");
+    if (!outcome) {
+        extensions.push({ url: "response", valueString: JSON.stringify(safeResponse) });
+    }
+    const enrichedOutcome = outcome !== null && outcome !== void 0 ? outcome : {
+        resourceType: "OperationOutcome",
+        id: "ovok-http-error",
+        issue: [{
+                severity: "error",
+                code: status === 429 ? "throttled" : "exception",
+                details: { text: bodyText || message },
+            }],
+    };
+    const existingExtensions = Array.isArray(enrichedOutcome.extension)
+        ? enrichedOutcome.extension
+        : [];
+    enrichedOutcome.extension = [
+        ...existingExtensions,
+        { url: ovok_error_utils_1.OVOK_HTTP_ERROR_EXTENSION_URL, extension: extensions },
+    ];
+    const headers = new Headers(response.headers);
+    headers.delete("content-length");
+    headers.set("content-type", "application/fhir+json");
+    return new Response(JSON.stringify(enrichedOutcome), {
+        status,
+        statusText: response.statusText,
+        headers,
+    });
+};
 const waitForRetry = (milliseconds, signal) => new Promise((resolve, reject) => {
     var _a;
     if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
@@ -122,6 +198,7 @@ const isNetworkError = (error) => {
     }
     return isNetworkError(error.cause);
 };
+const isRetrySafePost = (pathname) => pathname === "/ai/fhir/search";
 class OvokClient extends core_1.MedplumClient {
     /**
      * @param config - The configuration for the client.
@@ -129,7 +206,10 @@ class OvokClient extends core_1.MedplumClient {
      */
     constructor(config) {
         var _a, _b, _c, _d, _e, _f;
-        const storage = (_a = config.storage) !== null && _a !== void 0 ? _a : new core_1.ClientStorage(undefined, config.storagePrefix);
+        if (config.requestTimeoutMs !== undefined && (!Number.isFinite(config.requestTimeoutMs) || config.requestTimeoutMs <= 0)) {
+            throw new RangeError("requestTimeoutMs must be a positive finite number.");
+        }
+        const storage = (_a = config.storage) !== null && _a !== void 0 ? _a : new core_1.ClientStorage(new core_1.MemoryStorage(), config.storagePrefix);
         const fetchImplementation = (_b = config.fetch) !== null && _b !== void 0 ? _b : globalThis.fetch.bind(globalThis);
         const baseUrl = (_c = config.baseUrl) !== null && _c !== void 0 ? _c : "https://api.medplum.com/";
         const normalizedBaseUrl = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
@@ -138,6 +218,7 @@ class OvokClient extends core_1.MedplumClient {
         let clearActiveLogin = () => undefined;
         let terminalRefreshToken;
         let terminalRefreshError;
+        const refreshState = { unavailable: false };
         const isTokenRefresh = (url, options) => new URL(url, normalizedBaseUrl).href === tokenUrl &&
             (options === null || options === void 0 ? void 0 : options.method) === "POST" &&
             typeof options.body === "string" &&
@@ -151,7 +232,40 @@ class OvokClient extends core_1.MedplumClient {
         };
         const fetchOnce = async (url, options) => {
             var _a, _b;
-            const response = await fetchImplementation(url, options);
+            const requestTimeoutMs = config.requestTimeoutMs;
+            let response;
+            if (requestTimeoutMs === undefined) {
+                response = await fetchImplementation(url, options);
+            }
+            else {
+                const controller = new AbortController();
+                const callerSignal = options === null || options === void 0 ? void 0 : options.signal;
+                let timedOut = false;
+                const abortFromCaller = () => controller.abort(callerSignal === null || callerSignal === void 0 ? void 0 : callerSignal.reason);
+                const timeout = setTimeout(() => {
+                    timedOut = true;
+                    controller.abort(timeoutError());
+                }, requestTimeoutMs);
+                if (callerSignal === null || callerSignal === void 0 ? void 0 : callerSignal.aborted) {
+                    abortFromCaller();
+                }
+                else {
+                    callerSignal === null || callerSignal === void 0 ? void 0 : callerSignal.addEventListener("abort", abortFromCaller, { once: true });
+                }
+                try {
+                    response = await fetchImplementation(url, { ...options, signal: controller.signal });
+                }
+                catch (error) {
+                    if (timedOut) {
+                        throw timeoutError();
+                    }
+                    throw error;
+                }
+                finally {
+                    clearTimeout(timeout);
+                    callerSignal === null || callerSignal === void 0 ? void 0 : callerSignal.removeEventListener("abort", abortFromCaller);
+                }
+            }
             const requestUrl = new URL(url, normalizedBaseUrl);
             if (isTokenRefresh(url, options)) {
                 if (response.status === 400) {
@@ -190,7 +304,9 @@ class OvokClient extends core_1.MedplumClient {
             else if (response.status === 401) {
                 unauthenticatedReason = { type: "request-unauthorized", status: 401 };
             }
-            return response;
+            return isTokenRefresh(url, options)
+                ? response
+                : withHttpErrorMetadata(response);
         };
         const fetchWithRefreshRetry = async (url, options) => {
             var _a, _b, _c, _d;
@@ -224,6 +340,9 @@ class OvokClient extends core_1.MedplumClient {
                 const response = await fetchOnce(url, options);
                 if (isTemporaryRefreshFailure(response.status)) {
                     void ((_a = response.body) === null || _a === void 0 ? void 0 : _a.cancel().catch(() => undefined));
+                    if (config.keepSessionOnRefreshUnavailable) {
+                        refreshState.unavailable = true;
+                    }
                     throw refreshUnavailableError(response);
                 }
                 return response;
@@ -241,6 +360,11 @@ class OvokClient extends core_1.MedplumClient {
                     if ((signal === null || signal === void 0 ? void 0 : signal.aborted) || !isNetworkError(error)) {
                         throw error;
                     }
+                    if (config.keepSessionOnRefreshUnavailable) {
+                        refreshState.unavailable = true;
+                        lastNetworkError = error;
+                        break;
+                    }
                     if (Date.now() >= expiresAt) {
                         lastNetworkError = error;
                         break;
@@ -255,6 +379,10 @@ class OvokClient extends core_1.MedplumClient {
                 if (!isTemporaryRefreshFailure(lastResponse.status)) {
                     return lastResponse;
                 }
+                if (config.keepSessionOnRefreshUnavailable) {
+                    refreshState.unavailable = true;
+                    break;
+                }
                 const remainingMs = expiresAt - Date.now();
                 if (remainingMs <= 0) {
                     break;
@@ -274,6 +402,13 @@ class OvokClient extends core_1.MedplumClient {
                 type: "refresh-unavailable",
                 ...(status === undefined ? {} : { status }),
             };
+            if (config.keepSessionOnRefreshUnavailable) {
+                refreshState.unavailable = true;
+                if (lastResponse) {
+                    return lastResponse;
+                }
+                throw lastNetworkError !== null && lastNetworkError !== void 0 ? lastNetworkError : refreshUnavailableError(undefined);
+            }
             unauthenticatedReason = reason;
             markActiveAccountExpired();
             if (lastResponse) {
@@ -291,6 +426,9 @@ class OvokClient extends core_1.MedplumClient {
             storage,
             onUnauthenticated: () => {
                 var _a;
+                if (refreshState.unavailable) {
+                    return;
+                }
                 const reason = unauthenticatedReason !== null && unauthenticatedReason !== void 0 ? unauthenticatedReason : {
                     type: "request-unauthorized",
                     status: 401,
@@ -303,6 +441,9 @@ class OvokClient extends core_1.MedplumClient {
         this.socialLoginClientId = "";
         clearActiveLogin = this.clearActiveLogin.bind(this);
         this.hasExplicitStorageAdapter = config.storage !== undefined;
+        this.clientOptions = config;
+        this.keepSessionOnRefreshUnavailable = config.keepSessionOnRefreshUnavailable === true;
+        this.refreshState = refreshState;
         this.socialLoginClientId = (_e = config.socialLoginClientId) !== null && _e !== void 0 ? _e : "";
         this.addEventListener("profileRefreshed", () => this.syncSavedAccountProfile());
         this.bindMethods(authMethods);
@@ -323,14 +464,53 @@ class OvokClient extends core_1.MedplumClient {
         this.bindMethods(patientMethods);
         this.bindMethods(patientSharingMethods);
         this.bindMethods(signalsMethods, (error) => {
-            const mapped = (0, errors_1.mapSignalsError)((0, rate_limit_error_1.mapRateLimitError)(error), {
+            const mapped = (0, errors_2.mapSignalsError)((0, rate_limit_error_1.mapRateLimitError)(error), {
                 signalsRequest: true,
             });
-            return (0, errors_1.isSignalsError)(mapped) ? mapped : (0, ovok_error_1.mapOvokApiError)(mapped);
+            return (0, errors_2.isSignalsError)(mapped) ? mapped : (0, ovok_error_1.mapOvokApiError)(mapped);
         });
         this.clientStorage = storage;
         this.offlineQueueOptions = (_f = config.offlineQueue) !== null && _f !== void 0 ? _f : {};
     }
+    get(url, options) {
+        const request = super.get(url, options);
+        void request.catch(() => this.invalidateUrl(url));
+        return request;
+    }
+    async refreshIfExpired(gracePeriod) {
+        var _a;
+        const activeLogin = this.getActiveLogin();
+        const accessToken = this.getAccessToken();
+        const expiresAt = accessToken ? (0, core_1.tryGetJwtExpiration)(accessToken) : undefined;
+        try {
+            await super.refreshIfExpired(gracePeriod);
+        }
+        catch (error) {
+            const activeAccount = this.getSavedAccounts().find((account) => { var _a; return account.id === ((_a = activeLogin === null || activeLogin === void 0 ? void 0 : activeLogin.profile) === null || _a === void 0 ? void 0 : _a.reference); });
+            if (this.keepSessionOnRefreshUnavailable &&
+                this.refreshState.unavailable &&
+                activeLogin &&
+                accessToken &&
+                !(activeAccount === null || activeAccount === void 0 ? void 0 : activeAccount.expired) &&
+                expiresAt !== undefined &&
+                expiresAt > Date.now()) {
+                (_a = this.clientStorage) === null || _a === void 0 ? void 0 : _a.setObject("activeLogin", activeLogin);
+                this.setAccessToken(accessToken, activeLogin.refreshToken);
+                return;
+            }
+            throw error;
+        }
+        finally {
+            this.refreshState.unavailable = false;
+        }
+    }
+    post(url, body, contentType, options) {
+        const pathname = new URL(url.toString(), this.getBaseUrl()).pathname;
+        if (!isRetrySafePost(pathname)) {
+            options = { ...options, maxRetries: 0, maxRetryTime: 0 };
+        }
+        return super.post(url, body, contentType, options);
+    }
     /** Lists saved accounts without exposing their access or refresh tokens. */
     getSavedAccounts() {
         var _a, _b;
@@ -355,10 +535,10 @@ class OvokClient extends core_1.MedplumClient {
         var _a, _b;
         const login = this.getLogin(accountId);
         if (!login) {
-            throw new Error(`No saved account found for ${accountId}.`);
+            throw new errors_1.OvokAccountError("account_not_found");
         }
         if (this.getExpiredAccountIds().includes(accountId)) {
-            throw new Error("This account's session has expired. Sign in again.");
+            throw new errors_1.OvokAccountError("account_expired");
         }
         const previousLogin = this.getActiveLogin();
         try {
@@ -382,36 +562,29 @@ class OvokClient extends core_1.MedplumClient {
      * Accounts with an expired server session are removed locally; network and service
      * failures retain the account so it can be removed after connectivity returns.
      */
-    async removeAccount(accountId) {
+    async removeAccount(accountId, requestOptions) {
         var _a;
         const login = this.getLogin(accountId);
         if (!login) {
-            throw new Error(`No saved account found for ${accountId}.`);
+            throw new errors_1.OvokAccountError("account_not_found");
         }
         const previousLogin = this.getActiveLogin();
         const previousAccountId = (_a = previousLogin === null || previousLogin === void 0 ? void 0 : previousLogin.profile) === null || _a === void 0 ? void 0 : _a.reference;
+        const wasActive = previousAccountId === accountId;
+        const sessionClient = this.createAccountSessionClient(login);
         try {
-            await this.setActiveLogin(login);
-            await this.delete("auth/session/current");
+            await sessionClient.delete("auth/session/current", ...(requestOptions === undefined ? [] : [requestOptions]));
         }
         catch (error) {
-            if (this.getExpiredAccountIds().includes(accountId)) {
-                this.removeSavedAccount(accountId);
-                if (previousLogin && previousAccountId && previousAccountId !== accountId) {
-                    await this.restoreActiveLogin(previousLogin);
-                }
-                else {
-                    this.clearActiveLogin();
-                }
-                return;
-            }
-            if (previousLogin && previousAccountId !== accountId) {
-                await this.restoreActiveLogin(previousLogin);
+            if (!sessionClient.getSavedAccounts().some((account) => account.id === accountId && account.expired)) {
+                throw error;
             }
-            throw error;
         }
-        this.clearActiveLogin();
         this.removeSavedAccount(accountId);
+        if (!wasActive) {
+            return;
+        }
+        this.clearActiveLogin();
         const availableAccountIds = new Set(this.getSavedAccounts().filter((account) => !account.expired).map((account) => account.id));
         let nextLogin;
         if (previousAccountId && previousAccountId !== accountId) {
@@ -447,34 +620,34 @@ class OvokClient extends core_1.MedplumClient {
         }
     }
     /** Saves a measurement immediately, or durably queues it when the opt-in queue is enabled. */
-    async saveMeasurement(params) {
+    async saveMeasurement(params, requestOptions) {
         const observations = await this.generateObservationBodiesByMeasurement(params);
-        return this.saveObservations(observations);
+        return this.saveObservations(observations, ...(requestOptions === undefined ? [] : [requestOptions]));
     }
     /** Reads Ovok's composed FHIR and public-route capability statement. */
-    async getCapabilityStatement(version = "R4") {
-        return this.get(`/fhir/${version}/metadata`);
+    async getCapabilityStatement(version = "R4", requestOptions) {
+        return this.get(`/fhir/${version}/metadata`, ...(requestOptions === undefined ? [] : [requestOptions]));
     }
     /** Returns the non-FHIR public routes published by the backend statement. */
-    async getPublicApiEndpoints(version = "R4") {
-        return (0, capability_1.getOvokPublicApiEndpoints)(await this.getCapabilityStatement(version));
+    async getPublicApiEndpoints(version = "R4", requestOptions) {
+        return (0, capability_1.getOvokPublicApiEndpoints)(await this.getCapabilityStatement(version, ...(requestOptions === undefined ? [] : [requestOptions])));
     }
     /** Saves observations with conditional creates so a retry cannot create a duplicate. */
-    async saveObservations(observations) {
+    async saveObservations(observations, requestOptions) {
         const linkedObservations = (0, observation_bundle_utils_1.linkObservationMembers)(observations);
         const queue = this.getOfflineMeasurementQueue();
         if (queue) {
-            const { id, flush } = await queue.enqueueAndFlush(linkedObservations);
+            const { id, flush } = await queue.enqueueAndFlush(linkedObservations, ...(requestOptions === undefined ? [] : [requestOptions]));
             const response = flush.responses[id];
             return response
                 ? { status: "saved", response }
                 : { status: "queued", queueId: id };
         }
-        const response = await this.executeConditionalObservationCreates(linkedObservations);
+        const response = await this.executeConditionalObservationCreates(linkedObservations, requestOptions);
         return { status: "saved", response };
     }
     /** Flushes measurements queued while offline. Call this on connectivity/app-resume events. */
-    async flushOfflineMeasurementQueue(options = {}) {
+    async flushOfflineMeasurementQueue(options = {}, requestOptions) {
         const queue = this.getOfflineMeasurementQueue();
         if (!queue) {
             return {
@@ -483,9 +656,10 @@ class OvokClient extends core_1.MedplumClient {
                 queued: 0,
                 exhausted: 0,
                 responses: {},
+                failures: {},
             };
         }
-        return queue.flush(options);
+        return queue.flush(options, ...(requestOptions === undefined ? [] : [requestOptions]));
     }
     getOfflineMeasurementQueue() {
         var _a;
@@ -495,7 +669,7 @@ class OvokClient extends core_1.MedplumClient {
         if (!this.clientStorage || !this.hasExplicitStorageAdapter) {
             throw new Error("Offline measurement queue requires a durable client storage adapter.");
         }
-        (_a = this.offlineMeasurementQueue) !== null && _a !== void 0 ? _a : (this.offlineMeasurementQueue = new offline_1.OfflineMeasurementQueue(this.clientStorage, (bundle) => this.executeObservationBundle(bundle), {
+        (_a = this.offlineMeasurementQueue) !== null && _a !== void 0 ? _a : (this.offlineMeasurementQueue = new offline_1.OfflineMeasurementQueue(this.clientStorage, (bundle, requestOptions) => this.executeObservationBundle(bundle, ...(requestOptions === undefined ? [] : [requestOptions])), {
             ...this.offlineQueueOptions,
             getOwnerKey: () => {
                 var _a, _b, _c;
@@ -521,8 +695,13 @@ class OvokClient extends core_1.MedplumClient {
     clear() {
         var _a, _b, _c;
         const storage = this.clientStorage;
-        const logins = this.getLogins();
         const activeAccountId = (_b = (_a = this.getActiveLogin()) === null || _a === void 0 ? void 0 : _a.profile) === null || _b === void 0 ? void 0 : _b.reference;
+        const logins = this.getLogins().map((login) => {
+            var _a;
+            return ((_a = login.profile) === null || _a === void 0 ? void 0 : _a.reference) === activeAccountId
+                ? { ...login, accessToken: "", refreshToken: "" }
+                : login;
+        });
         const expiredAccountIds = new Set(this.getExpiredAccountIds());
         if (activeAccountId) {
             expiredAccountIds.add(activeAccountId);
@@ -547,6 +726,19 @@ class OvokClient extends core_1.MedplumClient {
         var _a, _b;
         return ((_b = (_a = this.clientStorage) === null || _a === void 0 ? void 0 : _a.getObject(account_storage_1.EXPIRED_ACCOUNTS_STORAGE_KEY)) !== null && _b !== void 0 ? _b : []);
     }
+    createAccountSessionClient(login) {
+        const storage = new core_1.ClientStorage(new core_1.MemoryStorage(), this.clientOptions.storagePrefix);
+        storage.setObject("activeLogin", login);
+        storage.setObject(account_storage_1.LOGINS_STORAGE_KEY, [login]);
+        const client = new OvokClient({
+            ...this.clientOptions,
+            storage,
+            offlineQueue: undefined,
+            onUnauthenticated: undefined,
+        });
+        client.setAccessToken(login.accessToken, login.refreshToken);
+        return client;
+    }
     setAccountExpired(accountId, expired) {
         if (this.clientStorage) {
             (0, account_storage_1.setStoredAccountExpired)(this.clientStorage, accountId, expired);
@@ -580,16 +772,16 @@ class OvokClient extends core_1.MedplumClient {
             // Keep the saved login available for a later retry if restoration is offline.
         }
     }
-    async executeConditionalObservationCreates(observations) {
+    async executeConditionalObservationCreates(observations, requestOptions) {
         const entries = observations.map(offline_1.entryForObservation);
         return this.executeObservationBundle({
             resourceType: "Bundle",
             type: "transaction",
             entry: entries,
-        });
+        }, ...(requestOptions === undefined ? [] : [requestOptions]));
     }
-    async executeObservationBundle(bundle) {
-        const response = await (0, observation_bundle_utils_1.executeObservationBundle)(bundle, (request) => this.executeBatch(request));
+    async executeObservationBundle(bundle, requestOptions) {
+        const response = await (0, observation_bundle_utils_1.executeObservationBundle)(bundle, (request) => this.executeBatch(request, ...(requestOptions === undefined ? [] : [requestOptions])));
         this.invalidateSearches("Observation");
         return response;
     }

package/dist/client/patient/methods.d.ts

@@ -1,25 +1,26 @@
+import type { MedplumRequestOptions } from "@medplum/core";
 import { OvokClient } from "../ovok-client";
 import { OvokCurrentPatientProfile, OvokPatientLatestObservationsQuery, OvokPatientObservationBundle, OvokPatientAppointment, OvokPatientCarePlan, OvokPatientDashboard, OvokPatientDashboardQuery, OvokPatientDevice, OvokPatientMeasurement, OvokPatientNotification, OvokPatientQuestionnaire, OvokPatientQuestionnaireResponse, OvokPatientResourceQuery, OvokPatientSchedule, OvokPatientSchedulingQuery, OvokPatientSlot, OvokPatientTelemetryHistory, OvokPatientTelemetryHistoryQuery } from "./types";
-export declare function getCurrentPatientProfile(this: OvokClient): Promise<OvokCurrentPatientProfile>;
-export declare function getPatientLatestObservations(this: OvokClient, params?: OvokPatientLatestObservationsQuery): Promise<OvokPatientObservationBundle>;
-export declare function getPatientDeviceTelemetry(this: OvokClient, deviceId: string): Promise<OvokPatientObservationBundle>;
-export declare function getPatientDeviceTelemetryHistory(this: OvokClient, deviceId: string, params?: OvokPatientTelemetryHistoryQuery): Promise<OvokPatientTelemetryHistory>;
-export declare function listPatientAppointments(this: OvokClient, params?: OvokPatientSchedulingQuery): Promise<OvokPatientAppointment[]>;
-export declare function getPatientAppointment(this: OvokClient, appointmentId: string): Promise<OvokPatientAppointment>;
-export declare function createPatientAppointment(this: OvokClient, appointment: OvokPatientAppointment): Promise<OvokPatientAppointment>;
-export declare function updatePatientAppointment(this: OvokClient, appointment: OvokPatientAppointment): Promise<OvokPatientAppointment>;
-export declare function listPatientSchedules(this: OvokClient, params?: OvokPatientSchedulingQuery): Promise<OvokPatientSchedule[]>;
-export declare function listPatientSlots(this: OvokClient, params?: OvokPatientSchedulingQuery): Promise<OvokPatientSlot[]>;
-export declare function listPatientMeasurementHistory(this: OvokClient, params?: OvokPatientResourceQuery): Promise<OvokPatientMeasurement[]>;
-export declare function getPatientMeasurement(this: OvokClient, measurementId: string): Promise<OvokPatientMeasurement>;
-export declare function listPatientCarePlans(this: OvokClient, params?: OvokPatientResourceQuery): Promise<OvokPatientCarePlan[]>;
-export declare function getPatientCarePlan(this: OvokClient, carePlanId: string): Promise<OvokPatientCarePlan>;
-export declare function listPatientQuestionnaires(this: OvokClient, params?: OvokPatientResourceQuery): Promise<OvokPatientQuestionnaire[]>;
-export declare function getPatientQuestionnaire(this: OvokClient, questionnaireId: string): Promise<OvokPatientQuestionnaire>;
-export declare function listPatientQuestionnaireResponses(this: OvokClient, params?: OvokPatientResourceQuery): Promise<OvokPatientQuestionnaireResponse[]>;
-export declare function getPatientQuestionnaireResponse(this: OvokClient, questionnaireResponseId: string): Promise<OvokPatientQuestionnaireResponse>;
-export declare function listPatientDevices(this: OvokClient, params?: OvokPatientResourceQuery): Promise<OvokPatientDevice[]>;
-export declare function getPatientDevice(this: OvokClient, deviceId: string): Promise<OvokPatientDevice>;
-export declare function listPatientNotifications(this: OvokClient, params?: OvokPatientResourceQuery): Promise<OvokPatientNotification[]>;
-export declare function getPatientNotification(this: OvokClient, notificationId: string): Promise<OvokPatientNotification>;
-export declare function getPatientDashboard(this: OvokClient, params?: OvokPatientDashboardQuery): Promise<OvokPatientDashboard>;
+export declare function getCurrentPatientProfile(this: OvokClient, requestOptions?: MedplumRequestOptions): Promise<OvokCurrentPatientProfile>;
+export declare function getPatientLatestObservations(this: OvokClient, params?: OvokPatientLatestObservationsQuery, requestOptions?: MedplumRequestOptions): Promise<OvokPatientObservationBundle>;
+export declare function getPatientDeviceTelemetry(this: OvokClient, deviceId: string, requestOptions?: MedplumRequestOptions): Promise<OvokPatientObservationBundle>;
+export declare function getPatientDeviceTelemetryHistory(this: OvokClient, deviceId: string, params?: OvokPatientTelemetryHistoryQuery, requestOptions?: MedplumRequestOptions): Promise<OvokPatientTelemetryHistory>;
+export declare function listPatientAppointments(this: OvokClient, params?: OvokPatientSchedulingQuery, requestOptions?: MedplumRequestOptions): Promise<OvokPatientAppointment[]>;
+export declare function getPatientAppointment(this: OvokClient, appointmentId: string, requestOptions?: MedplumRequestOptions): Promise<OvokPatientAppointment>;
+export declare function createPatientAppointment(this: OvokClient, appointment: OvokPatientAppointment, requestOptions?: MedplumRequestOptions): Promise<OvokPatientAppointment>;
+export declare function updatePatientAppointment(this: OvokClient, appointment: OvokPatientAppointment, requestOptions?: MedplumRequestOptions): Promise<OvokPatientAppointment>;
+export declare function listPatientSchedules(this: OvokClient, params?: OvokPatientSchedulingQuery, requestOptions?: MedplumRequestOptions): Promise<OvokPatientSchedule[]>;
+export declare function listPatientSlots(this: OvokClient, params?: OvokPatientSchedulingQuery, requestOptions?: MedplumRequestOptions): Promise<OvokPatientSlot[]>;
+export declare function listPatientMeasurementHistory(this: OvokClient, params?: OvokPatientResourceQuery, requestOptions?: MedplumRequestOptions): Promise<OvokPatientMeasurement[]>;
+export declare function getPatientMeasurement(this: OvokClient, measurementId: string, requestOptions?: MedplumRequestOptions): Promise<OvokPatientMeasurement>;
+export declare function listPatientCarePlans(this: OvokClient, params?: OvokPatientResourceQuery, requestOptions?: MedplumRequestOptions): Promise<OvokPatientCarePlan[]>;
+export declare function getPatientCarePlan(this: OvokClient, carePlanId: string, requestOptions?: MedplumRequestOptions): Promise<OvokPatientCarePlan>;
+export declare function listPatientQuestionnaires(this: OvokClient, params?: OvokPatientResourceQuery, requestOptions?: MedplumRequestOptions): Promise<OvokPatientQuestionnaire[]>;
+export declare function getPatientQuestionnaire(this: OvokClient, questionnaireId: string, requestOptions?: MedplumRequestOptions): Promise<OvokPatientQuestionnaire>;
+export declare function listPatientQuestionnaireResponses(this: OvokClient, params?: OvokPatientResourceQuery, requestOptions?: MedplumRequestOptions): Promise<OvokPatientQuestionnaireResponse[]>;
+export declare function getPatientQuestionnaireResponse(this: OvokClient, questionnaireResponseId: string, requestOptions?: MedplumRequestOptions): Promise<OvokPatientQuestionnaireResponse>;
+export declare function listPatientDevices(this: OvokClient, params?: OvokPatientResourceQuery, requestOptions?: MedplumRequestOptions): Promise<OvokPatientDevice[]>;
+export declare function getPatientDevice(this: OvokClient, deviceId: string, requestOptions?: MedplumRequestOptions): Promise<OvokPatientDevice>;
+export declare function listPatientNotifications(this: OvokClient, params?: OvokPatientResourceQuery, requestOptions?: MedplumRequestOptions): Promise<OvokPatientNotification[]>;
+export declare function getPatientNotification(this: OvokClient, notificationId: string, requestOptions?: MedplumRequestOptions): Promise<OvokPatientNotification>;
+export declare function getPatientDashboard(this: OvokClient, params?: OvokPatientDashboardQuery, requestOptions?: MedplumRequestOptions): Promise<OvokPatientDashboard>;