@zapier/zapier-sdk 0.4.0 → 0.4.1

package/src/api/client.ts

@@ -16,8 +16,12 @@ import { createDebugLogger, createDebugFetch } from "./debug";
 import { pollUntilComplete } from "./polling";
 import { getTokenFromEnvOrConfig } from "../auth";
 
-// Set of path prefixes that should be treated as subdomains
-const SUBDOMAIN_PREFIXES = new Set(["relay"]);
+// Configuration for path prefixes that should be treated as subdomains
+const SUBDOMAIN_PREFIXES = {
+  relay: {
+    authHeader: "X-Relay-Authorization",
+  },
+} as const;
 
 export function createZapierApi(options: ApiClientOptions): ApiClient {
   const {
@@ -32,19 +36,26 @@ export function createZapierApi(options: ApiClientOptions): ApiClient {
   const debugLog = createDebugLogger(debug);
   const fetch = createDebugFetch({ originalFetch, debugLog });
 
-  // Helper to build full URLs
+  // Helper to build full URLs and return routing info
   function buildUrl(
     path: string,
     searchParams?: Record<string, string>,
-  ): string {
+  ): {
+    url: string;
+    subdomainConfig?: (typeof SUBDOMAIN_PREFIXES)[keyof typeof SUBDOMAIN_PREFIXES];
+  } {
     // Check if this is a path that needs subdomain routing
     const pathSegments = path.split("/").filter(Boolean);
     let finalBaseUrl = baseUrl;
+    let subdomainConfig:
+      | (typeof SUBDOMAIN_PREFIXES)[keyof typeof SUBDOMAIN_PREFIXES]
+      | undefined;
 
-    if (pathSegments.length > 0 && SUBDOMAIN_PREFIXES.has(pathSegments[0])) {
+    if (pathSegments.length > 0 && pathSegments[0] in SUBDOMAIN_PREFIXES) {
       // Transform paths to use subdomain routing
       // /prefix/domain/path -> prefix.zapier.com/domain/path
-      const subdomain = pathSegments[0];
+      const subdomain = pathSegments[0] as keyof typeof SUBDOMAIN_PREFIXES;
+      subdomainConfig = SUBDOMAIN_PREFIXES[subdomain];
       const baseUrlObj = new URL(baseUrl);
       baseUrlObj.hostname = `${subdomain}.${baseUrlObj.hostname}`;
       finalBaseUrl = baseUrlObj.toString();
@@ -59,12 +70,13 @@ export function createZapierApi(options: ApiClientOptions): ApiClient {
         url.searchParams.set(key, value);
       });
     }
-    return url.toString();
+    return { url: url.toString(), subdomainConfig };
   }
 
   // Helper to build headers
   async function buildHeaders(
     options: RequestOptions = {},
+    subdomainConfig?: (typeof SUBDOMAIN_PREFIXES)[keyof typeof SUBDOMAIN_PREFIXES],
   ): Promise<Record<string, string>> {
     const headers: Record<string, string> = {
       ...options.headers,
@@ -87,7 +99,8 @@ export function createZapierApi(options: ApiClientOptions): ApiClient {
       }
 
       if (resolvedToken) {
-        headers.Authorization = getAuthorizationHeader(resolvedToken);
+        const authHeaderName = subdomainConfig?.authHeader || "Authorization";
+        headers[authHeaderName] = getAuthorizationHeader(resolvedToken);
       }
     }
 
@@ -127,21 +140,23 @@ export function createZapierApi(options: ApiClientOptions): ApiClient {
     }
   }
 
-  // Plain fetch method that matches the standard fetch signature
+  // Plain fetch method for API paths (must start with /)
   async function plainFetch(
-    input: string | URL,
+    path: string,
     init?: RequestInit & {
       searchParams?: Record<string, string>;
       authRequired?: boolean;
-      customErrorHandler?: (response: Response) => Error | undefined;
     },
   ): Promise<Response> {
-    const url =
-      typeof input === "string" && !input.startsWith("http")
-        ? buildUrl(input, init?.searchParams)
-        : input.toString();
+    if (!path.startsWith("/")) {
+      throw new Error(
+        `plainFetch expects a path starting with '/', got: ${path}`,
+      );
+    }
+
+    const { url, subdomainConfig } = buildUrl(path, init?.searchParams);
 
-    const headers = await buildHeaders(init as RequestOptions);
+    const headers = await buildHeaders(init as RequestOptions, subdomainConfig);
 
     // Merge headers from init with our built headers
     const finalHeaders = {
@@ -179,11 +194,10 @@ export function createZapierApi(options: ApiClientOptions): ApiClient {
       headers,
       searchParams: options.searchParams,
       authRequired: options.authRequired,
-      customErrorHandler: options.customErrorHandler,
     });
 
-    const hadAuthToken = !!(await buildHeaders(options)).Authorization;
-    return handleResponse(response, options.customErrorHandler, hadAuthToken);
+    // plainFetch already handled all auth and headers
+    return handleResponse(response, options.customErrorHandler);
   }
 
   return {
@@ -212,13 +226,13 @@ export function createZapierApi(options: ApiClientOptions): ApiClient {
     },
 
     async poll(path: string, options: PollOptions = {}): Promise<any> {
-      const url = buildUrl(path, options.searchParams);
-      const headers = await buildHeaders(options);
-
       return pollUntilComplete({
-        fetch,
-        url,
-        headers,
+        fetchPoll: () =>
+          plainFetch(path, {
+            method: "GET",
+            searchParams: options.searchParams,
+            authRequired: options.authRequired,
+          }),
         maxAttempts: options.maxAttempts,
         initialDelay: options.initialDelay,
         maxDelay: options.maxDelay,
@@ -229,14 +243,13 @@ export function createZapierApi(options: ApiClientOptions): ApiClient {
     },
 
     async fetch(
-      input: string | URL,
+      path: string,
       init?: RequestInit & {
         searchParams?: Record<string, string>;
         authRequired?: boolean;
-        customErrorHandler?: (response: Response) => Error | undefined;
       },
     ): Promise<Response> {
-      return plainFetch(input, init);
+      return plainFetch(path, init);
     },
   };
 }

package/src/api/polling.ts

@@ -6,9 +6,7 @@
  */
 
 export async function pollUntilComplete(options: {
-  fetch: typeof globalThis.fetch;
-  url: string;
-  headers?: Record<string, string>;
+  fetchPoll: () => Promise<Response>;
   maxAttempts?: number;
   initialDelay?: number;
   maxDelay?: number;
@@ -17,9 +15,7 @@ export async function pollUntilComplete(options: {
   resultExtractor?: (response: any) => any;
 }): Promise<any> {
   const {
-    fetch,
-    url,
-    headers = {},
+    fetchPoll,
     maxAttempts = 30,
     initialDelay = 50,
     maxDelay = 1000,
@@ -31,7 +27,7 @@ export async function pollUntilComplete(options: {
   let delay = initialDelay;
 
   for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    const response = await fetch(url, { headers });
+    const response = await fetchPoll();
 
     if (response.status === successStatus) {
       // Success - extract and return results
@@ -47,7 +43,7 @@ export async function pollUntilComplete(options: {
     } else {
       // Error occurred
       throw new Error(
-        `Request failed: GET ${url} - ${response.status} ${response.statusText}`,
+        `Poll request failed: ${response.status} ${response.statusText}`,
       );
     }
   }

package/src/api/types.ts

@@ -26,11 +26,10 @@ export interface ApiClient {
   delete: (path: string, options?: RequestOptions) => Promise<any>;
   poll: (path: string, options?: PollOptions) => Promise<any>;
   fetch: (
-    input: string | URL,
+    path: string,
     init?: RequestInit & {
       searchParams?: Record<string, string>;
       authRequired?: boolean;
-      customErrorHandler?: (response: Response) => Error | undefined;
     },
   ) => Promise<Response>;
 }

package/src/functions/{fetch → request}/index.ts

@@ -1,11 +1,11 @@
 import { getOrCreateApiClient } from "../../api";
 import type { FunctionOptions } from "../../types/domain";
 
-export interface RelayFetchOptions {
+export interface RelayRequestOptions {
   /** HTTP method */
   method?: string;
-  /** Request body as a string */
-  body?: string;
+  /** Request body (can be string, FormData, Blob, etc.) */
+  body?: BodyInit | null;
   /** Request headers */
   headers?: HeadersInit;
   /** Zapier authentication ID to use for the request */
@@ -16,6 +16,9 @@ export interface RelayFetchOptions {
   authenticationTemplate?: string;
 }
 
+// Legacy type alias
+export type RelayFetchOptions = RelayRequestOptions;
+
 export interface RelayFetchConfig extends FunctionOptions {
   /** Event callback function */
   onEvent?: (event: any) => void;
@@ -49,14 +52,14 @@ function transformUrlToRelayPath(url: string | URL): string {
  * @returns Promise<Response> - The response from the request
  */
 /**
- * Schema-compatible wrapper function for the fetch functionality
+ * Schema-compatible wrapper function for the request functionality
  */
-export async function fetch(
+export async function request(
   options: {
     url: string;
     method?: string;
-    body?: string;
-    headers?: Record<string, string>;
+    body?: BodyInit | null;
+    headers?: HeadersInit;
     authenticationId?: number;
     callbackUrl?: string;
     authenticationTemplate?: string;
@@ -92,7 +95,7 @@ export async function fetch(
  */
 export async function relayFetch(
   url: string | URL,
-  options: RelayFetchOptions = {},
+  options: RelayRequestOptions = {},
   config: RelayFetchConfig = {},
 ): Promise<Response> {
   const api = getOrCreateApiClient(config);
@@ -138,43 +141,10 @@ export async function relayFetch(
     headers["X-Authentication-Template"] = authenticationTemplate;
   }
 
-  // For Relay requests, we need to disable the default authorization and add our own
-  const requestOptions = {
-    headers,
-    authRequired: false, // Disable automatic Authorization header
-    customErrorHandler: (response: Response) => {
-      if (!response.ok) {
-        return new Error(
-          `Relay request failed: ${response.status} ${response.statusText}`,
-        );
-      }
-      return undefined;
-    },
-  };
-
-  // Add X-Relay-Authorization header manually
-  let token = config.token;
-  if (!token && config.getToken) {
-    token = await config.getToken();
-  }
-  if (!token) {
-    const { getTokenFromEnvOrConfig } = await import("../../auth");
-    token = await getTokenFromEnvOrConfig({
-      onEvent: config.onEvent,
-      fetch: config.fetch,
-    });
-  }
-  if (token) {
-    const { getAuthorizationHeader } = await import("../../api/auth");
-    headers["X-Relay-Authorization"] = getAuthorizationHeader(token);
-  }
-
-  // Use the API client's fetch method directly
+  // Use the API client's fetch method directly - let it handle auth automatically
   return await api.fetch(relayPath, {
     method,
     body,
-    headers: requestOptions.headers,
-    authRequired: requestOptions.authRequired,
-    customErrorHandler: requestOptions.customErrorHandler,
+    headers,
   });
 }

package/src/functions/request/info.ts

@@ -0,0 +1,11 @@
+import { request } from "./index";
+import { RelayRequestSchema } from "./schemas";
+
+export const requestInfo = {
+  name: "request",
+  inputSchema: RelayRequestSchema,
+  implementation: request,
+};
+
+// Legacy export for compatibility
+export const fetchInfo = requestInfo;

package/src/functions/{fetch → request}/schemas.ts

@@ -1,13 +1,13 @@
 import { z } from "zod";
 import type { FunctionOptions } from "../../types/domain";
 
-// Pure Zod schema for the fetch function
-export const RelayFetchSchema = z
+// Pure Zod schema for the request function
+export const RelayRequestSchema = z
   .object({
     url: z
       .string()
       .url()
-      .describe("The URL to fetch (will be proxied through Relay)"),
+      .describe("The URL to request (will be proxied through Relay)"),
     method: z
       .enum(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
       .optional()
@@ -34,13 +34,20 @@ export const RelayFetchSchema = z
   .describe("Make authenticated HTTP requests through Zapier's Relay service");
 
 // Type inferred from schema + function config
-export type RelayFetchOptions = z.infer<typeof RelayFetchSchema> &
+export type RelayRequestOptions = z.infer<typeof RelayRequestSchema> &
   FunctionOptions & {
     /** Base URL for Relay service */
     relayBaseUrl?: string;
   };
 
 // SDK function interface
+export interface RelayRequestSdkFunction {
+  request: (options: RelayRequestOptions) => Promise<Response>;
+}
+
+// Legacy exports for compatibility
+export const RelayFetchSchema = RelayRequestSchema;
+export type RelayFetchOptions = RelayRequestOptions;
 export interface RelayFetchSdkFunction {
   fetch: (options: RelayFetchOptions) => Promise<Response>;
 }

package/src/index.ts

@@ -2,6 +2,7 @@
 export * from "./types/domain";
 export * from "./types/properties";
 export * from "./plugins/apps";
+export * from "./plugins/fetch";
 
 // Export schema utilities for CLI
 export { isPositional } from "./schema-utils";
@@ -27,8 +28,11 @@ export { runAction } from "./functions/runAction";
 export { listFields } from "./functions/listFields";
 export { generateTypes } from "./functions/generateTypes";
 export { bundleCode } from "./functions/bundleCode";
-export { fetch, relayFetch } from "./functions/fetch";
-export { RelayFetchSchema } from "./functions/fetch/schemas";
+export { request, relayFetch } from "./functions/request";
+export {
+  RelayRequestSchema,
+  RelayFetchSchema,
+} from "./functions/request/schemas";
 
 // Export the main combined SDK
 export { createZapierSdk, ZapierSdkOptions } from "./sdk";

package/src/plugins/apps/index.ts

@@ -55,19 +55,18 @@ function createActionTypeProxy(
 ) {
   // Special handling for "fetch" action type
   if (actionType === "fetch") {
-    return async (fetchOptions: {
-      url: string;
-      method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";
-      body?: string;
-      headers?: Record<string, string>;
-      callbackUrl?: string;
-      authenticationTemplate?: string;
-      authenticationId?: number;
-    }) => {
+    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 || fetchOptions.authenticationId;
+      const authenticationId = pinnedAuthId || init?.authenticationId;
 
       if (!authenticationId) {
         throw new Error(
@@ -76,8 +75,8 @@ function createActionTypeProxy(
       }
 
       // Call sdk.fetch with the resolved authenticationId
-      return sdk.fetch({
-        ...fetchOptions,
+      return sdk.fetch(url, {
+        ...init,
         authenticationId,
       });
     };

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

@@ -13,7 +13,7 @@ import { findUniqueAuthentication } from "./functions/findUniqueAuthentication";
 import { listFields } from "./functions/listFields";
 import { generateTypes } from "./functions/generateTypes";
 import { bundleCode } from "./functions/bundleCode";
-import { fetch } from "./functions/fetch";
+import { request } from "./functions/request";
 
 // Import function registry info objects (only for CLI registry)
 import { listAppsInfo } from "./functions/listApps/info";
@@ -28,7 +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 { fetchInfo } from "./functions/fetch/info";
+import { requestInfo } from "./functions/request/info";
 
 // Function registry as array - uses names from function info objects
 const functionRegistry = [
@@ -44,7 +44,7 @@ const functionRegistry = [
   listFieldsInfo,
   generateTypesInfo,
   bundleCodeInfo,
-  fetchInfo,
+  requestInfo,
 ];
 
 // Import the properly typed SDK interfaces
@@ -52,6 +52,7 @@ 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
 
@@ -101,18 +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
-    fetch: (options) => fetch({ ...options, api }),
+    request: (options) => request({ ...options, api }),
   };
 
-  // Now extend the base SDK with plugins to create the full SDK
-  const fullSdk: ZapierSdk = {
-    ...baseSdk,
-    // Add plugins - apps plugin gets the base SDK cast as full ZapierSdk type
-    // This is safe because by the time plugin functions are called, fullSdk will be complete
-    apps: createAppsPlugin({
-      sdk: baseSdk as ZapierSdk,
-    }),
-  };
+  // 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/sdk.ts

@@ -11,10 +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 { RelayFetchSdkFunction } from "../functions/fetch/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
@@ -30,12 +31,14 @@ export interface ZapierSdkFunctions
     GenerateTypesSdkFunction,
     ListAppsSdkFunction,
     BundleCodeSdkFunction,
-    RelayFetchSdkFunction {
+    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!
 }
 

package/src/functions/fetch/info.ts

@@ -1,8 +0,0 @@
-import { fetch } from "./index";
-import { RelayFetchSchema } from "./schemas";
-
-export const fetchInfo = {
-  name: "fetch",
-  inputSchema: RelayFetchSchema,
-  implementation: fetch,
-};