@zapier/zapier-sdk 0.77.0 → 0.77.2

package/dist/api/concurrency.d.ts

@@ -1,28 +0,0 @@
-/**
- * FIFO semaphore.
- *
- * Bounds the number of concurrent holders to `maxPermits`. Callers `acquire`
- * a slot and invoke the returned function to release it. Slots are granted
- * to waiters in arrival order. `Infinity` short-circuits to a no-op so
- * callers can disable throttling without branching at every call site.
- *
- * The release function is idempotent: calling it more than once does
- * nothing. This makes try/finally bookkeeping safe even if cleanup paths
- * overlap.
- *
- * AbortSignal: a queued `acquire` that observes its signal aborting will
- * remove itself from the queue and reject. A signal that aborts after
- * `acquire` has resolved is the caller's responsibility — they already hold
- * the slot and must call release.
- */
-export interface Semaphore {
-    acquire(signal?: AbortSignal): Promise<() => void>;
-    /**
-     * Synchronously claim a slot if one is available. Returns the release
-     * function on success and null when the caller would have to queue.
-     * Useful for emitting telemetry only when an `acquire` actually waits.
-     */
-    tryAcquire(): (() => void) | null;
-}
-export declare function createSemaphore(maxPermits: number): Semaphore;
-//# sourceMappingURL=concurrency.d.ts.map

package/dist/api/concurrency.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"concurrency.d.ts","sourceRoot":"","sources":["../../src/api/concurrency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,MAAM,WAAW,SAAS;IACxB,OAAO,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,IAAI,CAAC,CAAC;IACnD;;;;OAIG;IACH,UAAU,IAAI,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAAC;CACnC;AAaD,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,CAyE7D"}

package/dist/api/concurrency.js

@@ -1,90 +0,0 @@
-/**
- * FIFO semaphore.
- *
- * Bounds the number of concurrent holders to `maxPermits`. Callers `acquire`
- * a slot and invoke the returned function to release it. Slots are granted
- * to waiters in arrival order. `Infinity` short-circuits to a no-op so
- * callers can disable throttling without branching at every call site.
- *
- * The release function is idempotent: calling it more than once does
- * nothing. This makes try/finally bookkeeping safe even if cleanup paths
- * overlap.
- *
- * AbortSignal: a queued `acquire` that observes its signal aborting will
- * remove itself from the queue and reject. A signal that aborts after
- * `acquire` has resolved is the caller's responsibility — they already hold
- * the slot and must call release.
- */
-const NO_OP_RELEASE = () => { };
-const NO_OP_SEMAPHORE = {
-    acquire: async () => NO_OP_RELEASE,
-    tryAcquire: () => NO_OP_RELEASE,
-};
-export function createSemaphore(maxPermits) {
-    if (maxPermits === Infinity) {
-        return NO_OP_SEMAPHORE;
-    }
-    if (!Number.isInteger(maxPermits) || maxPermits <= 0) {
-        throw new Error(`maxPermits must be a positive integer or Infinity, got: ${maxPermits}`);
-    }
-    let permits = maxPermits;
-    const waiters = [];
-    const release = () => {
-        const next = waiters.shift();
-        if (next) {
-            // Hand the slot directly to the next waiter — permits stays the same.
-            next.grant();
-        }
-        else {
-            permits++;
-        }
-    };
-    const makeReleaseOnce = () => {
-        let released = false;
-        return () => {
-            if (released)
-                return;
-            released = true;
-            release();
-        };
-    };
-    return {
-        tryAcquire() {
-            if (permits > 0) {
-                permits--;
-                return makeReleaseOnce();
-            }
-            return null;
-        },
-        async acquire(signal) {
-            if (signal?.aborted) {
-                throw signal.reason ?? new DOMException("Aborted", "AbortError");
-            }
-            if (permits > 0) {
-                permits--;
-                return makeReleaseOnce();
-            }
-            return new Promise((resolve, reject) => {
-                const onAbort = () => {
-                    const idx = waiters.indexOf(waiter);
-                    if (idx !== -1) {
-                        waiters.splice(idx, 1);
-                        waiter.cancel(signal?.reason ?? new DOMException("Aborted", "AbortError"));
-                    }
-                };
-                const waiter = {
-                    grant: () => {
-                        signal?.removeEventListener("abort", onAbort);
-                        resolve(makeReleaseOnce());
-                    },
-                    cancel: (reason) => {
-                        signal?.removeEventListener("abort", onAbort);
-                        reject(reason);
-                    },
-                };
-                signal?.addEventListener("abort", onAbort);
-                waiters.push(waiter);
-            });
-        },
-    };
-}

