@ovok/core 0.4.35 → 0.4.37

package/dist/client/auth/session-fetch.d.ts

@@ -0,0 +1,35 @@
+import { IClientStorage } from "@medplum/core";
+import type { OvokClientOptions } from "../ovok-client";
+export type OvokUnauthenticatedReason = {
+    type: "refresh-rejected";
+    status: 400 | 401 | 403;
+} | {
+    type: "refresh-unavailable";
+    status?: number;
+} | {
+    type: "authentication-rejected";
+    status: number;
+} | {
+    type: "request-unauthorized";
+    status: 401;
+};
+type SessionFetchContext = {
+    config: OvokClientOptions;
+    storage: IClientStorage;
+    fetchImplementation: (url: string, options?: RequestInit) => Promise<Response>;
+    normalizedBaseUrl: string;
+    tokenUrl: string;
+};
+/**
+ * The client's `fetch`: request timeouts, token-refresh retries within the access token's
+ * lifetime, and tracking why a session ended, which `onUnauthenticated` reports.
+ */
+export declare function createSessionFetch({ config, storage, fetchImplementation, normalizedBaseUrl, tokenUrl }: SessionFetchContext): {
+    fetch: (url: string, options: RequestInit | undefined) => Promise<Response>;
+    onUnauthenticated: () => void;
+    refreshState: {
+        unavailable: boolean;
+    };
+    setClearActiveLogin: (clear: () => void) => void;
+};
+export {};

