@zapier/zapier-sdk 0.77.0 → 0.77.2

package/dist/utils/retry-utils.js

@@ -1,97 +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 const MAX_CONSECUTIVE_ERRORS = 3;
-/**
- * Base delay for error backoff in milliseconds
- * Each error adds this amount (with scaling) to the wait time
- */
-export const BASE_ERROR_BACKOFF_MS = 1000;
-/**
- * Base delay for exponential backoff in milliseconds
- */
-export const BASE_EXPONENTIAL_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 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)
- * calculateErrorBackoffMs(1000, 0);
- *
- * // 2 errors: returns 1000-1500ms base + up to 1000ms error backoff = 1000-2500ms
- * calculateErrorBackoffMs(1000, 2);
- *
- * // 6 errors: returns 1000-1500ms base + 2000ms capped backoff = 3000-3500ms
- * calculateErrorBackoffMs(1000, 6);
- */
-export function calculateErrorBackoffMs(baseInterval, errorCount) {
-    // Jitter to avoid thundering herd (multiple clients retrying at exact same time)
-    const jitter = Math.random() * JITTER_FACTOR * baseInterval;
-    // Exponential backoff scaled by error count, but capped at 2x base interval
-    // This prevents wait times from growing unboundedly
-    const errorBackoff = Math.min(BASE_ERROR_BACKOFF_MS * (errorCount / 2), baseInterval * 2);
-    return Math.floor(baseInterval + jitter + errorBackoff);
-}
-/**
- * Calculate exponential backoff delay with jitter
- *
- * @param attempt - The attempt number (1-based)
- * @param baseDelayMs - Base delay in milliseconds (default: 1000)
- * @returns Delay in milliseconds: baseDelayMs * 2^(attempt-1) + jitter
- *
- * @example
- * calculateExponentialBackoffMs(1) // ~1000-1500ms
- * calculateExponentialBackoffMs(2) // ~2000-3000ms
- * calculateExponentialBackoffMs(3) // ~4000-6000ms
- */
-export function calculateExponentialBackoffMs(attempt, baseDelayMs = BASE_EXPONENTIAL_BACKOFF_MS) {
-    const baseDelay = baseDelayMs * Math.pow(2, attempt - 1);
-    const jitter = Math.random() * JITTER_FACTOR * baseDelay;
-    return Math.floor(baseDelay + jitter);
-}
-/**
- * Sleep for a specified number of milliseconds. If `signal` is provided
- * and aborts during the sleep, resolves early. Resolves rather than
- * rejecting on abort so callers don't need to wrap each sleep in a
- * try/catch — the next operation in the loop is the one that should
- * surface the cancellation (typically a fetch with the same signal).
- */
-export function sleep(ms, signal) {
-    if (!signal) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-    }
-    if (signal.aborted)
-        return Promise.resolve();
-    return new Promise((resolve) => {
-        const timer = setTimeout(() => {
-            signal.removeEventListener("abort", onAbort);
-            resolve();
-        }, ms);
-        const onAbort = () => {
-            clearTimeout(timer);
-            resolve();
-        };
-        signal.addEventListener("abort", onAbort, { once: true });
-    });
-}

package/dist/utils/should-open-browser.d.ts

@@ -1,24 +0,0 @@
-/**
- * Decide whether `createConnection` should attempt to auto-open a browser
- * tab. Used as the default for `browser: "auto"`. Callers can always force
- * with `browser: "always"` or `browser: "never"`.
- *
- * Returns `false` only when we're confident the open would land somewhere
- * the user can't act on:
- *
- *   1. CI — no human at the keyboard.
- *   2. SSH session — the browser would launch on the remote host, not on
- *      the user's local machine.
- *   3. Headless Linux — no display server means there's nowhere for a
- *      browser to land. (macOS / Windows are assumed to have a display.)
- *
- * Otherwise returns `true`. Notably this does NOT branch on `isTTY` or
- * any agent env-var allowlist — the URL is always printed to stderr
- * regardless, so a failed or skipped auto-open degrades gracefully to
- * "user copies the printed URL." We bias toward opening because the cost
- * of a false negative (user has to copy/paste) is small, while the cost
- * of a false positive (browser opens in the wrong place) only really
- * matters for the three scenarios above.
- */
-export declare function shouldOpenBrowser(): boolean;
-//# sourceMappingURL=should-open-browser.d.ts.map

package/dist/utils/should-open-browser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"should-open-browser.d.ts","sourceRoot":"","sources":["../../src/utils/should-open-browser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAY3C"}

package/dist/utils/should-open-browser.js