package/dist/api/debug.d.ts

@@ -1,14 +0,0 @@
-/**
- * Debug Logging Utilities
- *
- * This module provides debug logging capabilities for API requests and responses,
- * including request timing and detailed logging of HTTP interactions.
- */
-import type { DebugLogger } from "./types";
-export declare function createDebugLogger(enabled: boolean): DebugLogger;
-export declare function censorHeaders(headers?: HeadersInit): Record<string, string> | undefined;
-export declare function createDebugFetch(options: {
-    originalFetch: typeof globalThis.fetch;
-    debugLog: DebugLogger;
-}): (input: RequestInfo | URL, options?: RequestInit) => Promise<Response>;
-//# sourceMappingURL=debug.d.ts.map

package/dist/api/debug.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../../src/api/debug.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAa3C,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,WAAW,CA0C/D;AAED,wBAAgB,aAAa,CAC3B,OAAO,CAAC,EAAE,WAAW,GACpB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAwCpC;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE;IACxC,aAAa,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;IACvC,QAAQ,EAAE,WAAW,CAAC;CACvB,IAEe,OAAO,WAAW,GAAG,GAAG,EAAE,UAAU,WAAW,uBA0C9D"}

package/dist/api/debug.js

@@ -1,133 +0,0 @@
-/**
- * Debug Logging Utilities
- *
- * This module provides debug logging capabilities for API requests and responses,
- * including request timing and detailed logging of HTTP interactions.
- */
-// We don't want to import util since it might not work in a browser. So we'll lazily load it and cache the result so
-// we can use it synchronously after that. The types above are just to make our linter happy.
-let utilModule = null;
-let utilPromise = null;
-export function createDebugLogger(enabled) {
-    if (!enabled) {
-        return () => { }; // No-op function when debug is disabled
-    }
-    // Try to load util module on first use.
-    if (!utilPromise) {
-        utilPromise = import("util")
-            .then((util) => {
-            utilModule = util;
-            return util;
-        })
-            .catch(() => {
-            utilModule = null;
-            return null;
-        });
-    }
-    return (message, data) => {
-        // Route debug output to stderr so it never pollutes stdout when callers
-        // pipe CLI output (e.g. `--json` responses) into a JSON parser.
-        if (data === undefined || data === "") {
-            console.error(`[Zapier SDK] ${message}`);
-            return;
-        }
-        // Use cached module if available for sync logging. Yes, this means if the util module isn't yet loaded, we'll fall
-        // back to a plain old console.error, which might mean we don't see proper formatting/nesting. But that's unlikely
-        // since this logging happens during async fetching. Alternatively, we could switch to async logging, but this
-        // seems fine since we have to have a fallback anyway.
-        if (utilModule) {
-            const formatted = utilModule.inspect(data, {
-                colors: true,
-                depth: null,
-                breakLength: 80,
-            });
-            console.error(`[Zapier SDK] ${message}`, formatted);
-        }
-        else {
-            // Fallback - browser will handle formatting automatically
-            console.error(`[Zapier SDK] ${message}`, data);
-        }
-    };
-}
-export function censorHeaders(headers) {
-    if (!headers)
-        return headers;
-    const headersObj = new Headers(headers);
-    const authKeys = ["authorization", "x-api-key"];
-    for (const [key, value] of headersObj.entries()) {
-        if (authKeys.some((authKey) => key.toLowerCase() === authKey)) {
-            // Find space after prefix (like "Bearer ")
-            const spaceIndex = value.indexOf(" ");
-            if (spaceIndex > 0 && spaceIndex < value.length - 1) {
-                const prefix = value.substring(0, spaceIndex + 1); // Include the space
-                const token = value.substring(spaceIndex + 1);
-                if (token.length > 12) {
-                    // Show first 4 and last 4 chars, truncate middle
-                    const start = token.substring(0, 4);
-                    const end = token.substring(token.length - 4);
-                    headersObj.set(key, `${prefix}${start}...${end}`);
-                }
-                else {
-                    // Short token, use first character + three dots
-                    const firstChar = token.charAt(0);
-                    headersObj.set(key, `${prefix}${firstChar}...`);
-                }
-            }
-            else {
-                // No prefix found, truncate the whole value
-                if (value.length > 12) {
-                    const start = value.substring(0, 4);
-                    const end = value.substring(value.length - 4);
-                    headersObj.set(key, `${start}...${end}`);
-                }
-                else {
-                    // Short token, use first character + three dots
-                    const firstChar = value.charAt(0);
-                    headersObj.set(key, `${firstChar}...`);
-                }
-            }
-        }
-    }
-    return Object.fromEntries(headersObj);
-}
-export function createDebugFetch(options) {
-    const { originalFetch, debugLog } = options;
-    return async (input, options) => {
-        const startTime = Date.now();
-        // Convert input to URL string for logging
-        const url = typeof input === "string" ? input : input.toString();
-        const method = options?.method || "GET";
-        debugLog(`→ ${method} ${url}`, {
-            headers: censorHeaders(options?.headers),
-            body: options?.body && typeof options.body === "string"
-                ? (() => {
-                    try {
-                        return JSON.parse(options.body);
-                    }
-                    catch {
-                        return options.body;
-                    }
-                })()
-                : options?.body,
-        });
-        try {
-            const response = await originalFetch(input, options);
-            const duration = Date.now() - startTime;
-            debugLog(`← ${response.status} ${response.statusText} (${duration}ms)`, {
-                url,
-                method,
-                status: response.status,
-            });
-            return response;
-        }
-        catch (error) {
-            const duration = Date.now() - startTime;
-            debugLog(`✖ Request failed (${duration}ms)`, {
-                url,
-                method,
-                error: error instanceof Error ? error.message : error,
-            });
-            throw error;
-        }
-    };
-}

