@zapier/zapier-sdk 0.0.2 → 0.0.3

package/src/actions-sdk.ts

@@ -4,13 +4,19 @@ import {
   ActionExecutionOptions,
   ActionExecutionResult,
   ActionField,
-  NeedsRequest,
-  NeedsResponse,
   Authentication,
-  AuthenticationsResponse,
-  AppNotFoundError,
   BaseSdkOptions,
 } from "./types";
+import { createZapierApi, type ApiClient } from "./api";
+import { listAuths } from "./functions/listAuths";
+import { listApps } from "./functions/listApps";
+import { getApp } from "./functions/getApp";
+import { listActions } from "./functions/listActions";
+import { getAction } from "./functions/getAction";
+import { runAction } from "./functions/runAction";
+import { listFields } from "./functions/listFields";
+import { generateTypes as generateTypesFunction } from "./functions/generateTypes";
+import { bundleCode as bundleCodeFunction } from "./functions/bundleCode";
 import {
   AppsListOptions,
   AppsGetOptions,
@@ -22,7 +28,6 @@ import {
   FieldsListOptions,
   GenerateOptions,
   BundleOptions,
-  SdkSchemas,
 } from "./schemas";
 export * from "./schemas";
 export * from "./output-schemas";
@@ -69,10 +74,6 @@ export interface BundleFunction {
 export interface ActionsService {
   list(options?: ActionsListOptions): Promise<Action[]>;
   get(options: ActionsGetOptions): Promise<Action>;
-  /** @deprecated Use sdk.fields.list() instead */
-  fields(options: FieldsListOptions): Promise<ActionField[]>;
-  /** @deprecated Use sdk.fields.list() instead */
-  getFields(options: FieldsListOptions): Promise<ActionField[]>;
   run: ActionRunner & ActionProxy;
 }
 
@@ -110,52 +111,42 @@ export function createActionsSdk(options: ActionsSdkOptions = {}): ActionsSdk {
   // If no token provided, try to get it from environment variable
   const finalToken = token || process.env.ZAPIER_TOKEN;
 
-  const debugLog = createDebugLogger(debug);
-
-  // Wrap fetch with debug logging if debug is enabled
-  const wrappedFetch = debug
-    ? createDebugFetch({
-        originalFetch: customFetch,
-        debugLog,
-      })
-    : customFetch;
+  // Create the API client
+  const api = createZapierApi({
+    baseUrl,
+    token: finalToken,
+    debug,
+    fetch: customFetch,
+  });
 
   // Create SDK object - we'll populate services after creation to avoid circular dependency
   const sdk: ActionsSdk = {} as ActionsSdk;
 
   const appsService = createAppsService({
-    fetch: wrappedFetch,
-    baseUrl,
+    api,
     token: finalToken,
     authentications,
-    debugLog: debug ? debugLog : undefined,
     sdk,
   });
 
   const actionsService = createActionsService({
-    fetch: wrappedFetch,
-    baseUrl,
+    api,
     token: finalToken,
     authentications,
-    debugLog,
     sdk,
   });
 
   const authsService = createAuthsService({
-    fetch: wrappedFetch,
-    baseUrl,
+    api,
     token: finalToken,
     authentications,
-    debugLog,
     sdk,
   });
 
   const fieldsService = createFieldsService({
-    fetch: wrappedFetch,
-    baseUrl,
+    api,
     token: finalToken,
     authentications,
-    debugLog,
     sdk,
   });
 
@@ -163,17 +154,11 @@ export function createActionsSdk(options: ActionsSdkOptions = {}): ActionsSdk {
   const generateFunction: GenerateFunction = async (
     options: GenerateOptions,
   ) => {
-    // Validate options using schema
-    const validatedOptions = SdkSchemas.generate.parse(options);
-
-    return await generateTypes(validatedOptions, sdk);
+    return generateTypesFunction({ ...options, api, token: finalToken });
   };
 
   const bundleFunction: BundleFunction = async (options: BundleOptions) => {
-    // Validate options using schema
-    const validatedOptions = SdkSchemas.bundle.parse(options);
-
-    return await bundleCode(validatedOptions);
+    return bundleCodeFunction(options);
   };
 
   // Populate the SDK object
@@ -184,293 +169,59 @@ export function createActionsSdk(options: ActionsSdkOptions = {}): ActionsSdk {
   sdk.generate = generateFunction;
   sdk.bundle = bundleFunction;
 
-  if (debug) {
-    debugLog("🚀 Zapier SDK initialized", {
-      baseUrl,
-      hasAuth: !!finalToken,
-      tokenType: finalToken ? (isJwt(finalToken) ? "JWT" : "Bearer") : "none",
-      appAuthCount: authentications ? Object.keys(authentications).length : 0,
-    });
-  }
+  // Note: Debug logging for SDK initialization is now handled by the API client
 
   return sdk;
 }
 
 interface AppsServiceOptions {
-  fetch: typeof globalThis.fetch;
-  baseUrl: string;
+  api: ApiClient;
   token?: string;
   authentications?: { [appKey: string]: { id: number }[] };
-  debugLog?: (message: string, details?: any) => void;
   sdk: ActionsSdk;
 }
 
 interface AuthsServiceOptions {
-  fetch: typeof globalThis.fetch;
-  baseUrl: string;
+  api: ApiClient;
   token?: string;
   authentications?: { [appKey: string]: { id: number }[] };
-  debugLog?: (message: string, details?: any) => void;
   sdk: ActionsSdk;
 }
 
 interface ActionsServiceOptions {
-  fetch: typeof globalThis.fetch;
-  baseUrl: string;
+  api: ApiClient;
   token?: string;
   authentications?: { [appKey: string]: { id: number }[] };
-  debugLog?: (message: string, data?: any) => void;
   sdk: ActionsSdk;
 }
 
 interface FieldsServiceOptions {
-  fetch: typeof globalThis.fetch;
-  baseUrl: string;
+  api: ApiClient;
   token?: string;
   authentications?: { [appKey: string]: { id: number }[] };
-  debugLog?: (message: string, data?: any) => void;
   sdk: ActionsSdk;
 }
 
 function createAppsService(options: AppsServiceOptions): AppsService {
-  const { fetch, baseUrl, debugLog } = options;
+  const { api, token } = options;
 
   return {
     async list(options?: AppsListOptions): Promise<Integration[]> {
-      const url = new URL("/api/v4/apps/", baseUrl);
-
-      // Add query parameters if provided
-      if (options?.category) {
-        url.searchParams.set("category", options.category);
-      }
-      if (options?.limit) {
-        url.searchParams.set("limit", options.limit.toString());
-      }
-      if (options?.offset) {
-        url.searchParams.set("offset", options.offset.toString());
-      }
-
-      const response = await fetch(url.toString());
-      if (!response.ok) {
-        throw new Error(
-          `Failed to fetch apps: ${response.status} ${response.statusText}`,
-        );
-      }
-
-      const data = await response.json();
-
-      // Debug: Log pagination info if debug is enabled
-      if (debugLog) {
-        debugLog("API Response Pagination Info", {
-          resultsCount: data.results?.length || 0,
-          hasNext: !!data.next,
-          hasPrevious: !!data.previous,
-          count: data.count,
-          nextUrl: data.next,
-          previousUrl: data.previous,
-        });
-      }
-
-      // Transform API response to our Integration interface
-      const apps =
-        data.results?.map(
-          (app: any): Integration => ({
-            key: app.slug,
-            name: app.name,
-            description: app.description,
-            version: "1.0.0", // API doesn't provide version
-            category: app.category?.name,
-            actions: [], // Will be populated separately
-            triggers: [],
-            current_implementation_id: app.current_implementation_id,
-          }),
-        ) || [];
-
-      // Add pagination metadata to the response
-      if (apps.length > 0) {
-        (apps as any).__pagination = {
-          count: data.count,
-          hasNext: !!data.next,
-          hasPrevious: !!data.previous,
-          nextUrl: data.next,
-          previousUrl: data.previous,
-        };
-      }
-
-      return apps;
+      return listApps({ ...options, api, token });
     },
 
     async get(options: AppsGetOptions): Promise<Integration> {
-      const { key } = options;
-      const url = new URL(`/api/v4/apps/${key}/`, baseUrl);
-
-      const response = await fetch(url.toString());
-      if (!response.ok) {
-        if (response.status === 404) {
-          throw new AppNotFoundError(key);
-        }
-        throw new Error(
-          `Failed to fetch app: ${response.status} ${response.statusText}`,
-        );
-      }
-
-      const app = await response.json();
-
-      return {
-        key: app.slug,
-        name: app.name,
-        description: app.description,
-        version: "1.0.0",
-        category: app.category?.name,
-        actions: [],
-        triggers: [],
-        current_implementation_id: app.current_implementation_id,
-      };
+      return getApp({ ...options, api, token });
     },
   };
 }
 
 function createAuthsService(options: AuthsServiceOptions): AuthsService {
-  const { fetch, baseUrl, token, authentications, debugLog, sdk } = options;
-
-  // Local function to handle the actual API fetching
-  const listAuths = async (
-    options?: AuthsListOptions,
-  ): Promise<Authentication[]> => {
-    const url = new URL("/api/v4/authentications/", baseUrl);
-
-    // Handle appKey filtering by getting the selected_api first
-    if (options?.appKey) {
-      try {
-        // Use the SDK's getApp function instead of duplicating the API call
-        const appData = await sdk.apps.get({ key: options.appKey });
-        const selectedApi = appData.current_implementation_id;
-        if (selectedApi) {
-          // Use versionless_selected_api to find auths across all app versions
-          // Extract the base name without the version (e.g., "SlackCLIAPI" from "SlackCLIAPI@1.21.1")
-          const versionlessApi = selectedApi.split("@")[0];
-          url.searchParams.set("versionless_selected_api", versionlessApi);
-        }
-      } catch (error) {
-        // If it's an AppNotFoundError, re-throw it
-        if (error instanceof AppNotFoundError) {
-          throw error;
-        }
-        // For other errors, continue without app filtering
-        console.warn(
-          `Warning: Could not filter by app ${options.appKey}:`,
-          error instanceof Error ? error.message : "Unknown error",
-        );
-      }
-    }
-
-    // Add other query parameters if provided
-    if (options?.account_id) {
-      url.searchParams.set("account_id", options.account_id);
-    }
-    if (options?.owner) {
-      url.searchParams.set("owner", options.owner);
-    }
-    if (options?.limit) {
-      url.searchParams.set("limit", options.limit.toString());
-    }
-    if (options?.offset) {
-      url.searchParams.set("offset", options.offset.toString());
-    }
-
-    // Build headers with auth if available
-    const headers: Record<string, string> = {};
-
-    if (token) {
-      headers["Authorization"] = getAuthorizationHeader(token);
-    } else {
-      throw new Error(
-        "Authentication token is required to list authentications. Please provide token when creating the SDK.",
-      );
-    }
-
-    const response = await fetch(url.toString(), { headers });
-    if (!response.ok) {
-      if (response.status === 401) {
-        throw new Error(
-          `Authentication failed. Your token may not have permission to access authentications or may be expired. (HTTP ${response.status})`,
-        );
-      }
-      if (response.status === 403) {
-        throw new Error(
-          `Access forbidden. Your token may not have the required scopes to list authentications. (HTTP ${response.status})`,
-        );
-      }
-      throw new Error(
-        `Failed to fetch authentications: ${response.status} ${response.statusText}`,
-      );
-    }
-
-    const data: AuthenticationsResponse = await response.json();
-
-    // Debug: Log pagination info if debug is enabled
-    if (debugLog) {
-      debugLog("API Response Pagination Info", {
-        resultsCount: data.results?.length || 0,
-        hasNext: !!data.next,
-        hasPrevious: !!data.previous,
-        count: data.count,
-        nextUrl: data.next,
-        previousUrl: data.previous,
-      });
-    }
-
-    // Transform API response
-    const auths = data.results || [];
-
-    // Add pagination metadata to the response
-    if (auths.length > 0) {
-      (auths as any).__pagination = {
-        count: data.count,
-        hasNext: !!data.next,
-        hasPrevious: !!data.previous,
-        nextUrl: data.next,
-        previousUrl: data.previous,
-      };
-    }
-
-    return auths;
-  };
+  const { api, token, authentications } = options;
 
   return {
     async list(options?: AuthsListOptions): Promise<Authentication[]> {
-      // If a limit is provided and no specific owner filter, prioritize owned auths
-      if (options?.limit && options?.owner === undefined) {
-        // First get owned auths
-        const ownedAuths = await listAuths({
-          ...options,
-          owner: "me",
-        });
-
-        // If we have enough owned auths, just slice and return
-        if (ownedAuths.length >= options.limit) {
-          return ownedAuths.slice(0, options.limit);
-        }
-
-        // Get all auths up to the original limit to fill remaining slots
-        const allAuths = await listAuths({
-          ...options,
-          owner: undefined,
-        });
-
-        // Filter out auths the user already owns to avoid duplicates
-        const ownedAuthIds = new Set(ownedAuths.map((auth) => auth.id));
-        const additionalAuths = allAuths.filter(
-          (auth) => !ownedAuthIds.has(auth.id),
-        );
-
-        // Combine and slice to the requested limit
-        const combined = [...ownedAuths, ...additionalAuths];
-        return combined.slice(0, options.limit);
-      }
-
-      // Standard implementation for non-prioritized requests
-      return listAuths(options);
+      return listAuths({ ...options, api, token });
     },
 
     find(options: { appKey: string }): number {
@@ -498,260 +249,26 @@ function createAuthsService(options: AuthsServiceOptions): AuthsService {
 }
 
 function createFieldsService(options: FieldsServiceOptions): FieldsService {
-  const { fetch, baseUrl, token, sdk } = options;
+  const { api, token } = options;
 
   return {
     async list(options: FieldsListOptions): Promise<ActionField[]> {
-      // Map consistent parameter names to internal API names
-      const { app, action, type, authId, params } = options;
-      const appKey = app;
-      const actionKey = action;
-      const actionType = type;
-
-      // Build headers with auth if available
-      const headers: Record<string, string> = {};
-      if (token) {
-        headers["Authorization"] = getAuthorizationHeader(token);
-      }
-
-      // Use the SDK's getApp function instead of duplicating the API call
-      const appData = await sdk.apps.get({ key: appKey });
-      const selectedApi = appData.current_implementation_id;
-
-      if (!selectedApi) {
-        throw new Error("No current_implementation_id found for app");
-      }
-
-      // Build needs request
-      const needsRequest: NeedsRequest = {
-        selected_api: selectedApi,
-        action: actionKey,
-        type_of: actionType,
-        authentication_id: authId,
-        params: params || {},
-      };
-
-      const needsUrl = new URL("/api/v4/implementations/needs/", baseUrl);
-
-      // Add Content-Type to headers
-      const needsHeaders = { ...headers, "Content-Type": "application/json" };
-
-      const needsResponse = await fetch(needsUrl.toString(), {
-        method: "POST",
-        headers: needsHeaders,
-        body: JSON.stringify(needsRequest),
-      });
-
-      if (!needsResponse.ok) {
-        // Add more detailed error info for debugging
-        let errorMessage = `Failed to fetch action fields: ${needsResponse.status} ${needsResponse.statusText}`;
-        try {
-          const errorBody = await needsResponse.text();
-          errorMessage += ` - ${errorBody}`;
-        } catch {
-          // Ignore error reading response body
-        }
-        throw new Error(errorMessage);
-      }
-
-      const needsData: NeedsResponse = await needsResponse.json();
-
-      if (!needsData.success) {
-        throw new Error(
-          `Failed to get action fields: ${
-            needsData.errors?.join(", ") || "Unknown error"
-          }`,
-        );
-      }
-
-      // Transform API response to our ActionField interface
-      return (needsData.needs || []).map((need: any) => ({
-        key: need.key,
-        label: need.label,
-        required: need.required || false,
-        type: need.type,
-        helpText: need.help_text,
-        helpTextHtml: need.help_text_html,
-        choices: need.choices?.map((choice: any) => ({
-          value: choice.value,
-          label: choice.label,
-        })),
-        default: need.default,
-        placeholder: need.placeholder,
-        computed: need.computed,
-        customField: need.custom_field,
-        dependsOn: need.depends_on,
-        format: need.format,
-        inputFormat: need.input_format,
-      }));
+      return listFields({ ...options, api, token });
     },
   };
 }
 
 function createActionsService(options: ActionsServiceOptions): ActionsService {
-  const { fetch, baseUrl, token, authentications, debugLog, sdk } = options;
+  const { api, token, authentications } = options;
 
   // Create the base service with named methods
   const baseService: ActionsService = {
     async list(options?: ActionsListOptions): Promise<Action[]> {
-      // If filtering by appKey, use optimized approach with selected_apis parameter
-      if (options?.appKey) {
-        try {
-          // Use the SDK's getApp function instead of duplicating the API call
-          const appData = await sdk.apps.get({ key: options.appKey });
-
-          // Extract implementation name from current_implementation_id (e.g., "SlackCLIAPI@1.20.0" -> "SlackCLIAPI")
-          const implementationId =
-            appData.current_implementation_id?.split("@")[0];
-          if (!implementationId) {
-            throw new Error("No current_implementation_id found for app");
-          }
-
-          const url = new URL("/api/v4/implementations/", baseUrl);
-          url.searchParams.set("global", "true");
-          url.searchParams.set("public_only", "true");
-          url.searchParams.set("selected_apis", implementationId);
-
-          const response = await fetch(url.toString());
-          if (!response.ok) {
-            throw new Error(
-              `Failed to fetch actions: ${response.status} ${response.statusText}`,
-            );
-          }
-
-          const data = await response.json();
-          const actions: Action[] = [];
-
-          // Transform implementations to actions
-          for (const implementation of data.results || []) {
-            if (implementation.actions) {
-              for (const action of implementation.actions) {
-                const transformedAction: Action = {
-                  key: action.key,
-                  name: action.name || action.label,
-                  description: action.description || "",
-                  appKey: implementation.slug || "",
-                  type: action.type || action.type_of || "read",
-                  inputFields: [], // Would need additional API call for detailed fields
-                  outputFields: [],
-                };
-
-                // Apply type filter if provided
-                if (options?.type && transformedAction.type !== options.type) {
-                  continue;
-                }
-
-                actions.push(transformedAction);
-              }
-            }
-          }
-
-          // Add pagination metadata for app-specific queries
-          if (actions.length > 0) {
-            (actions as any).__pagination = {
-              count: data.count,
-              hasNext: !!data.next,
-              hasPrevious: !!data.previous,
-              nextUrl: data.next,
-              previousUrl: data.previous,
-            };
-          }
-
-          return actions;
-        } catch (error) {
-          // If it's an AppNotFoundError, don't try fallback - just re-throw
-          if (error instanceof AppNotFoundError) {
-            throw error;
-          }
-          // Fallback to original approach if optimized approach fails
-          console.warn(
-            "Optimized app lookup failed, falling back to full scan:",
-            error,
-          );
-        }
-      }
-
-      // Original approach for general queries or when optimization fails
-      const url = new URL("/api/v4/implementations/", baseUrl);
-
-      // Add query parameters
-      url.searchParams.set("global", "true");
-      url.searchParams.set("public_only", "true");
-
-      const response = await fetch(url.toString());
-      if (!response.ok) {
-        throw new Error(
-          `Failed to fetch actions: ${response.status} ${response.statusText}`,
-        );
-      }
-
-      const data = await response.json();
-      const actions: Action[] = [];
-
-      // Transform implementations to actions
-      for (const implementation of data.results || []) {
-        if (implementation.actions) {
-          for (const action of implementation.actions) {
-            const transformedAction: Action = {
-              key: action.key,
-              name: action.name || action.label,
-              description: action.description || "",
-              appKey: implementation.slug || "",
-              type: action.type || action.type_of || "read",
-              inputFields: [], // Would need additional API call for detailed fields
-              outputFields: [],
-            };
-
-            // Apply filters
-            if (
-              options?.appKey &&
-              transformedAction.appKey !== options.appKey
-            ) {
-              continue;
-            }
-            if (options?.type && transformedAction.type !== options.type) {
-              continue;
-            }
-
-            actions.push(transformedAction);
-          }
-        }
-      }
-
-      // Add pagination metadata for general queries
-      if (actions.length > 0) {
-        (actions as any).__pagination = {
-          count: data.count,
-          hasNext: !!data.next,
-          hasPrevious: !!data.previous,
-          nextUrl: data.next,
-          previousUrl: data.previous,
-        };
-      }
-
-      return actions;
+      return listActions({ ...options, api, token });
     },
 
     async get(options: ActionsGetOptions): Promise<Action> {
-      const { app, action: actionKey, type } = options;
-      const actions = await baseService.list({ appKey: app });
-      const action = actions.find(
-        (a) => a.key === actionKey && a.type === type,
-      );
-
-      if (!action) {
-        throw new Error(`Action not found: ${actionKey} with type ${type}`);
-      }
-
-      return action;
-    },
-
-    async fields(options: FieldsListOptions): Promise<ActionField[]> {
-      return await sdk.fields.list(options);
-    },
-
-    async getFields(options: FieldsListOptions): Promise<ActionField[]> {
-      return await sdk.fields.list(options);
+      return getAction({ ...options, api, token });
     },
 
     // run will be replaced with function/proxy pattern below
@@ -763,20 +280,6 @@ function createActionsService(options: ActionsServiceOptions): ActionsService {
   ): Promise<ActionExecutionResult> => {
     const { app, type, action, inputs, authId: providedAuthId } = params;
 
-    // Validate that the action exists
-    const actionData = await baseService.get({
-      app: app,
-      action: action,
-      type: type,
-    });
-
-    // Validate action type matches
-    if (actionData.type !== type) {
-      throw new Error(
-        `Action type mismatch: expected ${type}, got ${actionData.type}`,
-      );
-    }
-
     // Resolve auth ID for this specific app
     let authId: number | undefined = providedAuthId;
 
@@ -793,29 +296,16 @@ function createActionsService(options: ActionsServiceOptions): ActionsService {
       authId = auths[0].id;
     }
 
-    // Execute the action using the appropriate API based on action type
-    const startTime = Date.now();
-    const result = await executeActionWithStrategy({
-      fetch,
-      baseUrl,
-      appSlug: app,
-      actionKey: action,
-      actionType: actionData.type,
-      executionOptions: { inputs: inputs || {} },
-      auth: token ? { token: token, authentication_id: authId } : undefined,
-      debugLog,
-      sdk,
+    // Delegate to standalone runAction function
+    return runAction({
+      app,
+      type,
+      action,
+      inputs,
+      authId,
+      api,
+      token,
     });
-    const executionTime = Date.now() - startTime;
-
-    return {
-      success: true,
-      data: result,
-      metadata: {
-        executionTime,
-        requestId: generateRequestId(),
-      },
-    };
   };
 
   // Create proxy wrapper for the run function
@@ -864,822 +354,3 @@ function createActionsService(options: ActionsServiceOptions): ActionsService {
   // Return the service with the new run function/proxy
   return baseService;
 }
-
-interface ExecuteActionStrategyOptions {
-  fetch: typeof globalThis.fetch;
-  baseUrl: string;
-  appSlug: string;
-  actionKey: string;
-  actionType: string;
-  executionOptions: ActionExecutionOptions;
-  auth?: { token: string; authentication_id?: number };
-  debugLog?: (message: string, data?: any) => void;
-  sdk: ActionsSdk;
-}
-
-async function executeActionWithStrategy(
-  options: ExecuteActionStrategyOptions,
-): Promise<any> {
-  const {
-    fetch,
-    baseUrl,
-    appSlug,
-    actionKey,
-    actionType,
-    executionOptions,
-    auth,
-    debugLog,
-    sdk,
-  } = options;
-  debugLog?.("🎯 Choosing execution strategy", { actionType });
-
-  // Actions API supports: read, read_bulk, write
-  // Invoke API supports: search, read, write, read_bulk, and more
-
-  const actionsApiTypes = ["read", "read_bulk", "write"];
-  const useActionsApi = actionsApiTypes.includes(actionType);
-
-  if (useActionsApi) {
-    debugLog?.("🔧 Using Actions API", {
-      actionType,
-      reason: "supported type",
-    });
-    return executeActionViaActionsApi({
-      fetch,
-      baseUrl,
-      appSlug,
-      actionKey,
-      actionType,
-      executionOptions,
-      auth,
-      debugLog,
-      sdk,
-    });
-  } else {
-    debugLog?.("🔧 Using Invoke API", {
-      actionType,
-      reason: "unsupported by Actions API",
-    });
-    return executeActionViaInvokeApi({
-      fetch,
-      baseUrl,
-      appSlug,
-      actionKey,
-      actionType,
-      executionOptions,
-      auth,
-      debugLog,
-      sdk,
-    });
-  }
-}
-
-interface ExecuteActionViaActionsApiOptions {
-  fetch: typeof globalThis.fetch;
-  baseUrl: string;
-  appSlug: string;
-  actionKey: string;
-  actionType: string;
-  executionOptions: ActionExecutionOptions;
-  auth?: { token: string; authentication_id?: number };
-  debugLog?: (message: string, data?: any) => void;
-  sdk: ActionsSdk;
-}
-
-async function executeActionViaActionsApi(
-  options: ExecuteActionViaActionsApiOptions,
-): Promise<any> {
-  const {
-    fetch,
-    baseUrl,
-    appSlug,
-    actionKey,
-    actionType,
-    executionOptions,
-    auth,
-    sdk,
-  } = options;
-  // Note: Action validation is handled by the caller before reaching this function
-
-  // Use the SDK's getApp function instead of duplicating the API call
-  const appData = await sdk.apps.get({ key: appSlug });
-  const selectedApi = appData.current_implementation_id;
-
-  if (!selectedApi) {
-    throw new Error("No current_implementation_id found for app");
-  }
-
-  if (!auth?.token) {
-    throw new Error(
-      "Authentication token is required. Please provide token when creating the SDK.",
-    );
-  }
-
-  // Determine if token is JWT and use appropriate prefix
-  const authHeader = getAuthorizationHeader(auth.token);
-
-  // Step 1: POST to /actions/v1/runs to start execution
-  const runRequest = {
-    data: {
-      authentication_id: auth.authentication_id || 1,
-      selected_api: selectedApi,
-      action_key: actionKey,
-      action_type: actionType,
-      inputs: executionOptions.inputs || {},
-    },
-  };
-
-  const runUrl = `${baseUrl}/api/actions/v1/runs`;
-
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: authHeader,
-  };
-
-  const runResponse = await fetch(runUrl, {
-    method: "POST",
-    headers,
-    body: JSON.stringify(runRequest),
-  });
-
-  if (!runResponse.ok) {
-    throw new Error(
-      `Failed to start action execution: POST ${runUrl} - ${runResponse.status} ${runResponse.statusText}`,
-    );
-  }
-
-  const runData = await runResponse.json();
-  const runId = runData.data.id;
-
-  // Step 2: Poll GET /actions/v1/runs/{run_id} for results
-  return await pollForResults({ fetch, baseUrl, runId, authHeader });
-}
-
-interface PollForResultsOptions {
-  fetch: typeof globalThis.fetch;
-  baseUrl: string;
-  runId: string;
-  authHeader: string;
-}
-
-async function pollForResults(options: PollForResultsOptions): Promise<any> {
-  const { fetch, baseUrl, runId, authHeader } = options;
-  let delay = 50; // Start with 50ms
-  const maxDelay = 1000; // Cap at 1 second
-  const maxAttempts = 30; // Maximum number of polling attempts
-
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    const pollUrl = `${baseUrl}/api/actions/v1/runs/${runId}`;
-
-    const response = await fetch(pollUrl, {
-      headers: {
-        Authorization: authHeader,
-      },
-    });
-
-    if (response.status === 200) {
-      // Action completed
-      const result = await response.json();
-      return result.data;
-    } else if (response.status === 202) {
-      // Still processing, wait and try again
-      await new Promise((resolve) => setTimeout(resolve, delay));
-      delay = Math.min(delay * 2, maxDelay); // Double delay up to max
-      continue;
-    } else {
-      // Error occurred
-      throw new Error(
-        `Failed to fetch action results: GET ${pollUrl} - ${response.status} ${response.statusText}`,
-      );
-    }
-  }
-
-  throw new Error(`Action execution timed out after ${maxAttempts} attempts`);
-}
-
-interface ExecuteActionViaInvokeApiOptions {
-  fetch: typeof globalThis.fetch;
-  baseUrl: string;
-  appSlug: string;
-  actionKey: string;
-  actionType: string;
-  executionOptions: ActionExecutionOptions;
-  auth?: { token: string; authentication_id?: number };
-  debugLog?: (message: string, data?: any) => void;
-  sdk: ActionsSdk;
-}
-
-async function executeActionViaInvokeApi(
-  options: ExecuteActionViaInvokeApiOptions,
-): Promise<any> {
-  const {
-    fetch,
-    baseUrl,
-    appSlug,
-    actionKey,
-    actionType,
-    executionOptions,
-    auth,
-    sdk,
-  } = options;
-  // Note: Action and app validation is handled by the caller before reaching this function
-
-  // Use the SDK's getApp function instead of duplicating the API call
-  const appData = await sdk.apps.get({ key: appSlug });
-  const selectedApi = appData.current_implementation_id;
-
-  if (!selectedApi) {
-    throw new Error("No current_implementation_id found for app");
-  }
-
-  if (!auth?.token) {
-    throw new Error(
-      "Authentication token is required. Please provide token when creating the SDK.",
-    );
-  }
-
-  // Determine if token is JWT and use appropriate prefix
-  const authHeader = getAuthorizationHeader(auth.token);
-
-  // Step 1: POST to /invoke/v1/invoke to start execution
-  const invokeRequest = {
-    selected_api: selectedApi,
-    action: actionKey,
-    type_of: actionType,
-    authentication_id: auth.authentication_id || 1,
-    params: executionOptions.inputs || {},
-  };
-
-  const invokeUrl = `${baseUrl}/api/invoke/v1/invoke`;
-
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: authHeader,
-  };
-
-  const invokeResponse = await fetch(invokeUrl, {
-    method: "POST",
-    headers,
-    body: JSON.stringify(invokeRequest),
-  });
-
-  if (!invokeResponse.ok) {
-    throw new Error(
-      `Failed to start action execution: POST ${invokeUrl} - ${invokeResponse.status} ${invokeResponse.statusText}`,
-    );
-  }
-
-  const invokeData = await invokeResponse.json();
-  const invocationId = invokeData.invocation_id;
-
-  // Step 2: Poll GET /invoke/v1/invoke/{invocation_id} for results
-  return await pollForInvokeResults({
-    fetch,
-    baseUrl,
-    invocationId,
-    authHeader,
-  });
-}
-
-interface PollForInvokeResultsOptions {
-  fetch: typeof globalThis.fetch;
-  baseUrl: string;
-  invocationId: string;
-  authHeader: string;
-}
-
-async function pollForInvokeResults(
-  options: PollForInvokeResultsOptions,
-): Promise<any> {
-  const { fetch, baseUrl, invocationId, authHeader } = options;
-  let delay = 50; // Start with 50ms
-  const maxDelay = 1000; // Cap at 1 second
-  const maxAttempts = 30; // Maximum number of polling attempts
-
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    const pollUrl = `${baseUrl}/api/invoke/v1/invoke/${invocationId}`;
-
-    const response = await fetch(pollUrl, {
-      headers: {
-        Authorization: authHeader,
-      },
-    });
-
-    if (response.status === 200) {
-      // Action completed
-      const result = await response.json();
-      return result.results || result;
-    } else if (response.status === 202) {
-      // Still processing, wait and try again
-      await new Promise((resolve) => setTimeout(resolve, delay));
-      delay = Math.min(delay * 2, maxDelay); // Double delay up to max
-      continue;
-    } else {
-      // Error occurred
-      throw new Error(
-        `Failed to fetch action results: GET ${pollUrl} - ${response.status} ${response.statusText}`,
-      );
-    }
-  }
-
-  throw new Error(`Action execution timed out after ${maxAttempts} attempts`);
-}
-
-function generateRequestId(): string {
-  return Math.random().toString(36).substring(2) + Date.now().toString(36);
-}
-
-function getAuthorizationHeader(token: string): string {
-  // 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}`;
-}
-
-function isJwt(token: string): boolean {
-  // 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 createDebugLogger(enabled: boolean) {
-  if (!enabled) {
-    return () => {}; // No-op function when debug is disabled
-  }
-
-  return (message: string, data?: any) => {
-    const timestamp = new Date().toISOString();
-    if (data) {
-      console.log(`[${timestamp}] Zapier SDK: ${message}`, data);
-    } else {
-      console.log(`[${timestamp}] Zapier SDK: ${message}`);
-    }
-  };
-}
-
-interface DebugFetchOptions {
-  originalFetch: typeof globalThis.fetch;
-  debugLog: (message: string, data?: any) => void;
-}
-
-function createDebugFetch(options: DebugFetchOptions) {
-  const { originalFetch, debugLog } = options;
-  return async (input: RequestInfo | URL, options?: RequestInit) => {
-    const startTime = Date.now();
-
-    // Convert input to URL string for logging
-    const urlString =
-      input instanceof URL
-        ? input.toString()
-        : typeof input === "string"
-          ? input
-          : input.url;
-
-    // Log request
-    const requestInfo = {
-      method: options?.method || "GET",
-      url: urlString,
-      headers: options?.headers
-        ? maskSensitiveHeaders(options.headers)
-        : undefined,
-      hasBody: !!options?.body,
-    };
-
-    debugLog("📤 HTTP Request", requestInfo);
-
-    try {
-      const response = await originalFetch(input, options);
-      const duration = Date.now() - startTime;
-
-      // Log response
-      debugLog("📥 HTTP Response", {
-        status: response.status,
-        statusText: response.statusText,
-        ok: response.ok,
-        duration: `${duration}ms`,
-        url: urlString,
-      });
-
-      return response;
-    } catch (error) {
-      const duration = Date.now() - startTime;
-
-      debugLog("❌ HTTP Error", {
-        error: error instanceof Error ? error.message : "Unknown error",
-        duration: `${duration}ms`,
-        url: urlString,
-      });
-
-      throw error;
-    }
-  };
-}
-
-function maskSensitiveHeaders(headers: HeadersInit): Record<string, string> {
-  const maskedHeaders: Record<string, string> = {};
-
-  if (headers instanceof Headers) {
-    headers.forEach((value, key) => {
-      maskedHeaders[key] =
-        key.toLowerCase() === "authorization" ? maskToken(value) : value;
-    });
-  } else if (Array.isArray(headers)) {
-    headers.forEach(([key, value]) => {
-      maskedHeaders[key] =
-        key.toLowerCase() === "authorization" ? maskToken(value) : value;
-    });
-  } else {
-    Object.entries(headers).forEach(([key, value]) => {
-      maskedHeaders[key] =
-        key.toLowerCase() === "authorization" ? maskToken(value) : value;
-    });
-  }
-
-  return maskedHeaders;
-}
-
-function maskToken(token: string): string {
-  if (token.length <= 8) {
-    return "***";
-  }
-
-  // Show first 4 and last 4 characters, mask the middle
-  const start = token.substring(0, 4);
-  const end = token.substring(token.length - 4);
-  const middle = "*".repeat(Math.min(token.length - 8, 20)); // Cap mask length
-
-  return `${start}${middle}${end}`;
-}
-
-// ============================================================================
-// Generate Implementation
-// ============================================================================
-
-interface ActionWithActionFields extends Omit<Action, "inputFields"> {
-  inputFields: ActionField[];
-}
-
-async function generateTypes(
-  options: GenerateOptions,
-  sdk: ActionsSdk,
-): Promise<string> {
-  const { appKey, authId, output = `./types/${appKey}.d.ts` } = options;
-
-  // Parse app identifier (support app@version format)
-  const { app, version } = parseAppIdentifier(appKey);
-
-  // Fetch all actions for the app
-  const actions = await sdk.actions.list({ appKey: app });
-
-  if (actions.length === 0) {
-    const typeDefinitions = generateEmptyTypesFile(app, version);
-
-    if (output) {
-      const fs = await import("fs");
-      const path = await import("path");
-      fs.mkdirSync(path.dirname(output), { recursive: true });
-      fs.writeFileSync(output, typeDefinitions, "utf8");
-    }
-
-    return typeDefinitions;
-  }
-
-  // Fetch input fields for each action
-  const actionsWithFields: ActionWithActionFields[] = [];
-
-  if (authId) {
-    for (const action of actions) {
-      try {
-        const fields = await sdk.fields.list({
-          app: action.appKey,
-          action: action.key,
-          type: action.type,
-          authId: authId,
-        });
-        actionsWithFields.push({ ...action, inputFields: fields });
-      } catch {
-        // If we can't get fields for an action, include it without fields
-        actionsWithFields.push({ ...action, inputFields: [] });
-      }
-    }
-  } else {
-    // Convert actions to have empty input fields (will generate generic types)
-    actions.forEach((action) => {
-      actionsWithFields.push({ ...action, inputFields: [] });
-    });
-  }
-
-  // Generate TypeScript types
-  const typeDefinitions = generateTypeDefinitions(
-    app,
-    actionsWithFields,
-    version,
-  );
-
-  // Write to file if output path specified
-  if (output) {
-    const fs = await import("fs");
-    const path = await import("path");
-    fs.mkdirSync(path.dirname(output), { recursive: true });
-    fs.writeFileSync(output, typeDefinitions, "utf8");
-  }
-
-  return typeDefinitions;
-}
-
-function parseAppIdentifier(identifier: string): {
-  app: string;
-  version?: string;
-} {
-  const parts = identifier.split("@");
-  return {
-    app: parts[0],
-    version: parts[1],
-  };
-}
-
-function generateTypeDefinitions(
-  appKey: string,
-  actions: ActionWithActionFields[],
-  version?: string,
-): string {
-  // Handle empty actions
-  if (actions.length === 0) {
-    return generateEmptyTypesFile(appKey, version);
-  }
-
-  // Group actions by type
-  const actionsByType = actions.reduce(
-    (acc, action) => {
-      if (!acc[action.type]) {
-        acc[action.type] = [];
-      }
-      acc[action.type].push(action);
-      return acc;
-    },
-    {} as Record<string, ActionWithActionFields[]>,
-  );
-
-  const appName = capitalize(appKey);
-  const versionComment = version
-    ? ` * Generated for ${appKey}@${version}`
-    : ` * Generated for ${appKey}`;
-
-  let output = `/* eslint-disable @typescript-eslint/naming-convention */
-/**
- * Auto-generated TypeScript types for Zapier ${appKey} actions
-${versionComment}
- * Generated on: ${new Date().toISOString()}
- * 
- * Usage:
- *   import type { ${appName}Actions } from './path/to/this/file'
- *   const sdk: ActionsSdk & { actions: ${appName}Actions } = createActionsSdk(...)
- */
-
-import type { ActionExecutionOptions, ActionExecutionResult } from '@zapier/zapier-sdk'
-
-`;
-
-  // Generate input types for each action
-  actions.forEach((action) => {
-    if (action.inputFields.length > 0) {
-      const inputTypeName = `${appName}${capitalize(action.type)}${capitalize(
-        sanitizeActionName(action.key),
-      )}Inputs`;
-
-      output += `interface ${inputTypeName} {\n`;
-
-      action.inputFields.forEach((field) => {
-        const isOptional = !field.required;
-        const fieldType = mapFieldTypeToTypeScript(field);
-        const description = field.helpText
-          ? `  /** ${escapeComment(field.helpText)} */\n`
-          : "";
-
-        output += `${description}  ${sanitizeFieldName(field.key)}${
-          isOptional ? "?" : ""
-        }: ${fieldType}\n`;
-      });
-
-      output += `}\n\n`;
-    }
-  });
-
-  // Generate action type interfaces for each action type
-  Object.entries(actionsByType).forEach(([actionType, typeActions]) => {
-    const typeName = `${appName}${capitalize(actionType)}Actions`;
-
-    output += `interface ${typeName} {\n`;
-
-    typeActions.forEach((action: ActionWithActionFields) => {
-      const actionName = sanitizeActionName(action.key);
-      const description = action.description
-        ? `  /** ${escapeComment(action.description)} */\n`
-        : "";
-
-      // Generate type-safe action method signature
-      if (action.inputFields.length > 0) {
-        const inputTypeName = `${appName}${capitalize(action.type)}${capitalize(
-          sanitizeActionName(action.key),
-        )}Inputs`;
-        output += `${description}  ${actionName}: (options: { inputs: ${inputTypeName} } & Omit<ActionExecutionOptions, 'inputs'>) => Promise<ActionExecutionResult>\n`;
-      } else {
-        // No specific input fields available - use generic Record<string, any> for inputs
-        output += `${description}  ${actionName}: (options?: { inputs?: Record<string, any> } & ActionExecutionOptions) => Promise<ActionExecutionResult>\n`;
-      }
-    });
-
-    output += `}\n\n`;
-  });
-
-  // Generate the main app actions interface
-  output += `export interface ${appName}Actions {\n`;
-  output += `  run: {\n`;
-  output += `    ${appKey}: {\n`;
-
-  Object.keys(actionsByType).forEach((actionType) => {
-    const typeName = `${appName}${capitalize(actionType)}Actions`;
-    output += `      ${actionType}: ${typeName}\n`;
-  });
-
-  output += `    }\n`;
-  output += `  }\n`;
-  output += `}\n`;
-
-  return output;
-}
-
-function generateEmptyTypesFile(appKey: string, version?: string): string {
-  const appName = capitalize(appKey);
-  const versionComment = version
-    ? ` * Generated for ${appKey}@${version}`
-    : ` * Generated for ${appKey}`;
-
-  return `/* eslint-disable @typescript-eslint/naming-convention */
-/**
- * Auto-generated TypeScript types for Zapier ${appKey} actions
-${versionComment}
- * Generated on: ${new Date().toISOString()}
- * 
- * No actions found for this app.
- */
-
-import type { ActionExecutionOptions, ActionExecutionResult } from '@zapier/zapier-sdk'
-
-export interface ${appName}Actions {
-  run: {
-    ${appKey}: {
-      // No actions available
-    }
-  }
-}
-`;
-}
-
-function capitalize(str: string): string {
-  return str.charAt(0).toUpperCase() + str.slice(1).replace(/[-_]/g, "");
-}
-
-function sanitizeActionName(actionKey: string): string {
-  // Ensure the action name is a valid TypeScript identifier
-  return actionKey.replace(/[^a-zA-Z0-9_$]/g, "_");
-}
-
-function sanitizeFieldName(fieldKey: string): string {
-  // Ensure the field name is a valid TypeScript identifier
-  return fieldKey.replace(/[^a-zA-Z0-9_$]/g, "_");
-}
-
-function escapeComment(comment: string): string {
-  // Escape comment text to prevent breaking the JSDoc comment
-  return comment.replace(/\*\//g, "*\\/").replace(/\r?\n/g, " ");
-}
-
-function mapFieldTypeToTypeScript(field: ActionField): string {
-  // Handle choices (enum-like fields)
-  if (field.choices && field.choices.length > 0) {
-    const choiceValues = field.choices
-      .filter(
-        (choice) =>
-          choice.value !== undefined &&
-          choice.value !== null &&
-          choice.value !== "",
-      )
-      .map((choice) =>
-        typeof choice.value === "string" ? `"${choice.value}"` : choice.value,
-      );
-
-    if (choiceValues.length > 0) {
-      return choiceValues.join(" | ");
-    }
-    // If all choices were filtered out, fall through to default type handling
-  }
-
-  // Map Zapier field types to TypeScript types
-  switch (field.type?.toLowerCase()) {
-    case "string":
-    case "text":
-    case "email":
-    case "url":
-    case "password":
-      return "string";
-    case "integer":
-    case "number":
-      return "number";
-    case "boolean":
-      return "boolean";
-    case "datetime":
-    case "date":
-      return "string"; // ISO date strings
-    case "file":
-      return "string"; // File URL or content
-    case "array":
-      return "any[]";
-    case "object":
-      return "Record<string, any>";
-    default:
-      // Default to string for unknown types, with union for common cases
-      return "string | number | boolean";
-  }
-}
-
-// ============================================================================
-// Bundle Implementation
-// ============================================================================
-
-async function bundleCode(options: BundleOptions): Promise<string> {
-  const {
-    input,
-    output,
-    target = "es2020",
-    cjs = false,
-    minify = false,
-    string: returnString = false,
-  } = options;
-
-  // Dynamically import esbuild
-  const { buildSync } = await import("esbuild");
-  const fs = await import("fs");
-  const path = await import("path");
-
-  // Resolve input path
-  const resolvedInput = path.resolve(process.cwd(), input);
-
-  try {
-    // Bundle with esbuild
-    const result = buildSync({
-      entryPoints: [resolvedInput],
-      bundle: true,
-      platform: "node",
-      target: target,
-      format: cjs ? "cjs" : "esm",
-      minify: minify,
-      write: false,
-      external: [], // Bundle everything
-      banner: {
-        js: "#!/usr/bin/env node",
-      },
-    });
-
-    if (result.errors.length > 0) {
-      throw new Error(
-        `Bundle failed: ${result.errors.map((e) => e.text).join(", ")}`,
-      );
-    }
-
-    const bundledCode = result.outputFiles?.[0]?.text;
-    if (!bundledCode) {
-      throw new Error("No output generated");
-    }
-
-    let finalOutput = bundledCode;
-
-    if (returnString) {
-      // Output as quoted string for node -e using JSON.stringify
-      finalOutput = JSON.stringify(bundledCode);
-    }
-
-    // Write to file if output path specified
-    if (output) {
-      fs.mkdirSync(path.dirname(output), { recursive: true });
-      fs.writeFileSync(output, finalOutput, "utf8");
-    }
-
-    return finalOutput;
-  } catch (error) {
-    throw new Error(
-      `Bundle failed: ${
-        error instanceof Error ? error.message : "Unknown error"
-      }`,
-    );
-  }
-}