@zapier/zapier-sdk 0.0.2 → 0.0.3

package/dist/actions-sdk.js

@@ -10,35 +10,21 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createActionsSdk = createActionsSdk;
-const types_1 = require("./types");
-const schemas_1 = require("./schemas");
+const api_1 = require("./api");
+const listAuths_1 = require("./functions/listAuths");
+const listApps_1 = require("./functions/listApps");
+const getApp_1 = require("./functions/getApp");
+const listActions_1 = require("./functions/listActions");
+const getAction_1 = require("./functions/getAction");
+const runAction_1 = require("./functions/runAction");
+const listFields_1 = require("./functions/listFields");
+const generateTypes_1 = require("./functions/generateTypes");
+const bundleCode_1 = require("./functions/bundleCode");
 __exportStar(require("./schemas"), exports);
 __exportStar(require("./output-schemas"), exports);
 function createActionsSdk(options = {}) {
@@ -56,58 +42,45 @@ function createActionsSdk(options = {}) {
     const { fetch: customFetch = globalThis.fetch, baseUrl = "https://zapier.com", token, authentications = {}, debug = false, } = options;
     // 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 = (0, api_1.createZapierApi)({
+        baseUrl,
+        token: finalToken,
+        debug,
+        fetch: customFetch,
+    });
     // Create SDK object - we'll populate services after creation to avoid circular dependency
     const sdk = {};
     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,
     });
     // Create root namespace tools
     const generateFunction = async (options) => {
-        // Validate options using schema
-        const validatedOptions = schemas_1.SdkSchemas.generate.parse(options);
-        return await generateTypes(validatedOptions, sdk);
+        return (0, generateTypes_1.generateTypes)({ ...options, api, token: finalToken });
     };
     const bundleFunction = async (options) => {
-        // Validate options using schema
-        const validatedOptions = schemas_1.SdkSchemas.bundle.parse(options);
-        return await bundleCode(validatedOptions);
+        return (0, bundleCode_1.bundleCode)(options);
     };
     // Populate the SDK object
     sdk.apps = appsService;