package/dist/api/error-classification.d.ts

@@ -1,19 +0,0 @@
-/**
- * Classifies an HTTP error by status code. A 4xx is permanent for now
- * (auth/permission/bad request); 5xx and network errors are transient. We read
- * `statusCode` off any `ZapierError`, not just `ZapierApiError`: a policy denial
- * escapes `api.fetch` as a `ZapierApprovalError` (a sibling subclass) carrying a
- * 403, and it must be treated as permanent too. 429 stays transient —
- * `api.fetch` already backed off and retried it upstream, so a
- * `ZapierRateLimitError` (also a `ZapierError`) that escapes should be retried
- * on the normal cadence rather than treated as permanent.
- *
- * A `ZapierAuthenticationError` with no `statusCode` is the one carve-out: the
- * token-exchange / credential-resolution layer throws these for setup problems
- * (token endpoint rejected the credentials, missing keychain secret, no
- * credentials at all) that never self-heal, so they are permanent even without
- * a status. Auth errors that DO carry a status fall through to the rule above,
- * so a 5xx/429 from the token endpoint still retries.
- */
-export declare function isPermanentHttpError(err: unknown): boolean;
-//# sourceMappingURL=error-classification.d.ts.map

package/dist/api/error-classification.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"error-classification.d.ts","sourceRoot":"","sources":["../../src/api/error-classification.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAe1D"}

package/dist/api/error-classification.js