@@ -1,55 +0,0 @@
-/**
- * Decide whether `createConnection` should attempt to auto-open a browser
- * tab. Used as the default for `browser: "auto"`. Callers can always force
- * with `browser: "always"` or `browser: "never"`.
- *
- * Returns `false` only when we're confident the open would land somewhere
- * the user can't act on:
- *
- *   1. CI — no human at the keyboard.
- *   2. SSH session — the browser would launch on the remote host, not on
- *      the user's local machine.
- *   3. Headless Linux — no display server means there's nowhere for a
- *      browser to land. (macOS / Windows are assumed to have a display.)
- *
- * Otherwise returns `true`. Notably this does NOT branch on `isTTY` or
- * any agent env-var allowlist — the URL is always printed to stderr
- * regardless, so a failed or skipped auto-open degrades gracefully to
- * "user copies the printed URL." We bias toward opening because the cost
- * of a false negative (user has to copy/paste) is small, while the cost
- * of a false positive (browser opens in the wrong place) only really
- * matters for the three scenarios above.
- */
-export function shouldOpenBrowser() {
-    if (isCiEnv())
-        return false;
-    const env = globalThis.process?.env;
-    if (env?.SSH_TTY || env?.SSH_CONNECTION)
-        return false;
-    if (globalThis.process?.platform === "linux" &&
-        !env?.DISPLAY &&
-        !env?.WAYLAND_DISPLAY) {
-        return false;
-    }
-    return true;
-}
-/**
- * Inlined copy of `plugins/eventEmission/utils.ts`'s `isCi()`. Inlined
- * rather than imported so `should-open-browser.ts` (a general util) doesn't
- * reach into a peer plugin's internals — no other `utils/` file does that.
- * Reads `globalThis.process?.env` to match `isCi()` and the rest of the core
- * package's universal-SDK access pattern (safe in browser bundles).
- */
-function isCiEnv() {
-    const env = globalThis.process?.env;
-    return !!(env?.CI ||
-        env?.CONTINUOUS_INTEGRATION ||
-        env?.GITHUB_ACTIONS ||
-        env?.JENKINS_URL ||
-        env?.GITLAB_CI ||
-        env?.CIRCLECI ||
-        env?.TRAVIS ||
-        env?.BUILDKITE ||
-        env?.DRONE ||
-        env?.BITBUCKET_PIPELINES_UUID);
-}

package/dist/utils/telemetry.d.ts

@@ -1,11 +0,0 @@
-import type { SdkEvent, EventCallback } from "../types/events";
-/**
- * Emit an event exactly once per (handler, event type) pair for the
- * lifetime of the process. Safe to call on every request — subsequent
- * calls for the same handler+type are silently dropped.
- *
- * Test isolation is free: each test's fresh vi.fn() is a new function
- * reference the WeakMap has never seen.
- */
-export declare function emitOnce(onEvent: EventCallback, event: SdkEvent): void;
-//# sourceMappingURL=telemetry.d.ts.map

package/dist/utils/telemetry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"telemetry.d.ts","sourceRoot":"","sources":["../../src/utils/telemetry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAI/D;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,aAAa,EAAE,KAAK,EAAE,QAAQ,GAAG,IAAI,CAStE"}

package/dist/utils/telemetry.js

@@ -1,19 +0,0 @@
-const emittedOnce = new WeakMap();
-/**
- * Emit an event exactly once per (handler, event type) pair for the
- * lifetime of the process. Safe to call on every request — subsequent
- * calls for the same handler+type are silently dropped.
- *
- * Test isolation is free: each test's fresh vi.fn() is a new function
- * reference the WeakMap has never seen.
- */
-export function emitOnce(onEvent, event) {
-    if (!emittedOnce.has(onEvent)) {
-        emittedOnce.set(onEvent, new Set());
-    }
-    const fired = emittedOnce.get(onEvent);
-    if (!fired.has(event.type)) {
-        fired.add(event.type);
-        onEvent(event);
-    }
-}

package/dist/utils/type-guard-utils.d.ts

@@ -1,7 +0,0 @@
-/**
- * Returns true only for plain objects created via `{}`, `new Object()`, or
- * `Object.create(null)`. Rejects all class instances (FormData, Blob, etc.)
- * without needing to enumerate them.
- */
-export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
-//# sourceMappingURL=type-guard-utils.d.ts.map

package/dist/utils/type-guard-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"type-guard-utils.d.ts","sourceRoot":"","sources":["../../src/utils/type-guard-utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAIlC"}

package/dist/utils/type-guard-utils.js

@@ -1,11 +0,0 @@
-/**
- * Returns true only for plain objects created via `{}`, `new Object()`, or
- * `Object.create(null)`. Rejects all class instances (FormData, Blob, etc.)
- * without needing to enumerate them.
- */
-export function isPlainObject(value) {
-    if (typeof value !== "object" || value === null)
-        return false;
-    const proto = Object.getPrototypeOf(value);
-    return proto === Object.prototype || proto === null;
-}

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