package/dist/client/auth/session-fetch.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSessionFetch = createSessionFetch;
+/* eslint-disable max-lines -- one refresh state machine; splitting it would scatter its shared session state. */
+const core_1 = require("@medplum/core");
+const account_storage_1 = require("./account-storage");
+const session_http_1 = require("./session-http");
+/**
+ * The client's `fetch`: request timeouts, token-refresh retries within the access token's
+ * lifetime, and tracking why a session ended, which `onUnauthenticated` reports.
+ */
+function createSessionFetch({ config, storage, fetchImplementation, normalizedBaseUrl, tokenUrl }) {
+    let unauthenticatedReason;
+    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" &&
+        new URLSearchParams(options.body).get("grant_type") === "refresh_token";
+    const markActiveAccountExpired = () => {
+        var _a, _b;
+        const accountId = (_b = (_a = storage.getObject("activeLogin")) === null || _a === void 0 ? void 0 : _a.profile) === null || _b === void 0 ? void 0 : _b.reference;
+        if (accountId) {
+            (0, account_storage_1.setStoredAccountExpired)(storage, accountId, true);
+        }
+    };
+    const fetchOnce = async (url, options) => {
+        var _a, _b;
+        const response = await (0, session_http_1.fetchWithTimeout)(fetchImplementation, url, options, config.requestTimeoutMs);
+        const requestUrl = new URL(url, normalizedBaseUrl);
+        if (isTokenRefresh(url, options)) {
+            if (response.status === 400) {
+                let invalidGrant = false;
+                try {
+                    invalidGrant = (await response.clone().json()).error === "invalid_grant";
+                }
+                catch (_c) {
+                    // Do not sign out unless the response confirms that the refresh token was revoked.
+                }
+                if (!invalidGrant) {
+                    throw (0, session_http_1.refreshResponseError)(response);
+                }
+            }
+            if ([400, 401, 403].includes(response.status)) {
+                unauthenticatedReason = {
+                    type: "refresh-rejected",
+                    status: response.status,
+                };
+                markActiveAccountExpired();
+            }
+            else if (response.ok) {
+                const accountId = (_b = (_a = storage.getObject("activeLogin")) === null || _a === void 0 ? void 0 : _a.profile) === null || _b === void 0 ? void 0 : _b.reference;
+                if (accountId) {
+                    (0, account_storage_1.setStoredAccountExpired)(storage, accountId, false);
+                }
+                unauthenticatedReason = undefined;
+            }
+        }
+        else if (requestUrl.href === tokenUrl && !response.ok) {
+            unauthenticatedReason = {
+                type: "authentication-rejected",
+                status: response.status,
+            };
+        }
+        else if (response.status === 401) {
+            unauthenticatedReason = { type: "request-unauthorized", status: 401 };
+        }
+        return isTokenRefresh(url, options)
+            ? response
+            : (0, session_http_1.withHttpErrorMetadata)(response);
+    };
+    const fetchWithRefreshRetry = async (url, options) => {
+        var _a, _b, _c, _d;
+        const requestUrl = new URL(url, normalizedBaseUrl);
+        if (!isTokenRefresh(url, options)) {
+            const response = await fetchOnce(url, options);
+            const sessionEnded = requestUrl.pathname.endsWith("/auth/session/current") && response.status === 401;
+            if (sessionEnded) {
+                markActiveAccountExpired();
+            }
+            return response;
+        }
+        const login = storage.getObject("activeLogin");
+        if (terminalRefreshError) {
+            if ((login === null || login === void 0 ? void 0 : login.accessToken) && login.accessToken !== terminalRefreshToken) {
+                terminalRefreshToken = undefined;
+                terminalRefreshError = undefined;
+            }
+            else {
+                throw terminalRefreshError;
+            }
+        }
+        const expiresAt = (login === null || login === void 0 ? void 0 : login.accessToken) ? (0, core_1.tryGetJwtExpiration)(login.accessToken) : undefined;
+        const signal = options === null || options === void 0 ? void 0 : options.signal;
+        if (expiresAt !== undefined && options) {
+            const tokenRequestOptions = options;
+            tokenRequestOptions.maxRetries = 0;
+            tokenRequestOptions.maxRetryTime = 0;
+        }
+        if (expiresAt === undefined) {
+            const response = await fetchOnce(url, options);
+            if ((0, session_http_1.isTemporaryRefreshFailure)(response.status)) {
+                void ((_a = response.body) === null || _a === void 0 ? void 0 : _a.cancel().catch(() => undefined));
+                if (config.keepSessionOnRefreshUnavailable) {
+                    refreshState.unavailable = true;
+                }
+                throw (0, session_http_1.refreshUnavailableError)(response);
+            }
+            return response;
+        }
+        let attempt = 0;
+        let firstAttempt = true;
+        let lastResponse;
+        let lastNetworkError;
+        while (firstAttempt || Date.now() < expiresAt) {
+            firstAttempt = false;
+            try {
+                lastResponse = await fetchOnce(url, options);
+            }
+            catch (error) {
+                if ((signal === null || signal === void 0 ? void 0 : signal.aborted) || !(0, session_http_1.isNetworkError)(error)) {
+                    throw error;
+                }
+                if (config.keepSessionOnRefreshUnavailable) {
+                    refreshState.unavailable = true;
+                    lastNetworkError = error;
+                    break;
+                }
+                if (Date.now() >= expiresAt) {
+                    lastNetworkError = error;
+                    break;
+                }
+                lastNetworkError = error;
+                const remainingMs = expiresAt - Date.now();
+                const backoffMs = (0, session_http_1.refreshBackoffMs)(attempt);
+                await (0, session_http_1.waitForRetry)(Math.min(backoffMs, remainingMs), signal);
+                attempt += 1;
+                continue;
+            }
+            if (!(0, session_http_1.isTemporaryRefreshFailure)(lastResponse.status)) {
+                return lastResponse;
+            }
+            if (config.keepSessionOnRefreshUnavailable) {
+                refreshState.unavailable = true;
+                break;
+            }
+            const remainingMs = expiresAt - Date.now();
+            if (remainingMs <= 0) {
+                break;
+            }
+            const backoffMs = (0, session_http_1.refreshBackoffMs)(attempt);
+            const waitMs = Math.min(Math.max((_b = (0, session_http_1.retryAfterMs)(lastResponse)) !== null && _b !== void 0 ? _b : 0, backoffMs), remainingMs);
+            if (waitMs >= remainingMs) {
+                await (0, session_http_1.waitForRetry)(remainingMs, signal);
+                break;
+            }
+            void ((_c = lastResponse.body) === null || _c === void 0 ? void 0 : _c.cancel().catch(() => undefined));
+            await (0, session_http_1.waitForRetry)(waitMs, signal);
+            attempt += 1;
+        }
+        const status = lastResponse === null || lastResponse === void 0 ? void 0 : lastResponse.status;
+        const reason = {
+            type: "refresh-unavailable",
+            ...(status === undefined ? {} : { status }),
+        };
+        if (config.keepSessionOnRefreshUnavailable) {
+            refreshState.unavailable = true;
+            if (lastResponse) {
+                return lastResponse;
+            }
+            throw lastNetworkError !== null && lastNetworkError !== void 0 ? lastNetworkError : (0, session_http_1.refreshUnavailableError)(undefined);
+        }
+        unauthenticatedReason = reason;
+        markActiveAccountExpired();
+        if (lastResponse) {
+            return lastResponse;
+        }
+        terminalRefreshToken = login === null || login === void 0 ? void 0 : login.accessToken;
+        terminalRefreshError = lastNetworkError !== null && lastNetworkError !== void 0 ? lastNetworkError : (0, session_http_1.refreshUnavailableError)(undefined);
+        clearActiveLogin();
+        (_d = config.onUnauthenticated) === null || _d === void 0 ? void 0 : _d.call(config, reason);
+        unauthenticatedReason = undefined;
+        throw terminalRefreshError;
+    };
+    const onUnauthenticated = () => {
+        var _a;
+        if (refreshState.unavailable) {
+            return;
+        }
+        const reason = unauthenticatedReason !== null && unauthenticatedReason !== void 0 ? unauthenticatedReason : {
+            type: "request-unauthorized",
+            status: 401,
+        };
+        unauthenticatedReason = undefined;
+        (_a = config.onUnauthenticated) === null || _a === void 0 ? void 0 : _a.call(config, reason);
+    };
+    return {
+        fetch: fetchWithRefreshRetry,
+        onUnauthenticated,
+        refreshState,
+        setClearActiveLogin: (clear) => {
+            clearActiveLogin = clear;
+        },
+    };
+}