@@ -1,31 +0,0 @@
-import { ZapierAuthenticationError, ZapierError } from "../types/errors";
-/**
- * Classifies an HTTP error by status code. A 4xx is permanent for now
- * (auth/permission/bad request); 5xx and network errors are transient. We read
- * `statusCode` off any `ZapierError`, not just `ZapierApiError`: a policy denial
- * escapes `api.fetch` as a `ZapierApprovalError` (a sibling subclass) carrying a
- * 403, and it must be treated as permanent too. 429 stays transient —
- * `api.fetch` already backed off and retried it upstream, so a
- * `ZapierRateLimitError` (also a `ZapierError`) that escapes should be retried
- * on the normal cadence rather than treated as permanent.
- *
- * A `ZapierAuthenticationError` with no `statusCode` is the one carve-out: the
- * token-exchange / credential-resolution layer throws these for setup problems
- * (token endpoint rejected the credentials, missing keychain secret, no
- * credentials at all) that never self-heal, so they are permanent even without
- * a status. Auth errors that DO carry a status fall through to the rule above,
- * so a 5xx/429 from the token endpoint still retries.
- */
-export function isPermanentHttpError(err) {
-    if (!(err instanceof ZapierError))
-        return false;
-    if (err instanceof ZapierAuthenticationError &&
-        err.statusCode === undefined) {
-        return true;
-    }
-    const { statusCode } = err;
-    return (statusCode !== undefined &&
-        statusCode >= 400 &&
-        statusCode < 500 &&
-        statusCode !== 429);
-}

package/dist/api/index.d.ts

@@ -1,33 +0,0 @@
-/**
- * Zapier API Client Module
- *
- * This module provides a centralized API layer for all HTTP interactions
- * with Zapier's various APIs. It handles authentication, error handling,
- * polling, and provides consistent patterns across all services.
- */
-export type { ApiClient, ApiClientOptions, RequestOptions, PollOptions, DebugLogger, Action, Field, Choice, ActionExecutionResult, ActionField, ActionFieldChoice, NeedsRequest, NeedsResponse, Connection, ConnectionsResponse, Implementation, ImplementationsResponse, } from "./types";
-import type { ApiClient } from "./types";
-import type { Credentials } from "../types/credentials";
-export type { SseMessage, JsonSseMessage } from "./sse-parser";
-export { isJwt, getAuthorizationHeader, extractUserIdsFromJwt } from "./auth";
-export { createDebugLogger, createDebugFetch } from "./debug";
-export { pollUntilComplete } from "./polling";
-export { createZapierApi } from "./client";
-export { isPermanentHttpError } from "./error-classification";
-export declare function generateRequestId(): string;
-/**
- * Utility function to get or create an API client for standalone functions
- *
- * @param config - Configuration that may include an existing API client
- * @returns ApiClient instance
- */
-export declare function getOrCreateApiClient(config: {
-    baseUrl?: string;
-    credentials?: Credentials;
-    /** @deprecated Use `credentials` instead */
-    token?: string;
-    api?: ApiClient;
-    debug?: boolean;
-    fetch?: typeof globalThis.fetch;
-}): ApiClient;
-//# sourceMappingURL=index.d.ts.map

package/dist/api/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,YAAY,EAEV,SAAS,EACT,gBAAgB,EAChB,cAAc,EACd,WAAW,EACX,WAAW,EAEX,MAAM,EACN,KAAK,EACL,MAAM,EACN,qBAAqB,EACrB,WAAW,EACX,iBAAiB,EACjB,YAAY,EACZ,aAAa,EACb,UAAU,EACV,mBAAmB,EACnB,cAAc,EACd,uBAAuB,GACxB,MAAM,SAAS,CAAC;AAGjB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAKxD,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAG/D,OAAO,EAAE,KAAK,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,QAAQ,CAAC;AAG9E,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAG9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAG9C,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAG3C,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAM9D,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE;IAC3C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,4CAA4C;IAC5C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,SAAS,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;CACjC,GAAG,SAAS,CAsBZ"}

package/dist/api/index.js