@@ -116,205 +89,25 @@ function createActionsSdk(options = {}) {
     sdk.fields = fieldsService;
     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;
 }
 function createAppsService(options) {
-    const { fetch, baseUrl, debugLog } = options;
+    const { api, token } = options;
     return {
         async list(options) {
-            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) => ({
-                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.__pagination = {
-                    count: data.count,
-                    hasNext: !!data.next,
-                    hasPrevious: !!data.previous,
-                    nextUrl: data.next,
-                    previousUrl: data.previous,
-                };
-            }
-            return apps;
+            return (0, listApps_1.listApps)({ ...options, api, token });
         },
         async get(options) {
-            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 types_1.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 (0, getApp_1.getApp)({ ...options, api, token });
         },
     };
 }
 function createAuthsService(options) {
-    const { fetch, baseUrl, token, authentications, debugLog, sdk } = options;
-    // Local function to handle the actual API fetching
-    const listAuths = async (options) => {
-        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 types_1.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 = {};
-        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 = 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.__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) {
-            // 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 (0, listAuths_1.listAuths)({ ...options, api, token });
         },
         find(options) {
             if (!authentications) {
@@ -332,225 +125,28 @@ function createAuthsService(options) {
     };
 }
 function createFieldsService(options) {
-    const { fetch, baseUrl, token, sdk } = options;
+    const { api, token } = options;
     return {
         async list(options) {
-            // 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 = {};
-            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 = {
-                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 = 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) => ({
-                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) => ({
-                    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 (0, listFields_1.listFields)({ ...options, api, token });
         },
     };
 }
 function createActionsService(options) {
-    const { fetch, baseUrl, token, authentications, debugLog, sdk } = options;
+    const { api, token, authentications } = options;
     // Create the base service with named methods
     const baseService = {
         async list(options) {
-            // 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 = [];
-                    // Transform implementations to actions
-                    for (const implementation of data.results || []) {
-                        if (implementation.actions) {
-                            for (const action of implementation.actions) {
-                                const transformedAction = {
-                                    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.__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 types_1.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 = [];
-            // Transform implementations to actions
-            for (const implementation of data.results || []) {
-                if (implementation.actions) {
-                    for (const action of implementation.actions) {
-                        const transformedAction = {
-                            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.__pagination = {
-                    count: data.count,
-                    hasNext: !!data.next,
-                    hasPrevious: !!data.previous,
-                    nextUrl: data.next,
-                    previousUrl: data.previous,
-                };
-            }
-            return actions;
+            return (0, listActions_1.listActions)({ ...options, api, token });
         },
         async get(options) {
-            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) {
-            return await sdk.fields.list(options);
-        },
-        async getFields(options) {
-            return await sdk.fields.list(options);
+            return (0, getAction_1.getAction)({ ...options, api, token });
         },
         // run will be replaced with function/proxy pattern below
     };
     // Create the run function with proxy capabilities
     const runFunction = async (params) => {
         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 = providedAuthId;
         if (!authId && authentications) {
@@ -563,28 +159,16 @@ function createActionsService(options) {
             }
             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 (0, runAction_1.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
     const runWithProxy = new Proxy(runFunction, {
@@ -622,573 +206,3 @@ function createActionsService(options) {
     // Return the service with the new run function/proxy
     return baseService;
 }
-async function executeActionWithStrategy(options) {
-    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,
-        });
-    }
-}
-async function executeActionViaActionsApi(options) {
-    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 });
-}
-async function pollForResults(options) {
-    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`);
-}
-async function executeActionViaInvokeApi(options) {
-    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,
-    });
-}
-async function pollForInvokeResults(options) {
-    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() {
-    return Math.random().toString(36).substring(2) + Date.now().toString(36);
-}
-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}`;
-}
-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 createDebugLogger(enabled) {
-    if (!enabled) {
-        return () => { }; // No-op function when debug is disabled
-    }
-    return (message, data) => {
-        const timestamp = new Date().toISOString();
-        if (data) {
-            console.log(`[${timestamp}] Zapier SDK: ${message}`, data);
-        }
-        else {
-            console.log(`[${timestamp}] Zapier SDK: ${message}`);
-        }
-    };
-}
-function createDebugFetch(options) {
-    const { originalFetch, debugLog } = options;
-    return async (input, options) => {
-        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) {
-    const maskedHeaders = {};
-    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) {
-    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}`;
-}
-async function generateTypes(options, sdk) {
-    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 Promise.resolve().then(() => __importStar(require("fs")));
-            const path = await Promise.resolve().then(() => __importStar(require("path")));
-            fs.mkdirSync(path.dirname(output), { recursive: true });
-            fs.writeFileSync(output, typeDefinitions, "utf8");
-        }
-        return typeDefinitions;
-    }
-    // Fetch input fields for each action
-    const actionsWithFields = [];
-    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 Promise.resolve().then(() => __importStar(require("fs")));
-        const path = await Promise.resolve().then(() => __importStar(require("path")));
-        fs.mkdirSync(path.dirname(output), { recursive: true });
-        fs.writeFileSync(output, typeDefinitions, "utf8");
-    }
-    return typeDefinitions;
-}
-function parseAppIdentifier(identifier) {
-    const parts = identifier.split("@");
-    return {
-        app: parts[0],
-        version: parts[1],
-    };
-}
-function generateTypeDefinitions(appKey, actions, version) {
-    // 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;
-    }, {});
-    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) => {
-            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, version) {
-    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) {
-    return str.charAt(0).toUpperCase() + str.slice(1).replace(/[-_]/g, "");
-}
-function sanitizeActionName(actionKey) {
-    // Ensure the action name is a valid TypeScript identifier
-    return actionKey.replace(/[^a-zA-Z0-9_$]/g, "_");
-}
-function sanitizeFieldName(fieldKey) {
-    // Ensure the field name is a valid TypeScript identifier
-    return fieldKey.replace(/[^a-zA-Z0-9_$]/g, "_");
-}
-function escapeComment(comment) {
-    // Escape comment text to prevent breaking the JSDoc comment
-    return comment.replace(/\*\//g, "*\\/").replace(/\r?\n/g, " ");
-}
-function mapFieldTypeToTypeScript(field) {
-    // 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) {
-    const { input, output, target = "es2020", cjs = false, minify = false, string: returnString = false, } = options;
-    // Dynamically import esbuild
-    const { buildSync } = await Promise.resolve().then(() => __importStar(require("esbuild")));
-    const fs = await Promise.resolve().then(() => __importStar(require("fs")));
-    const path = await Promise.resolve().then(() => __importStar(require("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"}`);
-    }
-}