@zapier/zapier-sdk 0.8.2 → 0.8.3

package/dist/index.cjs

@@ -3,6 +3,7 @@
 var zod = require('zod');
 var fs = require('fs');
 var path = require('path');
+var promises = require('timers/promises');
 
 // src/types/properties.ts
 function withFormatter(schema, formatMeta) {
@@ -2277,52 +2278,162 @@ function createDebugFetch(options) {
     }
   };
 }
-
-// src/api/polling.ts
+var DEFAULT_TIMEOUT_MS = 18e4;
+var DEFAULT_SUCCESS_STATUS = 200;
+var DEFAULT_PENDING_STATUS = 202;
+var DEFAULT_INITIAL_DELAY_MS = 50;
+var DEFAULT_MAX_POLLING_INTERVAL_MS = 1e4;
+var MAX_CONSECUTIVE_ERRORS = 3;
+var MAX_TIMEOUT_BUFFER_MS = 1e4;
+var BASE_ERROR_BACKOFF_MS = 1e3;
+var JITTER_FACTOR = 0.5;
+var 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
+  [1e4, 1e3],
+  // Up to 10s: poll every 1s
+  [3e4, 2500],
+  // Up to 30s: poll every 2.5s
+  [6e4, 5e3]
+  // Up to 60s: poll every 5s
+];
+var calculateWaitTime = (baseInterval, errorCount) => {
+  const jitter = Math.random() * JITTER_FACTOR * baseInterval;
+  const errorBackoff = Math.min(
+    BASE_ERROR_BACKOFF_MS * (errorCount / 2),
+    baseInterval * 2
+    // Cap error backoff at 2x the base interval
+  );
+  return Math.floor(baseInterval + jitter + errorBackoff);
+};
+var processResponse = async (response, successStatus, pendingStatus, resultExtractor, errorCount) => {
+  if (!response.ok) {
+    return {
+      status: "continue" /* 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
+    };
+  }
+  if (response.status === successStatus) {
+    try {
+      const resultJson = await response.json();
+      return {
+        result: resultExtractor(resultJson),
+        status: "success" /* Success */,
+        errorCount: 0
+      };
+    } catch (error) {
+      throw new ZapierApiError(
+        "Result extractor failed to parse successful response as JSON",
+        {
+          statusCode: response.status,
+          cause: error
+        }
+      );
+    }
+  }
+  if (response.status !== pendingStatus) {
+    throw new ZapierApiError(
+      `Unexpected response status during polling: ${response.status}`,
+      {
+        statusCode: response.status
+      }
+    );
+  }
+  return {
+    status: "continue" /* Continue */,
+    errorCount: 0
+  };
+};
 async function pollUntilComplete(options) {
   const {
     fetchPoll,
-    maxAttempts = 30,
-    initialDelay = 50,
-    maxDelay = 1e3,
-    successStatus = 200,
-    pendingStatus = 202,
+    timeoutMs = DEFAULT_TIMEOUT_MS,
+    initialDelay = DEFAULT_INITIAL_DELAY_MS,
+    successStatus = DEFAULT_SUCCESS_STATUS,
+    pendingStatus = DEFAULT_PENDING_STATUS,
     resultExtractor = (response) => response
   } = options;
-  let delay = initialDelay;
+  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;
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    const response = await fetchPoll();
-    if (response.status === successStatus) {
-      errorCount = 0;
-      const result = await response.json();
-      return resultExtractor(result);
-    } else if (response.status === pendingStatus) {
-      errorCount = 0;
-      if (attempt < maxAttempts - 1) {
-        await new Promise((resolve3) => setTimeout(resolve3, delay));
-        delay = Math.min(delay * 2, maxDelay);
-        continue;
-      }
-    } else {
-      errorCount++;
-      if (errorCount >= 3) {
+  const pollingStages = [
+    ...DEFAULT_POLLING_STAGES,
+    [timeoutMs + MAX_TIMEOUT_BUFFER_MS, DEFAULT_MAX_POLLING_INTERVAL_MS]
+    // Up to timeout + 10s: poll every 10s
+  ];
+  if (initialDelay > 0) {
+    await promises.setTimeout(initialDelay);
+  }
+  while (true) {
+    attempts++;
+    const elapsedTime = Date.now() - startTime;
+    const pollingInterval = pollingStages.find(
+      ([maxTimeForStage, _interval]) => {
+        return elapsedTime < maxTimeForStage;
+      }
+    );
+    if (!pollingInterval) {
+      throw new ZapierTimeoutError(
+        `Operation timed out after ${Math.floor(elapsedTime / 1e3)}s (${attempts} attempts)`,
+        {
+          attempts
+        }
+      );
+    }
+    if (attempts > 1) {
+      const waitTime = calculateWaitTime(pollingInterval[1], errorCount);
+      await promises.setTimeout(waitTime);
+    }
+    try {
+      const response = await fetchPoll();
+      const {
+        result,
+        errorCount: newErrorCount,
+        status
+      } = await processResponse(
+        response,
+        successStatus,
+        pendingStatus,
+        resultExtractor,
+        errorCount
+      );
+      errorCount = newErrorCount;
+      if (status === "success" /* Success */) {
+        return result;
+      }
+      if (errorCount >= MAX_CONSECUTIVE_ERRORS) {
         throw new ZapierApiError(
           `Poll request failed: ${response.status} ${response.statusText}`,
           { statusCode: response.status }
         );
       }
-      if (attempt < maxAttempts - 1) {
-        await new Promise((resolve3) => setTimeout(resolve3, delay));
-        delay = Math.min(delay * 2, maxDelay);
-        continue;
+    } 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
+          }
+        );
       }
     }
   }
