@zapier/zapier-sdk 0.13.6 → 0.13.7

package/src/api/debug.ts

@@ -1,154 +0,0 @@
-/**
- * Debug Logging Utilities
- *
- * This module provides debug logging capabilities for API requests and responses,
- * including request timing and detailed logging of HTTP interactions.
- */
-
-import type { DebugLogger } from "./types";
-
-import type { InspectOptions } from "util";
-
-type UtilModule = {
-  inspect: (object: unknown, options?: InspectOptions) => string;
-};
-
-// We don't want to import util since it might not work in a browser. So we'll lazily load it and cache the result so
-// we can use it synchronously after that. The types above are just to make our linter happy.
-let utilModule: UtilModule | null = null;
-let utilPromise: Promise<UtilModule | null> | null = null;
-
-export function createDebugLogger(enabled: boolean): DebugLogger {
-  if (!enabled) {
-    return () => {}; // No-op function when debug is disabled
-  }
-
-  // Try to load util module on first use.
-  if (!utilPromise) {
-    utilPromise = import("util")
-      .then((util) => {
-        utilModule = util;
-        return util;
-      })
-      .catch(() => {
-        utilModule = null;
-        return null;
-      });
-  }
-
-  return (message: string, data?: unknown) => {
-    if (data === undefined || data === "") {
-      console.log(`[Zapier SDK] ${message}`);
-      return;
-    }
-
-    // Use cached module if available for sync logging. Yes, this means if the util module isn't yet loaded, we'll fall
-    // back to a plain old console.log, which might mean we don't see proper formatting/nesting. But that's unlikely
-    // since this logging happens during async fetching. Alternatively, we could switch to async logging, but this
-    // seems fine since we have to have a fallback anyway.
-    if (utilModule) {
-      const formatted = utilModule.inspect(data, {
-        colors: true,
-        depth: null,
-        breakLength: 80,
-      });
-      console.log(`[Zapier SDK] ${message}`, formatted);
-    } else {
-      // Fallback - browser will handle formatting automatically
-      console.log(`[Zapier SDK] ${message}`, data);
-    }
-  };
-}
-
-export function censorHeaders(
-  headers?: HeadersInit,
-): Record<string, string> | undefined {
-  if (!headers) return headers;
-
-  const headersObj = new Headers(headers);
-  const authKeys = ["authorization", "x-api-key"];
-
-  for (const [key, value] of headersObj.entries()) {
-    if (authKeys.some((authKey) => key.toLowerCase() === authKey)) {
-      // Find space after prefix (like "Bearer ")
-      const spaceIndex = value.indexOf(" ");
-      if (spaceIndex > 0 && spaceIndex < value.length - 1) {
-        const prefix = value.substring(0, spaceIndex + 1); // Include the space
-        const token = value.substring(spaceIndex + 1);
-
-        if (token.length > 12) {
-          // Show first 4 and last 4 chars, truncate middle
-          const start = token.substring(0, 4);
-          const end = token.substring(token.length - 4);
-          headersObj.set(key, `${prefix}${start}...${end}`);
-        } else {
-          // Short token, use first character + three dots
-          const firstChar = token.charAt(0);
-          headersObj.set(key, `${prefix}${firstChar}...`);
-        }
-      } else {
-        // No prefix found, truncate the whole value
-        if (value.length > 12) {
-          const start = value.substring(0, 4);
-          const end = value.substring(value.length - 4);
-          headersObj.set(key, `${start}...${end}`);
-        } else {
-          // Short token, use first character + three dots
-          const firstChar = value.charAt(0);
-          headersObj.set(key, `${firstChar}...`);
-        }
-      }
-    }
-  }
-
-  return Object.fromEntries(headersObj);
-}
-
-export function createDebugFetch(options: {
-  originalFetch: typeof globalThis.fetch;
-  debugLog: DebugLogger;
-}) {
-  const { originalFetch, debugLog } = options;
-  return async (input: RequestInfo | URL, options?: RequestInit) => {
-    const startTime = Date.now();
-
-    // Convert input to URL string for logging
-    const url = typeof input === "string" ? input : input.toString();
-    const method = options?.method || "GET";
-
-    debugLog(`→ ${method} ${url}`, {
-      headers: censorHeaders(options?.headers),
-      body:
-        options?.body && typeof options.body === "string"
-          ? (() => {
-              try {
-                return JSON.parse(options.body);
-              } catch {
-                return options.body;
-              }
-            })()
-          : options?.body,
-    });
-
-    try {
-      const response = await originalFetch(input, options);
-      const duration = Date.now() - startTime;
-
-      debugLog(`← ${response.status} ${response.statusText} (${duration}ms)`, {
-        url,
-        method,
-        status: response.status,
-      });
-
-      return response;
-    } catch (error) {
-      const duration = Date.now() - startTime;
-      debugLog(`✖ Request failed (${duration}ms)`, {
-        url,
-        method,
-        error: error instanceof Error ? error.message : error,
-      });
-      throw error;
-    }
-  };
-}

