adapty 0.8.4 → 0.8.6

package/dist/sdk/adapty/index.js

@@ -0,0 +1,27 @@
+import { createHttp } from '../core/http/index.js';
+import { accessLevels } from './access-levels.js';
+import { apps } from './apps/index.js';
+import { auth } from './auth/index.js';
+import { developerErrorParser } from './errors.js';
+export { platforms } from './apps/index.js';
+export { developerErrorParser } from './errors.js';
+/** Exported because the adapter compares the resolved URL with it and warns when they differ. */
+export const DEFAULT_ADAPTY_API_URL = 'https://api-admin.adapty.io/api/v1/developer';
+/** The assembly point of the developer API: one transport, resources on top of it. */
+export const createAdapty = (options = {}) => {
+    const http = createHttp({
+        baseUrl: options.baseUrl ?? DEFAULT_ADAPTY_API_URL,
+        clock: options.clock,
+        fetch: options.fetch,
+        headers: options.userAgent === undefined ? undefined : { 'user-agent': options.userAgent },
+        onRetry: options.onRetry,
+        parseError: developerErrorParser,
+        signal: options.signal,
+        token: options.token,
+    });
+    return {
+        accessLevels: accessLevels(http),
+        apps: apps(http),
+        auth: auth(http),
+    };
+};

package/dist/sdk/adapty/pagination.d.ts

@@ -0,0 +1,23 @@
+import type { QueryParams } from '../core/http/index.js';
+/**
+ * The paginated answer, and the query that asks for a page. Product and not core: `meta.pagination`
+ * and the bracketed `page[...]` names are this API's convention, not the transport's business. ASA
+ * follows the same convention today, so sdk/asa can import this until the two actually diverge.
+ */
+export type Pagination = {
+    count: number;
+    page: number;
+    pages: number;
+};
+export type Paginated<T> = {
+    data: T[];
+    meta: {
+        pagination: Pagination;
+    };
+};
+/** Page selection as we take it: camelCase in, the server's names on the wire. */
+export type PageParams = {
+    page?: number | undefined;
+    pageSize?: number | undefined;
+};
+export declare const pageQuery: (params: PageParams | undefined) => QueryParams;

package/dist/sdk/adapty/pagination.js

@@ -0,0 +1 @@
+export const pageQuery = (params) => ({ 'page[number]': params?.page, 'page[size]': params?.pageSize });

package/dist/sdk/core/auth/device-flow.d.ts

@@ -0,0 +1,46 @@
+import type { Clock } from '../clock.js';
+export type DeviceCode = {
+    deviceCode: string;
+    expiresInSec: number;
+    intervalSec: number;
+    userCode: string;
+    verificationUri: string;
+    verificationUriComplete: string | undefined;
+};
+export type PollResult<TToken> = {
+    status: 'authorized';
+    token: TToken;
+} | {
+    status: 'denied';
+} | {
+    status: 'expired';
+} | {
+    status: 'pending';
+} | {
+    status: 'slow_down';
+};
+/**
+ * The device flow port (RFC 8628) — all the orchestration below knows. What sits inside a token
+ * (for Adapty, an access_token plus the user) is the port's business.
+ */
+export type DeviceAuthApi<TToken> = {
+    pollToken(deviceCode: string): Promise<PollResult<TToken>>;
+    requestDeviceCode(): Promise<DeviceCode>;
+};
+export type DeviceFlowDeps = {
+    clock: Clock;
+    maxConsecutiveErrors?: number | undefined;
+    /** Do not poll faster than this, even if the server allows it. */
+    minIntervalMs?: number | undefined;
+    /** Show the code and the link to the user. Sdk prints nothing itself. */
+    onCode: (code: DeviceCode) => void;
+    /** One poll failed (network, odd answer). The flow goes on up to maxConsecutiveErrors. */
+    onTransientError?: ((error: unknown, consecutive: number) => void) | undefined;
+    signal?: AbortSignal | undefined;
+};
+/**
+ * Device flow orchestration with every effect kept outside: the network behind the api port, time
+ * behind clock, cancellation behind signal. That is what makes expiry, slow_down, poll failures
+ * and Ctrl+C unit-testable.
+ */
+export declare const runDeviceFlow: <TToken>(api: DeviceAuthApi<TToken>, deps: DeviceFlowDeps) => Promise<TToken>;

package/dist/sdk/core/auth/device-flow.js

