@zapier/zapier-sdk 0.18.3 → 0.19.0

package/dist/types/telemetry-events.js

@@ -1,8 +0,0 @@
-/**
- * Event emission types matching Avro schemas for SDK telemetry
- *
- * These interfaces correspond to the Avro schemas:
- * - application_lifecycle_event.avsc
- * - error_occurred_event.avsc
- */
-export {};

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

@@ -1,31 +0,0 @@
-/**
- * Array utility functions for working with async iterators and arrays
- */
-/**
- * Creates an array from an async iterable, similar to Array.from() but for async iterables
- *
- * @param asyncIterable - An async iterable to convert to an array
- * @returns Promise that resolves to an array containing all items from the async iterable
- *
- * @example
- * async function* generateNumbers() {
- *   yield 1;
- *   yield 2;
- *   yield 3;
- * }
- *
- * const numbers = await fromAsync(generateNumbers()); // [1, 2, 3]
- *
- * @example
- * // With async generator that fetches data
- * async function* fetchUsers() {
- *   for (let page = 1; page <= 3; page++) {
- *     const users = await fetchUsersPage(page);
- *     yield* users;
- *   }
- * }
- *
- * const allUsers = await fromAsync(fetchUsers());
- */
-export declare function toArrayFromAsync<T>(asyncIterable: AsyncIterable<T>): Promise<T[]>;
-//# sourceMappingURL=array-utils.d.ts.map

package/dist/utils/array-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"array-utils.d.ts","sourceRoot":"","sources":["../../src/utils/array-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,gBAAgB,CAAC,CAAC,EACtC,aAAa,EAAE,aAAa,CAAC,CAAC,CAAC,GAC9B,OAAO,CAAC,CAAC,EAAE,CAAC,CAQd"}

package/dist/utils/array-utils.js

@@ -1,36 +0,0 @@
-/**
- * Array utility functions for working with async iterators and arrays
- */
-/**
- * Creates an array from an async iterable, similar to Array.from() but for async iterables
- *
- * @param asyncIterable - An async iterable to convert to an array
- * @returns Promise that resolves to an array containing all items from the async iterable
- *
- * @example
- * async function* generateNumbers() {
- *   yield 1;
- *   yield 2;
- *   yield 3;
- * }
- *
- * const numbers = await fromAsync(generateNumbers()); // [1, 2, 3]
- *
- * @example
- * // With async generator that fetches data
- * async function* fetchUsers() {
- *   for (let page = 1; page <= 3; page++) {
- *     const users = await fetchUsersPage(page);
- *     yield* users;
- *   }
- * }
- *
- * const allUsers = await fromAsync(fetchUsers());
- */
-export async function toArrayFromAsync(asyncIterable) {
-    const result = [];
-    for await (const item of asyncIterable) {
-        result.push(item);
-    }
-    return result;
-}

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

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

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

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

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

