@zapier/zapier-sdk 0.18.3 → 0.19.0

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":""}

package/dist/api/polling.test.js

@@ -1,318 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { pollUntilComplete } from "./polling";
-import { ZapierTimeoutError, ZapierApiError, ZapierValidationError, } from "../types/errors";
-// Mock the timers/promises module
-vi.mock("timers/promises", () => ({
-    setTimeout: vi.fn(() => Promise.resolve()),
-}));
-describe("pollUntilComplete", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    afterEach(() => {
-        vi.clearAllMocks();
-    });
-    describe("successful polling", () => {
-        it("should return immediately on first successful response", async () => {
-            const mockResponse = {
-                ok: true,
-                status: 200,
-                json: vi.fn().mockResolvedValue({ data: "success" }),
-            };
-            const fetchPoll = vi.fn().mockResolvedValue(mockResponse);
-            const result = await pollUntilComplete({ fetchPoll });
-            expect(result).toEqual({ data: "success" });
-            expect(fetchPoll).toHaveBeenCalledTimes(1);
-        });
-        it("should poll until success status is received", async () => {
-            const pendingResponse = {
-                ok: true,
-                status: 202,
-            };
-            const successResponse = {
-                ok: true,
-                status: 200,
-                json: vi.fn().mockResolvedValue({ data: "complete" }),
-            };
-            const fetchPoll = vi
-                .fn()
-                .mockResolvedValueOnce(pendingResponse)
-                .mockResolvedValueOnce(pendingResponse)
-                .mockResolvedValueOnce(successResponse);
-            const result = await pollUntilComplete({ fetchPoll });
-            expect(result).toEqual({ data: "complete" });
-            expect(fetchPoll).toHaveBeenCalledTimes(3);
-        });
-        it("should use custom success and pending status codes", async () => {
-            const pendingResponse = {
-                ok: true,
-                status: 301,
-            };
-            const successResponse = {
-                ok: true,
-                status: 204,
-                json: vi.fn().mockResolvedValue({ done: true }),
-            };
-            const fetchPoll = vi
-                .fn()
-                .mockResolvedValueOnce(pendingResponse)
-                .mockResolvedValueOnce(successResponse);
-            const result = await pollUntilComplete({
-                fetchPoll,
-                successStatus: 204,
-                pendingStatus: 301,
-            });
-            expect(result).toEqual({ done: true });
-            expect(fetchPoll).toHaveBeenCalledTimes(2);
-        });
-        it("should apply result extractor function", async () => {
-            const mockResponse = {
-                ok: true,
-                status: 200,
-                json: vi.fn().mockResolvedValue({
-                    nested: { data: { value: "extracted" } },
-                }),
-            };
-            const fetchPoll = vi.fn().mockResolvedValue(mockResponse);
-            const resultExtractor = (response) => response.nested.data.value;
-            const result = await pollUntilComplete({
-                fetchPoll,
-                resultExtractor,
-            });
-            expect(result).toBe("extracted");
-        });
-    });
-    describe("initial delay", () => {
-        it("should wait for initial delay before first poll", async () => {
-            const mockResponse = {
-                ok: true,
-                status: 200,
-                json: vi.fn().mockResolvedValue({ data: "success" }),
-            };
-            const fetchPoll = vi.fn().mockResolvedValue(mockResponse);
-            const { setTimeout: mockSetTimeout } = await import("timers/promises");
-            const result = await pollUntilComplete({
-                fetchPoll,
-                initialDelay: 500,
-            });
-            expect(result).toEqual({ data: "success" });
-            expect(fetchPoll).toHaveBeenCalledTimes(1);
-            // Verify setTimeout was called with the initial delay
-            expect(mockSetTimeout).toHaveBeenCalledWith(500);
-        });
-    });
-    describe("error handling", () => {
-        it("should retry on transient network errors", async () => {
-            const successResponse = {
-                ok: true,
-                status: 200,
-                json: vi.fn().mockResolvedValue({ data: "recovered" }),
-            };
-            const fetchPoll = vi
-                .fn()
-                .mockRejectedValueOnce(new Error("Network error"))
-                .mockRejectedValueOnce(new Error("Network error"))
-                .mockResolvedValueOnce(successResponse);
-            const result = await pollUntilComplete({ fetchPoll });
-            expect(result).toEqual({ data: "recovered" });
-            expect(fetchPoll).toHaveBeenCalledTimes(3);
-        });
-        it("should fail after MAX_CONSECUTIVE_ERRORS network failures", async () => {
-            const fetchPoll = vi
-                .fn()
-                .mockRejectedValue(new Error("Persistent network error"));
-            await expect(pollUntilComplete({ fetchPoll })).rejects.toThrow(ZapierApiError);
-            expect(fetchPoll).toHaveBeenCalledTimes(3);
-        });
-        it("should retry on HTTP error responses", async () => {
-            const errorResponse = {
-                ok: false,
-                status: 500,
-                statusText: "Internal Server Error",
-            };
-            const successResponse = {
-                ok: true,
-                status: 200,
-                json: vi.fn().mockResolvedValue({ data: "recovered" }),
-            };
-            const fetchPoll = vi
-                .fn()
-                .mockResolvedValueOnce(errorResponse)
-                .mockResolvedValueOnce(errorResponse)
-                .mockResolvedValueOnce(successResponse);
-            const result = await pollUntilComplete({ fetchPoll });
-            expect(result).toEqual({ data: "recovered" });
-            expect(fetchPoll).toHaveBeenCalledTimes(3);
-        });
-        it("should fail after MAX_CONSECUTIVE_ERRORS HTTP failures", async () => {
-            const errorResponse = {
-                ok: false,
-                status: 503,
-                statusText: "Service Unavailable",
-            };
-            const fetchPoll = vi.fn().mockResolvedValue(errorResponse);
-            await expect(pollUntilComplete({ fetchPoll })).rejects.toThrow(ZapierApiError);
-            expect(fetchPoll).toHaveBeenCalledTimes(3);
-        });
-        it("should throw error for unexpected response status", async () => {
-            const unexpectedResponse = {
-                ok: true,
-                status: 301, // Not success (200) or pending (202)
-            };
-            const fetchPoll = vi.fn().mockResolvedValue(unexpectedResponse);
-            await expect(pollUntilComplete({ fetchPoll })).rejects.toThrow("Unexpected response status");
-            // Will retry 3 times before failing
-            expect(fetchPoll).toHaveBeenCalledTimes(3);
-        });
-        it("should throw error if successful response is not valid JSON", async () => {
-            const mockResponse = {
-                ok: true,
-                status: 200,
-                json: vi.fn().mockRejectedValue(new Error("Invalid JSON")),
-            };
-            const fetchPoll = vi.fn().mockResolvedValue(mockResponse);
-            await expect(pollUntilComplete({ fetchPoll })).rejects.toThrow("Failed to poll after 3 consecutive errors");
-            // Will retry 3 times before failing
-            expect(fetchPoll).toHaveBeenCalledTimes(3);
-        });
-    });
-    describe("timeout behavior", () => {
-        it("should timeout after specified duration", async () => {
-            // Mock Date.now to simulate time passing
-            const originalDateNow = Date.now;
-            let currentTime = 1000;
-            Date.now = vi.fn(() => currentTime);
-            const pendingResponse = {
-                ok: true,
-                status: 202,
-            };
-            const fetchPoll = vi.fn().mockImplementation(() => {
-                // Simulate time passing with each poll
-                currentTime += 500;
-                return Promise.resolve(pendingResponse);
-            });
-            try {
-                await expect(pollUntilComplete({
-                    fetchPoll,
-                    timeoutMs: 1000,
-                    initialDelay: 0,
-                })).rejects.toThrow(ZapierTimeoutError);
-            }
-            finally {
-                Date.now = originalDateNow;
-            }
-        });
-        it("should use default timeout when not specified", async () => {
-            // Mock Date.now to simulate time passing beyond default timeout
-            const originalDateNow = Date.now;
-            let currentTime = 1000;
-            Date.now = vi.fn(() => currentTime);
-            const pendingResponse = {
-                ok: true,
-                status: 202,
-            };
-            const fetchPoll = vi.fn().mockImplementation(() => {
-                // Simulate time passing beyond default timeout (180 seconds + buffer)
-                currentTime += 50000;
-                return Promise.resolve(pendingResponse);
-            });
-            try {
-                await expect(pollUntilComplete({
-                    fetchPoll,
-                    initialDelay: 0,
-                })).rejects.toThrow(ZapierTimeoutError);
-            }
-            finally {
-                Date.now = originalDateNow;
-            }
-        });
-    });
-    describe("input validation", () => {
-        it("should throw error for invalid timeout", async () => {
-            const fetchPoll = vi.fn();
-            await expect(pollUntilComplete({
-                fetchPoll,
-                timeoutMs: 0,
-            })).rejects.toThrow(ZapierValidationError);
-            await expect(pollUntilComplete({
-                fetchPoll,
-                timeoutMs: -1000,
-            })).rejects.toThrow(/Timeout must be greater than 0/);
-        });
-        it("should throw error for negative initial delay", async () => {
-            const fetchPoll = vi.fn();
-            await expect(pollUntilComplete({
-                fetchPoll,
-                initialDelay: -100,
-            })).rejects.toThrow(ZapierValidationError);
-            await expect(pollUntilComplete({
-                fetchPoll,
-                initialDelay: -1,
-            })).rejects.toThrow(/Initial delay must be non-negative/);
-        });
-    });
-    describe("edge cases", () => {
-        it("should handle rapid status changes", async () => {
-            const responses = [
-                { ok: true, status: 202 },
-                { ok: false, status: 500 },
-                { ok: true, status: 202 },
-                {
-                    ok: true,
-                    status: 200,
-                    json: vi.fn().mockResolvedValue({ data: "success" }),
-                },
-            ];
-            let index = 0;
-            const fetchPoll = vi.fn().mockImplementation(() => {
-                const response = responses[index];
-                index++;
-                return Promise.resolve(response);
-            });
-            const result = await pollUntilComplete({ fetchPoll });
-            expect(result).toEqual({ data: "success" });
-            expect(fetchPoll).toHaveBeenCalledTimes(4);
-        });
-        it("should handle immediate success with no initial delay", async () => {
-            const mockResponse = {
-                ok: true,
-                status: 200,
-                json: vi.fn().mockResolvedValue({ instant: true }),
-            };
-            const fetchPoll = vi.fn().mockResolvedValue(mockResponse);
-            const result = await pollUntilComplete({
-                fetchPoll,
-                initialDelay: 0,
-            });
-            expect(result).toEqual({ instant: true });
-            expect(fetchPoll).toHaveBeenCalledTimes(1);
-        });
-        it("should handle very short timeout", async () => {
-            // Mock Date.now to simulate time passing
-            const originalDateNow = Date.now;
-            let currentTime = 1000;
-            Date.now = vi.fn(() => currentTime);
-            const pendingResponse = {
-                ok: true,
-                status: 202,
-            };
-            const fetchPoll = vi.fn().mockImplementation(() => {
-                // Simulate time passing beyond the short timeout
-                currentTime += 200;
-                return Promise.resolve(pendingResponse);
-            });
-            try {
-                await expect(pollUntilComplete({
-                    fetchPoll,
-                    timeoutMs: 100,
-                    initialDelay: 0,
-                })).rejects.toThrow(ZapierTimeoutError);
-                // Should have made at least 1 attempt before timing out
-                expect(fetchPoll.mock.calls.length).toBeGreaterThanOrEqual(1);
-            }
-            finally {
-                Date.now = originalDateNow;
-            }
-        });
-    });
-});

