@zapier/zapier-sdk 0.18.3 → 0.19.0

package/dist/utils/pagination-utils.js

@@ -1,165 +0,0 @@
-const offsetCursorMarker = "$$offset$$";
-function splitOffsetCursor(cursor) {
-    if (!cursor) {
-        return [0, cursor];
-    }
-    try {
-        const parsedCursor = JSON.parse(cursor);
-        if (!Array.isArray(parsedCursor)) {
-            return [0, cursor];
-        }
-        const [marker, offset, currentCursor] = parsedCursor;
-        if (marker !== offsetCursorMarker) {
-            return [0, cursor];
-        }
-        if (typeof offset !== "number") {
-            return [0, cursor];
-        }
-        return [offset, currentCursor];
-    }
-    catch {
-        return [0, cursor];
-    }
-}
-function createOffsetCursor(offset, currentCursor) {
-    return JSON.stringify([offsetCursorMarker, offset, currentCursor]);
-}
-export function createPrefixedCursor(prefix, cursor) {
-    if (!cursor) {
-        return `${prefix}::`;
-    }
-    return `${prefix}::${cursor}`;
-}
-export function splitPrefixedCursor(cursor, prefixes) {
-    if (!cursor) {
-        return [undefined, undefined];
-    }
-    const [prefix, ...rest] = cursor.split("::");
-    if (prefixes && !prefixes.includes(prefix)) {
-        return [undefined, cursor];
-    }
-    cursor = rest.join("::");
-    if (!cursor) {
-        return [prefix, undefined];
-    }
-    return [prefix, cursor];
-}
-/**
- * Utility for paginating through API endpoints that return cursor-based pages
- *
- * @param pageFunction - Function that fetches a single page with {data, nextCursor} structure
- * @param pageOptions - Options to pass to the page function (cursor will be managed automatically)
- * @returns Async iterator that yields pages
- */
-export async function* paginateMaxItems(pageFunction, pageOptions) {
-    let cursor = pageOptions?.cursor;
-    let totalItemsYielded = 0;
-    const maxItems = pageOptions?.maxItems;
-    const pageSize = pageOptions?.pageSize;
-    do {
-        const options = {
-            ...(pageOptions || {}),
-            cursor,
-            pageSize: maxItems !== undefined && pageSize !== undefined
-                ? Math.min(pageSize, maxItems)
-                : pageSize,
-        };
-        const page = await pageFunction(options);
-        if (maxItems !== undefined) {
-            const remainingItems = maxItems - totalItemsYielded;
-            if (page.data.length >= remainingItems) {
-                const yieldedPage = {
-                    ...page,
-                    data: page.data.slice(0, remainingItems),
-                    nextCursor: undefined,
-                };
-                yield yieldedPage;
-                break;
-            }
-        }
-        yield page;
-        totalItemsYielded += page.data.length;
-        cursor = page.nextCursor;
-    } while (cursor);
-}
-export async function* paginateBuffered(pageFunction, pageOptions) {
-    const pageSize = pageOptions?.pageSize;
-    const [cursorOffset, currentCursor] = splitOffsetCursor(pageOptions?.cursor);
-    const options = {
-        ...(pageOptions || {}),
-        cursor: currentCursor,
-    };
-    const iterator = paginateMaxItems(pageFunction, options);
-    let bufferedPages = [];
-    let isFirstPage = true;
-    let cursor;
-    for await (let page of iterator) {
-        if (isFirstPage) {
-            isFirstPage = false;
-            if (cursorOffset) {
-                page = {
-                    ...page,
-                    data: page.data.slice(cursorOffset),
-                };
-            }
-        }
-        if (!pageSize) {
-            yield page;
-            cursor = page.nextCursor;
-            continue;
-        }
-        const bufferedLength = bufferedPages.reduce((acc, page) => acc + page.data.length, 0);
-        // If we don't have enough to fill a page, buffer this page.
-        if (bufferedLength + page.data.length < pageSize) {
-            bufferedPages.push(page);
-            cursor = page.nextCursor;
-            continue;
-        }
-        // Let's yield a page from our buffered pages.
-        const bufferedItems = bufferedPages.map((p) => p.data).flat();
-        const allItems = [...bufferedItems, ...page.data];
-        const pageItems = allItems.slice(0, pageSize);
-        const remainingItems = allItems.slice(pageItems.length);
-        // No extra items to buffer, so we can just yield a normal page with a cursor to the next one.
-        if (remainingItems.length === 0) {
-            yield {
-                ...page,
-                data: pageItems,
-                nextCursor: page.nextCursor,
-            };
-            bufferedPages = [];
-            cursor = page.nextCursor;
-            continue;
-        }
-        // Yield our items with a cursor to offset into this page.
-        yield {
-            ...page,
-            data: pageItems,
-            nextCursor: createOffsetCursor(page.data.length - remainingItems.length, cursor),
-        };
-        while (remainingItems.length > pageSize) {
-            const pageItems = remainingItems.splice(0, pageSize);
-            yield {
-                ...page,
-                data: pageItems,
-                nextCursor: createOffsetCursor(page.data.length - remainingItems.length, cursor),
-            };
-        }
-        bufferedPages = [
-            {
-                ...page,
-                data: remainingItems,
-            },
-        ];
-        cursor = page.nextCursor;
-    }
-    if (bufferedPages.length > 0) {
-        const lastBufferedPage = bufferedPages.slice(-1)[0];
-        const bufferedItems = bufferedPages.map((p) => p.data).flat();
-        yield {
-            ...lastBufferedPage,
-            data: bufferedItems,
-        };
-    }
-}
-export const paginate = paginateBuffered;