@@ -0,0 +1,62 @@
+import { throwIfAborted } from '../clock.js';
+import { CancelledError, DeviceFlowDeniedError, DeviceFlowExpiredError } from '../errors.js';
+/** RFC 8628, 3.5: on slow_down the interval grows by 5 seconds. */
+const SLOW_DOWN_STEP_MS = 5000;
+const DEFAULT_MIN_INTERVAL_MS = 5000;
+const DEFAULT_MAX_CONSECUTIVE_ERRORS = 10;
+/**
+ * Device flow orchestration with every effect kept outside: the network behind the api port, time
+ * behind clock, cancellation behind signal. That is what makes expiry, slow_down, poll failures
+ * and Ctrl+C unit-testable.
+ */
+export const runDeviceFlow = async (api, deps) => {
+    const { clock, signal } = deps;
+    const maxConsecutiveErrors = deps.maxConsecutiveErrors ?? DEFAULT_MAX_CONSECUTIVE_ERRORS;
+    throwIfAborted(signal);
+    const code = await api.requestDeviceCode();
+    deps.onCode(code);
+    const deadline = clock.now() + code.expiresInSec * 1000;
+    let intervalMs = Math.max(code.intervalSec * 1000, deps.minIntervalMs ?? DEFAULT_MIN_INTERVAL_MS);
+    let consecutiveErrors = 0;
+    for (;;) {
+        if (clock.now() >= deadline) {
+            throw new DeviceFlowExpiredError();
+        }
+        await clock.sleep(intervalMs, signal);
+        throwIfAborted(signal);
+        let result;
+        try {
+            result = await api.pollToken(code.deviceCode);
+            consecutiveErrors = 0;
+        }
+        catch (error) {
+            if (error instanceof CancelledError) {
+                throw error;
+            }
+            consecutiveErrors += 1;
+            if (consecutiveErrors >= maxConsecutiveErrors) {
+                throw error;
+            }
+            deps.onTransientError?.(error, consecutiveErrors);
+            continue;
+        }
+        switch (result.status) {
+            case 'authorized': {
+                return result.token;
+            }
+            case 'pending': {
+                break;
+            }
+            case 'slow_down': {
+                intervalMs += SLOW_DOWN_STEP_MS;
+                break;
+            }
+            case 'expired': {
+                throw new DeviceFlowExpiredError();
+            }
+            case 'denied': {
+                throw new DeviceFlowDeniedError();
+            }
+        }
+    }
+};

package/dist/sdk/core/clock.d.ts

@@ -0,0 +1,7 @@
+/** Time as a dependency: device flow and retry take a Clock, so tests never wait for real. */
+export type Clock = {
+    now(): number;
+    sleep(ms: number, signal?: AbortSignal): Promise<void>;
+};
+export declare const systemClock: Clock;
+export declare const throwIfAborted: (signal: AbortSignal | undefined) => void;

package/dist/sdk/core/clock.js

@@ -0,0 +1,21 @@
+import { setTimeout as delay } from 'node:timers/promises';
+import { CancelledError, isAbortError } from './errors.js';
+export const systemClock = {
+    now: () => Date.now(),
+    sleep: async (ms, signal) => {
+        try {
+            await delay(ms, undefined, signal ? { signal } : {});
+        }
+        catch (error) {
+            if (isAbortError(error)) {
+                throw new CancelledError();
+            }
+            throw error;
+        }
+    },
+};
+export const throwIfAborted = (signal) => {
+    if (signal?.aborted === true) {
+        throw new CancelledError();
+    }
+};

