@zapier/zapier-sdk 0.0.3 → 0.1.1

package/dist/actions-sdk.js

@@ -1,208 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-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);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createActionsSdk = createActionsSdk;
-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 = {}) {
-    // Auto-load .env files (searches up directory tree)
-    try {
-        const { findUpSync } = require("find-up");
-        const envPath = findUpSync(".env");
-        if (envPath) {
-            require("dotenv").config({ path: envPath, quiet: true });
-        }
-    }
-    catch {
-        // Silently fail if dotenv/find-up not available or .env not found
-    }
-    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;
-    // 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({
-        api,
-        token: finalToken,
-        authentications,
-        sdk,
-    });
-    const actionsService = createActionsService({
-        api,
-        token: finalToken,
-        authentications,
-        sdk,
-    });
-    const authsService = createAuthsService({
-        api,
-        token: finalToken,
-        authentications,
-        sdk,
-    });
-    const fieldsService = createFieldsService({
-        api,
-        token: finalToken,
-        authentications,
-        sdk,
-    });
-    // Create root namespace tools
-    const generateFunction = async (options) => {
-        return (0, generateTypes_1.generateTypes)({ ...options, api, token: finalToken });
-    };
-    const bundleFunction = async (options) => {
-        return (0, bundleCode_1.bundleCode)(options);
-    };
-    // Populate the SDK object
-    sdk.apps = appsService;
-    sdk.actions = actionsService;
-    sdk.auths = authsService;
-    sdk.fields = fieldsService;
-    sdk.generate = generateFunction;
-    sdk.bundle = bundleFunction;
-    // Note: Debug logging for SDK initialization is now handled by the API client
-    return sdk;
-}
-function createAppsService(options) {
-    const { api, token } = options;
-    return {
-        async list(options) {
-            return (0, listApps_1.listApps)({ ...options, api, token });
-        },
-        async get(options) {
-            return (0, getApp_1.getApp)({ ...options, api, token });
-        },
-    };
-}
-function createAuthsService(options) {
-    const { api, token, authentications } = options;
-    return {
-        async list(options) {
-            return (0, listAuths_1.listAuths)({ ...options, api, token });
-        },
-        find(options) {
-            if (!authentications) {
-                throw new Error(`No authentication configured`);
-            }
-            const auths = authentications[options.appKey] || [];
-            if (auths.length === 0) {
-                throw new Error(`No authentication configured for app "${options.appKey}"`);
-            }
-            if (auths.length > 1) {
-                throw new Error(`Multiple authentications found for app "${options.appKey}". Please specify which one to use.`);
-            }
-            return auths[0].id;
-        },
-    };
-}
-function createFieldsService(options) {
-    const { api, token } = options;
-    return {
-        async list(options) {
-            return (0, listFields_1.listFields)({ ...options, api, token });
-        },
-    };
-}
-function createActionsService(options) {
-    const { api, token, authentications } = options;
-    // Create the base service with named methods
-    const baseService = {
-        async list(options) {
-            return (0, listActions_1.listActions)({ ...options, api, token });
-        },
-        async get(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;
-        // Resolve auth ID for this specific app
-        let authId = providedAuthId;
-        if (!authId && authentications) {
-            const auths = authentications[app] || [];
-            if (auths.length === 0) {
-                throw new Error(`No authentication configured for app "${app}"`);
-            }
-            if (auths.length > 1) {
-                throw new Error(`Multiple authentications found for app "${app}". Please specify which one to use.`);
-            }
-            authId = auths[0].id;
-        }
-        // Delegate to standalone runAction function
-        return (0, runAction_1.runAction)({
-            app,
-            type,
-            action,
-            inputs,
-            authId,
-            api,
-            token,
-        });
-    };
-    // Create proxy wrapper for the run function
-    const runWithProxy = new Proxy(runFunction, {
-        get(target, prop) {
-            if (typeof prop === "string") {
-                // Return app-level proxy
-                return new Proxy({}, {
-                    get(_target, actionType) {
-                        if (typeof actionType !== "string")
-                            return undefined;
-                        return new Proxy({}, {
-                            get(_target, actionKey) {
-                                if (typeof actionKey !== "string")
-                                    return undefined;
-                                // Return function that calls the main run function
-                                return async (options = {}) => {
-                                    return await runFunction({
-                                        app: prop,
-                                        type: actionType, // Cast because proxy string can't be typed as enum
-                                        action: actionKey,
-                                        inputs: options.inputs,
-                                        authId: options.authId,
-                                    });
-                                };
-                            },
-                        });
-                    },
-                });
-            }
-            return target[prop];
-        },
-    });
-    // Add the run function/proxy to the base service
-    baseService.run = runWithProxy;
-    // Return the service with the new run function/proxy
-    return baseService;
-}

package/dist/api.d.ts

@@ -1,62 +0,0 @@
-/**
- * Zapier API Client Module
- *
- * This module provides a centralized API layer for all HTTP interactions
- * with Zapier's various APIs. It handles authentication, error handling,
- * polling, and provides consistent patterns across all services.
- */
-export interface ApiClientOptions {
-    baseUrl: string;
-    token?: string;
-    debug?: boolean;
-    fetch?: typeof globalThis.fetch;
-}
-export interface ApiClient {
-    get: (path: string, options?: RequestOptions) => Promise<any>;
-    post: (path: string, data?: any, options?: RequestOptions) => Promise<any>;
-    put: (path: string, data?: any, options?: RequestOptions) => Promise<any>;
-    delete: (path: string, options?: RequestOptions) => Promise<any>;
-    poll: (path: string, options?: PollOptions) => Promise<any>;
-}
-export interface RequestOptions {
-    headers?: Record<string, string>;
-    searchParams?: Record<string, string>;
-    authRequired?: boolean;
-    customErrorHandler?: (response: Response) => Error | undefined;
-}
-export interface PollOptions extends RequestOptions {
-    maxAttempts?: number;
-    initialDelay?: number;
-    maxDelay?: number;
-    successStatus?: number;
-    pendingStatus?: number;
-    resultExtractor?: (response: any) => any;
-}
-export declare function isJwt(token: string): boolean;
-export declare function getAuthorizationHeader(token: string): string;
-export declare function pollUntilComplete(options: {
-    fetch: typeof globalThis.fetch;
-    url: string;
-    headers?: Record<string, string>;
-    maxAttempts?: number;
-    initialDelay?: number;
-    maxDelay?: number;
-    successStatus?: number;
-    pendingStatus?: number;
-    resultExtractor?: (response: any) => any;
-}): Promise<any>;
-export declare function createZapierApi(options: ApiClientOptions): ApiClient;
-export declare function generateRequestId(): string;
-/**
- * Utility function to get or create an API client for standalone functions
- *
- * @param config - Configuration that may include an existing API client
- * @returns ApiClient instance
- */
-export declare function getOrCreateApiClient(config: {
-    baseUrl?: string;
-    token?: string;
-    api?: ApiClient;
-    debug?: boolean;
-    fetch?: typeof globalThis.fetch;
-}): ApiClient;

package/dist/api.js

@@ -1,227 +0,0 @@
-"use strict";
-/**
- * Zapier API Client Module
- *
- * This module provides a centralized API layer for all HTTP interactions
- * with Zapier's various APIs. It handles authentication, error handling,
- * polling, and provides consistent patterns across all services.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isJwt = isJwt;
-exports.getAuthorizationHeader = getAuthorizationHeader;
-exports.pollUntilComplete = pollUntilComplete;
-exports.createZapierApi = createZapierApi;
-exports.generateRequestId = generateRequestId;
-exports.getOrCreateApiClient = getOrCreateApiClient;
-// ============================================================================
-// Authentication Utilities
-// ============================================================================
-function isJwt(token) {
-    // JWT tokens have exactly 3 parts separated by dots
-    const parts = token.split(".");
-    if (parts.length !== 3) {
-        return false;
-    }
-    // Each part should be base64url encoded (no padding)
-    // Basic validation - each part should be non-empty and contain valid base64url characters
-    const base64UrlPattern = /^[A-Za-z0-9_-]+$/;
-    return parts.every((part) => part.length > 0 && base64UrlPattern.test(part));
-}
-function getAuthorizationHeader(token) {
-    // Check if token is a JWT (has 3 parts separated by dots)
-    if (isJwt(token)) {
-        return `JWT ${token}`;
-    }
-    // Default to Bearer for other token types
-    return `Bearer ${token}`;
-}
-// ============================================================================
-// Debug Logging
-// ============================================================================
-function createDebugLogger(enabled) {
-    if (!enabled) {
-        return () => { }; // No-op function when debug is disabled
-    }
-    return (message, data) => {
-        console.log(`[Zapier SDK] ${message}`, data || "");
-    };
-}
-function createDebugFetch(options) {
-    const { originalFetch, debugLog } = options;
-    return async (input, options) => {
-        const startTime = Date.now();
-        // Convert input to URL string for logging
-        const url = typeof input === "string" ? input : input.toString();
-        const method = options?.method || "GET";
-        debugLog(`→ ${method} ${url}`, {
-            headers: options?.headers,
-            body: options?.body ? JSON.parse(options.body) : undefined,
-        });
-        try {
-            const response = await originalFetch(input, options);
-            const duration = Date.now() - startTime;
-            debugLog(`← ${response.status} ${response.statusText} (${duration}ms)`, {
-                url,
-                method,
-                status: response.status,
-            });
-            return response;
-        }
-        catch (error) {
-            const duration = Date.now() - startTime;
-            debugLog(`✖ Request failed (${duration}ms)`, {
-                url,
-                method,
-                error: error instanceof Error ? error.message : error,
-            });
-            throw error;
-        }
-    };
-}
-// ============================================================================
-// Polling Utilities
-// ============================================================================
-async function pollUntilComplete(options) {
-    const { fetch, url, headers = {}, maxAttempts = 30, initialDelay = 50, maxDelay = 1000, successStatus = 200, pendingStatus = 202, resultExtractor = (response) => response, } = options;
-    let delay = initialDelay;
-    for (let attempt = 0; attempt < maxAttempts; attempt++) {
-        const response = await fetch(url, { headers });
-        if (response.status === successStatus) {
-            // Success - extract and return results
-            const result = await response.json();
-            return resultExtractor(result);
-        }
-        else if (response.status === pendingStatus) {
-            // Still processing - wait and retry
-            if (attempt < maxAttempts - 1) {
-                await new Promise((resolve) => setTimeout(resolve, delay));
-                delay = Math.min(delay * 2, maxDelay); // Exponential backoff
-                continue;
-            }
-        }
-        else {
-            // Error occurred
-            throw new Error(`Request failed: GET ${url} - ${response.status} ${response.statusText}`);
-        }
-    }
-    throw new Error(`Operation timed out after ${maxAttempts} attempts`);
-}
-// ============================================================================
-// API Client Factory
-// ============================================================================
-function createZapierApi(options) {
-    const { baseUrl, token, debug = false, fetch: originalFetch = globalThis.fetch, } = options;
-    const debugLog = createDebugLogger(debug);
-    const fetch = createDebugFetch({ originalFetch, debugLog });
-    // Helper to build full URLs
-    function buildUrl(path, searchParams) {
-        const url = new URL(path, baseUrl);
-        if (searchParams) {
-            Object.entries(searchParams).forEach(([key, value]) => {
-                url.searchParams.set(key, value);
-            });
-        }
-        return url.toString();
-    }
-    // Helper to build headers
-    function buildHeaders(options = {}) {
-        const headers = {
-            ...options.headers,
-        };
-        // Add auth header if token provided and not explicitly disabled
-        if (token && options.authRequired !== false) {
-            headers.Authorization = getAuthorizationHeader(token);
-        }
-        return headers;
-    }
-    // Helper to handle responses
-    async function handleResponse(response, customErrorHandler) {
-        if (!response.ok) {
-            // Check for custom error handling first
-            if (customErrorHandler) {
-                const customError = customErrorHandler(response);
-                if (customError) {
-                    throw customError;
-                }
-            }
-            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-        }
-        // Try to parse JSON, fall back to text if that fails
-        try {
-            return await response.json();
-        }
-        catch {
-            return await response.text();
-        }
-    }
-    // Helper to perform HTTP requests with JSON handling
-    async function fetchJson(method, path, data, options = {}) {
-        const url = buildUrl(path, options.searchParams);
-        const headers = buildHeaders(options);
-        // Add Content-Type for JSON requests with body data
-        if (data && typeof data === "object") {
-            headers["Content-Type"] = "application/json";
-        }
-        const response = await fetch(url, {
-            method,
-            headers,
-            body: data ? JSON.stringify(data) : undefined,
-        });
-        return handleResponse(response, options.customErrorHandler);
-    }
-    return {
-        async get(path, options = {}) {
-            return fetchJson("GET", path, undefined, options);
-        },
-        async post(path, data, options = {}) {
-            return fetchJson("POST", path, data, options);
-        },
-        async put(path, data, options = {}) {
-            return fetchJson("PUT", path, data, options);
-        },
-        async delete(path, options = {}) {
-            return fetchJson("DELETE", path, undefined, options);
-        },
-        async poll(path, options = {}) {
-            const url = buildUrl(path, options.searchParams);
-            const headers = buildHeaders(options);
-            return pollUntilComplete({
-                fetch,
-                url,
-                headers,
-                maxAttempts: options.maxAttempts,
-                initialDelay: options.initialDelay,
-                maxDelay: options.maxDelay,
-                successStatus: options.successStatus,
-                pendingStatus: options.pendingStatus,
-                resultExtractor: options.resultExtractor,
-            });
-        },
-    };
-}
-// ============================================================================
-// Utility Functions
-// ============================================================================
-function generateRequestId() {
-    return Math.random().toString(36).substring(2) + Date.now().toString(36);
-}
-// ============================================================================
-// Utility Functions for Standalone Functions
-// ============================================================================
-/**
- * Utility function to get or create an API client for standalone functions
- *
- * @param config - Configuration that may include an existing API client
- * @returns ApiClient instance
- */
-function getOrCreateApiClient(config) {
-    const { baseUrl = "https://zapier.com", token = process.env.ZAPIER_TOKEN, api: providedApi, debug = false, fetch: customFetch, } = config;
-    // Use provided API client or create a new one
-    return (providedApi ||
-        createZapierApi({
-            baseUrl,
-            token,
-            debug,
-            fetch: customFetch,
-        }));
-}

package/dist/output-schemas.d.ts

@@ -1,95 +0,0 @@
-import { z } from "zod";
-export interface FormattedItem {
-    title: string;
-    subtitle?: string;
-    details: Array<{
-        text: string;
-        style: "normal" | "dim" | "accent" | "warning" | "success";
-    }>;
-}
-export interface FormatMetadata {
-    format: (item: any) => FormattedItem;
-}
-export declare function withOutputSchema<T extends z.ZodType>(inputSchema: T, outputSchema: z.ZodType): T;
-export declare function getFormatMetadata(schema: z.ZodType): FormatMetadata | undefined;
-export declare function getOutputSchema(inputSchema: z.ZodType): z.ZodType | undefined;
-export declare const AppItemSchema: z.ZodObject<{
-    key: z.ZodString;
-    name: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodString>;
-    category: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    key: string;
-    name?: string | undefined;
-    description?: string | undefined;
-    category?: string | undefined;
-}, {
-    key: string;
-    name?: string | undefined;
-    description?: string | undefined;
-    category?: string | undefined;
-}>;
-export declare const ActionItemSchema: z.ZodObject<{
-    key: z.ZodString;
-    name: z.ZodOptional<z.ZodString>;
-    type: z.ZodString;
-    appKey: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    key: string;
-    type: string;
-    name?: string | undefined;
-    description?: string | undefined;
-    appKey?: string | undefined;
-}, {
-    key: string;
-    type: string;
-    name?: string | undefined;
-    description?: string | undefined;
-    appKey?: string | undefined;
-}>;
-export declare const AuthItemSchema: z.ZodObject<{
-    id: z.ZodNumber;
-    title: z.ZodOptional<z.ZodString>;
-    label: z.ZodOptional<z.ZodString>;
-    identifier: z.ZodOptional<z.ZodString>;
-    account_id: z.ZodOptional<z.ZodString>;
-    is_private: z.ZodOptional<z.ZodBoolean>;
-    shared_with_all: z.ZodOptional<z.ZodBoolean>;
-    marked_stale_at: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    id: number;
-    account_id?: string | undefined;
-    title?: string | undefined;
-    label?: string | undefined;
-    identifier?: string | undefined;
-    is_private?: boolean | undefined;
-    shared_with_all?: boolean | undefined;
-    marked_stale_at?: string | undefined;
-}, {
-    id: number;
-    account_id?: string | undefined;
-    title?: string | undefined;
-    label?: string | undefined;
-    identifier?: string | undefined;
-    is_private?: boolean | undefined;
-    shared_with_all?: boolean | undefined;
-    marked_stale_at?: string | undefined;
-}>;
-export declare const FieldItemSchema: z.ZodObject<{
-    key: z.ZodString;
-    name: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    key: string;
-    name?: string | undefined;
-    description?: string | undefined;
-}, {
-    key: string;
-    name?: string | undefined;
-    description?: string | undefined;
-}>;
-export type AppItem = z.infer<typeof AppItemSchema>;
-export type ActionItem = z.infer<typeof ActionItemSchema>;
-export type AuthItem = z.infer<typeof AuthItemSchema>;
-export type FieldItem = z.infer<typeof FieldItemSchema>;