@ovok/core 0.4.49-dev.495 → 0.4.49-dev.496

package/dist/next/auth/user-session.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserSession = void 0;
+const ovok_errors_1 = require("../errors/ovok-errors");
+const session_1 = require("./session");
+const REJECTED_REFRESH_STATUSES = new Set([400, 401, 403]);
+class UserSession {
+    constructor(store, endpoint, settings, now = Date.now) {
+        this.store = store;
+        this.endpoint = endpoint;
+        this.settings = settings;
+        this.now = now;
+        this.loaded = null;
+        this.pendingRefresh = null;
+    }
+    current() {
+        var _a;
+        (_a = this.loaded) !== null && _a !== void 0 ? _a : (this.loaded = this.store.load());
+        return this.loaded;
+    }
+    async begin(tokens) {
+        const session = (0, session_1.sessionFromLogin)(tokens, this.now());
+        await this.save(session);
+        return session;
+    }
+    async end() {
+        this.loaded = Promise.resolve(null);
+        await this.store.clear();
+    }
+    async accessToken() {
+        var _a, _b;
+        const session = await this.current();
+        const refreshable = session !== null && session.refreshToken !== null;
+        if (refreshable && (0, session_1.isSessionStaleAt)(session, this.now())) {
+            await this.refresh();
+        }
+        return (_b = (_a = (await this.current())) === null || _a === void 0 ? void 0 : _a.accessToken) !== null && _b !== void 0 ? _b : null;
+    }
+    refresh() {
+        var _a;
+        (_a = this.pendingRefresh) !== null && _a !== void 0 ? _a : (this.pendingRefresh = this.exchangeRefreshToken().finally(() => {
+            this.pendingRefresh = null;
+        }));
+        return this.pendingRefresh;
+    }
+    async exchangeRefreshToken() {
+        var _a;
+        const session = await this.current();
+        const refreshToken = (_a = session === null || session === void 0 ? void 0 : session.refreshToken) !== null && _a !== void 0 ? _a : null;
+        if (session === null || refreshToken === null) {
+            return false;
+        }
+        try {
+            const response = await this.endpoint.request(this.refreshForm(refreshToken));
+            await this.save((0, session_1.sessionAfterRefresh)(session, response, this.now()));
+            return true;
+        }
+        catch (error) {
+            return this.signOutIfRejected(error);
+        }
+    }
+    /** Only a refused refresh token signs the user out; an outage keeps the session for a later retry. */
+    async signOutIfRejected(error) {
+        const status = error instanceof ovok_errors_1.OvokError ? error.status : null;
+        const rejected = status !== null && REJECTED_REFRESH_STATUSES.has(status);
+        if (rejected) {
+            await this.end();
+            this.settings.onUnauthenticated({ type: "refresh-rejected", status });
+            return false;
+        }
+        throw error;
+    }
+    refreshForm(refreshToken) {
+        const client = this.settings.clientId ? { client_id: this.settings.clientId } : {};
+        return { grant_type: "refresh_token", refresh_token: refreshToken, ...client };
+    }
+    async save(session) {
+        this.loaded = Promise.resolve(session);
+        await this.store.save(session);
+    }
+}
+exports.UserSession = UserSession;

package/dist/next/config/ovok-config.d.ts

@@ -0,0 +1,42 @@
+import { OvokStorage } from "../storage/ovok-storage";
+export type OvokFetch = (url: string, init: RequestInit) => Promise<Response>;
+export type OvokUnauthenticatedReason = {
+    type: "refresh-rejected";
+    status: number;
+};
+type OvokBaseConfig = {
+    baseUrl: string;
+    tenantCode: string;
+    fhirPath?: string;
+    storage?: OvokStorage;
+    fetch?: OvokFetch;
+    timeoutMs?: number;
+    maxNetworkRetries?: number;
+    onUnauthenticated?: (reason: OvokUnauthenticatedReason) => void;
+};
+type OvokUserClientConfig = {
+    clientId?: string;
+    clientSecret?: undefined;
+};
+type OvokMachineClientConfig = {
+    clientId: string;
+    clientSecret: string;
+};
+export type OvokConfig = OvokBaseConfig & (OvokUserClientConfig | OvokMachineClientConfig);
+export type MachineClient = {
+    clientId: string;
+    clientSecret: string;
+};
+export type OvokSettings = {
+    baseUrl: string;
+    tenantCode: string;
+    fhirPath: string;
+    storage: OvokStorage;
+    fetch: OvokFetch;
+    timeoutMs: number;
+    maxNetworkRetries: number;
+    clientId: string | null;
+    machineClient: MachineClient | null;
+    onUnauthenticated: (reason: OvokUnauthenticatedReason) => void;
+};
+export {};