package/dist/sdk/core/errors.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Sdk errors carry no user-facing text and no exit code: the adapter assigns both
+ * (src/cli/errors.ts, and a future MCP server).
+ *
+ * Every error has a stable `kind`, and the adapter switches over it. An instanceof chain would
+ * let a new error class fall through to the fallback and become exit 1 with no readable text.
+ */
+export type SdkErrorKind = 'api' | 'auth_required' | 'cancelled' | 'device_flow_denied' | 'device_flow_expired' | 'network' | 'storage' | 'validation';
+/** Abstract on purpose: `new SdkError(...)` would be an error without a kind, unrecognisable. */
+export declare abstract class SdkError extends Error {
+    abstract readonly kind: SdkErrorKind;
+    constructor(message: string, options?: ErrorOptions);
+}
+/** No response at all: DNS, refused connection, a dropped socket. */
+export declare class NetworkError extends SdkError {
+    readonly kind = "network";
+    readonly url: string;
+    constructor(url: string, cause: unknown);
+}
+/** The server answered with an error. `code` and `details` follow the service's own format. */
+export declare class ApiError extends SdkError {
+    readonly kind = "api";
+    readonly code: string | undefined;
+    readonly details: unknown;
+    readonly retryAfterMs: number | undefined;
+    readonly status: number;
+    constructor(init: {
+        code?: string | undefined;
+        details?: unknown;
+        message: string;
+        retryAfterMs?: number | undefined;
+        status: number;
+    });
+}
+/** missing: no token stored locally. rejected: the server answered 401. */
+export type AuthRequiredReason = 'missing' | 'rejected';
+export declare class AuthRequiredError extends SdkError {
+    readonly kind = "auth_required";
+    readonly reason: AuthRequiredReason;
+    constructor(reason: AuthRequiredReason);
+}
+export declare class CancelledError extends SdkError {
+    readonly kind = "cancelled";
+    constructor();
+}
+export type Issue = {
+    message: string;
+    /** The input field the problem belongs to. No path: the input as a whole is wrong. */
+    path?: string | undefined;
+};
+/** A business rule broken before any network call. */
+export declare class ValidationError extends SdkError {
+    readonly kind = "validation";
+    readonly issues: readonly Issue[];
+    constructor(issues: readonly Issue[]);
+}
+export declare class DeviceFlowExpiredError extends SdkError {
+    readonly kind = "device_flow_expired";
+    constructor();
+}
+export declare class DeviceFlowDeniedError extends SdkError {
+    readonly kind = "device_flow_denied";
+    constructor();
+}
+/** The session file is there but unusable: corrupted JSON, or something else in its place. */
+export declare class StorageError extends SdkError {
+    readonly kind = "storage";
+    readonly path: string;
+    constructor(message: string, path: string, options?: ErrorOptions);
+}
+/**
+ * Every concrete error: a switch over `kind` narrows to the class. instanceof on the abstract
+ * base gives the base, without .status, .url or .issues.
+ */
+export type AnySdkError = ApiError | AuthRequiredError | CancelledError | DeviceFlowDeniedError | DeviceFlowExpiredError | NetworkError | StorageError | ValidationError;
+export declare const isSdkError: (error: unknown) => error is AnySdkError;
+type Assert<T extends true> = T;
+/** Safety net: a kind whose class never made it into AnySdkError breaks the build here. */
+export type AllKindsCovered = Assert<SdkErrorKind extends AnySdkError['kind'] ? true : false>;
+export declare const isAbortError: (error: unknown) => boolean;
+export {};

package/dist/sdk/core/errors.js

@@ -0,0 +1,84 @@
+/**
+ * Sdk errors carry no user-facing text and no exit code: the adapter assigns both
+ * (src/cli/errors.ts, and a future MCP server).
+ *
+ * Every error has a stable `kind`, and the adapter switches over it. An instanceof chain would
+ * let a new error class fall through to the fallback and become exit 1 with no readable text.
+ */
+/** Abstract on purpose: `new SdkError(...)` would be an error without a kind, unrecognisable. */
+export class SdkError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = new.target.name;
+    }
+}
+/** No response at all: DNS, refused connection, a dropped socket. */
+export class NetworkError extends SdkError {
+    kind = 'network';
+    url;
+    constructor(url, cause) {
+        super(`Request to ${url} failed`, { cause });
+        this.url = url;
+    }
+}
+/** The server answered with an error. `code` and `details` follow the service's own format. */
+export class ApiError extends SdkError {
+    kind = 'api';
+    code;
+    details;
+    retryAfterMs;
+    status;
+    constructor(init) {
+        super(init.message);
+        this.status = init.status;
+        this.code = init.code;
+        this.details = init.details;
+        this.retryAfterMs = init.retryAfterMs;
+    }
+}
+export class AuthRequiredError extends SdkError {
+    kind = 'auth_required';
+    reason;
+    constructor(reason) {
+        super(reason === 'missing' ? 'Not authenticated' : 'Token expired or invalid');
+        this.reason = reason;
+    }
+}
+export class CancelledError extends SdkError {
+    kind = 'cancelled';
+    constructor() {
+        super('Operation cancelled');
+    }
+}
+/** A business rule broken before any network call. */
+export class ValidationError extends SdkError {
+    kind = 'validation';
+    issues;
+    constructor(issues) {
+        super(issues.map(issue => (issue.path === undefined ? issue.message : `${issue.path}: ${issue.message}`)).join('; '));
+        this.issues = issues;
+    }
+}
+export class DeviceFlowExpiredError extends SdkError {
+    kind = 'device_flow_expired';
+    constructor() {
+        super('Device code expired before authorization');
+    }
+}
+export class DeviceFlowDeniedError extends SdkError {
+    kind = 'device_flow_denied';
+    constructor() {
+        super('Authorization denied');
+    }
+}
+/** The session file is there but unusable: corrupted JSON, or something else in its place. */
+export class StorageError extends SdkError {
+    kind = 'storage';
+    path;
+    constructor(message, path, options) {
+        super(message, options);
+        this.path = path;
+    }
+}
+export const isSdkError = (error) => error instanceof SdkError;
+export const isAbortError = (error) => error instanceof Error && error.name === 'AbortError';

