@zapier/zapier-sdk 0.3.1 → 0.4.1

package/src/plugins/apps/index.ts

@@ -2,13 +2,11 @@ import {
   ActionExecutionOptions,
   ActionExecutionResult,
 } from "../../types/domain";
-import { type ApiClient } from "../../api";
-import { runAction } from "../../functions/runAction";
 import type { ActionProxy } from "./types";
+import type { ZapierSdk } from "../../types/sdk";
 
 export interface AppsPluginOptions {
-  api: ApiClient;
-  token?: string;
+  sdk: ZapierSdk;
 }
 
 interface AppFactoryOptions {
@@ -25,7 +23,7 @@ function createActionFunction(
   return async (
     actionOptions: ActionExecutionOptions = {},
   ): Promise<ActionExecutionResult> => {
-    const { api, token } = options;
+    const { sdk } = options;
     const { inputs, authenticationId: providedAuthenticationId } =
       actionOptions;
 
@@ -38,15 +36,13 @@ function createActionFunction(
       );
     }
 
-    // Call runAction with the resolved parameters
-    return runAction({
+    // Call sdk.runAction with the resolved parameters
+    return sdk.runAction({
       appKey,
       actionType: actionType as any,
       actionKey,
       inputs,
       authenticationId,
-      api: api,
-      token,
     });
   };
 }
@@ -57,6 +53,35 @@ function createActionTypeProxy(
   options: AppsPluginOptions,
   pinnedAuthId?: number,
 ) {
+  // Special handling for "fetch" action type
+  if (actionType === "fetch") {
+    return async (
+      url: string | URL,
+      init?: RequestInit & {
+        authenticationId?: number;
+        callbackUrl?: string;
+        authenticationTemplate?: string;
+      },
+    ) => {
+      const { sdk } = options;
+
+      // Use pinned auth ID first, then provided auth ID
+      const authenticationId = pinnedAuthId || init?.authenticationId;
+
+      if (!authenticationId) {
+        throw new Error(
+          `Authentication ID is required for fetch. Either use the factory pattern: sdk.apps.${appKey}({ authenticationId }).fetch(...) or provide authenticationId in the fetch call.`,
+        );
+      }
+
+      // Call sdk.fetch with the resolved authenticationId
+      return sdk.fetch(url, {
+        ...init,
+        authenticationId,
+      });
+    };
+  }
+
   return new Proxy(
     {},
     {

package/src/plugins/apps/types.ts

@@ -7,12 +7,28 @@ interface AppFactoryOptions {
   authenticationId: number;
 }
 
-interface ActionTypeProxy {
+// Base action type proxy for regular actions
+interface BaseActionTypeProxy {
   [action: string]: (
     options?: ActionExecutionOptions,
   ) => Promise<ActionExecutionResult>;
 }
 
+// Special fetch function type
+interface FetchActionType {
+  fetch: (
+    url: string | URL,
+    init?: RequestInit & {
+      authenticationId?: number;
+      callbackUrl?: string;
+      authenticationTemplate?: string;
+    },
+  ) => Promise<Response>;
+}
+
+// Combined action type proxy
+type ActionTypeProxy = BaseActionTypeProxy & Partial<FetchActionType>;
+
 interface AppProxy {
   [type: string]: ActionTypeProxy;
 }

package/src/plugins/fetch/index.ts

@@ -0,0 +1,50 @@
+import type { ZapierSdk } from "../../types/sdk";
+
+export interface FetchPluginOptions {
+  sdk: ZapierSdk;
+}
+
+/**
+ * Creates a fetch function with standard fetch signature that delegates to sdk.request
+ */
+export function createFetchPlugin(options: FetchPluginOptions) {
+  const { sdk } = options;
+
+  return async function fetch(
+    url: string | URL,
+    init?: RequestInit & {
+      authenticationId?: number;
+      callbackUrl?: string;
+      authenticationTemplate?: string;
+    },
+  ): Promise<Response> {
+    const {
+      authenticationId,
+      callbackUrl,
+      authenticationTemplate,
+      ...fetchInit
+    } = init || {};
+
+    return sdk.request({
+      url: url.toString(),
+      method: fetchInit.method as any,
+      body: fetchInit.body as any,
+      headers: fetchInit.headers as any,
+      authenticationId,
+      callbackUrl,
+      authenticationTemplate,
+    });
+  };
+}
+
+// Export types for TypeScript
+export interface FetchPluginSdkExtension {
+  fetch: (
+    url: string | URL,
+    init?: RequestInit & {
+      authenticationId?: number;
+      callbackUrl?: string;
+      authenticationTemplate?: string;
+    },
+  ) => Promise<Response>;
+}

package/src/plugins/fetch/types.ts

@@ -0,0 +1,2 @@
+// Re-export types from index for consistency
+export type { FetchPluginSdkExtension } from "./index";

package/src/sdk.ts

@@ -1,6 +1,5 @@
 import { createZapierApi } from "./api";
 import { BaseSdkOptions } from "./types/domain";
-import { getTokenFromEnvOrConfig } from "./auth";
 // Import function implementations
 import { listApps } from "./functions/listApps";
 import { getApp } from "./functions/getApp";
@@ -14,6 +13,7 @@ import { findUniqueAuthentication } from "./functions/findUniqueAuthentication";
 import { listFields } from "./functions/listFields";
 import { generateTypes } from "./functions/generateTypes";
 import { bundleCode } from "./functions/bundleCode";
+import { request } from "./functions/request";
 
 // Import function registry info objects (only for CLI registry)
 import { listAppsInfo } from "./functions/listApps/info";
@@ -28,6 +28,7 @@ import { findUniqueAuthenticationInfo } from "./functions/findUniqueAuthenticati
 import { listFieldsInfo } from "./functions/listFields/info";
 import { generateTypesInfo } from "./functions/generateTypes/info";
 import { bundleCodeInfo } from "./functions/bundleCode/info";
+import { requestInfo } from "./functions/request/info";
 
 // Function registry as array - uses names from function info objects
 const functionRegistry = [
@@ -43,13 +44,15 @@ const functionRegistry = [
   listFieldsInfo,
   generateTypesInfo,
   bundleCodeInfo,
+  requestInfo,
 ];
 
-// Import the properly typed SDK interface
-import type { ZapierSdk } from "./types/sdk";
+// Import the properly typed SDK interfaces
+import type { BaseZapierSdk, ZapierSdk } from "./types/sdk";
 
 // Import plugin functions
 import { createAppsPlugin } from "./plugins/apps/index";
+import { createFetchPlugin } from "./plugins/fetch/index";
 
 // TODO: Add plugin registry back when needed for CLI compatibility
 
@@ -68,30 +71,18 @@ export function createZapierSdk(options: ZapierSdkOptions = {}): ZapierSdk {
     debug = false,
   } = options;
 
-  // If no explicit token or getToken provided, try env var then CLI config with event callbacks
-  const resolvedGetToken =
-    getToken ||
-    (!token
-      ? () => getTokenFromEnvOrConfig({ onEvent, fetch: customFetch })
-      : undefined);
-
-  // Create the API client
+  // Create the API client - it will handle token resolution internally
   const api = createZapierApi({
     baseUrl,
     token,
-    getToken: resolvedGetToken,
+    getToken,
     debug,
     fetch: customFetch,
+    onEvent,
   });
 
-  // Create plugins directly - TypeScript will enforce correct implementation
-  const appsPlugin = createAppsPlugin({
-    api,
-    token,
-  });
-
-  // Compose final SDK - TypeScript will enforce we have all required properties
-  const fullSdk: ZapierSdk = {
+  // Create base SDK with core functions only - TypeScript will enforce completeness
+  const baseSdk: BaseZapierSdk = {
     // Registry for CLI
     __registry: functionRegistry,
 
@@ -111,10 +102,15 @@ export function createZapierSdk(options: ZapierSdkOptions = {}): ZapierSdk {
     listFields: (options) => listFields({ ...options, api }),
     generateTypes: (options) => generateTypes({ ...options, api }),
     bundleCode: (options) => bundleCode(options), // No API config needed
-
-    // Add plugins
-    apps: appsPlugin,
+    request: (options) => request({ ...options, api }),
   };
 
+  // Mutate baseSdk to add plugins so they can access each other
+  const fullSdk = baseSdk as ZapierSdk;
+
+  // Add plugins to the SDK - they now have access to the full SDK including other plugins
+  fullSdk.apps = createAppsPlugin({ sdk: fullSdk });
+  fullSdk.fetch = createFetchPlugin({ sdk: fullSdk });
+
   return fullSdk;
 }

package/src/types/domain.ts

@@ -36,6 +36,22 @@ export interface BaseSdkOptions {
   debug?: boolean;
 }
 
+// Common options shared across all function types
+export interface FunctionOptions {
+  /** Base URL for Zapier API */
+  baseUrl?: string;
+  /** Authentication token */
+  token?: string;
+  /** Function to dynamically resolve authentication token */
+  getToken?: () => Promise<string | undefined>;
+  /** Optional pre-instantiated API client */
+  api?: any;
+  /** Enable debug logging */
+  debug?: boolean;
+  /** Custom fetch implementation */
+  fetch?: typeof globalThis.fetch;
+}
+
 // Error Classes
 export class ZapierSdkError extends Error {
   constructor(

package/src/types/sdk.ts

@@ -11,9 +11,11 @@ import type { FindUniqueAuthenticationSdkFunction } from "../functions/findUniqu
 import type { GenerateTypesSdkFunction } from "../functions/generateTypes/schemas";
 import type { ListAppsSdkFunction } from "../functions/listApps/schemas";
 import type { BundleCodeSdkFunction } from "../functions/bundleCode/schemas";
+import type { RelayRequestSdkFunction } from "../functions/request/schemas";
 
 // Plugin interfaces
 import type { AppsPluginSdkExtension } from "../plugins/apps/types";
+import type { FetchPluginSdkExtension } from "../plugins/fetch/types";
 
 // Compose SDK functions from individual function interfaces
 export interface ZapierSdkFunctions
@@ -28,15 +30,28 @@ export interface ZapierSdkFunctions
     FindUniqueAuthenticationSdkFunction,
     GenerateTypesSdkFunction,
     ListAppsSdkFunction,
-    BundleCodeSdkFunction {
+    BundleCodeSdkFunction,
+    RelayRequestSdkFunction {
   // All functions now properly typed!
 }
 
 // Compose SDK plugins from individual plugin interfaces
-export interface ZapierSdkPlugins extends AppsPluginSdkExtension {
+export interface ZapierSdkPlugins
+  extends AppsPluginSdkExtension,
+    FetchPluginSdkExtension {
   // All plugins now properly typed!
 }
 
+// Base SDK interface with core functions only (no plugins)
+export interface BaseZapierSdk extends ZapierSdkFunctions {
+  // Special property for CLI to access schemas
+  __registry: Array<{
+    name: string;
+    inputSchema: any;
+    implementation: Function;
+  }>;
+}
+
 // Main SDK interface with functions and plugins
 export interface ZapierSdk extends ZapierSdkFunctions, ZapierSdkPlugins {
   // Special property for CLI to access schemas

package/tsconfig.json

@@ -1,7 +1,7 @@
 {
   "compilerOptions": {
     "target": "ES2020",
-    "module": "CommonJS",
+    "module": "ES2020",
     "declaration": true,
     "outDir": "./dist",
     "rootDir": "./src",
@@ -11,7 +11,7 @@
     "esModuleInterop": true,
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
-    "moduleResolution": "node"
+    "moduleResolution": "bundler"
   },
   "include": ["src/**/*"],
   "exclude": ["dist", "node_modules"]

package/tsup.config.ts

@@ -0,0 +1,21 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["src/index.ts"],
+  format: ["cjs", "esm"],
+  dts: true,
+  clean: true,
+  splitting: false,
+  sourcemap: false,
+  // Preserve tree shaking by maintaining individual module exports
+  treeshake: true,
+  // Output to separate directories for each format
+  outDir: "dist",
+  outExtension({ format }) {
+    return {
+      js: format === "cjs" ? ".cjs" : ".mjs",
+    };
+  },
+  // Make the optional CLI login package external so it doesn't cause build issues
+  external: ["@zapier/zapier-sdk-cli-login"],
+});

package/dist/api/auth.d.ts

@@ -1,8 +0,0 @@
-/**
- * Authentication Utilities
- *
- * This module provides utilities for handling authentication tokens,
- * including JWT detection and authorization header generation.
- */
-export declare function isJwt(token: string): boolean;
-export declare function getAuthorizationHeader(token: string): string;

package/dist/api/auth.js

@@ -1,29 +0,0 @@
-"use strict";
-/**
- * Authentication Utilities
- *
- * This module provides utilities for handling authentication tokens,
- * including JWT detection and authorization header generation.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isJwt = isJwt;
-exports.getAuthorizationHeader = getAuthorizationHeader;
-function isJwt(token) {
-    // JWT tokens have exactly 3 parts separated by dots
-    const parts = token.split(".");
-    if (parts.length !== 3) {
-        return false;
-    }
-    // Each part should be base64url encoded (no padding)
-    // Basic validation - each part should be non-empty and contain valid base64url characters
-    const base64UrlPattern = /^[A-Za-z0-9_-]+$/;
-    return parts.every((part) => part.length > 0 && base64UrlPattern.test(part));
-}
-function getAuthorizationHeader(token) {
-    // Check if token is a JWT (has 3 parts separated by dots)
-    if (isJwt(token)) {
-        return `JWT ${token}`;
-    }
-    // Default to Bearer for other token types
-    return `Bearer ${token}`;
-}

package/dist/api/client.d.ts

@@ -1,8 +0,0 @@
-/**
- * API Client Implementation
- *
- * This module contains the core API client implementation, including
- * HTTP method handlers, response processing, and client factory functions.
- */
-import type { ApiClient, ApiClientOptions } from "./types";
-export declare function createZapierApi(options: ApiClientOptions): ApiClient;

package/dist/api/client.js

@@ -1,119 +0,0 @@
-"use strict";
-/**
- * API Client Implementation
- *
- * This module contains the core API client implementation, including
- * HTTP method handlers, response processing, and client factory functions.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createZapierApi = createZapierApi;
-const auth_1 = require("./auth");
-const debug_1 = require("./debug");
-const polling_1 = require("./polling");
-const auth_2 = require("../auth");
-function createZapierApi(options) {
-    const { baseUrl, token, getToken, debug = false, fetch: originalFetch = globalThis.fetch, } = options;
-    const debugLog = (0, debug_1.createDebugLogger)(debug);
-    const fetch = (0, debug_1.createDebugFetch)({ originalFetch, debugLog });
-    // Helper to build full URLs
-    function buildUrl(path, searchParams) {
-        const url = new URL(path, baseUrl);
-        if (searchParams) {
-            Object.entries(searchParams).forEach(([key, value]) => {
-                url.searchParams.set(key, value);
-            });
-        }
-        return url.toString();
-    }
-    // Helper to build headers
-    async function buildHeaders(options = {}) {
-        const headers = {
-            ...options.headers,
-        };
-        // Add auth header if token provided and not explicitly disabled
-        if (options.authRequired !== false) {
-            let resolvedToken = token;
-            // Token resolution precedence: explicit token > getToken() > env var
-            if (!resolvedToken && getToken) {
-                resolvedToken = await getToken();
-            }
-            if (!resolvedToken) {
-                resolvedToken = (0, auth_2.getTokenFromEnv)();
-            }
-            if (resolvedToken) {
-                headers.Authorization = (0, auth_1.getAuthorizationHeader)(resolvedToken);
-            }
-        }
-        return headers;
-    }
-    // Helper to handle responses
-    async function handleResponse(response, customErrorHandler) {
-        if (!response.ok) {
-            // Check for custom error handling first
-            if (customErrorHandler) {
-                const customError = customErrorHandler(response);
-                if (customError) {
-                    throw customError;
-                }
-            }
-            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-        }
-        // Try to parse JSON, fall back to text if that fails
-        try {
-            return await response.json();
-        }
-        catch {
-            return await response.text();
-        }
-    }
-    // Helper to perform HTTP requests with JSON handling
-    async function fetchJson(method, path, data, options = {}) {
-        const url = buildUrl(path, options.searchParams);
-        const headers = await buildHeaders(options);
-        // Add Content-Type for JSON requests with body data
-        if (data && typeof data === "object") {
-            headers["Content-Type"] = "application/json";
-        }
-        const response = await fetch(url, {
-            method,
-            headers,
-            body: data ? JSON.stringify(data) : undefined,
-        });
-        return handleResponse(response, options.customErrorHandler);
-    }
-    return {
-        async get(path, options = {}) {
-            return fetchJson("GET", path, undefined, options);
-        },
-        async post(path, data, options = {}) {
-            return fetchJson("POST", path, data, options);
-        },
-        async put(path, data, options = {}) {
-            return fetchJson("PUT", path, data, options);
-        },
-        async delete(path, options = {}) {
-            return fetchJson("DELETE", path, undefined, options);
-        },
-        async poll(path, options = {}) {
-            const url = buildUrl(path, options.searchParams);
-            const headers = await buildHeaders(options);
-            return (0, polling_1.pollUntilComplete)({
-                fetch,
-                url,
-                headers,
-                maxAttempts: options.maxAttempts,
-                initialDelay: options.initialDelay,
-                maxDelay: options.maxDelay,
-                successStatus: options.successStatus,
-                pendingStatus: options.pendingStatus,
-                resultExtractor: options.resultExtractor,
-            });
-        },
-        requireAuthTo(operation) {
-            // Check if any authentication method is available
-            if (!token && !getToken && !(0, auth_2.getTokenFromEnv)()) {
-                throw new Error(`Authentication token is required to ${operation}. Please provide token in options or set ZAPIER_TOKEN environment variable.`);
-            }
-        },
-    };
-}

package/dist/api/debug.d.ts

@@ -1,12 +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";
-export declare function createDebugLogger(enabled: boolean): DebugLogger;
-export declare function createDebugFetch(options: {
-    originalFetch: typeof globalThis.fetch;
-    debugLog: DebugLogger;
-}): (input: RequestInfo | URL, options?: RequestInit) => Promise<Response>;

package/dist/api/debug.js

@@ -1,50 +0,0 @@
-"use strict";
-/**
- * Debug Logging Utilities
- *
- * This module provides debug logging capabilities for API requests and responses,
- * including request timing and detailed logging of HTTP interactions.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDebugLogger = createDebugLogger;
-exports.createDebugFetch = createDebugFetch;
-function createDebugLogger(enabled) {
-    if (!enabled) {
-        return () => { }; // No-op function when debug is disabled
-    }
-    return (message, data) => {
-        console.log(`[Zapier SDK] ${message}`, data || "");
-    };
-}
-function createDebugFetch(options) {
-    const { originalFetch, debugLog } = options;
-    return async (input, options) => {
-        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: options?.headers,
-            body: options?.body ? JSON.parse(options.body) : undefined,
-        });
-        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/dist/api/index.d.ts

@@ -1,28 +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.
- */
-export type { ApiClient, ApiClientOptions, RequestOptions, PollOptions, DebugLogger, Integration, Action, Trigger, Field, Choice, ActionExecutionResult, ActionField, ActionFieldChoice, NeedsRequest, NeedsResponse, Authentication, AuthenticationsResponse, } from "./types";
-import type { ApiClient } from "./types";
-export { isJwt, getAuthorizationHeader } from "./auth";
-export { createDebugLogger, createDebugFetch } from "./debug";
-export { pollUntilComplete } from "./polling";
-export { createZapierApi } from "./client";
-export declare function generateRequestId(): string;
-/**
- * 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 declare function getOrCreateApiClient(config: {
-    baseUrl?: string;
-    token?: string;
-    getToken?: () => Promise<string | undefined>;
-    api?: ApiClient;
-    debug?: boolean;
-    fetch?: typeof globalThis.fetch;
-}): ApiClient;

package/dist/api/index.js

@@ -1,52 +0,0 @@
-"use strict";
-/**
- * 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.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createZapierApi = exports.pollUntilComplete = exports.createDebugFetch = exports.createDebugLogger = exports.getAuthorizationHeader = exports.isJwt = void 0;
-exports.generateRequestId = generateRequestId;
-exports.getOrCreateApiClient = getOrCreateApiClient;
-// Re-export authentication utilities
-var auth_1 = require("./auth");
-Object.defineProperty(exports, "isJwt", { enumerable: true, get: function () { return auth_1.isJwt; } });
-Object.defineProperty(exports, "getAuthorizationHeader", { enumerable: true, get: function () { return auth_1.getAuthorizationHeader; } });
-// Re-export debug utilities
-var debug_1 = require("./debug");
-Object.defineProperty(exports, "createDebugLogger", { enumerable: true, get: function () { return debug_1.createDebugLogger; } });
-Object.defineProperty(exports, "createDebugFetch", { enumerable: true, get: function () { return debug_1.createDebugFetch; } });
-// Re-export polling utilities
-var polling_1 = require("./polling");
-Object.defineProperty(exports, "pollUntilComplete", { enumerable: true, get: function () { return polling_1.pollUntilComplete; } });
-// Re-export the main client factory
-var client_1 = require("./client");
-Object.defineProperty(exports, "createZapierApi", { enumerable: true, get: function () { return client_1.createZapierApi; } });
-// Import for local use
-const client_2 = require("./client");
-// Utility Functions
-function generateRequestId() {
-    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
- */
-function getOrCreateApiClient(config) {
-    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 (0, client_2.createZapierApi)({
-        baseUrl,
-        token,
-        getToken,
-        debug,
-        fetch: customFetch,
-    });
-}