@zapier/zapier-sdk 0.1.1 → 0.2.1

package/src/functions/runAction/index.ts

@@ -22,16 +22,10 @@ export async function runAction(
     actionKey,
     inputs,
     authenticationId: providedAuthenticationId,
-    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);
+  api.requireAuthTo("run actions");
 
   // Validate that the action exists
   const actionData = await getAction({
@@ -48,17 +42,15 @@ export async function runAction(
     );
   }
 
-  // Execute the action using the appropriate API based on action type
+  // Execute the action using the Actions API (supports all action types)
   const startTime = Date.now();
-  const result = await executeActionWithStrategy({
+  const result = await executeAction({
     api,
     appSlug: appKey,
     actionKey: actionKey,
     actionType: actionData.type,
     executionOptions: { inputs: inputs || {} },
-    auth: token
-      ? { token: token, authentication_id: providedAuthenticationId }
-      : undefined,
+    authenticationId: providedAuthenticationId,
     options,
   });
   const executionTime = Date.now() - startTime;
@@ -73,70 +65,18 @@ export async function runAction(
   };
 }
 
-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 {
+interface ExecuteActionOptions {
   api: any;
   appSlug: string;
   actionKey: string;
   actionType: string;
   executionOptions: { inputs: Record<string, any> };
-  auth?: { token: string; authentication_id?: number };
+  authenticationId?: number;
   options: RunActionOptions;
 }
 
-async function executeActionViaActionsApi(
-  apiOptions: ExecuteActionViaActionsApiOptions,
+async function executeAction(
+  actionOptions: ExecuteActionOptions,
 ): Promise<any> {
   const {
     api,
@@ -144,9 +84,9 @@ async function executeActionViaActionsApi(
     actionKey,
     actionType,
     executionOptions,
-    auth,
+    authenticationId,
     options,
-  } = apiOptions;
+  } = actionOptions;
 
   // Use the standalone getApp function
   const appData = await getApp({
@@ -163,16 +103,10 @@ async function executeActionViaActionsApi(
     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,
+      authentication_id: authenticationId || 1,
       selected_api: selectedApi,
       action_key: actionKey,
       action_type: actionType,
@@ -191,68 +125,4 @@ async function executeActionViaActionsApi(
   });
 }
 
-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({
-    appKey: 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,
-  });
-}
-
 // No registry info here - moved to info.ts for proper tree-shaking

package/src/functions/runAction/schemas.ts

@@ -27,6 +27,8 @@ export type RunActionOptions = z.infer<typeof RunActionSchema> & {
   baseUrl?: string;
   /** Authentication token */
   token?: string;
+  /** Function to dynamically resolve authentication token */
+  getToken?: () => Promise<string | undefined>;
   /** Optional pre-instantiated API client */
   api?: any;
   /** Enable debug logging */

package/src/index.ts

@@ -6,6 +6,9 @@ export * from "./plugins/apps";
 // Export schema utilities for CLI
 export { isPositional } from "./schema-utils";
 
+// Export auth utilities for CLI use
+export * from "./auth";
+
 // Export resolvers for CLI use
 export * from "./resolvers";
 
@@ -13,6 +16,7 @@ export * from "./resolvers";
 
 // Export individual functions for tree-shaking
 export { listAuthentications } from "./functions/listAuthentications";
+export { getAuthentication } from "./functions/getAuthentication";
 export { findFirstAuthentication } from "./functions/findFirstAuthentication";
 export { findUniqueAuthentication } from "./functions/findUniqueAuthentication";
 export { listApps } from "./functions/listApps";

package/src/sdk.ts

@@ -1,5 +1,6 @@
 import { createZapierApi } from "./api";
 import { BaseSdkOptions } from "./types/domain";
+import { getTokenFromEnvOrConfig } from "./auth";
 // Import function implementations
 import { listApps } from "./functions/listApps";
 import { getApp } from "./functions/getApp";
@@ -7,6 +8,7 @@ import { listActions } from "./functions/listActions";
 import { getAction } from "./functions/getAction";
 import { runAction } from "./functions/runAction";
 import { listAuthentications } from "./functions/listAuthentications";
+import { getAuthentication } from "./functions/getAuthentication";
 import { findFirstAuthentication } from "./functions/findFirstAuthentication";
 import { findUniqueAuthentication } from "./functions/findUniqueAuthentication";
 import { listFields } from "./functions/listFields";
@@ -20,6 +22,7 @@ import { listActionsInfo } from "./functions/listActions/info";
 import { getActionInfo } from "./functions/getAction/info";
 import { runActionInfo } from "./functions/runAction/info";
 import { listAuthenticationsInfo } from "./functions/listAuthentications/info";
+import { getAuthenticationInfo } from "./functions/getAuthentication/info";
 import { findFirstAuthenticationInfo } from "./functions/findFirstAuthentication/info";
 import { findUniqueAuthenticationInfo } from "./functions/findUniqueAuthentication/info";
 import { listFieldsInfo } from "./functions/listFields/info";
@@ -34,6 +37,7 @@ const functionRegistry = [
   getActionInfo,
   runActionInfo,
   listAuthenticationsInfo,
+  getAuthenticationInfo,
   findFirstAuthenticationInfo,
   findUniqueAuthenticationInfo,
   listFieldsInfo,
@@ -49,122 +53,66 @@ import { createAppsPlugin } from "./plugins/apps/index";
 
 // TODO: Add plugin registry back when needed for CLI compatibility
 
-// Base SDK functions interface (functions + registry, no plugins)
-interface BaseZapierSdkWithFunctions {
-  __registry: Array<{
-    name: string;
-    inputSchema: any;
-    implementation: Function;
-  }>;
-  listApps: ZapierSdk["listApps"];
-  getApp: ZapierSdk["getApp"];
-  listActions: ZapierSdk["listActions"];
-  getAction: ZapierSdk["getAction"];
-  runAction: ZapierSdk["runAction"];
-  listAuthentications: ZapierSdk["listAuthentications"];
-  findFirstAuthentication: ZapierSdk["findFirstAuthentication"];
-  findUniqueAuthentication: ZapierSdk["findUniqueAuthentication"];
-  listFields: ZapierSdk["listFields"];
-  generateTypes: ZapierSdk["generateTypes"];
-  bundleCode: ZapierSdk["bundleCode"];
-}
-
 // Full SDK interface with plugins applied
 export type { ZapierSdk } from "./types/sdk";
 
 export interface ZapierSdkOptions extends BaseSdkOptions {}
 
-function createBaseZapierSdk(
-  options: ZapierSdkOptions = {},
-): BaseZapierSdkWithFunctions {
-  // 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
-  }
-
+export function createZapierSdk(options: ZapierSdkOptions = {}): ZapierSdk {
   const {
     fetch: customFetch = globalThis.fetch,
     baseUrl = "https://zapier.com",
     token,
+    getToken,
+    onEvent,
     debug = false,
   } = options;
 
-  // If no token provided, try to get it from environment variable
-  const finalToken = token || process.env.ZAPIER_TOKEN;
+  // If no explicit token or getToken provided, try env var then CLI config with event callbacks
+  const resolvedGetToken =
+    getToken ||
+    (!token
+      ? () => getTokenFromEnvOrConfig({ onEvent, fetch: customFetch })
+      : undefined);
 
   // Create the API client
   const api = createZapierApi({
     baseUrl,
-    token: finalToken,
+    token,
+    getToken: resolvedGetToken,
     debug,
     fetch: customFetch,
   });
 
-  // Build SDK directly - TypeScript will enforce correct implementation
-  const sdk: BaseZapierSdkWithFunctions = {
+  // Create plugins directly - TypeScript will enforce correct implementation
+  const appsPlugin = createAppsPlugin({
+    api,
+    token,
+  });
+
+  // Compose final SDK - TypeScript will enforce we have all required properties
+  const fullSdk: ZapierSdk = {
     // Registry for CLI
     __registry: functionRegistry,
 
     // Function implementations with API config injection
-    listApps: (options = {}) =>
-      listApps({ ...options, api, token: finalToken }),
-    getApp: (options) => getApp({ ...options, api, token: finalToken }),
-    listActions: (options = {}) =>
-      listActions({ ...options, api, token: finalToken }),
-    getAction: (options) => getAction({ ...options, api, token: finalToken }),
-    runAction: (options) => runAction({ ...options, api, token: finalToken }),
+    listApps: (options = {}) => listApps({ ...options, api }),
+    getApp: (options) => getApp({ ...options, api }),
+    listActions: (options = {}) => listActions({ ...options, api }),
+    getAction: (options) => getAction({ ...options, api }),
+    runAction: (options) => runAction({ ...options, api }),
     listAuthentications: (options = {}) =>
-      listAuthentications({ ...options, api, token: finalToken }),
+      listAuthentications({ ...options, api }),
+    getAuthentication: (options) => getAuthentication({ ...options, api }),
     findFirstAuthentication: (options = {}) =>
-      findFirstAuthentication({ ...options, api, token: finalToken }),
+      findFirstAuthentication({ ...options, api }),
     findUniqueAuthentication: (options = {}) =>
-      findUniqueAuthentication({ ...options, api, token: finalToken }),
-    listFields: (options) => listFields({ ...options, api, token: finalToken }),
-    generateTypes: (options) =>
-      generateTypes({ ...options, api, token: finalToken }),
+      findUniqueAuthentication({ ...options, api }),
+    listFields: (options) => listFields({ ...options, api }),
+    generateTypes: (options) => generateTypes({ ...options, api }),
     bundleCode: (options) => bundleCode(options), // No API config needed
-  };
-
-  return sdk;
-}
-
-export function createZapierSdk(options: ZapierSdkOptions = {}): ZapierSdk {
-  // Create base SDK
-  const baseSdk = createBaseZapierSdk(options);
 
-  // Extract options needed for plugins
-  const {
-    fetch: customFetch = globalThis.fetch,
-    baseUrl = "https://zapier.com",
-    token,
-    debug = false,
-  } = options;
-
-  const finalToken = token || process.env.ZAPIER_TOKEN;
-
-  // Create the API client for plugins
-  const api = createZapierApi({
-    baseUrl,
-    token: finalToken,
-    debug,
-    fetch: customFetch,
-  });
-
-  // Create plugins directly - TypeScript will enforce correct implementation
-  const appsPlugin = createAppsPlugin({
-    api,
-    token: finalToken,
-  });
-
-  // Compose final SDK - TypeScript will enforce we have all required properties
-  const fullSdk: ZapierSdk = {
-    ...baseSdk,
+    // Add plugins
     apps: appsPlugin,
   };
 

package/src/types/domain.ts

@@ -14,6 +14,9 @@ export type {
   AuthenticationsResponse,
 } from "../api/types";
 
+// Import event types
+import type { EventCallback } from "./events";
+
 // SDK Configuration Types
 export interface ActionExecutionOptions {
   inputs?: Record<string, any>;
@@ -26,6 +29,8 @@ export interface AuthObject {
 
 export interface BaseSdkOptions {
   token?: string;
+  getToken?: () => Promise<string | undefined>;
+  onEvent?: EventCallback;
   fetch?: typeof fetch;
   baseUrl?: string;
   debug?: boolean;

package/src/types/events.ts

@@ -0,0 +1,43 @@
+/**
+ * SDK Event System
+ *
+ * This module provides common event type definitions for the SDK's
+ * event system, including authentication, API, and loading events.
+ */
+
+// Generic event system
+export interface SdkEvent {
+  type: string;
+  payload?: Record<string, any>;
+  timestamp?: number;
+}
+
+export interface AuthEvent extends SdkEvent {
+  type: "auth_refreshing" | "auth_success" | "auth_error" | "auth_logout";
+  payload?: {
+    message?: string;
+    error?: string;
+    operation?: string;
+  };
+}
+
+export interface ApiEvent extends SdkEvent {
+  type: "api_request" | "api_response" | "api_error";
+  payload?: {
+    url?: string;
+    method?: string;
+    status?: number;
+    duration?: number;
+    error?: string;
+  };
+}
+
+export interface LoadingEvent extends SdkEvent {
+  type: "loading_start" | "loading_end";
+  payload?: {
+    operation?: string;
+    resource?: string;
+  };
+}
+
+export type EventCallback = (event: SdkEvent) => void;

package/src/types/properties.ts

@@ -9,7 +9,16 @@ export const AppKeyPropertySchema = withPositional(
 );
 
 export const ActionTypePropertySchema = z
-  .enum(["read", "write", "search", "create", "update", "delete"])
+  .enum([
+    "read",
+    "read_bulk",
+    "write",
+    "run",
+    "search",
+    "search_or_write",
+    "search_and_write",
+    "filter",
+  ])
   .describe("Action type that matches the action's defined type");
 
 export const ActionKeyPropertySchema = z

package/src/types/sdk.ts

@@ -5,6 +5,7 @@ import type { GetAppSdkFunction } from "../functions/getApp/schemas";
 import type { RunActionSdkFunction } from "../functions/runAction/schemas";
 import type { ListFieldsSdkFunction } from "../functions/listFields/schemas";
 import type { ListAuthenticationsSdkFunction } from "../functions/listAuthentications/schemas";
+import type { GetAuthenticationSdkFunction } from "../functions/getAuthentication/schemas";
 import type { FindFirstAuthenticationSdkFunction } from "../functions/findFirstAuthentication/schemas";
 import type { FindUniqueAuthenticationSdkFunction } from "../functions/findUniqueAuthentication/schemas";
 import type { GenerateTypesSdkFunction } from "../functions/generateTypes/schemas";
@@ -22,6 +23,7 @@ export interface ZapierSdkFunctions
     RunActionSdkFunction,
     ListFieldsSdkFunction,
     ListAuthenticationsSdkFunction,
+    GetAuthenticationSdkFunction,
     FindFirstAuthenticationSdkFunction,
     FindUniqueAuthenticationSdkFunction,
     GenerateTypesSdkFunction,