package/dist/utils/pagination-utils.test.d.ts

@@ -1,17 +0,0 @@
-export declare const ALL_ITEMS: {
-    id: number;
-    name: string;
-}[];
-export declare function listTestItems(options: {
-    pageSize?: number;
-    cursor?: string;
-    filter?: string;
-    maxItems?: number;
-}): Promise<{
-    data: {
-        id: number;
-        name: string;
-    }[];
-    nextCursor: string | undefined;
-}>;
-//# sourceMappingURL=pagination-utils.test.d.ts.map

package/dist/utils/pagination-utils.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pagination-utils.test.d.ts","sourceRoot":"","sources":["../../src/utils/pagination-utils.test.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,SAAS;;;GAGnB,CAAC;AAGJ,wBAAsB,aAAa,CAAC,OAAO,EAAE;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;;;;;;GA6CA"}

package/dist/utils/pagination-utils.test.js

@@ -1,461 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { paginate, paginateMaxItems } from "./pagination-utils";
-// Test data set - simulating a large dataset with cursor-based pagination
-export const ALL_ITEMS = Array.from({ length: 25 }, (_, i) => ({
-    id: i + 1,
-    name: `Item ${i + 1}`,
-}));
-// Test page function that implements cursor-based pagination logic
-export async function listTestItems(options) {
-    const { pageSize = 5, cursor, filter, maxItems } = options;
-    // Cap pageSize at 10 to simulate real API limits
-    let actualPageSize = Math.min(pageSize, 10);
-    // If maxItems hint is provided, further limit the page size for optimization
-    if (maxItems !== undefined && maxItems > 0) {
-        actualPageSize = Math.min(actualPageSize, maxItems);
-    }
-    // Filter items if filter is provided
-    let items = ALL_ITEMS;
-    if (filter) {
-        items = items.filter((item) => item.name.toLowerCase().includes(filter.toLowerCase()));
-    }
-    // Find starting position based on cursor
-    let startIndex = 0;
-    if (cursor) {
-        // Cursor format: "cursor-{itemId}"
-        const cursorId = parseInt(cursor.replace("cursor-", ""));
-        startIndex = items.findIndex((item) => item.id > cursorId);
-        if (startIndex === -1) {
-            // No more items after cursor
-            return { data: [], nextCursor: undefined };
-        }
-    }
-    // Get page of items
-    const pageItems = items.slice(startIndex, startIndex + actualPageSize);
-    // Determine next cursor
-    let nextCursor;
-    if (startIndex + actualPageSize < items.length && pageItems.length > 0) {
-        const lastItem = pageItems[pageItems.length - 1];
-        nextCursor = `cursor-${lastItem.id}`;
-    }
-    return {
-        data: pageItems,
-        nextCursor,
-    };
-}
-describe("paginate", () => {
-    it("should paginate through multiple pages", async () => {
-        const pageIterator = paginate(listTestItems, { pageSize: 3 });
-        const pages = [];
-        for await (const page of pageIterator) {
-            pages.push(page);
-        }
-        // With 25 items and pageSize 3, should have 9 pages (8 full + 1 partial)
-        expect(pages).toHaveLength(9);
-        // Check first page
-        expect(pages[0]).toEqual({
-            data: ALL_ITEMS.slice(0, 3),
-            nextCursor: "cursor-3",
-        });
-        // Check second page (cursor should be passed correctly)
-        expect(pages[1]).toEqual({
-            data: ALL_ITEMS.slice(3, 6),
-            nextCursor: "cursor-6",
-        });
-        // Check last page (should have no nextCursor)
-        expect(pages[8]).toEqual({
-            data: ALL_ITEMS.slice(24, 25),
-            nextCursor: undefined,
-        });
-        // Verify we got all 25 items across all pages
-        const allItems = pages.flatMap((page) => page.data);
-        expect(allItems).toHaveLength(25);
-    });
-    it("should cap pageSize at 10 when unbuffered", async () => {
-        // Use a page size larger than 10, should get capped
-        const pageIterator = paginateMaxItems(listTestItems, { pageSize: 50 });
-        const pages = [];
-        for await (const page of pageIterator) {
-            pages.push(page);
-        }
-        // Should get 3 pages: 10+10+5=25 (pageSize capped at 10)
-        expect(pages).toHaveLength(3);
-        expect(pages[0].data).toHaveLength(10); // First page capped at 10
-        expect(pages[1].data).toHaveLength(10); // Second page capped at 10
-        expect(pages[2].data).toHaveLength(5); // Last page has remaining 5
-        expect(pages[2].nextCursor).toBeUndefined(); // Last page has no nextCursor
-    });
-    it("should not cap pageSize when buffered", async () => {
-        const pageIterator = paginate(listTestItems, { pageSize: 50 });
-        for await (const page of pageIterator) {
-            expect(page.data).toHaveLength(25);
-            break;
-        }
-    });
-    it("should not cap pageSize when buffered", async () => {
-        const pageIterator = paginate(listTestItems, { pageSize: 15 });
-        const pages = [];
-        for await (const page of pageIterator) {
-            pages.push(page);
-        }
-        expect(pages).toHaveLength(2);
-        expect(pages[0].data).toHaveLength(15);
-        expect(pages[1].data).toHaveLength(10);
-    });
-    it("should continue from pseudo cursor", async () => {
-        const pageIterator = paginate(listTestItems, { pageSize: 15 });
-        const pages = [];
-        for await (const page of pageIterator) {
-            pages.push(page);
-            break;
-        }
-        const nextPageIterator = paginate(listTestItems, {
-            pageSize: 15,
-            cursor: pages[0].nextCursor,
-        });
-        for await (const page of nextPageIterator) {
-            pages.push(page);
-        }
-        expect(pages).toHaveLength(2);
-        expect(pages[0].data).toHaveLength(15);
-        expect(pages[1].data).toHaveLength(10);
-    });
-    it("should handle filtered results", async () => {
-        // Filter for items containing "1" (should match Item 1, Item 10-19, Item 21)
-        const pageIterator = paginate(listTestItems, {
-            pageSize: 4,
-            filter: "1",
-        });
-        const pages = [];
-        for await (const page of pageIterator) {
-            pages.push(page);
-        }
-        // Should have multiple pages due to pageSize: 4
-        expect(pages.length).toBeGreaterThan(1);
-        // All items should contain "1"
-        const allItems = pages.flatMap((page) => page.data);
-        expect(allItems.every((item) => item.name.includes("1"))).toBe(true);
-        // Should include items like Item 1, Item 10, Item 11, etc.
-        expect(allItems).toContainEqual(ALL_ITEMS[0]); // Item 1
-        expect(allItems).toContainEqual(ALL_ITEMS[9]); // Item 10
-        expect(allItems).toContainEqual(ALL_ITEMS[20]); // Item 21
-    });
-    it("should handle empty results", async () => {
-        // Filter that matches no items
-        const pageIterator = paginate(listTestItems, {
-            pageSize: 10,
-            filter: "nonexistent",
-        });
-        const pages = [];
-        for await (const page of pageIterator) {
-            pages.push(page);
-        }
-        expect(pages).toHaveLength(1);
-        expect(pages[0]).toEqual({
-            data: [],
-            nextCursor: undefined,
-        });
-    });
-    it("should pass through errors from the page function", async () => {
-        // Create a page function that throws an error
-        const errorPageFunction = async () => {
-            throw new Error("Page function failed");
-        };
-        const pageIterator = paginate(errorPageFunction, {});
-        let reachedUnreachableCode = undefined;
-        await expect(async () => {
-            for await (const page of pageIterator) {
-                // Should never reach here due to error
-                reachedUnreachableCode = page;
-            }
-        }).rejects.toThrow("Page function failed");
-        // Verify we never reached the unreachable code
-        expect(reachedUnreachableCode).toBeUndefined();
-    });
-    it("should start pagination from provided cursor", async () => {
-        // Test that pagination can start from a specific cursor position
-        const pageIterator = paginate(listTestItems, {
-            pageSize: 3,
-            cursor: "cursor-5", // Start after item 5
-        });
-        const pages = [];
-        for await (const page of pageIterator) {
-            pages.push(page);
-            if (pages.length >= 2)
-                break; // Just test first 2 pages
-        }
-        expect(pages).toHaveLength(2);
-        // First page should start after cursor-5 (from item 6)
-        expect(pages[0].data[0]).toEqual(ALL_ITEMS[5]); // Item 6
-        // Second page should continue properly
-        expect(pages[1].data[0]).toEqual(ALL_ITEMS[8]); // Item 9
-    });
-    it("should allow breaking out of pagination early", async () => {
-        // Test that users can break out of the iterator manually
-        const pageIterator = paginate(listTestItems, { pageSize: 3 });
-        const pages = [];
-        for await (const page of pageIterator) {
-            pages.push(page);
-            // Break after getting 3 pages
-            if (pages.length >= 3) {
-                break;
-            }
-        }
-        // Should have stopped at exactly 3 pages with 9 items (3+3+3=9)
-        const allItems = pages.flatMap((page) => page.data);
-        expect(allItems).toHaveLength(9);
-        expect(pages).toHaveLength(3);
-        // Should be first 9 items
-        expect(allItems).toEqual(ALL_ITEMS.slice(0, 9));
-    });
-    describe("conditional types for optional options", () => {
-        it("should work with function that takes no options", async () => {
-            async function fetchWithNoOptions(_options) {
-                return { data: [1, 2, 3] };
-            }
-            const pages = [];
-            for await (const page of paginate(fetchWithNoOptions)) {
-                pages.push(...page.data);
-            }
-            expect(pages).toEqual([1, 2, 3]);
-        });
-        it("should work with function that takes optional options", async () => {
-            async function fetchWithOptionalOptions(options) {
-                return { data: [`page-${options?.cursor || "1"}`] };
-            }
-            const pages = [];
-            for await (const page of paginate(fetchWithOptionalOptions, {
-                limit: 5,
-            })) {
-                pages.push(...page.data);
-            }
-            expect(pages).toEqual(["page-1"]);
-        });
-        it("should work with function that takes only cursor", async () => {
-            async function fetchWithOnlyCursor(_options) {
-                return { data: [true] };
-            }
-            const pages = [];
-            for await (const page of paginate(fetchWithOnlyCursor, {
-                cursor: "start",
-            })) {
-                pages.push(...page.data);
-            }
-            expect(pages).toEqual([true]);
-        });
-        it("should work when baseOptions is omitted entirely", async () => {
-            async function fetchSimple(_options) {
-                return { data: ["simple"] };
-            }
-            const pages = [];
-            for await (const page of paginate(fetchSimple)) {
-                pages.push(...page.data);
-            }
-            expect(pages).toEqual(["simple"]);
-        });
-    });
-    describe("maxItems functionality", () => {
-        it("should limit total items across pages", async () => {
-            const items = [];
-            for await (const page of paginate(listTestItems, {
-                pageSize: 3,
-                maxItems: 7,
-            })) {
-                items.push(...page.data);
-            }
-            expect(items).toHaveLength(7);
-            expect(items).toEqual(ALL_ITEMS.slice(0, 7));
-        });
-        it("should truncate the final page when maxItems is exceeded", async () => {
-            // Create a function that ignores maxItems hint to force truncation
-            async function fetchIgnoringMaxItems(options) {
-                return listTestItems({
-                    pageSize: options.pageSize,
-                    cursor: options.cursor,
-                });
-            }
-            const pageData = [];
-            for await (const page of paginate(fetchIgnoringMaxItems, {
-                pageSize: 3,
-                maxItems: 7,
-            })) {
-                pageData.push(page);
-            }
-            // Should have 3 pages: [3 items], [3 items], [1 item (truncated)]
-            expect(pageData).toHaveLength(3);
-            expect(pageData[0].data).toHaveLength(3);
-            expect(pageData[1].data).toHaveLength(3);
-            expect(pageData[2].data).toHaveLength(1); // Truncated page
-            expect(pageData[2].nextCursor).toBeUndefined(); // Should clear cursor
-        });
-        it("should stop early when maxItems is exactly a page boundary", async () => {
-            const items = [];
-            for await (const page of paginate(listTestItems, {
-                pageSize: 3,
-                maxItems: 6,
-            })) {
-                items.push(...page.data);
-            }
-            expect(items).toHaveLength(6);
-            expect(items).toEqual(ALL_ITEMS.slice(0, 6));
-        });
-        it("should handle maxItems of 0", async () => {
-            const items = [];
-            for await (const page of paginate(listTestItems, {
-                pageSize: 3,
-                maxItems: 0,
-            })) {
-                items.push(...page.data);
-            }
-            expect(items).toHaveLength(0);
-        });
-        it("should work normally when maxItems is larger than total items", async () => {
-            const items = [];
-            for await (const page of paginate(listTestItems, {
-                pageSize: 3,
-                maxItems: 100,
-            })) {
-                items.push(...page.data);
-            }
-            // Should get all items since limit is higher than total
-            expect(items).toEqual(ALL_ITEMS);
-        });
-        it("should work with maxItems and other options combined", async () => {
-            async function fetchWithLimit(options) {
-                const start = parseInt(options.cursor || "0");
-                let limit = options.limit;
-                // Apply maxItems hint for optimization
-                if (options.maxItems !== undefined && options.maxItems > 0) {
-                    limit = Math.min(limit, options.maxItems);
-                }
-                const items = ALL_ITEMS.slice(start, start + limit);
-                const nextCursor = start + limit < ALL_ITEMS.length
-                    ? (start + limit).toString()
-                    : undefined;
-                return { data: items, nextCursor };
-            }
-            const items = [];
-            for await (const page of paginate(fetchWithLimit, {
-                limit: 2,
-                maxItems: 5,
-            })) {
-                items.push(...page.data);
-            }
-            expect(items).toHaveLength(5);
-            expect(items).toEqual(ALL_ITEMS.slice(0, 5));
-        });
-        it("should preserve original page structure except for truncation", async () => {
-            // Create a function that ignores maxItems hint to force truncation
-            async function fetchIgnoringMaxItems(options) {
-                const pageSize = options.pageSize || 3;
-                const start = options.cursor
-                    ? parseInt(options.cursor.replace("cursor-", "")) + 1
-                    : 0;
-                const items = ALL_ITEMS.slice(start, start + pageSize);
-                const nextCursor = start + pageSize <= ALL_ITEMS.length
-                    ? `cursor-${ALL_ITEMS[start + pageSize - 1].id}`
-                    : undefined;
-                return { data: items, nextCursor };
-            }
-            let pageCount = 0;
-            for await (const page of paginate(fetchIgnoringMaxItems, {
-                pageSize: 3,
-                maxItems: 7,
-            })) {
-                pageCount++;
-                // All pages should have the expected structure
-                expect(page).toHaveProperty("data");
-                expect(Array.isArray(page.data)).toBe(true);
-                if (pageCount === 3) {
-                    // Final truncated page
-                    expect(page.data).toHaveLength(1);
-                    expect(page.nextCursor).toBeUndefined();
-                }
-                else {
-                    // Regular pages
-                    expect(page.data).toHaveLength(3);
-                    expect(typeof page.nextCursor).toBe("string");
-                }
-            }
-            expect(pageCount).toBe(3);
-        });
-        it("should handle API that ignores pageSize and returns more items on first page", async () => {
-            // Simulate an API that ignores pageSize and always returns 10 items per page
-            async function apiIgnoresPageSize(options) {
-                return listTestItems({
-                    cursor: options.cursor,
-                    pageSize: 10,
-                });
-            }
-            const pages = [];
-            // User requests pageSize: 3, but API returns 10 per page
-            for await (const page of paginate(apiIgnoresPageSize, {
-                pageSize: 3,
-            })) {
-                pages.push(page);
-                // Only get first page to test the behavior
-                break;
-            }
-            // Should get 1 page with only 3 items (paginate enforces pageSize limit)
-            expect(pages).toHaveLength(1);
-            expect(pages[0].data).toHaveLength(3);
-            expect(pages[0].data).toEqual(ALL_ITEMS.slice(0, 3));
-            // Cursor should still be present since there are more items available
-            expect(pages[0].nextCursor).toBeDefined();
-        });
-        it("should truncate oversized API response to pageSize", async () => {
-            // API always returns 10 items, but user wants pageSize: 3
-            async function apiReturns10Items(options) {
-                return listTestItems({
-                    cursor: options.cursor,
-                    pageSize: 10,
-                });
-            }
-            const pages = [];
-            for await (const page of paginate(apiReturns10Items, {
-                pageSize: 3,
-            })) {
-                pages.push(page);
-            }
-            // Should truncate each 10-item API response to 3 items per page
-            expect(pages).toHaveLength(9);
-            expect(pages[0].data).toHaveLength(3);
-            expect(pages[1].data).toHaveLength(3);
-            expect(pages[8].data).toHaveLength(1);
-            // Verify items are from different API calls
-            expect(pages[0].data).toEqual(ALL_ITEMS.slice(0, 3)); // Items 1-3 from first API call
-            expect(pages[1].data).toEqual(ALL_ITEMS.slice(3, 6)); // Items 11-13 from second API call
-            expect(pages[8].data).toEqual(ALL_ITEMS.slice(24, 25)); // Items 21-23 from third API call
-            // All pages should have nextCursor since API has more data
-            expect(pages[0].nextCursor).toBe('["$$offset$$",3,null]');
-            expect(pages[8].nextCursor).toBeUndefined();
-        });
-        it("should handle pageSize enforcement with maxItems limit", async () => {
-            // API returns 10 items, user wants pageSize: 3, maxItems: 7
-            async function apiReturns10Items(options) {
-                return listTestItems({
-                    cursor: options.cursor,
-                    pageSize: 10,
-                });
-            }
-            const pages = [];
-            for await (const page of paginate(apiReturns10Items, {
-                pageSize: 3,
-                maxItems: 7,
-            })) {
-                pages.push(page);
-            }
-            // Should get: [3, 3, 1] items (total 7, respecting maxItems)
-            expect(pages).toHaveLength(3);
-            expect(pages[0].data).toHaveLength(3);
-            expect(pages[1].data).toHaveLength(3);
-            expect(pages[2].data).toHaveLength(1); // Truncated to respect maxItems
-            // Last page should have no nextCursor (maxItems reached)
-            expect(pages[2].nextCursor).toBeUndefined();
-            // Verify total items
-            const allItems = pages.flatMap((p) => p.data);
-            expect(allItems).toHaveLength(7);
-            expect(allItems).toEqual(ALL_ITEMS.slice(0, 7));
-        });
-    });
-});

