@zapier/zapier-sdk 0.18.4 → 0.19.0

package/dist/api/client.test.js

@@ -1,96 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { createZapierApi } from "./client";
-import * as auth from "../auth";
-vi.mock("../auth");
-describe("ApiClient", () => {
-    const mockResolveAuthToken = vi.mocked(auth.resolveAuthToken);
-    beforeEach(() => {
-        vi.clearAllMocks();
-        // Prevent any actual HTTP calls
-        global.fetch = vi.fn().mockResolvedValue({
-            ok: true,
-            status: 200,
-            json: () => Promise.resolve({ data: "test" }),
-        });
-    });
-    describe("authentication token resolution", () => {
-        it("should pass authBaseUrl to resolveAuthToken when provided", async () => {
-            mockResolveAuthToken.mockResolvedValue("test-token");
-            const client = createZapierApi({
-                baseUrl: "https://api.custom.zapier.dev",
-                authBaseUrl: "https://auth.custom.zapier.dev",
-                debug: false,
-            });
-            // Make a request that would trigger token resolution
-            await client.get("/test", { authRequired: true });
-            expect(mockResolveAuthToken).toHaveBeenCalledWith({
-                token: undefined,
-                getToken: undefined,
-                onEvent: undefined,
-                fetch: expect.any(Function),
-                baseUrl: "https://api.custom.zapier.dev",
-                authBaseUrl: "https://auth.custom.zapier.dev",
-                authClientId: undefined,
-            });
-        });
-        it("should pass undefined authBaseUrl when not provided", async () => {
-            mockResolveAuthToken.mockResolvedValue("test-token");
-            const client = createZapierApi({
-                baseUrl: "https://api.custom.zapier.dev",
-                // authBaseUrl intentionally omitted
-                debug: false,
-            });
-            // Make a request that would trigger token resolution
-            await client.get("/test", { authRequired: true });
-            expect(mockResolveAuthToken).toHaveBeenCalledWith({
-                token: undefined,
-                getToken: undefined,
-                onEvent: undefined,
-                fetch: expect.any(Function),
-                baseUrl: "https://api.custom.zapier.dev",
-                authBaseUrl: undefined,
-                authClientId: undefined,
-            });
-        });
-        it("should pass authClientId to resolveAuthToken when provided", async () => {
-            mockResolveAuthToken.mockResolvedValue("test-token");
-            const client = createZapierApi({
-                baseUrl: "https://api.custom.zapier.dev",
-                authClientId: "custom-client-id",
-                debug: false,
-            });
-            // Make a request that would trigger token resolution
-            await client.get("/test", { authRequired: true });
-            expect(mockResolveAuthToken).toHaveBeenCalledWith({
-                token: undefined,
-                getToken: undefined,
-                onEvent: undefined,
-                fetch: expect.any(Function),
-                baseUrl: "https://api.custom.zapier.dev",
-                authBaseUrl: undefined,
-                authClientId: "custom-client-id",
-            });
-        });
-        it("should not call resolveAuthToken when token is provided directly", async () => {
-            mockResolveAuthToken.mockResolvedValue("direct-token");
-            const client = createZapierApi({
-                token: "direct-token",
-                baseUrl: "https://api.custom.zapier.dev",
-                authBaseUrl: "https://auth.custom.zapier.dev",
-                debug: false,
-            });
-            // Make a request that would use the direct token
-            await client.get("/test", { authRequired: true });
-            // resolveAuthToken is still called, but it returns the direct token immediately
-            expect(mockResolveAuthToken).toHaveBeenCalledWith({
-                token: "direct-token",
-                getToken: undefined,
-                onEvent: undefined,
-                fetch: expect.any(Function),
-                baseUrl: "https://api.custom.zapier.dev",
-                authBaseUrl: "https://auth.custom.zapier.dev",
-                authClientId: undefined,
-            });
-        });
-    });
-});

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,CAwC/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,131 +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) => {
-        if (data === undefined || data === "") {
-            console.log(`[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.log, 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.log(`[Zapier SDK] ${message}`, formatted);
-        }
-        else {
-            // Fallback - browser will handle formatting automatically
-            console.log(`[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/debug.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=debug.test.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"debug.test.d.ts","sourceRoot":"","sources":["../../src/api/debug.test.ts"],"names":[],"mappings":""}

package/dist/api/debug.test.js

@@ -1,59 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { censorHeaders } from "./debug";
-describe("censorHeaders", () => {
-    it("should return undefined for undefined headers", () => {
-        expect(censorHeaders(undefined)).toBeUndefined();
-    });
-    it("should return headers unchanged for non-auth headers", () => {
-        const headers = {
-            "Content-Type": "application/json",
-            "User-Agent": "test",
-        };
-        const result = censorHeaders(headers);
-        // Headers API normalizes header names to lowercase
-        expect(result["content-type"]).toBe("application/json");
-        expect(result["user-agent"]).toBe("test");
-    });
-    it("should censor authorization header with Bearer prefix - long token", () => {
-        const headers = { authorization: "Bearer abcdef1234567890xyz" };
-        const result = censorHeaders(headers);
-        expect(result.authorization).toBe("Bearer abcd...0xyz");
-    });
-    it("should censor authorization header with Bearer prefix - short token", () => {
-        const headers = { authorization: "Bearer short123" };
-        const result = censorHeaders(headers);
-        expect(result.authorization).toBe("Bearer s...");
-    });
-    it("should censor x-api-key header - long token", () => {
-        const headers = { "x-api-key": "sk-1234567890abcdefghij" };
-        const result = censorHeaders(headers);
-        expect(result["x-api-key"]).toBe("sk-1...ghij");
-    });
-    it("should censor x-api-key header - short token", () => {
-        const headers = { "x-api-key": "short" };
-        const result = censorHeaders(headers);
-        expect(result["x-api-key"]).toBe("s...");
-    });
-    it("should handle Headers object input", () => {
-        const headers = new Headers();
-        headers.set("authorization", "Bearer verylongtoken123456789");
-        const result = censorHeaders(headers);
-        expect(result.authorization).toBe("Bearer very...6789");
-    });
-    it("should handle mixed case authorization headers", () => {
-        const headers = { Authorization: "Bearer mixedcasetoken123" };
-        const result = censorHeaders(headers);
-        expect(result.authorization).toBe("Bearer mixe...n123");
-    });
-    it("should preserve non-auth headers while censoring auth headers", () => {
-        const headers = {
-            "Content-Type": "application/json",
-            authorization: "Bearer shouldbecensored123456789",
-            "User-Agent": "test-agent",
-        };
-        const result = censorHeaders(headers);
-        expect(result["content-type"]).toBe("application/json");
-        expect(result["user-agent"]).toBe("test-agent");
-        expect(result.authorization).toBe("Bearer shou...6789");
-    });
-});

package/dist/api/index.d.ts

@@ -1,30 +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, Authentication, AuthenticationsResponse, Implementation, ImplementationsResponse, } from "./types";
-import type { ApiClient } from "./types";
-export { isJwt, getAuthorizationHeader } from "./auth";
-export { createDebugLogger, createDebugFetch } from "./debug";
-export { pollUntilComplete } from "./polling";
-export { createZapierApi } from "./client";
-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;
-    authBaseUrl?: string;
-    token?: string;
-    getToken?: () => Promise<string | undefined>;
-    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,cAAc,EACd,uBAAuB,EACvB,cAAc,EACd,uBAAuB,GACxB,MAAM,SAAS,CAAC;AAGjB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAIzC,OAAO,EAAE,KAAK,EAAE,sBAAsB,EAAE,MAAM,QAAQ,CAAC;AAGvD,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;AAM3C,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE;IAC3C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAC7C,GAAG,CAAC,EAAE,SAAS,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;CACjC,GAAG,SAAS,CAwBZ"}

package/dist/api/index.js

@@ -1,43 +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 } 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";
-// 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, authBaseUrl, token, getToken, api: providedApi, debug = false, fetch: customFetch, } = config;
-    // Use provided API client or create a new one
-    if (providedApi) {
-        return providedApi;
-    }
-    return createZapierApi({
-        baseUrl,
-        authBaseUrl,
-        token,
-        getToken,
-        debug,
-        fetch: customFetch,
-    });
-}