package/dist/sdk/core/http/client.d.ts

@@ -0,0 +1,46 @@
+import type { Clock } from '../clock.js';
+import type { ErrorParser, ShouldRetry } from './policies.js';
+import type { RetryAttempt, RetryPolicy } from './retry.js';
+import type { QueryParams } from './url.js';
+export type HttpMethod = 'DELETE' | 'GET' | 'PATCH' | 'POST' | 'PUT';
+export type RequestOptions = {
+    /** A JSON-serializable value, or FormData for file uploads. */
+    body?: unknown;
+    headers?: Record<string, string> | undefined;
+    /** Retry on 429, 5xx and network errors. On by default for GET only. */
+    idempotent?: boolean | undefined;
+    /** Response headers, e.g. an ETag for optimistic locking. */
+    onResponse?: ((headers: Headers) => void) | undefined;
+    query?: QueryParams | undefined;
+    signal?: AbortSignal | undefined;
+};
+type BodylessOptions = Omit<RequestOptions, 'body'>;
+export type Http = {
+    delete<T>(path: string, options?: BodylessOptions): Promise<T>;
+    get<T>(path: string, options?: BodylessOptions): Promise<T>;
+    patch<T>(path: string, body?: unknown, options?: BodylessOptions): Promise<T>;
+    post<T>(path: string, body?: unknown, options?: BodylessOptions): Promise<T>;
+    put<T>(path: string, body?: unknown, options?: BodylessOptions): Promise<T>;
+    request<T>(method: HttpMethod, path: string, options?: RequestOptions): Promise<T>;
+};
+export type HttpOptions = {
+    baseUrl: string;
+    clock?: Clock | undefined;
+    fetch?: typeof globalThis.fetch | undefined;
+    headers?: Record<string, string> | undefined;
+    onRetry?: ((info: RetryAttempt) => void) | undefined;
+    parseError?: ErrorParser | undefined;
+    retry?: RetryPolicy | undefined;
+    /** When to retry an idempotent request. */
+    shouldRetry?: ShouldRetry | undefined;
+    signal?: AbortSignal | undefined;
+    token?: string | undefined;
+    /** Trailing slash in paths (Django style). On by default. */
+    trailingSlash?: boolean | undefined;
+};
+/**
+ * The transport: base URL, bearer token, JSON both ways, responses mapped to sdk errors,
+ * retry for idempotent requests. It knows nothing about resources or about the CLI.
+ */
+export declare const createHttp: (options: HttpOptions) => Http;
+export {};

package/dist/sdk/core/http/client.js