package/dist/utils/retry-utils.d.ts

@@ -1,45 +0,0 @@
-/**
- * Retry and Backoff Utilities
- *
- * Shared utilities for implementing resilient retry logic with exponential backoff
- * and jitter. Used by both polling and batch operations.
- */
-/**
- * Maximum number of consecutive errors before giving up
- * Prevents infinite retry loops when the API is consistently failing
- */
-export declare const MAX_CONSECUTIVE_ERRORS = 3;
-/**
- * Base delay for error backoff in milliseconds
- * Each error adds this amount (with scaling) to the wait time
- */
-export declare const BASE_ERROR_BACKOFF_MS = 1000;
-/**
- * Jitter factor (0.0 to 1.0) for randomizing wait times
- * Prevents thundering herd problem when many clients retry simultaneously
- * A factor of 0.5 means we add 0-50% random variance to the base interval
- */
-export declare const JITTER_FACTOR = 0.5;
-/**
- * Calculate wait time with jitter and error backoff
- *
- * This implements two key reliability patterns:
- * 1. Jitter - Adds randomness to prevent synchronized retries across clients
- * 2. Error backoff - Increases wait time when errors occur, giving the API time to recover
- *
- * @param baseInterval - The base wait time in milliseconds
- * @param errorCount - Number of consecutive errors (0 if no errors)
- * @returns Wait time in milliseconds with jitter and error backoff applied
- *
- * @example
- * // No errors: returns 1000-1500ms (1000 + 0-500ms jitter)
- * calculateWaitTime(1000, 0);
- *
- * // 2 errors: returns 1000-1500ms base + up to 1000ms error backoff = 1000-2500ms
- * calculateWaitTime(1000, 2);
- *
- * // 6 errors: returns 1000-1500ms base + 2000ms capped backoff = 3000-3500ms
- * calculateWaitTime(1000, 6);
- */
-export declare function calculateWaitTime(baseInterval: number, errorCount: number): number;
-//# sourceMappingURL=retry-utils.d.ts.map