package/dist/client/auth/session-http.d.ts

@@ -0,0 +1,11 @@
+export declare const retryAfterMs: (response: Response) => number | undefined;
+export declare const withHttpErrorMetadata: (response: Response) => Promise<Response>;
+export declare const waitForRetry: (milliseconds: number, signal?: AbortSignal) => Promise<void>;
+export declare const isTemporaryRefreshFailure: (status: number) => boolean;
+export declare const refreshUnavailableError: (response?: Response) => Error;
+export declare const refreshResponseError: (response: Response) => Error;
+export declare const isNetworkError: (error: unknown) => boolean;
+/** Fetches with an upper time bound, still honouring the caller's own abort signal. */
+export declare const fetchWithTimeout: (fetchImplementation: (url: string, options?: RequestInit) => Promise<Response>, url: string, options: RequestInit | undefined, requestTimeoutMs: number | undefined) => Promise<Response>;
+/** Exponential refresh backoff: 500 ms doubling per attempt, capped at 30 s. */
+export declare const refreshBackoffMs: (attempt: number) => number;

package/dist/client/auth/session-http.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refreshBackoffMs = exports.fetchWithTimeout = exports.isNetworkError = exports.refreshResponseError = exports.refreshUnavailableError = exports.isTemporaryRefreshFailure = exports.waitForRetry = exports.withHttpErrorMetadata = exports.retryAfterMs = void 0;
+const ovok_error_utils_1 = require("../errors/ovok-error-utils");
+const retryAfterMs = (response) => {
+    var _a, _b;
+    const value = (_b = (_a = response.headers) === null || _a === void 0 ? void 0 : _a.get) === null || _b === void 0 ? void 0 : _b.call(_a, "Retry-After");
+    if (!value) {
+        return undefined;
+    }
+    const seconds = Number(value);
+    if (Number.isFinite(seconds)) {
+        return Math.max(0, seconds * 1000);
+    }
+    const date = Date.parse(value);
+    return Number.isFinite(date) ? Math.max(0, date - Date.now()) : undefined;
+};
+exports.retryAfterMs = retryAfterMs;
+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 = (0, exports.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,
+    });
+};
+exports.withHttpErrorMetadata = withHttpErrorMetadata;
+const waitForRetry = (milliseconds, signal) => new Promise((resolve, reject) => {
+    var _a;
+    if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+        const error = new Error("Token refresh aborted");
+        error.name = "AbortError";
+        reject((_a = signal.reason) !== null && _a !== void 0 ? _a : error);
+        return;
+    }
+    const timer = setTimeout(() => {
+        signal === null || signal === void 0 ? void 0 : signal.removeEventListener("abort", abort);
+        resolve();
+    }, milliseconds);
+    const abort = () => {
+        var _a;
+        clearTimeout(timer);
+        const error = new Error("Token refresh aborted");
+        error.name = "AbortError";
+        reject((_a = signal === null || signal === void 0 ? void 0 : signal.reason) !== null && _a !== void 0 ? _a : error);
+    };
+    signal === null || signal === void 0 ? void 0 : signal.addEventListener("abort", abort, { once: true });
+});
+exports.waitForRetry = waitForRetry;
+const isTemporaryRefreshFailure = (status) => status === 429 || (status >= 500 && status <= 599);
+exports.isTemporaryRefreshFailure = isTemporaryRefreshFailure;
+const refreshUnavailableError = (response) => {
+    const error = new Error("Token refresh is temporarily unavailable");
+    error.name = "NetworkError";
+    Object.assign(error, { cause: response });
+    return error;
+};
+exports.refreshUnavailableError = refreshUnavailableError;
+const refreshResponseError = (response) => {
+    const error = new Error(`Token refresh returned HTTP ${response.status}`);
+    error.name = "TokenRefreshError";
+    Object.assign(error, { status: response.status, cause: response });
+    return error;
+};
+exports.refreshResponseError = refreshResponseError;
+const isNetworkError = (error) => {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    if (error.name === "NetworkError" ||
+        error.name === "UnknownHostException" ||
+        /network request failed|failed to fetch|load failed|unknownhostexception|econn|enotfound/i.test(error.message)) {
+        return true;
+    }
+    return (0, exports.isNetworkError)(error.cause);
+};
+exports.isNetworkError = isNetworkError;
+/** Fetches with an upper time bound, still honouring the caller's own abort signal. */
+const fetchWithTimeout = async (fetchImplementation, url, options, requestTimeoutMs) => {
+    if (requestTimeoutMs === undefined) {
+        return fetchImplementation(url, options);
+    }
+    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 {
+        return 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);
+    }
+};
+exports.fetchWithTimeout = fetchWithTimeout;
+/** Exponential refresh backoff: 500 ms doubling per attempt, capped at 30 s. */
+const refreshBackoffMs = (attempt) => Math.min(500 * (2 ** Math.min(attempt, 6)), 30000);
+exports.refreshBackoffMs = refreshBackoffMs;