@@ -1,107 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { toArrayFromAsync } from "./array-utils";
-describe("array-utils", () => {
-    describe("fromAsync", () => {
-        it("should convert async generator to array", async () => {
-            async function* generateNumbers() {
-                yield 1;
-                yield 2;
-                yield 3;
-            }
-            const result = await toArrayFromAsync(generateNumbers());
-            expect(result).toEqual([1, 2, 3]);
-        });
-        it("should handle empty async generator", async () => {
-            async function* generateNothing() {
-                // yield nothing
-            }
-            const result = await toArrayFromAsync(generateNothing());
-            expect(result).toEqual([]);
-        });
-        it("should handle async generator with async operations", async () => {
-            async function* generateWithDelay() {
-                for (let i = 1; i <= 3; i++) {
-                    await new Promise((resolve) => setTimeout(resolve, 1)); // Small delay
-                    yield i * 10;
-                }
-            }
-            const result = await toArrayFromAsync(generateWithDelay());
-            expect(result).toEqual([10, 20, 30]);
-        });
-        it("should handle async generator that yields different types", async () => {
-            async function* generateMixed() {
-                yield "hello";
-                yield 42;
-                yield { name: "test" };
-                yield [1, 2, 3];
-            }
-            const result = await toArrayFromAsync(generateMixed());
-            expect(result).toEqual(["hello", 42, { name: "test" }, [1, 2, 3]]);
-        });
-        it("should handle async generator with error", async () => {
-            async function* generateWithError() {
-                yield 1;
-                yield 2;
-                throw new Error("Test error");
-            }
-            await expect(toArrayFromAsync(generateWithError())).rejects.toThrow("Test error");
-        });
-        it("should handle async iterable from array with Symbol.asyncIterator", async () => {
-            const asyncIterable = {
-                async *[Symbol.asyncIterator]() {
-                    for (const item of ["a", "b", "c"]) {
-                        yield item;
-                    }
-                },
-            };
-            const result = await toArrayFromAsync(asyncIterable);
-            expect(result).toEqual(["a", "b", "c"]);
-        });
-        it("should handle large async generator efficiently", async () => {
-            async function* generateLargeSequence() {
-                for (let i = 0; i < 1000; i++) {
-                    yield i;
-                }
-            }
-            const result = await toArrayFromAsync(generateLargeSequence());
-            expect(result).toHaveLength(1000);
-            expect(result[0]).toBe(0);
-            expect(result[999]).toBe(999);
-        });
-        it("should handle async generator that yields promises (promises are auto-awaited)", async () => {
-            async function* generatePromises() {
-                yield Promise.resolve("first");
-                yield Promise.resolve("second");
-            }
-            const result = await toArrayFromAsync(generatePromises());
-            // for await automatically awaits promises, so we get resolved values
-            expect(result).toEqual(["first", "second"]);
-        });
-        it("should handle async generator that yields already resolved values", async () => {
-            async function* generateResolvedValues() {
-                yield await Promise.resolve("first");
-                yield await Promise.resolve("second");
-            }
-            const result = await toArrayFromAsync(generateResolvedValues());
-            // The resolved values are yielded directly
-            expect(result).toEqual(["first", "second"]);
-        });
-        it("should maintain order of async generator items", async () => {
-            async function* generateInOrder() {
-                for (let i = 1; i <= 5; i++) {
-                    // Simulate varying delays
-                    await new Promise((resolve) => setTimeout(resolve, Math.random() * 10));
-                    yield `item-${i}`;
-                }
-            }
-            const result = await toArrayFromAsync(generateInOrder());
-            expect(result).toEqual([
-                "item-1",
-                "item-2",
-                "item-3",
-                "item-4",
-                "item-5",
-            ]);
-        });
-    });
-});

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

@@ -1,72 +0,0 @@
-/**
- * Batch Operation Utilities
- *
- * This module provides utilities for executing multiple async operations
- * with concurrency control and retry logic.
- */
-/**
- * Options for batch execution
- */
-export interface BatchOptions {
-    /**
-     * Maximum number of concurrent operations (default: 10)
-     * Lower values are more "polite" but slower
-     * Higher values are faster but risk rate limits
-     */
-    concurrency?: number;
-    /**
-     * Whether to retry failed operations (default: true)
-     * When enabled, each operation gets up to MAX_CONSECUTIVE_ERRORS retries
-     */
-    retry?: boolean;
-    /**
-     * Delay in milliseconds between starting batches (default: 100ms)
-     * Adds a small delay between concurrent batches to avoid burst patterns
-     */
-    batchDelay?: number;
-    /**
-     * Overall timeout for the entire batch operation in milliseconds (default: 180000ms / 3 minutes)
-     * When exceeded, throws ZapierTimeoutError and stops processing remaining tasks
-     */
-    timeoutMs?: number;
-    /**
-     * Timeout for individual tasks in milliseconds (default: none)
-     * When set, each task will be cancelled if it exceeds this duration
-     * Tasks that timeout will be marked as rejected in the results
-     */
-    taskTimeoutMs?: number;
-}
-/**
- * Execute multiple async operations with concurrency limiting and retry logic
- *
- * This prevents overwhelming APIs by:
- * 1. Limiting concurrent operations (worker pool pattern)
- * 2. Adding small delays between batches to avoid burst detection
- * 3. Retrying failed operations with exponential backoff
- *
- * Problem Solved:
- * - Rate limit prevention: Steady stream instead of burst requests
- * - Connection pool management: Stays within browser/Node limits (~6-8 per domain)
- * - Resilience: Transient failures are retried automatically
- * - Observability: Returns detailed success/failure info for each operation
- *
- * Example Usage:
- * ```typescript
- * // Instead of Promise.allSettled (fires all at once):
- * const results = await Promise.allSettled(
- *   actions.map(a => sdk.listInputFields(a))
- * );
- *
- * // Use batch (controlled concurrency):
- * const results = await batch(
- *   actions.map(a => () => sdk.listInputFields(a)),
- *   { concurrency: 10, retry: true }
- * );
- * ```
- *
- * @param tasks - Array of functions that return promises (NOT promises themselves!)
- * @param options - Configuration for concurrency and retry behavior
- * @returns Promise resolving to array of settled results (same as Promise.allSettled)
- */
-export declare function batch<T>(tasks: (() => Promise<T>)[], options?: BatchOptions): Promise<PromiseSettledResult<T>[]>;
-//# sourceMappingURL=batch-utils.d.ts.map

