@ovok/core 0.4.49-dev.498 → 0.4.49-dev.500

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.498+92fd957",
+        version: "0.4.49-dev.500+07ba725",
     },
     fhirVersion: "4.0.1",
     format: ["json"],

package/dist/next/index.d.ts

@@ -8,6 +8,7 @@ export type { OvokErrorDetails } from "./errors/ovok-errors";
 export type { RequestOptions } from "./http/transmit";
 export type { QueryParams, QueryValue } from "./http/url";
 export type { Page, PagePromise } from "./paging/page";
+export type { RealtimeNotification, RealtimeNotificationHandler, RealtimeUnsubscribe } from "./resources/realtime/realtime-resource";
 export type { OvokReference, Session } from "./auth/session";
 export type { SavedAccount } from "./auth/saved-accounts-store";
 export type { SessionChangeListener } from "./auth/user-session";
@@ -42,6 +43,7 @@ export type { ContentResource } from "./resources/content/content-resource";
 export type { DocumentsResource } from "./resources/documents/documents-resource";
 export type { EmailResource } from "./resources/email/email-resource";
 export type { FhirResource } from "./resources/fhir-resource";
+export type { RealtimeResource } from "./resources/realtime/realtime-resource";
 export type { HealthResource } from "./resources/health-resource";
 export type { InvitesResource } from "./resources/invites/invites-resource";
 export type { LocalesResource } from "./resources/localization/locales-resource";

package/dist/next/ovok.d.ts

@@ -17,6 +17,7 @@ import { MeasurementsResource } from "./resources/measurements/measurements-reso
 import { PatientResource } from "./resources/patient/patient-resource";
 import { ProjectsResource } from "./resources/projects/projects-resource";
 import { QuestionnaireResponsesResource, QuestionnairesResource } from "./resources/questionnaires/questionnaires-resource";
+import { RealtimeResource } from "./resources/realtime/realtime-resource";
 import { SessionResource } from "./resources/session/session-resource";
 import { SharingResource } from "./resources/sharing/sharing-resource";
 import { SignalsResource } from "./resources/signals/signals-resource";