package/dist/api/router.d.ts

@@ -1,16 +0,0 @@
-import { type Handler } from "../temporary-internal-core";
-export interface Route {
-    method: string;
-    pattern: RegExp;
-    handler: Handler<any, any, any>;
-    paramMap: string[];
-}
-export declare function findMatchingRoute(routeList: Route[], method: string, path: string): {
-    handler: Handler<any, any, any>;
-    params: Record<string, string>;
-} | null;
-export declare function matchRoute(method: string, path: string): {
-    handler: Handler<any, any, any>;
-    params: Record<string, string>;
-} | null;
-//# sourceMappingURL=router.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../src/api/router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,OAAO,EAAE,MAAM,4BAA4B,CAAC;AAE1E,MAAM,WAAW,KAAK;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;IAChC,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAWD,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,KAAK,EAAE,EAClB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM;;;SAsBb;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;;;SAEtD"}

package/dist/api/router.js

@@ -1,31 +0,0 @@
-import { handleListApps } from "../temporary-internal-core";
-const routes = [
-    {
-        method: "GET",
-        pattern: /^\/api\/v0\/apps$/,
-        handler: handleListApps,
-        paramMap: [],
-    },
-];
-export function findMatchingRoute(routeList, method, path) {
-    for (const route of routeList) {
-        if (route.method !== method) {
-            continue;
-        }
-        const match = path.match(route.pattern);
-        if (match) {
-            const params = {};
-            route.paramMap.forEach((name, index) => {
-                params[name] = match[index + 1];
-            });
-            return {
-                handler: route.handler,
-                params,
-            };
-        }
-    }
-    return null;
-}
-export function matchRoute(method, path) {
-    return findMatchingRoute(routes, method, path);
-}

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

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

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

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

