@zapier/zapier-sdk 0.0.2 → 0.0.3

package/src/functions/listAuths.ts

@@ -0,0 +1,161 @@
+import { getOrCreateApiClient } from "../api";
+import type {
+  Authentication,
+  AuthenticationsResponse,
+  FunctionConfig,
+} from "../types";
+import { getApp } from "./getApp";
+
+export interface ListAuthsOptions extends FunctionConfig {
+  appKey?: string;
+  account_id?: string;
+  owner?: string;
+  limit?: number;
+  offset?: number;
+}
+
+/**
+ * List available authentications with optional filtering
+ *
+ * This function can be used standalone without instantiating a full SDK,
+ * which enables better tree-shaking in applications that only need this functionality.
+ *
+ * @param options - Filtering, pagination, and API configuration options
+ * @returns Promise<Authentication[]> with pagination metadata
+ */
+export async function listAuths(
+  options: ListAuthsOptions = {},
+): Promise<Authentication[]> {
+  const { token } = options;
+
+  if (!token && !process.env.ZAPIER_TOKEN) {
+    throw new Error(
+      "Authentication token is required to list authentications. Please provide token in options or set ZAPIER_TOKEN environment variable.",
+    );
+  }
+
+  const api = getOrCreateApiClient(options);
+
+  // Local function to handle the actual API fetching
+  const listAuthsInternal = async (
+    options: ListAuthsOptions = {},
+  ): Promise<Authentication[]> => {
+    // Build search parameters
+    const searchParams: Record<string, string> = {};
+
+    // Handle appKey filtering by getting the selected_api first
+    if (options.appKey) {
+      try {
+        // Use the standalone getApp function
+        const app = await getApp({
+          key: options.appKey,
+          api,
+          token: options.token,
+          baseUrl: options.baseUrl,
+          debug: options.debug,
+          fetch: options.fetch,
+        });
+        const selectedApi = app.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];
+          searchParams.versionless_selected_api = versionlessApi;
+        }
+      } catch (error) {
+        // If it's an AppNotFoundError, re-throw it
+        if (error instanceof Error && error.name === "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) {
+      searchParams.account_id = options.account_id;
+    }
+    if (options.owner) {
+      searchParams.owner = options.owner;
+    }
+    if (options.limit) {
+      searchParams.limit = options.limit.toString();
+    }
+    if (options.offset) {
+      searchParams.offset = options.offset.toString();
+    }
+
+    const data: AuthenticationsResponse = await api.get(
+      "/api/v4/authentications/",
+      {
+        searchParams,
+        customErrorHandler: (response) => {
+          if (response.status === 401) {
+            return new Error(
+              `Authentication failed. Your token may not have permission to access authentications or may be expired. (HTTP ${response.status})`,
+            );
+          }
+          if (response.status === 403) {
+            return new Error(
+              `Access forbidden. Your token may not have the required scopes to list authentications. (HTTP ${response.status})`,
+            );
+          }
+          return undefined;
+        },
+      },
+    );
+
+    // Transform API response
+    const auths = data.results || [];
+
+    // Add pagination metadata to the response
+    if (auths.length > 0) {
+      (auths as any).__pagination = {
+        count: data.count,
+        hasNext: !!data.next,
+        hasPrevious: !!data.previous,
+        nextUrl: data.next,
+        previousUrl: data.previous,
+      };
+    }
+
+    return auths;
+  };
+
+  // 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 listAuthsInternal({
+      ...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 listAuthsInternal({
+      ...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 listAuthsInternal(options);
+}

package/src/functions/listFields.ts

@@ -0,0 +1,95 @@
+import { getOrCreateApiClient } from "../api";
+import type {
+  ActionField,
+  NeedsRequest,
+  NeedsResponse,
+  FunctionConfig,
+} from "../types";
+import { getApp } from "./getApp";
+
+export interface ListFieldsOptions extends FunctionConfig {
+  app: string;
+  action: string;
+  type: string;
+  authId?: number;
+  params?: Record<string, any>;
+}
+
+/**
+ * List available fields for an action
+ *
+ * This function can be used standalone without instantiating a full SDK,
+ * which enables better tree-shaking in applications that only need this functionality.
+ *
+ * @param options - Action details, auth ID, params, and API configuration options
+ * @returns Promise<ActionField[]>
+ */
+export async function listFields(
+  options: ListFieldsOptions,
+): Promise<ActionField[]> {
+  const api = getOrCreateApiClient(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;
+
+  // Use the standalone getApp function
+  const appData = await getApp({
+    key: appKey,
+    api,
+    token: options.token,
+    baseUrl: options.baseUrl,
+    debug: options.debug,
+    fetch: options.fetch,
+  });
+  const selectedApi = appData.current_implementation_id;
+
+  if (!selectedApi) {
+    throw new Error("No current_implementation_id found for app");
+  }
+
+  // Build needs request
+  const needsRequest: NeedsRequest = {
+    selected_api: selectedApi,
+    action: actionKey,
+    type_of: actionType,
+    authentication_id: authId,
+    params: params || {},
+  };
+
+  const needsData: NeedsResponse = await api.post(
+    "/api/v4/implementations/needs/",
+    needsRequest,
+  );
+
+  if (!needsData.success) {
+    throw new Error(
+      `Failed to get action fields: ${
+        needsData.errors?.join(", ") || "Unknown error"
+      }`,
+    );
+  }
+
+  // Transform API response to our ActionField interface
+  return (needsData.needs || []).map((need: any) => ({
+    key: need.key,
+    label: need.label,
+    required: need.required || false,
+    type: need.type,
+    helpText: need.help_text,
+    helpTextHtml: need.help_text_html,
+    choices: need.choices?.map((choice: any) => ({
+      value: choice.value,
+      label: choice.label,
+    })),
+    default: need.default,
+    placeholder: need.placeholder,
+    computed: need.computed,
+    customField: need.custom_field,
+    dependsOn: need.depends_on,
+    format: need.format,
+    inputFormat: need.input_format,
+  }));
+}

package/src/functions/runAction.ts

@@ -0,0 +1,256 @@
+import { getOrCreateApiClient, generateRequestId } from "../api";
+import type { ActionExecutionResult, FunctionConfig } from "../types";
+import { getAction } from "./getAction";
+import { getApp } from "./getApp";
+
+export interface RunActionOptions extends FunctionConfig {
+  app: string;
+  type: string;
+  action: string;
+  inputs?: Record<string, any>;
+  authId?: number;
+}
+
+/**
+ * Execute an action
+ *
+ * This function can be used standalone without instantiating a full SDK,
+ * which enables better tree-shaking in applications that only need this functionality.
+ *
+ * @param options - Action execution parameters and API configuration options
+ * @returns Promise<ActionExecutionResult>
+ */
+export async function runAction(
+  options: RunActionOptions,
+): Promise<ActionExecutionResult> {
+  const { app, type, action, inputs, authId: providedAuthId, token } = options;
+
+  if (!token && !process.env.ZAPIER_TOKEN) {
+    throw new Error(
+      "Authentication token is required to run actions. Please provide token in options or set ZAPIER_TOKEN environment variable.",
+    );
+  }
+
+  const api = getOrCreateApiClient(options);
+
+  // Validate that the action exists
+  const actionData = await getAction({
+    ...options,
+    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}`,
+    );
+  }
+
+  // Execute the action using the appropriate API based on action type
+  const startTime = Date.now();
+  const result = await executeActionWithStrategy({
+    api,
+    appSlug: app,
+    actionKey: action,
+    actionType: actionData.type,
+    executionOptions: { inputs: inputs || {} },
+    auth: token
+      ? { token: token, authentication_id: providedAuthId }
+      : undefined,
+    options,
+  });
+  const executionTime = Date.now() - startTime;
+
+  return {
+    success: true,
+    data: result,
+    metadata: {
+      executionTime,
+      requestId: generateRequestId(),
+    },
+  };
+}
+
+interface ExecuteActionStrategyOptions {
+  api: any;
+  appSlug: string;
+  actionKey: string;
+  actionType: string;
+  executionOptions: { inputs: Record<string, any> };
+  auth?: { token: string; authentication_id?: number };
+  options: RunActionOptions;
+}
+
+async function executeActionWithStrategy(
+  strategyOptions: ExecuteActionStrategyOptions,
+): Promise<any> {
+  const {
+    api,
+    appSlug,
+    actionKey,
+    actionType,
+    executionOptions,
+    auth,
+    options,
+  } = strategyOptions;
+
+  // 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) {
+    return executeActionViaActionsApi({
+      api,
+      appSlug,
+      actionKey,
+      actionType,
+      executionOptions,
+      auth,
+      options,
+    });
+  } else {
+    return executeActionViaInvokeApi({
+      api,
+      appSlug,
+      actionKey,
+      actionType,
+      executionOptions,
+      auth,
+      options,
+    });
+  }
+}
+
+interface ExecuteActionViaActionsApiOptions {
+  api: any;
+  appSlug: string;
+  actionKey: string;
+  actionType: string;
+  executionOptions: { inputs: Record<string, any> };
+  auth?: { token: string; authentication_id?: number };
+  options: RunActionOptions;
+}
+
+async function executeActionViaActionsApi(
+  apiOptions: ExecuteActionViaActionsApiOptions,
+): Promise<any> {
+  const {
+    api,
+    appSlug,
+    actionKey,
+    actionType,
+    executionOptions,
+    auth,
+    options,
+  } = apiOptions;
+
+  // Use the standalone getApp function
+  const appData = await getApp({
+    key: appSlug,
+    api,
+    token: options.token,
+    baseUrl: options.baseUrl,
+    debug: options.debug,
+    fetch: options.fetch,
+  });
+  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.",
+    );
+  }
+
+  // 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 runData = await api.post("/api/actions/v1/runs", runRequest);
+  const runId = runData.data.id;
+
+  // Step 2: Poll GET /actions/v1/runs/{run_id} for results
+  return await api.poll(`/api/actions/v1/runs/${runId}`, {
+    successStatus: 200,
+    pendingStatus: 202,
+    resultExtractor: (result: any) => result.data,
+  });
+}
+
+interface ExecuteActionViaInvokeApiOptions {
+  api: any;
+  appSlug: string;
+  actionKey: string;
+  actionType: string;
+  executionOptions: { inputs: Record<string, any> };
+  auth?: { token: string; authentication_id?: number };
+  options: RunActionOptions;
+}
+
+async function executeActionViaInvokeApi(
+  apiOptions: ExecuteActionViaInvokeApiOptions,
+): Promise<any> {
+  const {
+    api,
+    appSlug,
+    actionKey,
+    actionType,
+    executionOptions,
+    auth,
+    options,
+  } = apiOptions;
+
+  // Use the standalone getApp function
+  const appData = await getApp({
+    key: appSlug,
+    api,
+    token: options.token,
+    baseUrl: options.baseUrl,
+    debug: options.debug,
+    fetch: options.fetch,
+  });
+  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.",
+    );
+  }
+
+  // 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 invokeData = await api.post("/api/invoke/v1/invoke", invokeRequest);
+  const invocationId = invokeData.invocation_id;
+
+  // Step 2: Poll GET /invoke/v1/invoke/{invocation_id} for results
+  return await api.poll(`/api/invoke/v1/invoke/${invocationId}`, {
+    successStatus: 200,
+    pendingStatus: 202,
+    resultExtractor: (result: any) => result.results || result,
+  });
+}

package/src/index.ts

@@ -2,5 +2,16 @@
 export * from "./types";
 export * from "./actions-sdk";
 
+// Export individual functions for tree-shaking
+export { listAuths } from "./functions/listAuths";
+export { listApps } from "./functions/listApps";
+export { getApp } from "./functions/getApp";
+export { listActions } from "./functions/listActions";
+export { getAction } from "./functions/getAction";
+export { runAction } from "./functions/runAction";
+export { listFields } from "./functions/listFields";
+export { generateTypes } from "./functions/generateTypes";
+export { bundleCode } from "./functions/bundleCode";
+
 // Export the main combined SDK
 export { createZapierSdk, ZapierSdk, ZapierSdkOptions } from "./sdk";

package/src/types.ts

@@ -231,6 +231,19 @@ export interface BaseSdkOptions {
   debug?: boolean;
 }
 
+export interface FunctionConfig {
+  /** Base URL for Zapier API */
+  baseUrl?: string;
+  /** Authentication token */
+  token?: string;
+  /** Optional pre-instantiated API client */
+  api?: any; // ApiClient type would cause circular import
+  /** Enable debug logging */
+  debug?: boolean;
+  /** Custom fetch implementation */
+  fetch?: typeof globalThis.fetch;
+}
+
 export interface CombinedSdk {
   [namespace: string]: any;
 }