@@ -1,25 +0,0 @@
-/**
- * Gets the Zapier base URL from a baseUrl if it matches Zapier hosting patterns.
- * Returns the root domain URL or undefined if not a Zapier domain.
- * This combines domain checking and URL extraction logic.
- */
-export declare function getZapierBaseUrl(baseUrl?: string): string | undefined;
-/**
- * Returns true if the baseUrl points at a developer's local machine
- * (`localhost` or `127.0.0.1`). Used to relax checks that don't make sense
- * when the SDK API and other services run on different localhost ports.
- */
-export declare function isLocalhostBaseUrl(baseUrl?: string): boolean;
-/**
- * Gets tracking base URL with the following precedence:
- * 1. Explicit trackingBaseUrl parameter
- * 2. ZAPIER_TRACKING_BASE_URL environment variable
- * 3. Derive from baseUrl if it's a Zapier domain
- * 4. Use baseUrl directly (whether Zapier-hosted or not)
- * 5. Default to ZAPIER_BASE_URL constant
- */
-export declare function getTrackingBaseUrl({ trackingBaseUrl, baseUrl, }: {
-    trackingBaseUrl?: string;
-    baseUrl?: string;
-}): string;
-//# sourceMappingURL=url-utils.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"url-utils.d.ts","sourceRoot":"","sources":["../../src/utils/url-utils.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CA+BrE;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAU5D;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,eAAe,EACf,OAAO,GACR,EAAE;IACD,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GAAG,MAAM,CA0BT"}

package/dist/utils/url-utils.js

@@ -1,79 +0,0 @@
-import { ZAPIER_BASE_URL } from "../constants";
-/**
- * Gets the Zapier base URL from a baseUrl if it matches Zapier hosting patterns.
- * Returns the root domain URL or undefined if not a Zapier domain.
- * This combines domain checking and URL extraction logic.
- */
-export function getZapierBaseUrl(baseUrl) {
-    if (!baseUrl) {
-        return undefined;
-    }
-    try {
-        const url = new URL(baseUrl);
-        const hostname = url.hostname;
-        // Check if it matches Zapier hosting patterns by examining the last two parts
-        const hostParts = hostname.split(".");
-        if (hostParts.length < 2) {
-            return undefined;
-        }
-        // Check if any part is "zapier" or starts with "zapier-"
-        const hasZapierPart = hostParts.some((part) => part === "zapier" || part.startsWith("zapier-"));
-        if (!hasZapierPart) {
-            return undefined;
-        }
-        // Extract root domain using the last two parts
-        const rootDomain = hostParts.slice(-2).join(".");
-        return `${url.protocol}//${rootDomain}`;
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * Returns true if the baseUrl points at a developer's local machine
- * (`localhost` or `127.0.0.1`). Used to relax checks that don't make sense
- * when the SDK API and other services run on different localhost ports.
- */
-export function isLocalhostBaseUrl(baseUrl) {
-    if (!baseUrl) {
-        return false;
-    }
-    try {
-        const { hostname } = new URL(baseUrl);
-        return hostname === "localhost" || hostname === "127.0.0.1";
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Gets tracking base URL with the following precedence:
- * 1. Explicit trackingBaseUrl parameter
- * 2. ZAPIER_TRACKING_BASE_URL environment variable
- * 3. Derive from baseUrl if it's a Zapier domain
- * 4. Use baseUrl directly (whether Zapier-hosted or not)
- * 5. Default to ZAPIER_BASE_URL constant
- */
-export function getTrackingBaseUrl({ trackingBaseUrl, baseUrl, }) {
-    // 1. Explicit parameter takes highest precedence
-    if (trackingBaseUrl) {
-        return trackingBaseUrl;
-    }
-    // 2. Environment variable override
-    if (globalThis.process?.env?.ZAPIER_TRACKING_BASE_URL) {
-        return globalThis.process?.env?.ZAPIER_TRACKING_BASE_URL;
-    }
-    // 3. Try to derive from baseUrl if it's a Zapier domain
-    if (baseUrl) {
-        const zapierBaseUrl = getZapierBaseUrl(baseUrl);
-        if (zapierBaseUrl) {
-            return zapierBaseUrl;
-        }
-    }
-    // 4. Use baseUrl directly for tracking (whether Zapier-hosted or not)
-    if (baseUrl) {
-        return baseUrl;
-    }
-    // 5. Default to ZAPIER_BASE_URL constant
-    return ZAPIER_BASE_URL;
-}