@@ -0,0 +1,127 @@
+import { systemClock } from '../clock.js';
+import { ApiError, AuthRequiredError, CancelledError, isAbortError, NetworkError } from '../errors.js';
+import { defaultErrorParser, defaultShouldRetry } from './policies.js';
+import { defaultRetryPolicy, retry } from './retry.js';
+import { buildUrl } from './url.js';
+/**
+ * The transport: base URL, bearer token, JSON both ways, responses mapped to sdk errors,
+ * retry for idempotent requests. It knows nothing about resources or about the CLI.
+ */
+export const createHttp = (options) => {
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    const clock = options.clock ?? systemClock;
+    const policy = options.retry ?? defaultRetryPolicy;
+    const shouldRetry = options.shouldRetry ?? defaultShouldRetry;
+    const parseError = options.parseError ?? defaultErrorParser;
+    const trailingSlash = options.trailingSlash ?? true;
+    const send = async (method, path, req) => {
+        const url = buildUrl(options.baseUrl, path, req.query, trailingSlash);
+        const signal = combineSignals(options.signal, req.signal);
+        const headers = new Headers({ accept: 'application/json', ...options.headers, ...req.headers });
+        if (options.token !== undefined) {
+            headers.set('authorization', `Bearer ${options.token}`);
+        }
+        const init = { headers, method };
+        if (req.body instanceof FormData) {
+            init.body = req.body;
+        }
+        else if (req.body !== undefined) {
+            headers.set('content-type', 'application/json');
+            init.body = JSON.stringify(req.body);
+        }
+        if (signal) {
+            init.signal = signal;
+        }
+        let response;
+        try {
+            response = await fetchImpl(url, init);
+        }
+        catch (error) {
+            if (signal?.aborted === true || isAbortError(error)) {
+                throw new CancelledError();
+            }
+            throw new NetworkError(url, error);
+        }
+        req.onResponse?.(response.headers);
+        // fetch resolves at the headers; reading the body can still fail or be cancelled.
+        // Keep the caller's onResponse callback outside this network-error conversion.
+        let payload;
+        try {
+            payload = await readBody(response);
+        }
+        catch (error) {
+            if (signal?.aborted === true || isAbortError(error)) {
+                throw new CancelledError();
+            }
+            throw new NetworkError(url, error);
+        }
+        if (response.ok) {
+            return payload;
+        }
+        if (response.status === 401) {
+            throw new AuthRequiredError('rejected');
+        }
+        const parsed = parseError(response.status, payload);
+        throw new ApiError({
+            code: parsed.code ?? `http_${response.status}`,
+            details: payload,
+            message: parsed.message ?? `${method} ${path} failed with HTTP ${response.status}`,
+            retryAfterMs: parseRetryAfter(response.headers.get('retry-after'), clock),
+            status: response.status,
+        });
+    };
+    const request = (method, path, req = {}) => {
+        const idempotent = req.idempotent ?? method === 'GET';
+        if (!idempotent) {
+            return send(method, path, req);
+        }
+        return retry(() => send(method, path, req), {
+            clock,
+            onRetry: options.onRetry,
+            policy,
+            shouldRetry,
+            signal: combineSignals(options.signal, req.signal),
+        });
+    };
+    return {
+        request,
+        delete: (path, req) => request('DELETE', path, req),
+        get: (path, req) => request('GET', path, req),
+        patch: (path, body, req) => request('PATCH', path, { ...req, body }),
+        post: (path, body, req) => request('POST', path, { ...req, body }),
+        put: (path, body, req) => request('PUT', path, { ...req, body }),
+    };
+};
+const combineSignals = (...signals) => {
+    const present = signals.filter((signal) => signal !== undefined);
+    if (present.length <= 1) {
+        return present[0];
+    }
+    return AbortSignal.any(present);
+};
+const readBody = async (response) => {
+    if (response.status === 204) {
+        return undefined;
+    }
+    const text = await response.text();
+    if (text.length === 0) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+};
+const parseRetryAfter = (header, clock) => {
+    if (header === null) {
+        return undefined;
+    }
+    const seconds = Number(header);
+    if (Number.isFinite(seconds)) {
+        return Math.max(0, seconds * 1000);
+    }
+    const date = Date.parse(header);
+    return Number.isNaN(date) ? undefined : Math.max(0, date - clock.now());
+};

package/dist/sdk/core/http/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The transport as a module: one door out. An eslint zone fences off the internals (client,
+ * policies, retry, url), so they can be rearranged without touching products.
+ */
+export { createHttp } from './client.js';
+export type { Http, HttpMethod, HttpOptions, RequestOptions } from './client.js';
+export { defaultErrorParser, defaultShouldRetry } from './policies.js';
+export type { ErrorParser, ShouldRetry } from './policies.js';
+export { defaultRetryPolicy, retry } from './retry.js';
+export type { RetryAttempt, RetryDecision, RetryOptions, RetryPolicy } from './retry.js';
+export type { QueryParams, QueryValue } from './url.js';

package/dist/sdk/core/http/index.js

@@ -0,0 +1,7 @@
+/**
+ * The transport as a module: one door out. An eslint zone fences off the internals (client,
+ * policies, retry, url), so they can be rearranged without touching products.
+ */
+export { createHttp } from './client.js';
+export { defaultErrorParser, defaultShouldRetry } from './policies.js';
+export { defaultRetryPolicy, retry } from './retry.js';

package/dist/sdk/core/http/policies.d.ts