package/dist/next/config/ovok-config.js

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

package/dist/next/config/settings.d.ts

@@ -0,0 +1,6 @@
+import { OvokConfig, OvokSettings } from "./ovok-config";
+export type RuntimeEnvironment = {
+    hasDocument: boolean;
+};
+export declare const currentEnvironment: () => RuntimeEnvironment;
+export declare function readSettings(config: OvokConfig, environment: RuntimeEnvironment): OvokSettings;

package/dist/next/config/settings.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.currentEnvironment = void 0;
+exports.readSettings = readSettings;
+const ovok_errors_1 = require("../errors/ovok-errors");
+const ovok_storage_1 = require("../storage/ovok-storage");
+const DEFAULT_FHIR_PATH = "fhir";
+const DEFAULT_TIMEOUT_MS = 30000;
+const DEFAULT_MAX_NETWORK_RETRIES = 2;
+const ABSOLUTE_HTTP_URL = /^https?:\/\/[^/\s]+/i;
+const currentEnvironment = () => ({ hasDocument: typeof document !== "undefined" });
+exports.currentEnvironment = currentEnvironment;
+function readSettings(config, environment) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const machineClient = readMachineClient(config, environment);
+    return {
+        baseUrl: readBaseUrl(config.baseUrl),
+        tenantCode: requireText(config.tenantCode, "tenantCode"),
+        fhirPath: trimSlashes((_a = config.fhirPath) !== null && _a !== void 0 ? _a : DEFAULT_FHIR_PATH),
+        storage: (_b = config.storage) !== null && _b !== void 0 ? _b : new ovok_storage_1.MemoryStorage(),
+        fetch: (_c = config.fetch) !== null && _c !== void 0 ? _c : globalFetch(),
+        timeoutMs: requirePositive((_d = config.timeoutMs) !== null && _d !== void 0 ? _d : DEFAULT_TIMEOUT_MS, "timeoutMs"),
+        maxNetworkRetries: requireCount((_e = config.maxNetworkRetries) !== null && _e !== void 0 ? _e : DEFAULT_MAX_NETWORK_RETRIES, "maxNetworkRetries"),
+        clientId: (_f = config.clientId) !== null && _f !== void 0 ? _f : null,
+        machineClient,
+        onUnauthenticated: (_g = config.onUnauthenticated) !== null && _g !== void 0 ? _g : (() => undefined),
+    };
+}
+const configError = (message) => new ovok_errors_1.OvokConfigError((0, ovok_errors_1.detailsFor)(message));
+const readBaseUrl = (baseUrl) => {
+    if (!ABSOLUTE_HTTP_URL.test(baseUrl)) {
+        throw configError("baseUrl must be an absolute http(s) URL.");
+    }
+    return baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+};
+const readMachineClient = (config, environment) => {
+    if (config.clientSecret === undefined) {
+        return null;
+    }
+    if (environment.hasDocument) {
+        throw configError("clientSecret is for servers only: a secret shipped to a browser is public.");
+    }
+    return {
+        clientId: requireText(config.clientId, "clientId"),
+        clientSecret: requireText(config.clientSecret, "clientSecret"),
+    };
+};
+const requireText = (value, name) => {
+    var _a;
+    const text = (_a = value === null || value === void 0 ? void 0 : value.trim()) !== null && _a !== void 0 ? _a : "";
+    if (text === "") {
+        throw configError(`${name} is required.`);
+    }
+    return text;
+};
+const requirePositive = (value, name) => {
+    if (!Number.isFinite(value) || value <= 0) {
+        throw configError(`${name} must be a positive number.`);
+    }
+    return value;
+};
+const requireCount = (value, name) => {
+    if (!Number.isInteger(value) || value < 0) {
+        throw configError(`${name} must be a whole number of at least 0.`);
+    }
+    return value;
+};
+const trimSlashes = (path) => path.replace(/^\/+|\/+$/g, "");
+const globalFetch = () => {
+    if (typeof globalThis.fetch !== "function") {
+        throw configError("No global fetch is available: pass config.fetch.");
+    }
+    return (url, init) => globalThis.fetch(url, init);
+};

package/dist/next/errors/error-from-response.d.ts

