@zapier/zapier-sdk 0.0.3 → 0.1.0

package/src/actions-sdk.ts

@@ -1,356 +0,0 @@
-import {
-  Integration,
-  Action,
-  ActionExecutionOptions,
-  ActionExecutionResult,
-  ActionField,
-  Authentication,
-  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,
-  ActionsListOptions,
-  ActionsGetOptions,
-  ActionsRunOptions,
-  AuthsListOptions,
-  AuthsFindOptions,
-  FieldsListOptions,
-  GenerateOptions,
-  BundleOptions,
-} from "./schemas";
-export * from "./schemas";
-export * from "./output-schemas";
-
-export interface ActionsSdk {
-  // Resource namespaces
-  apps: AppsService;
-  actions: ActionsService;
-  auths: AuthsService;
-  fields: FieldsService;
-
-  // Root namespace tools
-  generate: GenerateFunction;
-  bundle: BundleFunction;
-}
-
-export interface AppsService {
-  list(options?: AppsListOptions): Promise<Integration[]>;
-  get(options: AppsGetOptions): Promise<Integration>;
-}
-
-interface ActionRunner {
-  (params: ActionsRunOptions): Promise<ActionExecutionResult>;
-}
-
-interface ActionProxy {
-  [app: string]: {
-    [type: string]: {
-      [action: string]: (
-        options?: ActionExecutionOptions,
-      ) => Promise<ActionExecutionResult>;
-    };
-  };
-}
-
-export interface GenerateFunction {
-  (options: GenerateOptions): Promise<string>;
-}
-
-export interface BundleFunction {
-  (options: BundleOptions): Promise<string>;
-}
-
-export interface ActionsService {
-  list(options?: ActionsListOptions): Promise<Action[]>;
-  get(options: ActionsGetOptions): Promise<Action>;
-  run: ActionRunner & ActionProxy;
-}
-
-export interface AuthsService {
-  list(options?: AuthsListOptions): Promise<Authentication[]>;
-  find(options: AuthsFindOptions): number;
-}
-
-export interface FieldsService {
-  list(options: FieldsListOptions): Promise<ActionField[]>;
-}
-
-export interface ActionsSdkOptions extends BaseSdkOptions {}
-
-export function createActionsSdk(options: ActionsSdkOptions = {}): ActionsSdk {
-  // 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 = 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({
-    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: GenerateFunction = async (
-    options: GenerateOptions,
-  ) => {
-    return generateTypesFunction({ ...options, api, token: finalToken });
-  };
-
-  const bundleFunction: BundleFunction = async (options: BundleOptions) => {
-    return bundleCodeFunction(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;
-}
-
-interface AppsServiceOptions {
-  api: ApiClient;
-  token?: string;
-  authentications?: { [appKey: string]: { id: number }[] };
-  sdk: ActionsSdk;
-}
-
-interface AuthsServiceOptions {
-  api: ApiClient;
-  token?: string;
-  authentications?: { [appKey: string]: { id: number }[] };
-  sdk: ActionsSdk;
-}
-
-interface ActionsServiceOptions {
-  api: ApiClient;
-  token?: string;
-  authentications?: { [appKey: string]: { id: number }[] };
-  sdk: ActionsSdk;
-}
-
-interface FieldsServiceOptions {
-  api: ApiClient;
-  token?: string;
-  authentications?: { [appKey: string]: { id: number }[] };
-  sdk: ActionsSdk;
-}
-
-function createAppsService(options: AppsServiceOptions): AppsService {
-  const { api, token } = options;
-
-  return {
-    async list(options?: AppsListOptions): Promise<Integration[]> {
-      return listApps({ ...options, api, token });
-    },
-
-    async get(options: AppsGetOptions): Promise<Integration> {
-      return getApp({ ...options, api, token });
-    },
-  };
-}
-
-function createAuthsService(options: AuthsServiceOptions): AuthsService {
-  const { api, token, authentications } = options;
-
-  return {
-    async list(options?: AuthsListOptions): Promise<Authentication[]> {
-      return listAuths({ ...options, api, token });
-    },
-
-    find(options: { appKey: string }): number {
-      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: FieldsServiceOptions): FieldsService {
-  const { api, token } = options;
-
-  return {
-    async list(options: FieldsListOptions): Promise<ActionField[]> {
-      return listFields({ ...options, api, token });
-    },
-  };
-}
-
-function createActionsService(options: ActionsServiceOptions): ActionsService {
-  const { api, token, authentications } = options;
-
-  // Create the base service with named methods
-  const baseService: ActionsService = {
-    async list(options?: ActionsListOptions): Promise<Action[]> {
-      return listActions({ ...options, api, token });
-    },
-
-    async get(options: ActionsGetOptions): Promise<Action> {
-      return getAction({ ...options, api, token });
-    },
-
-    // run will be replaced with function/proxy pattern below
-  } as ActionsService;
-
-  // Create the run function with proxy capabilities
-  const runFunction = async (
-    params: ActionsRunOptions,
-  ): Promise<ActionExecutionResult> => {
-    const { app, type, action, inputs, authId: providedAuthId } = params;
-
-    // Resolve auth ID for this specific app
-    let authId: number | undefined = 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 runAction({
-      app,
-      type,
-      action,
-      inputs,
-      authId,
-      api,
-      token,
-    });
-  };
-
-  // Create proxy wrapper for the run function
-  const runWithProxy = new Proxy(runFunction, {
-    get(target, prop: string) {
-      if (typeof prop === "string") {
-        // Return app-level proxy
-        return new Proxy(
-          {},
-          {
-            get(_target, actionType: string) {
-              if (typeof actionType !== "string") return undefined;
-
-              return new Proxy(
-                {},
-                {
-                  get(_target, actionKey: string) {
-                    if (typeof actionKey !== "string") return undefined;
-
-                    // Return function that calls the main run function
-                    return async (
-                      options: ActionExecutionOptions = {},
-                    ): Promise<ActionExecutionResult> => {
-                      return await runFunction({
-                        app: prop,
-                        type: actionType as any, // 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 as ActionRunner & ActionProxy;
-
-  // Return the service with the new run function/proxy
-  return baseService;
-}

package/src/api.ts

@@ -1,361 +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.
- */
-
-// ============================================================================
-// Types
-// ============================================================================
-
-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;
-}
-
-interface DebugLogger {
-  (message: string, data?: any): void;
-}
-
-// ============================================================================
-// Authentication Utilities
-// ============================================================================
-
-export 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));
-}
-
-export 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}`;
-}
-
-// ============================================================================
-// Debug Logging
-// ============================================================================
-
-function createDebugLogger(enabled: boolean): DebugLogger {
-  if (!enabled) {
-    return () => {}; // No-op function when debug is disabled
-  }
-
-  return (message: string, data?: any) => {
-    console.log(`[Zapier SDK] ${message}`, data || "");
-  };
-}
-
-function createDebugFetch(options: {
-  originalFetch: typeof globalThis.fetch;
-  debugLog: DebugLogger;
-}) {
-  const { originalFetch, debugLog } = options;
-  return async (input: RequestInfo | URL, options?: RequestInit) => {
-    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 as string) : 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
-// ============================================================================
-
-export async 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> {
-  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
-// ============================================================================
-
-export function createZapierApi(options: ApiClientOptions): ApiClient {
-  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: string,
-    searchParams?: Record<string, string>,
-  ): string {
-    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: RequestOptions = {}): Record<string, string> {
-    const headers: Record<string, string> = {
-      ...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: Response,
-    customErrorHandler?: (response: Response) => Error | undefined,
-  ): Promise<any> {
-    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: string,
-    path: string,
-    data?: any,
-    options: RequestOptions = {},
-  ): Promise<any> {
-    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: string, options: RequestOptions = {}): Promise<any> {
-      return fetchJson("GET", path, undefined, options);
-    },
-
-    async post(
-      path: string,
-      data?: any,
-      options: RequestOptions = {},
-    ): Promise<any> {
-      return fetchJson("POST", path, data, options);
-    },
-
-    async put(
-      path: string,
-      data?: any,
-      options: RequestOptions = {},
-    ): Promise<any> {
-      return fetchJson("PUT", path, data, options);
-    },
-
-    async delete(path: string, options: RequestOptions = {}): Promise<any> {
-      return fetchJson("DELETE", path, undefined, options);
-    },
-
-    async poll(path: string, options: PollOptions = {}): Promise<any> {
-      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
-// ============================================================================
-
-export function generateRequestId(): string {
-  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
- */
-export function getOrCreateApiClient(config: {
-  baseUrl?: string;
-  token?: string;
-  api?: ApiClient;
-  debug?: boolean;
-  fetch?: typeof globalThis.fetch;
-}): ApiClient {
-  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,
-    })
-  );
-}