package/dist/api/polling.d.ts

@@ -1,46 +0,0 @@
-/**
- * Polling Utilities
- *
- * This module provides utilities for polling HTTP endpoints until completion,
- * with configurable retry logic and exponential backoff.
- */
-/**
- * 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 extract the result from the response */
-    resultExtractor?: (response: unknown) => TResult;
-    /** Initial delay before the first poll attempt (in milliseconds) */
-    initialDelay?: number;
-}
-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;AAgCH;;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,uDAAuD;IACvD,eAAe,CAAC,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK,OAAO,CAAC;IACjD,oEAAoE;IACpE,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,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;AAwDF;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,GAAG,OAAO,EACvD,OAAO,EAAE,WAAW,CAAC,OAAO,CAAC,GAC5B,OAAO,CAAC,OAAO,CAAC,CAyGlB"}

package/dist/api/polling.js

@@ -1,139 +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 { setTimeout } from "timers/promises";
-import { calculateWaitTime, MAX_CONSECUTIVE_ERRORS, } from "../utils/retry-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 = 10000;
-const MAX_TIMEOUT_BUFFER_MS = 10000;
-// Polling stages: [threshold_ms, interval_ms]
-// Note: These are default stages, actual hard timeout is enforced separately below
-const DEFAULT_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
-];
-const processResponse = async (response, successStatus, pendingStatus, 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();
-            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, resultExtractor = (response) => response, } = 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 },
-        });
-    }
-    const startTime = Date.now();
-    let attempts = 0;
-    let errorCount = 0;
-    // Build polling stages with the actual timeout appended
-    const pollingStages = [
-        ...DEFAULT_POLLING_STAGES,
-        [timeoutMs + MAX_TIMEOUT_BUFFER_MS, DEFAULT_MAX_POLLING_INTERVAL_MS], // Up to timeout + 10s: poll every 10s
-    ];
-    // Apply initial delay if specified
-    if (initialDelay > 0) {
-        await setTimeout(initialDelay);
-    }
-    while (true) {
-        attempts++;
-        const elapsedTime = Date.now() - startTime;
-        // Find the current polling stage
-        const pollingInterval = pollingStages.find(([maxTimeForStage, _interval]) => {
-            return elapsedTime < maxTimeForStage;
-        });
-        // If there isn't a current stage, throw timeout error
-        if (!pollingInterval) {
-            throw new ZapierTimeoutError(`Operation timed out after ${Math.floor(elapsedTime / 1000)}s (${attempts} attempts)`, {
-                attempts,
-            });
-        }
-        // Wait before polling (except on first attempt)
-        if (attempts > 1) {
-            const waitTime = calculateWaitTime(pollingInterval[1], errorCount);
-            await setTimeout(waitTime);
-        }
-        // Perform the poll request
-        try {
-            const response = await fetchPoll();
-            const { result, errorCount: newErrorCount, status, } = await processResponse(response, successStatus, pendingStatus, 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) {
-            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
-    }
-}

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

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=polling.test.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"polling.test.d.ts","sourceRoot":"","sources":["../../src/api/polling.test.ts"],"names":[],"mappings":""}