@@ -0,0 +1,14 @@
+import type { RetryDecision } from './retry.js';
+/** How to pull code and message out of an error body. Developer API and ASA differ, so it is a parameter. */
+export type ErrorParser = (status: number, body: unknown) => {
+    code?: string | undefined;
+    message?: string | undefined;
+};
+export type ShouldRetry = (error: unknown, attempt: number) => RetryDecision;
+/** Default: network errors with backoff, 429 and 5xx after the delay the server asked for, if any. */
+export declare const defaultShouldRetry: ShouldRetry;
+/**
+ * The default error format, tolerant of the three common body shapes:
+ * { error: 'code', error_description }, { error: { code, message } }, { code, message | detail }.
+ */
+export declare const defaultErrorParser: ErrorParser;

package/dist/sdk/core/http/policies.js

@@ -0,0 +1,29 @@
+import { ApiError, NetworkError } from '../errors.js';
+/** Default: network errors with backoff, 429 and 5xx after the delay the server asked for, if any. */
+export const defaultShouldRetry = (error) => {
+    if (error instanceof NetworkError) {
+        return {};
+    }
+    if (error instanceof ApiError && (error.status === 429 || error.status >= 500)) {
+        return { delayMs: error.retryAfterMs };
+    }
+    return false;
+};
+/**
+ * The default error format, tolerant of the three common body shapes:
+ * { error: 'code', error_description }, { error: { code, message } }, { code, message | detail }.
+ */
+export const defaultErrorParser = (_status, body) => {
+    if (!isRecord(body)) {
+        return {};
+    }
+    if (typeof body.error === 'string') {
+        return { code: body.error, message: asString(body.error_description ?? body.message) };
+    }
+    if (isRecord(body.error)) {
+        return { code: asString(body.error.code), message: asString(body.error.message) };
+    }
+    return { code: asString(body.code), message: asString(body.message ?? body.detail) };
+};
+const isRecord = (value) => typeof value === 'object' && value !== null;
+const asString = (value) => (typeof value === 'string' ? value : undefined);

package/dist/sdk/core/http/retry.d.ts

@@ -0,0 +1,27 @@
+import type { Clock } from '../clock.js';
+export type RetryPolicy = {
+    /** Total attempts, the first one included. */
+    attempts: number;
+    baseDelayMs: number;
+    maxDelayMs: number;
+};
+export declare const defaultRetryPolicy: RetryPolicy;
+/** false: do not retry. An object: retry, optionally after the delay the server suggested. */
+export type RetryDecision = false | {
+    delayMs?: number | undefined;
+};
+export type RetryAttempt = {
+    /** Number of the failed attempt, starting at 1. */
+    attempt: number;
+    delayMs: number;
+    error: unknown;
+};
+export type RetryOptions = {
+    clock: Clock;
+    /** Called before the pause. The sdk never prints: cli warns, MCP stays quiet. */
+    onRetry?: ((info: RetryAttempt) => void) | undefined;
+    policy: RetryPolicy;
+    shouldRetry: (error: unknown, attempt: number) => RetryDecision;
+    signal?: AbortSignal | undefined;
+};
+export declare const retry: <T>(fn: () => Promise<T>, options: RetryOptions) => Promise<T>;

package/dist/sdk/core/http/retry.js

@@ -0,0 +1,22 @@
+import { throwIfAborted } from '../clock.js';
+export const defaultRetryPolicy = { attempts: 3, baseDelayMs: 500, maxDelayMs: 8000 };
+export const retry = async (fn, options) => {
+    const { clock, policy, signal } = options;
+    for (let attempt = 1;; attempt += 1) {
+        throwIfAborted(signal);
+        try {
+            return await fn();
+        }
+        catch (error) {
+            const decision = attempt < policy.attempts ? options.shouldRetry(error, attempt) : false;
+            if (decision === false) {
+                throw error;
+            }
+            const delayMs = decision.delayMs ?? backoffDelay(policy, attempt);
+            options.onRetry?.({ attempt, delayMs, error });
+            await clock.sleep(delayMs, signal);
+        }
+    }
+};
+/** Exponential backoff without jitter: deterministic tests are worth more than spread here. */
+const backoffDelay = (policy, attempt) => Math.min(policy.maxDelayMs, policy.baseDelayMs * 2 ** (attempt - 1));

package/dist/sdk/core/http/url.d.ts

@@ -0,0 +1,3 @@
+export type QueryValue = boolean | number | readonly string[] | string | undefined;
+export type QueryParams = Record<string, QueryValue>;
+export declare const buildUrl: (baseUrl: string, path: string, query: QueryParams | undefined, trailingSlash: boolean) => string;