-  throw new ZapierTimeoutError(
-    `Operation timed out after ${maxAttempts} attempts`,
-    { attempts: maxAttempts, maxAttempts }
-  );
 }
 
 // src/auth.ts
@@ -2377,9 +2488,8 @@ var ZapierApiClient = class {
           searchParams: options.searchParams,
           authRequired: options.authRequired
         }),
-        maxAttempts: options.maxAttempts,
         initialDelay: options.initialDelay,
-        maxDelay: options.maxDelay,
+        timeoutMs: options.timeoutMs,
         successStatus: options.successStatus,
         pendingStatus: options.pendingStatus,
         resultExtractor: options.resultExtractor

package/dist/index.d.mts

@@ -1841,9 +1841,8 @@ interface RequestOptions {
     }) => Error | undefined;
 }
 interface PollOptions extends RequestOptions {
-    maxAttempts?: number;
     initialDelay?: number;
-    maxDelay?: number;
+    timeoutMs?: number;
     successStatus?: number;
     pendingStatus?: number;
     resultExtractor?: (response: unknown) => unknown;

package/dist/index.mjs

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { readFileSync, existsSync, writeFileSync } from 'fs';
 import { resolve } from 'path';
+import { setTimeout } from 'timers/promises';
 
 // src/types/properties.ts
 function withFormatter(schema, formatMeta) {
@@ -2275,52 +2276,162 @@ function createDebugFetch(options) {
     }
   };
 }