@@ -1,44 +0,0 @@
-/**
- * Zapier API Client Module
- *
- * This module provides a centralized API layer for all HTTP interactions
- * with Zapier's various APIs. It handles authentication, error handling,
- * polling, and provides consistent patterns across all services.
- */
-import { ZAPIER_BASE_URL } from "../constants";
-// Re-export authentication utilities
-export { isJwt, getAuthorizationHeader, extractUserIdsFromJwt } from "./auth";
-// Re-export debug utilities
-export { createDebugLogger, createDebugFetch } from "./debug";
-// Re-export polling utilities
-export { pollUntilComplete } from "./polling";
-// Re-export the main client factory
-export { createZapierApi } from "./client";
-// Re-export HTTP error classification
-export { isPermanentHttpError } from "./error-classification";
-// Import for local use
-import { createZapierApi } from "./client";
-// Utility Functions
-export function generateRequestId() {
-    return Math.random().toString(36).substring(2) + Date.now().toString(36);
-}
-/**
- * Utility function to get or create an API client for standalone functions
- *
- * @param config - Configuration that may include an existing API client
- * @returns ApiClient instance
- */
-export function getOrCreateApiClient(config) {
-    const { baseUrl = ZAPIER_BASE_URL, credentials, token, api: providedApi, debug = false, fetch: customFetch, } = config;
-    // Use provided API client or create a new one
-    if (providedApi) {
-        return providedApi;
-    }
-    return createZapierApi({
-        baseUrl,
-        credentials,
-        token,
-        debug,
-        fetch: customFetch,
-    });
-}

package/dist/api/polling.d.ts

@@ -1,64 +0,0 @@
-/**
- * Polling Utilities
- *
- * This module provides utilities for polling HTTP endpoints until completion,
- * with configurable retry logic and exponential backoff.
- */
-/**
- * Get the appropriate polling interval based on elapsed time.
- * Starts with frequent polling and backs off as time passes.
- * @param elapsedMs Time elapsed since polling started (in milliseconds)
- * @returns The polling interval to use (in milliseconds)
- */
-export declare function getPollingInterval(elapsedMs: number): number;
-/**
- * Options for the polling function
- */
-export interface PollOptions<TResult = unknown> {
-    /** Function that performs the HTTP request */
-    fetchPoll: () => Promise<Response>;
-    /** Maximum time to wait for completion (in milliseconds) */
-    timeoutMs?: number;
-    /** HTTP status code indicating successful completion */
-    successStatus?: number;
-    /** HTTP status code indicating the operation is still pending */
-    pendingStatus?: number;
-    /** Function to check if the response body indicates pending state (return true to continue polling) */
-    isPending?: (response: unknown) => boolean;
-    /** Function to extract the result from the response */
-    resultExtractor?: (response: unknown) => TResult;
-    /** Initial delay before the first poll attempt (in milliseconds) */
-    initialDelay?: number;
-    /** Maximum sleep duration between poll attempts after backoff is applied. */
-    maxPollingIntervalMs?: number;
-    /**
-     * Abort signal observed by the initial delay, the inter-poll sleep,
-     * and (when forwarded into `fetchPoll`) the in-flight HTTP request.
-     * On abort, this function throws `AbortError` rather than continuing
-     * to poll or treating it as a transient failure.
-     */
-    signal?: AbortSignal;
-}
-declare const enum PollStatus {
-    Success = "success",
-    Continue = "continue"
-}
-/**
- * Result of a poll operation
- */
-export type PollResult<TResult = unknown> = {
-    result?: TResult;
-    status: PollStatus;
-    errorCount: number;
-};
-/**
- * Polls an endpoint until completion, timeout, or error
- * @param options Configuration options for polling
- * @returns The extracted result from the successful response
- * @throws {ZapierValidationError} When the input parameters are invalid
- * @throws {ZapierTimeoutError} When the operation times out
- * @throws {ZapierApiError} When the API returns consecutive errors
- */
-export declare function pollUntilComplete<TResult = unknown>(options: PollOptions<TResult>): Promise<TResult>;
-export {};
-//# sourceMappingURL=polling.d.ts.map

package/dist/api/polling.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"polling.d.ts","sourceRoot":"","sources":["../../src/api/polling.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAiCH;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAG5D;AAED;;GAEG;AACH,MAAM,WAAW,WAAW,CAAC,OAAO,GAAG,OAAO;IAC5C,8CAA8C;IAC9C,SAAS,EAAE,MAAM,OAAO,CAAC,QAAQ,CAAC,CAAC;IACnC,4DAA4D;IAC5D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,wDAAwD;IACxD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,iEAAiE;IACjE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,uGAAuG;IACvG,SAAS,CAAC,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK,OAAO,CAAC;IAC3C,uDAAuD;IACvD,eAAe,CAAC,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK,OAAO,CAAC;IACjD,oEAAoE;IACpE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,6EAA6E;IAC7E,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;;OAKG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAWD,mBAAW,UAAU;IACnB,OAAO,YAAY;IACnB,QAAQ,aAAa;CACtB;AAED;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,OAAO,GAAG,OAAO,IAAI;IAC1C,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,UAAU,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAgEF;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,GAAG,OAAO,EACvD,OAAO,EAAE,WAAW,CAAC,OAAO,CAAC,GAC5B,OAAO,CAAC,OAAO,CAAC,CA4HlB"}