@@ -0,0 +1,2 @@
+import { OvokError } from "./ovok-errors";
+export declare function errorFromResponse(response: Response): Promise<OvokError>;

package/dist/next/errors/error-from-response.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorFromResponse = errorFromResponse;
+const ovok_error_1 = require("../../client/errors/ovok-error");
+const retry_after_1 = require("../http/retry-after");
+const ovok_errors_1 = require("./ovok-errors");
+async function errorFromResponse(response) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const fallback = Object.assign(new Error(`Ovok API answered ${response.status}`), {
+        status: response.status,
+        body: parseBody(await response.text()),
+    });
+    const details = (0, ovok_error_1.readOvokError)(fallback);
+    return (0, ovok_errors_1.errorForStatus)({
+        status: response.status,
+        code: (_a = details.code) !== null && _a !== void 0 ? _a : null,
+        type: (_b = details.type) !== null && _b !== void 0 ? _b : null,
+        message: details.message,
+        traceId: (_d = (_c = response.headers.get("x-trace-id")) !== null && _c !== void 0 ? _c : details.traceId) !== null && _d !== void 0 ? _d : null,
+        requestId: (_f = (_e = response.headers.get("x-request-id")) !== null && _e !== void 0 ? _e : details.requestId) !== null && _f !== void 0 ? _f : null,
+        retryAfterMs: (_h = (_g = (0, retry_after_1.retryAfterMs)(response.headers.get("retry-after"))) !== null && _g !== void 0 ? _g : details.retryAfterMs) !== null && _h !== void 0 ? _h : null,
+        fieldErrors: details.fieldErrors,
+    });
+}
+const parseBody = (text) => {
+    if (text === "") {
+        return undefined;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch (_a) {
+        return { message: text };
+    }
+};

package/dist/next/errors/ovok-errors.d.ts

@@ -0,0 +1,42 @@
+import { ValidationError } from "../../types/ValidationError";
+export type OvokErrorDetails = {
+    status: number | null;
+    code: string | null;
+    type: string | null;
+    message: string;
+    traceId: string | null;
+    requestId: string | null;
+    retryAfterMs: number | null;
+    fieldErrors: ValidationError[];
+};
+export declare class OvokError extends Error {
+    readonly status: number | null;
+    readonly code: string | null;
+    readonly type: string | null;
+    readonly traceId: string | null;
+    readonly requestId: string | null;
+    readonly retryAfterMs: number | null;
+    readonly fieldErrors: ValidationError[];
+    readonly cause: unknown;
+    constructor(details: OvokErrorDetails, cause?: unknown);
+}
+export declare class OvokValidationError extends OvokError {
+}
+export declare class OvokAuthenticationError extends OvokError {
+}
+export declare class OvokPermissionError extends OvokError {
+}
+export declare class OvokNotFoundError extends OvokError {
+}
+export declare class OvokConflictError extends OvokError {
+}
+export declare class OvokRateLimitError extends OvokError {
+}
+export declare class OvokServiceError extends OvokError {
+}
+export declare class OvokConnectionError extends OvokError {
+}
+export declare class OvokConfigError extends OvokError {
+}
+export declare function errorForStatus(details: OvokErrorDetails): OvokError;
+export declare const detailsFor: (message: string) => OvokErrorDetails;

package/dist/next/errors/ovok-errors.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detailsFor = exports.OvokConfigError = exports.OvokConnectionError = exports.OvokServiceError = exports.OvokRateLimitError = exports.OvokConflictError = exports.OvokNotFoundError = exports.OvokPermissionError = exports.OvokAuthenticationError = exports.OvokValidationError = exports.OvokError = void 0;
+exports.errorForStatus = errorForStatus;
+class OvokError extends Error {
+    constructor(details, cause) {
+        super(details.message);
+        this.name = new.target.name;
+        this.status = details.status;
+        this.code = details.code;
+        this.type = details.type;
+        this.traceId = details.traceId;
+        this.requestId = details.requestId;
+        this.retryAfterMs = details.retryAfterMs;
+        this.fieldErrors = details.fieldErrors;
+        Object.defineProperty(this, "cause", { value: cause, enumerable: false });
+    }
+}
+exports.OvokError = OvokError;
+class OvokValidationError extends OvokError {
+}
+exports.OvokValidationError = OvokValidationError;
+class OvokAuthenticationError extends OvokError {
+}
+exports.OvokAuthenticationError = OvokAuthenticationError;
+class OvokPermissionError extends OvokError {
+}
+exports.OvokPermissionError = OvokPermissionError;
+class OvokNotFoundError extends OvokError {
+}
+exports.OvokNotFoundError = OvokNotFoundError;
+class OvokConflictError extends OvokError {
+}
+exports.OvokConflictError = OvokConflictError;
+class OvokRateLimitError extends OvokError {
+}
+exports.OvokRateLimitError = OvokRateLimitError;
+class OvokServiceError extends OvokError {
+}
+exports.OvokServiceError = OvokServiceError;
+class OvokConnectionError extends OvokError {
+}
+exports.OvokConnectionError = OvokConnectionError;
+class OvokConfigError extends OvokError {
+}
+exports.OvokConfigError = OvokConfigError;
+const ERROR_CLASS_BY_STATUS = {
+    400: OvokValidationError,
+    401: OvokAuthenticationError,
+    403: OvokPermissionError,
+    404: OvokNotFoundError,
+    409: OvokConflictError,
+    422: OvokValidationError,
+    429: OvokRateLimitError,
+};
+const FIRST_SERVER_ERROR_STATUS = 500;
+function errorForStatus(details) {
+    var _a, _b;
+    const status = (_a = details.status) !== null && _a !== void 0 ? _a : 0;
+    const isServerError = status >= FIRST_SERVER_ERROR_STATUS;
+    const errorClass = isServerError ? OvokServiceError : (_b = ERROR_CLASS_BY_STATUS[status]) !== null && _b !== void 0 ? _b : OvokError;
+    return new errorClass(details);
+}
+const detailsFor = (message) => ({
+    status: null,
+    code: null,
+    type: null,
+    message,
+    traceId: null,
+    requestId: null,
+    retryAfterMs: null,
+    fieldErrors: [],
+});
+exports.detailsFor = detailsFor;

package/dist/next/http/http-client.d.ts

@@ -0,0 +1,35 @@
+import { Credentials } from "../auth/credentials";
+import { OvokSettings } from "../config/ovok-config";
+import { RetryPolicy } from "./retry-policy";
+import { RequestOptions } from "./transmit";
+export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+export type HttpRequest = {
+    method: HttpMethod;
+    path: string;
+    body?: unknown;
+    headers?: Record<string, string>;
+    idempotent?: boolean;
+};
+export type HttpContext = {
+    settings: OvokSettings;
+    credentials: Credentials;
+    retryPolicy: RetryPolicy;
+};
+export declare class HttpClient {
+    private readonly context;
+    private readonly basePath;
+    constructor(context: HttpContext, basePath?: string);
+    under(path: string): HttpClient;
+    anonymous(): HttpClient;
+    get<T>(path: string, options?: RequestOptions): Promise<T>;
+    post<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    put<T>(path: string, body: unknown, options?: RequestOptions): Promise<T>;
+    patch<T>(path: string, body: unknown, options?: RequestOptions): Promise<T>;
+    delete<T = void>(path: string, options?: RequestOptions): Promise<T>;
+    send<T>(request: HttpRequest, options?: RequestOptions): Promise<T>;
+    private sendAuthorized;
+    private sendWithRetries;
+    private attempt;
+    private isRetryable;
+    private toTransmit;
+}

package/dist/next/http/http-client.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+const credentials_1 = require("../auth/credentials");
+const error_from_response_1 = require("../errors/error-from-response");
+const ovok_errors_1 = require("../errors/ovok-errors");
+const retry_after_1 = require("./retry-after");
+const transmit_1 = require("./transmit");
+const url_1 = require("./url");
+const UNAUTHORIZED = 401;
+const JSON_TYPE = "application/json";
+class HttpClient {
+    constructor(context, basePath = "") {
+        this.context = context;
+        this.basePath = basePath;
+    }
+    under(path) {
+        return new HttpClient(this.context, (0, url_1.joinPath)(this.basePath, path));
+    }
+    anonymous() {
+        return new HttpClient({ ...this.context, credentials: credentials_1.noCredentials }, this.basePath);
+    }
+    get(path, options) {
+        return this.send({ method: "GET", path }, options);
+    }
+    post(path, body, options) {
+        return this.send({ method: "POST", path, body }, options);
+    }
+    put(path, body, options) {
+        return this.send({ method: "PUT", path, body }, options);
+    }
+    patch(path, body, options) {
+        return this.send({ method: "PATCH", path, body }, options);
+    }
+    delete(path, options) {
+        return this.send({ method: "DELETE", path }, options);
+    }
+    async send(request, options = {}) {
+        const response = await this.sendAuthorized(request, options);
+        if (response.ok) {
+            return readJson(response);
+        }
+        throw await (0, error_from_response_1.errorFromResponse)(response);
+    }
+    async sendAuthorized(request, options) {
+        const response = await this.sendWithRetries(request, options);
+        const unauthorized = response.status === UNAUTHORIZED;
+        if (unauthorized && (await this.context.credentials.refresh())) {
+            return this.sendWithRetries(request, options);
+        }
+        return response;
+    }
+    async sendWithRetries(request, options) {
+        var _a, _b;
+        const { retryPolicy } = this.context;
+        for (let attempt = 0;; attempt += 1) {
+            const outcome = await this.attempt(request, options);
+            const retry = retryPolicy.allows(request, attempt) && this.isRetryable(outcome);
+            if (retry) {
+                await discard(outcome.response);
+                await retryPolicy.pause(attempt, (0, retry_after_1.retryAfterMs)((_b = (_a = outcome.response) === null || _a === void 0 ? void 0 : _a.headers.get("retry-after")) !== null && _b !== void 0 ? _b : null));
+                continue;
+            }
+            return unwrap(outcome);
+        }
+    }
+    async attempt(request, options) {
+        try {
+            const response = await (0, transmit_1.transmit)(this.context.settings, await this.toTransmit(request), options);
+            return { response };
+        }
+        catch (error) {
+            return { error };
+        }
+    }
+    isRetryable(outcome) {
+        return outcome.response
+            ? this.context.retryPolicy.isRetryableStatus(outcome.response.status)
+            : outcome.error instanceof ovok_errors_1.OvokConnectionError;
+    }
+    async toTransmit(request) {
+        const token = await this.context.credentials.accessToken();
+        const contentType = request.body === undefined ? {} : { "Content-Type": JSON_TYPE };
+        const authorization = token ? { Authorization: `Bearer ${token}` } : {};
+        return {
+            url: `${this.context.settings.baseUrl}${(0, url_1.joinPath)(this.basePath, request.path)}`,
+            method: request.method,
+            headers: { Accept: JSON_TYPE, ...contentType, ...request.headers, ...authorization },
+            body: encodeBody(request.body),
+        };
+    }
+}
+exports.HttpClient = HttpClient;
+const unwrap = (outcome) => {
+    if (outcome.response) {
+        return outcome.response;
+    }
+    throw outcome.error;
+};
+const discard = async (response) => {
+    var _a;
+    await ((_a = response === null || response === void 0 ? void 0 : response.body) === null || _a === void 0 ? void 0 : _a.cancel().catch(() => undefined));
+};
+const encodeBody = (body) => {
+    if (body === undefined) {
+        return undefined;
+    }
+    return typeof body === "string" ? body : JSON.stringify(body);
+};
+const readJson = async (response) => {
+    const text = await response.text();
+    return (text === "" ? undefined : JSON.parse(text));
+};

package/dist/next/http/retry-after.d.ts

@@ -0,0 +1 @@
+export declare const retryAfterMs: (header: string | null) => number | null;

package/dist/next/http/retry-after.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retryAfterMs = void 0;
+const MS_PER_SECOND = 1000;
+const retryAfterMs = (header) => {
+    if (header === null) {
+        return null;
+    }
+    const seconds = Number(header);
+    if (Number.isFinite(seconds)) {
+        return seconds * MS_PER_SECOND;
+    }
+    const date = Date.parse(header);
+    return Number.isNaN(date) ? null : Math.max(0, date - Date.now());
+};
+exports.retryAfterMs = retryAfterMs;

package/dist/next/http/retry-policy.d.ts

@@ -0,0 +1,13 @@
+export type Sleep = (ms: number) => Promise<void>;
+export type RetryableRequest = {
+    method: string;
+    idempotent?: boolean;
+};
+export declare class RetryPolicy {
+    private readonly maxRetries;
+    private readonly wait;
+    constructor(maxRetries: number, wait?: Sleep);
+    allows(request: RetryableRequest, attempt: number): boolean;
+    isRetryableStatus(status: number): boolean;
+    pause(attempt: number, retryAfterMs: number | null): Promise<void>;
+}

package/dist/next/http/retry-policy.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryPolicy = void 0;
+const RETRYABLE_STATUSES = new Set([429, 502, 503, 504]);
+const IDEMPOTENT_METHODS = new Set(["GET", "HEAD", "PUT", "DELETE"]);
+const BASE_DELAY_MS = 300;
+const MAX_DELAY_MS = 5000;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+class RetryPolicy {
+    constructor(maxRetries, wait = sleep) {
+        this.maxRetries = maxRetries;
+        this.wait = wait;
+    }
+    allows(request, attempt) {
+        var _a;
+        const repeatable = (_a = request.idempotent) !== null && _a !== void 0 ? _a : IDEMPOTENT_METHODS.has(request.method);
+        return repeatable && attempt < this.maxRetries;
+    }
+    isRetryableStatus(status) {
+        return RETRYABLE_STATUSES.has(status);
+    }
+    pause(attempt, retryAfterMs) {
+        const backoffMs = BASE_DELAY_MS * 2 ** attempt;
+        return this.wait(Math.min(retryAfterMs !== null && retryAfterMs !== void 0 ? retryAfterMs : backoffMs, MAX_DELAY_MS));
+    }
+}
+exports.RetryPolicy = RetryPolicy;

package/dist/next/http/transmit.d.ts

@@ -0,0 +1,14 @@
+import { OvokSettings } from "../config/ovok-config";
+export type RequestOptions = {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+};
+export type TransmitRequest = {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body: string | undefined;
+};
+type TransmitSettings = Pick<OvokSettings, "fetch" | "timeoutMs">;
+export declare function transmit(settings: TransmitSettings, request: TransmitRequest, options?: RequestOptions): Promise<Response>;
+export {};

package/dist/next/http/transmit.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transmit = transmit;
+const ovok_errors_1 = require("../errors/ovok-errors");
+async function transmit(settings, request, options = {}) {
+    var _a;
+    const deadline = new Deadline((_a = options.timeoutMs) !== null && _a !== void 0 ? _a : settings.timeoutMs, options.signal);
+    try {
+        return await settings.fetch(request.url, {
+            method: request.method,
+            headers: request.headers,
+            body: request.body,
+            signal: deadline.signal,
+        });
+    }
+    catch (error) {
+        throw deadline.explain(error);
+    }
+    finally {
+        deadline.clear();
+    }
+}
+class Deadline {
+    constructor(timeoutMs, callerSignal) {
+        this.timeoutMs = timeoutMs;
+        this.callerSignal = callerSignal;
+        this.controller = new AbortController();
+        this.followCaller = () => { var _a; return this.controller.abort((_a = this.callerSignal) === null || _a === void 0 ? void 0 : _a.reason); };
+        this.expired = false;
+        this.timer = setTimeout(() => this.expire(), timeoutMs);
+        callerSignal === null || callerSignal === void 0 ? void 0 : callerSignal.addEventListener("abort", this.followCaller, { once: true });
+        if (callerSignal === null || callerSignal === void 0 ? void 0 : callerSignal.aborted) {
+            this.followCaller();
+        }
+    }
+    get signal() {
+        return this.controller.signal;
+    }
+    /** A caller's own abort passes through untouched; everything else is a connection failure. */
+    explain(error) {
+        var _a, _b;
+        if ((_a = this.callerSignal) === null || _a === void 0 ? void 0 : _a.aborted) {
+            return (_b = this.callerSignal.reason) !== null && _b !== void 0 ? _b : error;
+        }
+        const message = this.expired ? `The request timed out after ${this.timeoutMs} ms.` : "Could not reach the Ovok API.";
+        return new ovok_errors_1.OvokConnectionError((0, ovok_errors_1.detailsFor)(message), error);
+    }
+    clear() {
+        var _a;
+        clearTimeout(this.timer);
+        (_a = this.callerSignal) === null || _a === void 0 ? void 0 : _a.removeEventListener("abort", this.followCaller);
+    }
+    expire() {
+        this.expired = true;
+        this.controller.abort();
+    }
+}

package/dist/next/http/url.d.ts

@@ -0,0 +1,6 @@
+export type QueryValue = string | number | boolean | readonly string[] | undefined;
+export type QueryParams = Record<string, QueryValue>;
+export declare const joinPath: (...parts: string[]) => string;
+export declare const pathSegment: (value: string) => string;
+/** A list value repeats its key, so `date: ["ge1", "le2"]` is FHIR's AND; write "a,b" for OR. */
+export declare function toSearchQuery(params: QueryParams): string;