-
-// src/api/polling.ts
+var DEFAULT_TIMEOUT_MS = 18e4;
+var DEFAULT_SUCCESS_STATUS = 200;
+var DEFAULT_PENDING_STATUS = 202;
+var DEFAULT_INITIAL_DELAY_MS = 50;
+var DEFAULT_MAX_POLLING_INTERVAL_MS = 1e4;
+var MAX_CONSECUTIVE_ERRORS = 3;
+var MAX_TIMEOUT_BUFFER_MS = 1e4;
+var BASE_ERROR_BACKOFF_MS = 1e3;
+var JITTER_FACTOR = 0.5;
+var 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
+  [1e4, 1e3],
+  // Up to 10s: poll every 1s
+  [3e4, 2500],
+  // Up to 30s: poll every 2.5s
+  [6e4, 5e3]
+  // Up to 60s: poll every 5s
+];
+var calculateWaitTime = (baseInterval, errorCount) => {
+  const jitter = Math.random() * JITTER_FACTOR * baseInterval;
+  const errorBackoff = Math.min(
+    BASE_ERROR_BACKOFF_MS * (errorCount / 2),
+    baseInterval * 2
+    // Cap error backoff at 2x the base interval
+  );
+  return Math.floor(baseInterval + jitter + errorBackoff);
+};
+var processResponse = async (response, successStatus, pendingStatus, resultExtractor, errorCount) => {
+  if (!response.ok) {
+    return {
+      status: "continue" /* 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
+    };
+  }
+  if (response.status === successStatus) {
+    try {
+      const resultJson = await response.json();
+      return {
+        result: resultExtractor(resultJson),
+        status: "success" /* Success */,
+        errorCount: 0
+      };
+    } catch (error) {
+      throw new ZapierApiError(
+        "Result extractor failed to parse successful response as JSON",
+        {
+          statusCode: response.status,
+          cause: error
+        }
+      );
+    }
+  }
+  if (response.status !== pendingStatus) {
+    throw new ZapierApiError(
+      `Unexpected response status during polling: ${response.status}`,
+      {
+        statusCode: response.status
+      }
+    );
+  }
+  return {
+    status: "continue" /* Continue */,
+    errorCount: 0
+  };
+};
 async function pollUntilComplete(options) {
   const {
     fetchPoll,
-    maxAttempts = 30,
-    initialDelay = 50,
-    maxDelay = 1e3,
-    successStatus = 200,
-    pendingStatus = 202,
+    timeoutMs = DEFAULT_TIMEOUT_MS,
+    initialDelay = DEFAULT_INITIAL_DELAY_MS,
+    successStatus = DEFAULT_SUCCESS_STATUS,
+    pendingStatus = DEFAULT_PENDING_STATUS,
     resultExtractor = (response) => response
   } = options;
-  let delay = initialDelay;
+  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;
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    const response = await fetchPoll();
-    if (response.status === successStatus) {
-      errorCount = 0;
-      const result = await response.json();
-      return resultExtractor(result);
-    } else if (response.status === pendingStatus) {
-      errorCount = 0;
-      if (attempt < maxAttempts - 1) {
-        await new Promise((resolve3) => setTimeout(resolve3, delay));
-        delay = Math.min(delay * 2, maxDelay);
-        continue;
-      }
-    } else {
-      errorCount++;
-      if (errorCount >= 3) {
+  const pollingStages = [
+    ...DEFAULT_POLLING_STAGES,
+    [timeoutMs + MAX_TIMEOUT_BUFFER_MS, DEFAULT_MAX_POLLING_INTERVAL_MS]
+    // Up to timeout + 10s: poll every 10s
+  ];
+  if (initialDelay > 0) {
+    await setTimeout(initialDelay);
+  }
+  while (true) {
+    attempts++;
+    const elapsedTime = Date.now() - startTime;
+    const pollingInterval = pollingStages.find(
+      ([maxTimeForStage, _interval]) => {
+        return elapsedTime < maxTimeForStage;
+      }
+    );
+    if (!pollingInterval) {
+      throw new ZapierTimeoutError(
+        `Operation timed out after ${Math.floor(elapsedTime / 1e3)}s (${attempts} attempts)`,
+        {
+          attempts
+        }
+      );
+    }
+    if (attempts > 1) {
+      const waitTime = calculateWaitTime(pollingInterval[1], errorCount);
+      await setTimeout(waitTime);
+    }
+    try {
+      const response = await fetchPoll();
+      const {
+        result,
+        errorCount: newErrorCount,
+        status
+      } = await processResponse(
+        response,
+        successStatus,
+        pendingStatus,
+        resultExtractor,
+        errorCount
+      );
+      errorCount = newErrorCount;
+      if (status === "success" /* Success */) {
+        return result;
+      }
+      if (errorCount >= MAX_CONSECUTIVE_ERRORS) {
         throw new ZapierApiError(
           `Poll request failed: ${response.status} ${response.statusText}`,
           { statusCode: response.status }
         );
       }
-      if (attempt < maxAttempts - 1) {
-        await new Promise((resolve3) => setTimeout(resolve3, delay));
-        delay = Math.min(delay * 2, maxDelay);
-        continue;
+    } 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
+          }
+        );
       }
     }
   }
-  throw new ZapierTimeoutError(
-    `Operation timed out after ${maxAttempts} attempts`,
-    { attempts: maxAttempts, maxAttempts }
-  );
 }
 
 // src/auth.ts
@@ -2375,9 +2486,8 @@ var ZapierApiClient = class {
           searchParams: options.searchParams,
           authRequired: options.authRequired
         }),
-        maxAttempts: options.maxAttempts,
         initialDelay: options.initialDelay,
-        maxDelay: options.maxDelay,
+        timeoutMs: options.timeoutMs,
         successStatus: options.successStatus,
         pendingStatus: options.pendingStatus,
         resultExtractor: options.resultExtractor

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zapier/zapier-sdk",
-  "version": "0.8.2",
+  "version": "0.8.3",
   "description": "Complete Zapier SDK - combines all Zapier SDK packages",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",

package/src/api/client.ts

@@ -437,19 +437,20 @@ class ZapierApiClient implements ApiClient {
     path: string,
     options: PollOptions = {},
   ): Promise<TOutput> => {
-    return pollUntilComplete({
+    return pollUntilComplete<TOutput>({
       fetchPoll: () =>
         this.plainFetch(path, {
           method: "GET",
           searchParams: options.searchParams,
           authRequired: options.authRequired,
         }),
-      maxAttempts: options.maxAttempts,
       initialDelay: options.initialDelay,
-      maxDelay: options.maxDelay,
+      timeoutMs: options.timeoutMs,
       successStatus: options.successStatus,
       pendingStatus: options.pendingStatus,
-      resultExtractor: options.resultExtractor,
+      resultExtractor: options.resultExtractor as
+        | ((response: unknown) => TOutput)
+        | undefined,
     });
   };
 }