package/src/api/index.ts

@@ -1,90 +0,0 @@
-/**
- * Zapier API Client Module
- *
- * This module provides a centralized API layer for all HTTP interactions
- * with Zapier's various APIs. It handles authentication, error handling,
- * polling, and provides consistent patterns across all services.
- */
-
-// Re-export all types
-export type {
-  // API Client Infrastructure Types
-  ApiClient,
-  ApiClientOptions,
-  RequestOptions,
-  PollOptions,
-  DebugLogger,
-  // API Response Model Types
-  Action,
-  Field,
-  Choice,
-  ActionExecutionResult,
-  ActionField,
-  ActionFieldChoice,
-  NeedsRequest,
-  NeedsResponse,
-  Authentication,
-  AuthenticationsResponse,
-  Implementation,
-  ImplementationsResponse,
-} from "./types";
-
-// Import for local use
-import type { ApiClient } from "./types";
-
-// Re-export authentication utilities
-export { isJwt, getAuthorizationHeader } from "./auth";
-
-// Re-export debug utilities
-export { createDebugLogger, createDebugFetch } from "./debug";
-
-// Re-export polling utilities
-export { pollUntilComplete } from "./polling";
-
-// Re-export the main client factory
-export { createZapierApi } from "./client";
-
-// Import for local use
-import { createZapierApi } from "./client";
-
-// Utility Functions
-export function generateRequestId(): string {
-  return Math.random().toString(36).substring(2) + Date.now().toString(36);
-}
-
-/**
- * Utility function to get or create an API client for standalone functions
- *
- * @param config - Configuration that may include an existing API client
- * @returns ApiClient instance
- */
-export function getOrCreateApiClient(config: {
-  baseUrl?: string;
-  token?: string;
-  getToken?: () => Promise<string | undefined>;
-  api?: ApiClient;
-  debug?: boolean;
-  fetch?: typeof globalThis.fetch;
-}): ApiClient {
-  const {
-    baseUrl = "https://zapier.com",
-    token,
-    getToken,
-    api: providedApi,
-    debug = false,
-    fetch: customFetch,
-  } = config;
-
-  // Use provided API client or create a new one
-  if (providedApi) {
-    return providedApi;
-  }
-
-  return createZapierApi({
-    baseUrl,
-    token,
-    getToken,
-    debug,
-    fetch: customFetch,
-  });
-}

package/src/api/polling.test.ts

@@ -1,405 +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" }),
-      } as unknown as Response;
-
-      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,
-      } as Response;
-
-      const successResponse = {
-        ok: true,
-        status: 200,
-        json: vi.fn().mockResolvedValue({ data: "complete" }),
-      } as unknown as Response;
-
-      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,
-      } as Response;
-
-      const successResponse = {
-        ok: true,
-        status: 204,
-        json: vi.fn().mockResolvedValue({ done: true }),
-      } as unknown as Response;
-
-      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" } },
-        }),
-      } as unknown as Response;
-
-      const fetchPoll = vi.fn().mockResolvedValue(mockResponse);
-      const resultExtractor = (response: any) => 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" }),
-      } as unknown as Response;
-
-      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" }),
-      } as unknown as Response;
-
-      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",
-      } as Response;
-
-      const successResponse = {
-        ok: true,
-        status: 200,
-        json: vi.fn().mockResolvedValue({ data: "recovered" }),
-      } as unknown as Response;
-
-      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",
-      } as Response;
-
-      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)
-      } as Response;
-
-      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")),
-      } as unknown as Response;
-
-      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,
-      } as Response;
-
-      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,
-      } as Response;
-
-      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 } as Response,
-        { ok: false, status: 500 } as Response,
-        { ok: true, status: 202 } as Response,
-        {
-          ok: true,
-          status: 200,
-          json: vi.fn().mockResolvedValue({ data: "success" }),
-        } as unknown as Response,
-      ];
-
-      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 }),
-      } as unknown as Response;
-
-      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,
-      } as Response;
-
-      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;
-      }
-    });
-  });
-});