package/dist/client/experience/methods.js

@@ -34,85 +34,75 @@ exports.listChatSessions = listChatSessions;
 exports.getChatSession = getChatSession;
 exports.listChatMessages = listChatMessages;
 exports.searchAIFhir = searchAIFhir;
-const segment = (value) => encodeURIComponent(value);
-const query = (params) => {
-    const values = new URLSearchParams();
-    for (const [key, value] of Object.entries(params)) {
-        if (value !== undefined) {
-            values.set(key, String(value));
-        }
-    }
-    const encoded = values.toString();
-    return encoded === "" ? "" : `?${encoded}`;
-};
-const documentUrl = (client, path, params) => `${client.getBaseUrl().replace(/\/$/, "")}${path}${query(params)}`;
+const query_string_1 = require("../query-string");
+const documentUrl = (client, path, params) => `${client.getBaseUrl().replace(/\/$/, "")}${path}${(0, query_string_1.toQueryString)(params)}`;
 async function requestConsentSignature(consentId, requestOptions) {
-    return this.post(`/consent/signature/${segment(consentId)}`, undefined, undefined, requestOptions);
+    return this.post(`/consent/signature/${encodeURIComponent(consentId)}`, undefined, undefined, requestOptions);
 }
 async function createDocumentUpload(body, requestOptions) {
     return this.post("/document", body, undefined, requestOptions);
 }
 async function listDocuments(params = {}, requestOptions) {
-    return this.get(`/document${query(params)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
+    return this.get(`/document${(0, query_string_1.toQueryString)(params)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
 }
 /** Returns the authenticated document endpoint; navigating/fetching it follows the backend redirect. */
 async function getDocumentDownloadUrl(documentId, params = {}) {
-    return documentUrl(this, `/document/${segment(documentId)}`, params);
+    return documentUrl(this, `/document/${encodeURIComponent(documentId)}`, params);
 }
 /** Returns a public document endpoint for use in an image, download, or media element. */
 async function getPublicDocumentDownloadUrl(token, params = {}) {
-    return documentUrl(this, `/document/public/${segment(token)}`, params);
+    return documentUrl(this, `/document/public/${encodeURIComponent(token)}`, params);
 }
 async function deleteDocument(documentId, requestOptions) {
-    return (await this.delete(`/document/${segment(documentId)}`, ...(requestOptions === undefined ? [] : [requestOptions])));
+    return (await this.delete(`/document/${encodeURIComponent(documentId)}`, ...(requestOptions === undefined ? [] : [requestOptions])));
 }
 async function updateDocumentMetadata(documentId, body, requestOptions) {
-    return (await this.patch(`/document/${segment(documentId)}`, body, ...(requestOptions === undefined ? [] : [requestOptions])));
+    return (await this.patch(`/document/${encodeURIComponent(documentId)}`, body, ...(requestOptions === undefined ? [] : [requestOptions])));
 }
 async function generateDocumentReplacementUpload(documentId, body, requestOptions) {
-    return this.post(`/document/${segment(documentId)}`, body, undefined, requestOptions);
+    return this.post(`/document/${encodeURIComponent(documentId)}`, body, undefined, requestOptions);
 }
 async function searchMappedContent(type, language, params = {}, requestOptions) {
-    return this.get(`/cms/${segment(type)}/map/${segment(language)}${query(params)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
+    return this.get(`/cms/${encodeURIComponent(type)}/map/${encodeURIComponent(language)}${(0, query_string_1.toQueryString)(params)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
 }
 async function copyContentsFromParent(type, language, requestOptions) {
-    return this.post(`/cms/${segment(type)}/${segment(language)}/copy-from-parent-project`, undefined, undefined, requestOptions);
+    return this.post(`/cms/${encodeURIComponent(type)}/${encodeURIComponent(language)}/copy-from-parent-project`, undefined, undefined, requestOptions);
 }
 async function copyContentFromParent(type, language, key, requestOptions) {
-    return this.post(`/cms/${segment(type)}/${segment(language)}/${segment(key)}/copy-from-parent-project`, undefined, undefined, requestOptions);
+    return this.post(`/cms/${encodeURIComponent(type)}/${encodeURIComponent(language)}/${encodeURIComponent(key)}/copy-from-parent-project`, undefined, undefined, requestOptions);
 }
 async function createContent(type, language, body, requestOptions) {
-    return this.post(`/cms/${segment(type)}/${segment(language)}`, body, undefined, requestOptions);
+    return this.post(`/cms/${encodeURIComponent(type)}/${encodeURIComponent(language)}`, body, undefined, requestOptions);
 }
 async function updateContent(type, language, key, body, requestOptions) {
-    return (await this.put(`/cms/${segment(type)}/${segment(language)}/${segment(key)}`, body, undefined, requestOptions));
+    return (await this.put(`/cms/${encodeURIComponent(type)}/${encodeURIComponent(language)}/${encodeURIComponent(key)}`, body, undefined, requestOptions));
 }
 async function getContent(type, language, key, requestOptions) {
-    return this.get(`/cms/${segment(type)}/${segment(language)}/${segment(key)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
+    return this.get(`/cms/${encodeURIComponent(type)}/${encodeURIComponent(language)}/${encodeURIComponent(key)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
 }
 async function deleteContent(type, language, key, requestOptions) {
-    await this.delete(`/cms/${segment(type)}/${segment(language)}/${segment(key)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
+    await this.delete(`/cms/${encodeURIComponent(type)}/${encodeURIComponent(language)}/${encodeURIComponent(key)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
 }
 async function searchContent(type, language, params = {}, requestOptions) {
-    return this.get(`/cms/${segment(type)}/${segment(language)}${query(params)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
+    return this.get(`/cms/${encodeURIComponent(type)}/${encodeURIComponent(language)}${(0, query_string_1.toQueryString)(params)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
 }
 async function createVideoCallAppointment(body, requestOptions) {
     return this.post("/video-call/livekit/appointment", body, undefined, requestOptions);
 }
 async function updateVideoCallAppointment(appointmentId, body, requestOptions) {
-    return (await this.put(`/video-call/livekit/appointment/${segment(appointmentId)}`, body, undefined, requestOptions));
+    return (await this.put(`/video-call/livekit/appointment/${encodeURIComponent(appointmentId)}`, body, undefined, requestOptions));
 }
 async function listVideoCallAppointments(params = {}, requestOptions) {
-    return this.get(`/video-call/livekit/appointment${query(params)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
+    return this.get(`/video-call/livekit/appointment${(0, query_string_1.toQueryString)(params)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
 }
 async function getVideoCallAccessPermission(appointmentId, requestOptions) {
-    return this.get(`/video-call/livekit/access-permission/${segment(appointmentId)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
+    return this.get(`/video-call/livekit/access-permission/${encodeURIComponent(appointmentId)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
 }
 async function createVideoCallGuestAccess(appointmentId, body, requestOptions) {
-    return this.post(`/video-call/livekit/guest-access/${segment(appointmentId)}`, body, undefined, requestOptions);
+    return this.post(`/video-call/livekit/guest-access/${encodeURIComponent(appointmentId)}`, body, undefined, requestOptions);
 }
 async function createVideoCallUserAccess(appointmentId, requestOptions) {
-    return this.post(`/video-call/livekit/user-access/${segment(appointmentId)}`, undefined, undefined, requestOptions);
+    return this.post(`/video-call/livekit/user-access/${encodeURIComponent(appointmentId)}`, undefined, undefined, requestOptions);
 }
 async function sendVideoCallInvite(body, requestOptions) {
     return this.post("/video-call/livekit/mail/invite", body, undefined, requestOptions);
@@ -124,7 +114,7 @@ async function sendVideoCallCancellation(body, requestOptions) {
     return this.post("/video-call/livekit/mail/cancel", body, undefined, requestOptions);
 }
 async function sendVideoCallActiveNotification(appointmentId, requestOptions) {
-    return this.post(`/video-call/livekit/notification/active-call/${segment(appointmentId)}`, undefined, undefined, requestOptions);
+    return this.post(`/video-call/livekit/notification/active-call/${encodeURIComponent(appointmentId)}`, undefined, undefined, requestOptions);
 }
 async function translate(body, requestOptions) {
     return this.post("/ai/translation", body, undefined, requestOptions);
@@ -133,16 +123,16 @@ async function createChatSession(body, requestOptions) {
     return this.post("/ai/session", body, undefined, requestOptions);
 }
 async function sendChatMessage(sessionId, body, requestOptions) {
-    return this.post(`/ai/session/${segment(sessionId)}/message`, body, undefined, requestOptions);
+    return this.post(`/ai/session/${encodeURIComponent(sessionId)}/message`, body, undefined, requestOptions);
 }
 async function listChatSessions(params = {}, requestOptions) {
-    return this.get(`/ai/session${query(params)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
+    return this.get(`/ai/session${(0, query_string_1.toQueryString)(params)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
 }
 async function getChatSession(sessionId, params = {}, requestOptions) {
-    return this.get(`/ai/session/${segment(sessionId)}${query(params)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
+    return this.get(`/ai/session/${encodeURIComponent(sessionId)}${(0, query_string_1.toQueryString)(params)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
 }
 async function listChatMessages(sessionId, params = {}, requestOptions) {
-    return this.get(`/ai/session/${segment(sessionId)}/message${query(params)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
+    return this.get(`/ai/session/${encodeURIComponent(sessionId)}/message${(0, query_string_1.toQueryString)(params)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
 }
 async function searchAIFhir(request, requestOptions) {
     return this.post("/ai/fhir/search", request, undefined, requestOptions);

package/dist/client/notifications/methods.js

@@ -5,7 +5,6 @@ exports.listNotificationNotes = listNotificationNotes;
 exports.updateNotificationNote = updateNotificationNote;
 exports.patchNotificationNote = patchNotificationNote;
 exports.deleteNotificationNote = deleteNotificationNote;
-const segment = (value) => encodeURIComponent(value);
 const TARGET_PATH = {
     oob: "oob",
     alarm: "alarms",
@@ -16,14 +15,14 @@ function createNotificationNote(body, requestOptions) {
     return this.post("/v1/slim/notifications/notes", body, undefined, requestOptions);
 }
 function listNotificationNotes(kind, id, requestOptions) {
-    return this.get(`/v1/slim/notifications/${TARGET_PATH[kind]}/${segment(id)}/notes`, { ...{ cache: "reload" }, ...requestOptions });
+    return this.get(`/v1/slim/notifications/${TARGET_PATH[kind]}/${encodeURIComponent(id)}/notes`, { ...{ cache: "reload" }, ...requestOptions });
 }
 function updateNotificationNote(noteId, body, requestOptions) {
-    return this.put(`/v1/slim/notifications/notes/${segment(noteId)}`, body, undefined, requestOptions);
+    return this.put(`/v1/slim/notifications/notes/${encodeURIComponent(noteId)}`, body, undefined, requestOptions);
 }
 function patchNotificationNote(noteId, body, requestOptions) {
-    return this.patch(`/v1/slim/notifications/notes/${segment(noteId)}`, body, ...(requestOptions === undefined ? [] : [requestOptions]));
+    return this.patch(`/v1/slim/notifications/notes/${encodeURIComponent(noteId)}`, body, ...(requestOptions === undefined ? [] : [requestOptions]));
 }
 async function deleteNotificationNote(noteId, requestOptions) {
-    await this.delete(`/v1/slim/notifications/notes/${segment(noteId)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
+    await this.delete(`/v1/slim/notifications/notes/${encodeURIComponent(noteId)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
 }

package/dist/client/observation/services/creator.js

@@ -3,22 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObservationServiceCreator = void 0;
 const types_1 = require("../../../types");
 const baby_sleep_1 = require("./baby-sleep");
-const blood_glucose_1 = require("./blood-glucose");
 const blood_oxygen_1 = require("./blood-oxygen");
 const blood_pressure_1 = require("./blood-pressure");
-const body_temperature_1 = require("./body-temperature");
-const body_weight_1 = require("./body-weight");
 const ecg_1 = require("./ecg");
-const heart_rate_1 = require("./heart-rate");
-const heart_rate_variability_1 = require("./heart-rate-variability");
 const lipid_panel_1 = require("./lipid-panel");
-const respiratory_rate_1 = require("./respiratory-rate");
 const respiratory_therapy_1 = require("./respiratory-therapy");
-const resting_heart_rate_1 = require("./resting-heart-rate");
+const single_value_services_1 = require("./single-value-services");
 const step_count_1 = require("./step-count");
 const uric_acid_service_1 = require("./uric-acid-service");
-const vo2_max_1 = require("./vo2-max");
-const walking_heart_rate_average_1 = require("./walking-heart-rate-average");
 class ObservationServiceCreator {
     constructor() {
         this.services = new Map();
@@ -31,19 +23,13 @@ class ObservationServiceCreator {
         return ObservationServiceCreator.instance;
     }
     initializeServices() {
-        this.services.set(types_1.MeasurementTypeKey.bodyWeight, new body_weight_1.BodyWeightService());
+        for (const [type, service] of (0, single_value_services_1.singleValueObservationServices)()) {
+            this.services.set(type, service);
+        }
         this.services.set(types_1.MeasurementTypeKey.bloodPressure, new blood_pressure_1.BloodPressureService());
-        this.services.set(types_1.MeasurementTypeKey.bloodGlucose, new blood_glucose_1.BloodGlucoseService());
-        this.services.set(types_1.MeasurementTypeKey.temperature, new body_temperature_1.BodyTemperatureService());
         this.services.set(types_1.MeasurementTypeKey.bloodOxygenPulseRate, new blood_oxygen_1.BloodOxygenService());
         this.services.set(types_1.MeasurementTypeKey.ecg, new ecg_1.EcgService());
         this.services.set(types_1.MeasurementTypeKey.stepCount, new step_count_1.StepCountService());
-        this.services.set(types_1.MeasurementTypeKey.restingHeartRate, new resting_heart_rate_1.RestingHeartRateService());
-        this.services.set(types_1.MeasurementTypeKey.walkingHeartRateAverage, new walking_heart_rate_average_1.WalkingHeartRateAverageService());
-        this.services.set(types_1.MeasurementTypeKey.heartRateVariability, new heart_rate_variability_1.HeartRateVariabilityService());
-        this.services.set(types_1.MeasurementTypeKey.heartRate, new heart_rate_1.HeartRateService());
-        this.services.set(types_1.MeasurementTypeKey.respiratoryRate, new respiratory_rate_1.RespiratoryRateService());
-        this.services.set(types_1.MeasurementTypeKey.vo2Max, new vo2_max_1.Vo2MaxService());
         this.services.set(types_1.MeasurementTypeKey.urineAnalysis, new uric_acid_service_1.UricAcidService());
         this.services.set(types_1.MeasurementTypeKey.uricAcid, new uric_acid_service_1.UricAcidService());
         this.services.set(types_1.MeasurementTypeKey.lipidPanel, new lipid_panel_1.LipidPanelService());