package/dist/api/polling.js

@@ -1,180 +0,0 @@
-/**
- * Polling Utilities
- *
- * This module provides utilities for polling HTTP endpoints until completion,
- * with configurable retry logic and exponential backoff.
- */
-import { ZapierTimeoutError, ZapierApiError, ZapierValidationError, } from "../types/errors";
-import { sleep, calculateErrorBackoffMs, MAX_CONSECUTIVE_ERRORS, } from "../utils/retry-utils";
-import { isAbortError } from "../utils/abort-utils";
-// Constants
-const DEFAULT_TIMEOUT_MS = 180000;
-const DEFAULT_SUCCESS_STATUS = 200;
-const DEFAULT_PENDING_STATUS = 202;
-const DEFAULT_INITIAL_DELAY_MS = 50;
-const DEFAULT_MAX_POLLING_INTERVAL_MS = 60000;
-// Polling stages: [elapsed_time_threshold_ms, poll_interval_ms]
-const POLLING_STAGES = [
-    [125, 125], // Up to 125ms: poll every 125ms
-    [375, 250], // Up to 375ms: poll every 250ms
-    [875, 500], // Up to 875ms: poll every 500ms
-    [10000, 1000], // Up to 10s: poll every 1s
-    [30000, 2500], // Up to 30s: poll every 2.5s
-    [60000, 5000], // Up to 60s: poll every 5s
-    [180000, 10000], // Up to 3min: poll every 10s
-    // Beyond 3min: use DEFAULT_MAX_POLLING_INTERVAL_MS (60s)
-];
-/**
- * Get the appropriate polling interval based on elapsed time.
- * Starts with frequent polling and backs off as time passes.
- * @param elapsedMs Time elapsed since polling started (in milliseconds)
- * @returns The polling interval to use (in milliseconds)
- */
-export function getPollingInterval(elapsedMs) {
-    const stage = POLLING_STAGES.find(([threshold]) => elapsedMs < threshold);
-    return stage ? stage[1] : DEFAULT_MAX_POLLING_INTERVAL_MS;
-}
-function makeAbortError() {
-    if (typeof DOMException !== "undefined") {
-        return new DOMException("Polling was aborted", "AbortError");
-    }
-    const err = new Error("Polling was aborted");
-    err.name = "AbortError";
-    return err;
-}
-const processResponse = async (response, successStatus, pendingStatus, isPending, resultExtractor, errorCount) => {
-    // Handle other error responses
-    if (!response.ok) {
-        return {
-            status: "continue" /* PollStatus.Continue */,
-            // If for some reason the status is pending, we don't want to increment the error count
-            errorCount: response.status === pendingStatus ? errorCount : errorCount + 1,
-        };
-    }
-    // Check for successful completion
-    if (response.status === successStatus) {
-        try {
-            const resultJson = await response.json();
-            // Check if the response body indicates we should continue polling
-            if (isPending && isPending(resultJson)) {
-                return {
-                    status: "continue" /* PollStatus.Continue */,
-                    errorCount: 0,
-                };
-            }
-            return {
-                result: resultExtractor(resultJson),
-                status: "success" /* PollStatus.Success */,
-                errorCount: 0,
-            };
-        }
-        catch (error) {
-            throw new ZapierApiError("Result extractor failed to parse successful response as JSON", {
-                statusCode: response.status,
-                cause: error,
-            });
-        }
-    }
-    // If it's not pending, it's unexpected
-    if (response.status !== pendingStatus) {
-        throw new ZapierApiError(`Unexpected response status during polling: ${response.status}`, {
-            statusCode: response.status,
-        });
-    }
-    // It's still pending, so we continue polling
-    return {
-        status: "continue" /* PollStatus.Continue */,
-        errorCount: 0,
-    };
-};
-/**
- * Polls an endpoint until completion, timeout, or error
- * @param options Configuration options for polling
- * @returns The extracted result from the successful response
- * @throws {ZapierValidationError} When the input parameters are invalid
- * @throws {ZapierTimeoutError} When the operation times out
- * @throws {ZapierApiError} When the API returns consecutive errors
- */
-export async function pollUntilComplete(options) {
-    const { fetchPoll, timeoutMs = DEFAULT_TIMEOUT_MS, initialDelay = DEFAULT_INITIAL_DELAY_MS, successStatus = DEFAULT_SUCCESS_STATUS, pendingStatus = DEFAULT_PENDING_STATUS, isPending, resultExtractor = (response) => response, signal, maxPollingIntervalMs, } = options;
-    // Validate input parameters
-    if (timeoutMs <= 0) {
-        throw new ZapierValidationError("Timeout must be greater than 0", {
-            details: { timeoutMs },
-        });
-    }
-    if (initialDelay < 0) {
-        throw new ZapierValidationError("Initial delay must be non-negative", {
-            details: { initialDelay },
-        });
-    }
-    if (maxPollingIntervalMs !== undefined && maxPollingIntervalMs <= 0) {
-        throw new ZapierValidationError("Max polling interval must be greater than 0", {
-            details: { maxPollingIntervalMs },
-        });
-    }
-    if (signal?.aborted)
-        throw makeAbortError();
-    const startTime = Date.now();
-    let attempts = 0;
-    let errorCount = 0;
-    // Apply initial delay if specified. `sleep(..., signal)` resolves
-    // early on abort; the explicit re-check below converts that into a
-    // proper AbortError throw so the loop doesn't issue a request after
-    // the caller cancelled.
-    if (initialDelay > 0) {
-        await sleep(initialDelay, signal);
-        if (signal?.aborted)
-            throw makeAbortError();
-    }
-    while (true) {
-        if (signal?.aborted)
-            throw makeAbortError();
-        const elapsedTime = Date.now() - startTime;
-        // Check if we've exceeded the timeout
-        if (elapsedTime >= timeoutMs) {
-            throw new ZapierTimeoutError(`Operation timed out after ${Math.floor(elapsedTime / 1000)}s (${attempts} attempts)`, {
-                attempts,
-            });
-        }
-        // Wait before polling (except on first attempt)
-        if (attempts > 0) {
-            const interval = getPollingInterval(elapsedTime);
-            const waitTime = calculateErrorBackoffMs(interval, errorCount);
-            const cappedWaitTime = maxPollingIntervalMs === undefined
-                ? waitTime
-                : Math.min(waitTime, maxPollingIntervalMs);
-            await sleep(cappedWaitTime, signal);
-            if (signal?.aborted)
-                throw makeAbortError();
-        }
-        attempts++;
-        // Perform the poll request
-        try {
-            const response = await fetchPoll();
-            const { result, errorCount: newErrorCount, status, } = await processResponse(response, successStatus, pendingStatus, isPending, resultExtractor, errorCount);
-            errorCount = newErrorCount;
-            if (status === "success" /* PollStatus.Success */) {
-                return result;
-            }
-            if (errorCount >= MAX_CONSECUTIVE_ERRORS) {
-                // Too many consecutive errors, fail
-                throw new ZapierApiError(`Poll request failed: ${response.status} ${response.statusText}`, { statusCode: response.status });
-            }
-        }
-        catch (error) {
-            // Abort is intent, not failure. Surface immediately rather than
-            // counting it toward MAX_CONSECUTIVE_ERRORS and wrapping in
-            // ZapierApiError.
-            if (isAbortError(error))
-                throw error;
-            errorCount++;
-            if (errorCount >= MAX_CONSECUTIVE_ERRORS) {
-                throw new ZapierApiError(`Failed to poll after ${errorCount} consecutive errors: ${error instanceof Error ? error.message : String(error)}`, {
-                    cause: error,
-                });
-            }
-        }
-        // Continue polling if status is pending
-    }
-}