package/dist/api/router.test.js

@@ -1,103 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { matchRoute, findMatchingRoute } from "./router";
-import { handleListApps } from "../temporary-internal-core";
-describe("Router", () => {
-    describe("matchRoute (Integration)", () => {
-        it("should match GET /api/v0/apps", () => {
-            const match = matchRoute("GET", "/api/v0/apps");
-            expect(match).not.toBeNull();
-            expect(match?.handler).toBe(handleListApps);
-            expect(match?.params).toEqual({});
-        });
-        it("should not match POST /api/v0/apps", () => {
-            const match = matchRoute("POST", "/api/v0/apps");
-            expect(match).toBeNull();
-        });
-        it("should not match unknown paths", () => {
-            expect(matchRoute("GET", "/api/v0/unknown")).toBeNull();
-            expect(matchRoute("GET", "/")).toBeNull();
-        });
-        it("should not match partial paths if regex is anchored", () => {
-            // The regex is /^\/api\/v0\/apps$/ so it shouldn't match suffix
-            expect(matchRoute("GET", "/api/v0/apps/something")).toBeNull();
-        });
-    });
-    describe("findMatchingRoute (Unit)", () => {
-        const mockHandler = vi.fn();
-        const testRoutes = [
-            {
-                method: "GET",
-                pattern: /^\/items$/,
-                handler: mockHandler,
-                paramMap: [],
-            },
-            {
-                method: "GET",
-                pattern: /^\/items\/(\d+)$/,
-                handler: mockHandler,
-                paramMap: ["id"],
-            },
-            {
-                method: "POST",
-                pattern: /^\/items$/,
-                handler: mockHandler,
-                paramMap: [],
-            },
-            {
-                method: "GET",
-                pattern: /^\/users\/(\w+)\/posts\/(\d+)$/,
-                handler: mockHandler,
-                paramMap: ["userId", "postId"],
-            },
-        ];
-        it("should match exact path", () => {
-            const match = findMatchingRoute(testRoutes, "GET", "/items");
-            expect(match).not.toBeNull();
-            expect(match?.handler).toBe(mockHandler);
-            expect(match?.params).toEqual({});
-        });
-        it("should extract single parameter", () => {
-            const match = findMatchingRoute(testRoutes, "GET", "/items/123");
-            expect(match).not.toBeNull();
-            expect(match?.params).toEqual({ id: "123" });
-        });
-        it("should extract multiple parameters", () => {
-            const match = findMatchingRoute(testRoutes, "GET", "/users/alice/posts/456");
-            expect(match).not.toBeNull();
-            expect(match?.params).toEqual({ userId: "alice", postId: "456" });
-        });
-        it("should respect HTTP method", () => {
-            // GET /items exists
-            expect(findMatchingRoute(testRoutes, "GET", "/items")).not.toBeNull();
-            // POST /items exists
-            expect(findMatchingRoute(testRoutes, "POST", "/items")).not.toBeNull();
-            // PUT /items does not exist
-            expect(findMatchingRoute(testRoutes, "PUT", "/items")).toBeNull();
-        });
-        it("should not match if regex does not match", () => {
-            // /items/abc does not match /^\/items\/(\d+)$/ (\d+ is digits only)
-            expect(findMatchingRoute(testRoutes, "GET", "/items/abc")).toBeNull();
-        });
-        it("should handle empty route list", () => {
-            expect(findMatchingRoute([], "GET", "/anything")).toBeNull();
-        });
-        it("should return first matching route", () => {
-            const overlappingRoutes = [
-                {
-                    method: "GET",
-                    pattern: /^\/overlapping$/,
-                    handler: mockHandler,
-                    paramMap: [],
-                },
-                {
-                    method: "GET",
-                    pattern: /^\/overlapping$/, // duplicate pattern
-                    handler: () => Promise.resolve("second"),
-                    paramMap: [],
-                },
-            ];
-            const match = findMatchingRoute(overlappingRoutes, "GET", "/overlapping");
-            expect(match?.handler).toBe(mockHandler); // Should match the first one
-        });
-    });
-});