@@ -33,6 +34,7 @@ export declare class Ovok {
     readonly measurements: MeasurementsResource;
     readonly questionnaires: QuestionnairesResource;
     readonly questionnaireResponses: QuestionnaireResponsesResource;
+    readonly realtime: RealtimeResource;
     readonly consent: ConsentResource;
     readonly invites: InvitesResource;
     readonly sharing: SharingResource;

package/dist/next/ovok.js

@@ -28,6 +28,7 @@ const offline_measurement_queue_1 = require("./resources/measurements/offline-me
 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");
+const realtime_resource_1 = require("./resources/realtime/realtime-resource");
 const session_resource_1 = require("./resources/session/session-resource");
 const sharing_resource_1 = require("./resources/sharing/sharing-resource");
 const signals_resource_1 = require("./resources/signals/signals-resource");
@@ -42,10 +43,12 @@ class Ovok {
         const credentials = credentialsFor(settings);
         const http = new http_client_1.HttpClient({ settings, credentials, retryPolicy: new retry_policy_1.RetryPolicy(settings.maxNetworkRetries) });
         const session = credentials instanceof user_session_1.UserSession ? credentials : null;
-        const fhir = new fhir_resource_1.FhirResource(http.under(settings.fhirPath));
+        const fhirHttp = http.under(settings.fhirPath);
+        const fhir = new fhir_resource_1.FhirResource(fhirHttp);
         this.auth = new auth_resource_1.AuthResource(http, settings.tenantCode, session, settings.clientId);
         this.session = new session_resource_1.SessionResource(http, session);
         this.fhir = fhir;
+        this.realtime = new realtime_resource_1.RealtimeResource(fhirHttp, fhir, settings.baseUrl, this.session);
         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, {

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/realtime/realtime-binding.d.ts

@@ -0,0 +1,7 @@
+import { HttpClient } from "../../http/http-client";
+export type RealtimeBinding = {
+    token: string;
+    url: string;
+    expiresAt: number;
+};
+export declare const fetchRealtimeBinding: (http: HttpClient, subscriptionId: string, baseUrl: string) => Promise<RealtimeBinding>;

package/dist/next/resources/realtime/realtime-binding.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchRealtimeBinding = void 0;
+const ovok_errors_1 = require("../../errors/ovok-errors");
+const url_1 = require("../../http/url");
+const SOCKET_PATH = "/ws/subscriptions-r4";
+const fetchRealtimeBinding = async (http, subscriptionId, baseUrl) => {
+    var _a, _b, _c, _d, _e, _f;
+    const parameters = await http.send({
+        method: "GET",
+        path: `Subscription/${(0, url_1.pathSegment)(subscriptionId)}/$get-ws-binding-token`,
+        headers: { Accept: "application/fhir+json", "Cache-Control": "no-cache" },
+    });
+    const token = (_b = (_a = parameters.parameter) === null || _a === void 0 ? void 0 : _a.find((parameter) => parameter.name === "token")) === null || _b === void 0 ? void 0 : _b.valueString;
+    const url = (_d = (_c = parameters.parameter) === null || _c === void 0 ? void 0 : _c.find((parameter) => parameter.name === "websocket-url")) === null || _d === void 0 ? void 0 : _d.valueUrl;
+    const expires = (_f = (_e = parameters.parameter) === null || _e === void 0 ? void 0 : _e.find((parameter) => parameter.name === "expiration")) === null || _f === void 0 ? void 0 : _f.valueDateTime;
+    if (!token || !url || !expires) {
+        throw new ovok_errors_1.OvokServiceError((0, ovok_errors_1.detailsFor)("The realtime binding response is missing its token, URL, or expiry."));
+    }
+    const socketUrl = apiSocketUrl(url, baseUrl);
+    const expiresAt = Date.parse(expires);
+    if (!Number.isFinite(expiresAt)) {
+        throw new ovok_errors_1.OvokServiceError((0, ovok_errors_1.detailsFor)("The realtime binding response has an invalid expiry."));
+    }
+    return { token, url: socketUrl.toString(), expiresAt };
+};
+exports.fetchRealtimeBinding = fetchRealtimeBinding;
+const apiSocketUrl = (value, baseUrl) => {
+    let socketUrl;
+    try {
+        socketUrl = new URL(value);
+    }
+    catch (_a) {
+        throw new ovok_errors_1.OvokServiceError((0, ovok_errors_1.detailsFor)("The realtime binding response has an invalid WebSocket URL."));
+    }
+    const apiUrl = new URL(baseUrl);
+    const expectedProtocol = apiUrl.protocol === "https:" ? "wss:" : "ws:";
+    if (socketUrl.protocol !== expectedProtocol ||
+        socketUrl.host !== apiUrl.host ||
+        socketUrl.pathname !== SOCKET_PATH) {
+        throw new ovok_errors_1.OvokServiceError((0, ovok_errors_1.detailsFor)("The realtime WebSocket URL must use the configured API host."));
+    }
+    return socketUrl;
+};

package/dist/next/resources/realtime/realtime-connection.d.ts

@@ -0,0 +1,38 @@
+import { HttpClient } from "../../http/http-client";
+import { FhirResource } from "../fhir-resource";
+import { SessionResource } from "../session/session-resource";
+import { RealtimeNotificationHandler } from "./realtime-types";
+export declare class RealtimeConnection {
+    private readonly http;
+    private readonly fhir;
+    private readonly baseUrl;
+    private readonly session;
+    private readonly subscriptionId;
+    private readonly handler;
+    private socket;
+    private binding;
+    private profileReference;
+    private accessToken;
+    private reconnectDelayMs;
+    private reconnectTimer;
+    private refreshTimer;
+    private refreshInFlight;
+    private removeSessionListener;
+    private connecting;
+    private paused;
+    private stopped;
+    private deleted;
+    constructor(http: HttpClient, fhir: FhirResource, baseUrl: string, session: SessionResource, subscriptionId: string, handler: RealtimeNotificationHandler);
+    start(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    private connect;
+    private openSocket;
+    private socketClosed;
+    private sessionChanged;
+    private refreshBinding;
+    private scheduleBindingRefresh;
+    private scheduleReconnect;
+    private closeSocket;
+    private clearTimers;
+    private clearRefreshTimer;
+}

package/dist/next/resources/realtime/realtime-connection.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RealtimeConnection = void 0;
+const realtime_binding_1 = require("./realtime-binding");
+const realtime_socket_1 = require("./realtime-socket");
+const TOKEN_REFRESH_MARGIN_MS = 5 * 60000;
+const TOKEN_REFRESH_MIN_DELAY_MS = 60000;
+const INITIAL_RECONNECT_DELAY_MS = 1000;
+const MAX_RECONNECT_DELAY_MS = 30000;
+class RealtimeConnection {
+    constructor(http, fhir, baseUrl, session, subscriptionId, handler) {
+        this.http = http;
+        this.fhir = fhir;
+        this.baseUrl = baseUrl;
+        this.session = session;
+        this.subscriptionId = subscriptionId;
+        this.handler = handler;
+        this.socket = null;
+        this.binding = null;
+        this.profileReference = null;
+        this.accessToken = null;
+        this.reconnectDelayMs = INITIAL_RECONNECT_DELAY_MS;
+        this.reconnectTimer = null;
+        this.refreshTimer = null;
+        this.refreshInFlight = null;
+        this.removeSessionListener = null;
+        this.connecting = false;
+        this.paused = false;
+        this.stopped = false;
+        this.deleted = false;
+    }
+    async start() {
+        var _a, _b;
+        const session = await this.session.current();
+        this.profileReference = (_a = session === null || session === void 0 ? void 0 : session.profile.reference) !== null && _a !== void 0 ? _a : null;
+        this.accessToken = (_b = session === null || session === void 0 ? void 0 : session.accessToken) !== null && _b !== void 0 ? _b : null;
+        this.removeSessionListener = this.session.onChange((nextSession) => this.sessionChanged(nextSession));
+        await this.connect();
+    }
+    async unsubscribe() {
+        var _a, _b, _c;
+        if (this.deleted) {
+            return;
+        }
+        this.stopped = true;
+        (_a = this.removeSessionListener) === null || _a === void 0 ? void 0 : _a.call(this);
+        this.removeSessionListener = null;
+        this.clearTimers();
+        (_b = this.socket) === null || _b === void 0 ? void 0 : _b.close((_c = this.binding) === null || _c === void 0 ? void 0 : _c.token);
+        this.socket = null;
+        await this.fhir.delete("Subscription", this.subscriptionId);
+        this.deleted = true;
+    }
+    async connect() {
+        if (this.stopped || this.paused || this.connecting || this.socket) {
+            return;
+        }
+        this.connecting = true;
+        try {
+            const binding = await (0, realtime_binding_1.fetchRealtimeBinding)(this.http, this.subscriptionId, this.baseUrl);
+            if (this.stopped || this.paused) {
+                return;
+            }
+            this.binding = binding;
+            this.scheduleBindingRefresh(binding);
+            this.openSocket(binding);
+        }
+        finally {
+            this.connecting = false;
+        }
+    }
+    openSocket(binding) {
+        const socket = new realtime_socket_1.RealtimeSocket(binding.url, binding.token, this.handler, () => { this.reconnectDelayMs = INITIAL_RECONNECT_DELAY_MS; }, (closedSocket) => this.socketClosed(closedSocket));
+        this.socket = socket;
+        socket.open();
+    }
+    socketClosed(socket) {
+        if (socket !== this.socket) {
+            return;
+        }
+        this.socket = null;
+        this.clearRefreshTimer();
+        this.scheduleReconnect();
+    }
+    sessionChanged(session) {
+        if (session === null) {
+            this.paused = true;
+            this.clearTimers();
+            this.closeSocket();
+            return;
+        }
+        if (this.profileReference !== null && session.profile.reference !== this.profileReference) {
+            void this.unsubscribe().catch(() => undefined);
+            return;
+        }
+        this.profileReference = session.profile.reference;
+        if (this.paused) {
+            this.paused = false;
+            void this.connect().catch(() => this.scheduleReconnect());
+            return;
+        }
+        if (session.accessToken === this.accessToken) {
+            return;
+        }
+        this.accessToken = session.accessToken;
+        if (this.connecting) {
+            return;
+        }
+        void this.refreshBinding().catch(() => { var _a; return (_a = this.socket) === null || _a === void 0 ? void 0 : _a.close(); });
+    }
+    refreshBinding() {
+        if (this.refreshInFlight) {
+            return this.refreshInFlight;
+        }
+        this.refreshInFlight = (0, realtime_binding_1.fetchRealtimeBinding)(this.http, this.subscriptionId, this.baseUrl)
+            .then((binding) => {
+            var _a;
+            if (this.stopped || this.paused) {
+                return;
+            }
+            this.binding = binding;
+            this.scheduleBindingRefresh(binding);
+            (_a = this.socket) === null || _a === void 0 ? void 0 : _a.bind(binding.token);
+        })
+            .finally(() => {
+            this.refreshInFlight = null;
+        });
+        return this.refreshInFlight;
+    }
+    scheduleBindingRefresh(binding) {
+        this.clearRefreshTimer();
+        const delay = Math.max(TOKEN_REFRESH_MIN_DELAY_MS, binding.expiresAt - Date.now() - TOKEN_REFRESH_MARGIN_MS);
+        this.refreshTimer = setTimeout(() => {
+            void this.refreshBinding().catch(() => { var _a; return (_a = this.socket) === null || _a === void 0 ? void 0 : _a.close(); });
+        }, delay);
+    }
+    scheduleReconnect() {
+        if (this.stopped || this.paused || this.reconnectTimer !== null) {
+            return;
+        }
+        const delay = this.reconnectDelayMs;
+        this.reconnectDelayMs = Math.min(this.reconnectDelayMs * 2, MAX_RECONNECT_DELAY_MS);
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            void this.connect().catch(() => this.scheduleReconnect());
+        }, delay);
+    }
+    closeSocket() {
+        const socket = this.socket;
+        this.socket = null;
+        socket === null || socket === void 0 ? void 0 : socket.close();
+    }
+    clearTimers() {
+        if (this.reconnectTimer !== null) {
+            clearTimeout(this.reconnectTimer);
+        }
+        this.reconnectTimer = null;
+        this.clearRefreshTimer();
+    }
+    clearRefreshTimer() {
+        if (this.refreshTimer !== null) {
+            clearTimeout(this.refreshTimer);
+        }
+        this.refreshTimer = null;
+    }
+}
+exports.RealtimeConnection = RealtimeConnection;

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

@@ -0,0 +1,13 @@
+import { HttpClient } from "../../http/http-client";
+import { FhirResource } from "../fhir-resource";
+import { SessionResource } from "../session/session-resource";
+import { RealtimeNotificationHandler, RealtimeUnsubscribe } from "./realtime-types";
+export type { RealtimeNotification, RealtimeNotificationHandler, RealtimeUnsubscribe, } from "./realtime-types";
+export declare class RealtimeResource {
+    private readonly http;
+    private readonly fhir;
+    private readonly baseUrl;
+    private readonly session;
+    constructor(http: HttpClient, fhir: FhirResource, baseUrl: string, session: SessionResource);
+    subscribe(criteria: string, handler: RealtimeNotificationHandler): Promise<RealtimeUnsubscribe>;
+}

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RealtimeResource = void 0;
+const ovok_errors_1 = require("../../errors/ovok-errors");
+const realtime_connection_1 = require("./realtime-connection");
+class RealtimeResource {
+    constructor(http, fhir, baseUrl, session) {
+        this.http = http;
+        this.fhir = fhir;
+        this.baseUrl = baseUrl;
+        this.session = session;
+    }
+    async subscribe(criteria, handler) {
+        if (criteria.trim() === "") {
+            throw new ovok_errors_1.OvokValidationError((0, ovok_errors_1.detailsFor)("A realtime subscription criteria string is required."));
+        }
+        const subscription = {
+            resourceType: "Subscription",
+            status: "active",
+            reason: "Ovok SDK realtime subscription",
+            criteria,
+            channel: { type: "websocket" },
+        };
+        const created = await this.fhir.create(subscription);
+        if (!created.id) {
+            throw new ovok_errors_1.OvokServiceError((0, ovok_errors_1.detailsFor)("The realtime subscription response did not include an id."));
+        }
+        const connection = new realtime_connection_1.RealtimeConnection(this.http, this.fhir, this.baseUrl, this.session, created.id, handler);
+        try {
+            await connection.start();
+        }
+        catch (error) {
+            await connection.unsubscribe().catch(() => undefined);
+            throw error;
+        }
+        return () => connection.unsubscribe();
+    }
+}
+exports.RealtimeResource = RealtimeResource;

package/dist/next/resources/realtime/realtime-socket.d.ts

@@ -0,0 +1,23 @@
+import { RealtimeNotificationHandler } from "./realtime-types";
+export declare class RealtimeSocket {
+    private readonly url;
+    private token;
+    private readonly handler;
+    private readonly onHandshake;
+    private readonly onClose;
+    private socket;
+    private handshakeTimer;
+    private pingTimer;
+    private waitingForPong;
+    constructor(url: string, token: string, handler: RealtimeNotificationHandler, onHandshake: () => void, onClose: (socket: RealtimeSocket) => void);
+    open(): void;
+    bind(token: string): void;
+    close(unbindToken?: string): void;
+    private socketOpened;
+    private socketMessage;
+    private socketClosed;
+    private sendPing;
+    private sendBinding;
+    private clearTimers;
+    private clearHandshakeTimer;
+}

package/dist/next/resources/realtime/realtime-socket.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RealtimeSocket = void 0;
+const ovok_errors_1 = require("../../errors/ovok-errors");
+const SOCKET_OPEN = 1;
+const PING_INTERVAL_MS = 5000;
+const SOCKET_HANDSHAKE_TIMEOUT_MS = 10000;
+class RealtimeSocket {
+    constructor(url, token, handler, onHandshake, onClose) {
+        this.url = url;
+        this.token = token;
+        this.handler = handler;
+        this.onHandshake = onHandshake;
+        this.onClose = onClose;
+        this.socket = null;
+        this.handshakeTimer = null;
+        this.pingTimer = null;
+        this.waitingForPong = false;
+    }
+    open() {
+        if (typeof WebSocket === "undefined") {
+            throw new ovok_errors_1.OvokConfigError((0, ovok_errors_1.detailsFor)("This runtime does not provide WebSocket support."));
+        }
+        const socket = new WebSocket(this.url);
+        this.socket = socket;
+        socket.addEventListener("open", () => this.socketOpened(socket));
+        socket.addEventListener("message", (event) => this.socketMessage(socket, event));
+        socket.addEventListener("error", () => socket.close());
+        socket.addEventListener("close", () => this.socketClosed(socket));
+    }
+    bind(token) {
+        var _a;
+        this.token = token;
+        if (((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === SOCKET_OPEN) {
+            this.sendBinding(this.socket);
+        }
+    }
+    close(unbindToken) {
+        const socket = this.socket;
+        if ((socket === null || socket === void 0 ? void 0 : socket.readyState) === SOCKET_OPEN && unbindToken) {
+            try {
+                socket.send(JSON.stringify({ type: "unbind-from-token", payload: { token: unbindToken } }));
+            }
+            catch (_a) {
+                socket.close();
+            }
+        }
+        this.socket = null;
+        this.clearTimers();
+        socket === null || socket === void 0 ? void 0 : socket.close();
+    }
+    socketOpened(socket) {
+        if (socket !== this.socket) {
+            return;
+        }
+        this.sendBinding(socket);
+        this.handshakeTimer = setTimeout(() => socket.close(), SOCKET_HANDSHAKE_TIMEOUT_MS);
+        this.pingTimer = setInterval(() => this.sendPing(socket), PING_INTERVAL_MS);
+    }
+    socketMessage(socket, event) {
+        if (socket !== this.socket || typeof event.data !== "string") {
+            return;
+        }
+        let message;
+        try {
+            message = JSON.parse(event.data);
+        }
+        catch (_a) {
+            socket.close();
+            return;
+        }
+        if (!isRecord(message)) {
+            socket.close();
+            return;
+        }
+        if (message.type === "pong") {
+            this.waitingForPong = false;
+            return;
+        }
+        if (!isSubscriptionStatus(message)) {
+            socket.close();
+            return;
+        }
+        if (message.type === "handshake") {
+            this.clearHandshakeTimer();
+            this.onHandshake();
+            return;
+        }
+        if (message.type === "heartbeat") {
+            return;
+        }
+        if (message.type === "event-notification") {
+            this.handler({ ...message, type: "event-notification" });
+        }
+    }
+    socketClosed(socket) {
+        if (socket !== this.socket) {
+            return;
+        }
+        this.socket = null;
+        this.clearTimers();
+        this.onClose(this);
+    }
+    sendPing(socket) {
+        if (socket !== this.socket || socket.readyState !== SOCKET_OPEN) {
+            return;
+        }
+        if (this.waitingForPong) {
+            socket.close();
+            return;
+        }
+        try {
+            socket.send(JSON.stringify({ type: "ping" }));
+            this.waitingForPong = true;
+        }
+        catch (_a) {
+            socket.close();
+        }
+    }
+    sendBinding(socket) {
+        try {
+            socket.send(JSON.stringify({ type: "bind-with-token", payload: { token: this.token } }));
+        }
+        catch (_a) {
+            socket.close();
+        }
+    }
+    clearTimers() {
+        this.clearHandshakeTimer();
+        if (this.pingTimer !== null) {
+            clearInterval(this.pingTimer);
+        }
+        this.pingTimer = null;
+        this.waitingForPong = false;
+    }
+    clearHandshakeTimer() {
+        if (this.handshakeTimer !== null) {
+            clearTimeout(this.handshakeTimer);
+        }
+        this.handshakeTimer = null;
+    }
+}
+exports.RealtimeSocket = RealtimeSocket;
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isSubscriptionStatus = (value) => {
+    if (!isRecord(value) || !isRecord(value.subscription)) {
+        return false;
+    }
+    return (value.resourceType === "SubscriptionStatus" &&
+        typeof value.type === "string" &&
+        typeof value.subscription.reference === "string");
+};

package/dist/next/resources/realtime/realtime-types.d.ts

@@ -0,0 +1,6 @@
+import type { SubscriptionStatus } from "@medplum/fhirtypes";
+export type RealtimeNotification = SubscriptionStatus & {
+    type: "event-notification";
+};
+export type RealtimeNotificationHandler = (notification: RealtimeNotification) => void;
+export type RealtimeUnsubscribe = () => Promise<void>;

package/dist/next/resources/realtime/realtime-types.js

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

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.498+92fd957",
+  "version": "0.4.49-dev.500+07ba725",
   "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
+    }
   }
 }