package/dist/utils/batch-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"batch-utils.d.ts","sourceRoot":"","sources":["../../src/utils/batch-utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAwBH;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAWD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAsB,KAAK,CAAC,CAAC,EAC3B,KAAK,EAAE,CAAC,MAAM,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,EAC3B,OAAO,GAAE,YAAiB,GACzB,OAAO,CAAC,oBAAoB,CAAC,CAAC,CAAC,EAAE,CAAC,CAuIpC"}

package/dist/utils/batch-utils.js

@@ -1,162 +0,0 @@
-/**
- * Batch Operation Utilities
- *
- * This module provides utilities for executing multiple async operations
- * with concurrency control and retry logic.
- */
-import { setTimeout } from "timers/promises";
-import { calculateWaitTime, MAX_CONSECUTIVE_ERRORS } from "./retry-utils";
-import { ZapierTimeoutError } from "../types/errors";
-/**
- * Default number of concurrent operations
- * Chosen to be "polite" to APIs while still providing good throughput
- */
-const DEFAULT_CONCURRENCY = 10;
-/**
- * Delay between starting each batch of concurrent operations (milliseconds)
- * This prevents burst patterns that might trigger rate limiting
- */
-const BATCH_START_DELAY_MS = 25;
-/**
- * Default timeout for entire batch operation (milliseconds)
- * Set to 3 minutes to match polling default timeout
- */
-const DEFAULT_BATCH_TIMEOUT_MS = 180000;
-/**
- * Execute multiple async operations with concurrency limiting and retry logic
- *
- * This prevents overwhelming APIs by:
- * 1. Limiting concurrent operations (worker pool pattern)
- * 2. Adding small delays between batches to avoid burst detection
- * 3. Retrying failed operations with exponential backoff
- *
- * Problem Solved:
- * - Rate limit prevention: Steady stream instead of burst requests
- * - Connection pool management: Stays within browser/Node limits (~6-8 per domain)
- * - Resilience: Transient failures are retried automatically
- * - Observability: Returns detailed success/failure info for each operation
- *
- * Example Usage:
- * ```typescript
- * // Instead of Promise.allSettled (fires all at once):
- * const results = await Promise.allSettled(
- *   actions.map(a => sdk.listInputFields(a))
- * );
- *
- * // Use batch (controlled concurrency):
- * const results = await batch(
- *   actions.map(a => () => sdk.listInputFields(a)),
- *   { concurrency: 10, retry: true }
- * );
- * ```
- *
- * @param tasks - Array of functions that return promises (NOT promises themselves!)
- * @param options - Configuration for concurrency and retry behavior
- * @returns Promise resolving to array of settled results (same as Promise.allSettled)
- */
-export async function batch(tasks, options = {}) {
-    const { concurrency = DEFAULT_CONCURRENCY, retry = true, batchDelay = BATCH_START_DELAY_MS, timeoutMs = DEFAULT_BATCH_TIMEOUT_MS, taskTimeoutMs, } = options;
-    // Validate inputs
-    if (concurrency <= 0) {
-        throw new Error("Concurrency must be greater than 0");
-    }
-    if (timeoutMs <= 0) {
-        throw new Error("Timeout must be greater than 0");
-    }
-    if (taskTimeoutMs !== undefined && taskTimeoutMs <= 0) {
-        throw new Error("Task timeout must be greater than 0");
-    }
-    if (tasks.length === 0) {
-        return [];
-    }
-    // Track overall batch timing
-    const startTime = Date.now();
-    // Pre-allocate results array to maintain input order
-    const results = new Array(tasks.length);
-    // Create task queue with retry state
-    const taskQueue = tasks.map((task, index) => ({
-        index,
-        task,
-        errorCount: 0,
-    }));
-    /**
-     * Execute a single task with retry logic and optional per-task timeout
-     */
-    async function executeTask(taskState) {
-        const { index, task, errorCount } = taskState;
-        try {
-            let result;
-            // Apply per-task timeout if specified
-            if (taskTimeoutMs !== undefined) {
-                const timeoutPromise = setTimeout(taskTimeoutMs).then(() => {
-                    throw new ZapierTimeoutError(`Task timed out after ${taskTimeoutMs}ms`);
-                });
-                result = await Promise.race([task(), timeoutPromise]);
-            }
-            else {
-                result = await task();
-            }
-            results[index] = { status: "fulfilled", value: result };
-        }
-        catch (error) {
-            const newErrorCount = errorCount + 1;
-            // Don't retry timeout errors - they're unlikely to succeed on retry
-            const isTimeout = error instanceof ZapierTimeoutError;
-            // If retry is enabled and we haven't hit max errors and it's not a timeout, retry with backoff
-            if (retry && !isTimeout && newErrorCount < MAX_CONSECUTIVE_ERRORS) {
-                // Calculate backoff delay (base 1000ms with jitter and error scaling)
-                const waitTime = calculateWaitTime(1000, newErrorCount);
-                await setTimeout(waitTime);
-                // Re-queue the task with incremented error count
-                taskQueue.push({
-                    index,
-                    task,
-                    errorCount: newErrorCount,
-                });
-            }
-            else {
-                // Max retries reached, retry disabled, or timeout error - mark as rejected
-                results[index] = { status: "rejected", reason: error };
-            }
-        }
-    }
-    /**
-     * Worker that continuously picks up and executes tasks from the queue
-     * Checks overall batch timeout before processing each task
-     */
-    async function worker() {
-        while (taskQueue.length > 0) {
-            // Check overall batch timeout before processing next task
-            const elapsedTime = Date.now() - startTime;
-            if (elapsedTime >= timeoutMs) {
-                throw new ZapierTimeoutError(`Batch operation timed out after ${Math.floor(elapsedTime / 1000)}s. ${taskQueue.length} task(s) not completed.`);
-            }
-            const taskState = taskQueue.shift();
-            if (!taskState)
-                break;
-            await executeTask(taskState);
-            // Small delay to prevent burst patterns within a worker
-            // Only delay if there are more tasks to process
-            if (taskQueue.length > 0 && batchDelay > 0) {
-                await setTimeout(batchDelay);
-            }
-        }
-    }
-    /**
-     * Start workers in small batches to avoid initial burst
-     * This helps avoid rate limit triggers when starting many workers
-     */
-    const workerCount = Math.min(concurrency, tasks.length);
-    const workers = [];
-    for (let i = 0; i < workerCount; i++) {
-        workers.push(worker());
-        // Add small delay between starting workers to stagger the initial requests
-        // Skip delay for last worker
-        if (i < workerCount - 1 && batchDelay > 0) {
-            await setTimeout(batchDelay / 10); // 10ms between worker starts
-        }
-    }
-    // Wait for all workers to complete
-    await Promise.all(workers);
-    return results;
-}

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

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

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

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