@zapier/zapier-sdk 0.0.2 → 0.1.0

package/src/functions/listAuths/schemas.ts

@@ -0,0 +1,48 @@
+import { z } from "zod";
+import {
+  AppKeyPropertySchema,
+  LimitPropertySchema,
+  OffsetPropertySchema,
+} from "../../types/properties";
+import { withOutputSchema } from "../../schema-utils";
+import { AuthItemSchema } from "../../schemas/Auth";
+import type { Authentication } from "../../types/domain";
+
+// Pure Zod schema - no resolver metadata!
+export const ListAuthsSchema = withOutputSchema(
+  z
+    .object({
+      appKey: AppKeyPropertySchema.optional().describe(
+        "App slug to get authentications for (e.g., 'slack', 'github')",
+      ),
+      account_id: z.string().optional().describe("Filter by account ID"),
+      owner: z.string().optional().describe("Filter by owner"),
+      limit: LimitPropertySchema.optional().describe(
+        "Maximum number of items to return (1-200)",
+      ),
+      offset: OffsetPropertySchema.optional().describe(
+        "Number of items to skip for pagination",
+      ),
+    })
+    .describe("List available authentications with optional filtering"),
+  AuthItemSchema,
+);
+
+// Type inferred from schema + function config
+export type ListAuthsOptions = z.infer<typeof ListAuthsSchema> & {
+  /** Base URL for Zapier API */
+  baseUrl?: string;
+  /** Authentication token */
+  token?: string;
+  /** Optional pre-instantiated API client */
+  api?: any;
+  /** Enable debug logging */
+  debug?: boolean;
+  /** Custom fetch implementation */
+  fetch?: typeof globalThis.fetch;
+};
+
+// SDK function interface - ready to be mixed into main SDK interface
+export interface ListAuthsSdkFunction {
+  listAuths: (options?: Partial<ListAuthsOptions>) => Promise<Authentication[]>;
+}

package/src/functions/listFields/index.ts

@@ -0,0 +1,86 @@
+import { getOrCreateApiClient } from "../../api";
+import type {
+  ActionField,
+  NeedsRequest,
+  NeedsResponse,
+} from "../../types/domain";
+import { getApp } from "../getApp";
+import type { ListFieldsOptions } from "./schemas";
+
+/**
+ * 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, authentication ID, params, and API configuration options
+ * @returns Promise<ActionField[]>
+ */
+export async function listFields(
+  options: ListFieldsOptions,
+): Promise<ActionField[]> {
+  const api = getOrCreateApiClient(options);
+
+  // Extract parameters
+  const { appKey, actionKey, actionType, authenticationId, params } = options;
+
+  // Use the standalone getApp function
+  const appData = await getApp({
+    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: authenticationId,
+    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,
+  }));
+}
+
+// No registry info here - moved to info.ts for proper tree-shaking

package/src/functions/listFields/info.ts

@@ -0,0 +1,9 @@
+import { listFields } from "./index";
+import { ListFieldsSchema } from "./schemas";
+
+// Function registry info - imports both function and schema
+export const listFieldsInfo = {
+  name: listFields.name,
+  inputSchema: ListFieldsSchema,
+  implementation: listFields,
+};

package/src/functions/listFields/schemas.ts

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import {
+  AppKeyPropertySchema,
+  ActionTypePropertySchema,
+  ActionKeyPropertySchema,
+  AuthenticationIdPropertySchema,
+  ParamsPropertySchema,
+} from "../../types/properties";
+import { withOutputSchema } from "../../schema-utils";
+import { FieldItemSchema } from "../../schemas/Field";
+import type { ActionField } from "../../types/domain";
+
+// Pure Zod schema - no resolver metadata!
+export const ListFieldsSchema = withOutputSchema(
+  z
+    .object({
+      appKey: AppKeyPropertySchema,
+      actionType: ActionTypePropertySchema,
+      actionKey: ActionKeyPropertySchema,
+      authenticationId: AuthenticationIdPropertySchema.optional(),
+      params: ParamsPropertySchema.optional().describe(
+        "Additional parameters that may affect available fields",
+      ),
+    })
+    .describe("Get the input fields required for a specific action"),
+  FieldItemSchema,
+);
+
+// Type inferred from schema + function config
+export type ListFieldsOptions = z.infer<typeof ListFieldsSchema> & {
+  /** Base URL for Zapier API */
+  baseUrl?: string;
+  /** Authentication token */
+  token?: string;
+  /** Optional pre-instantiated API client */
+  api?: any;
+  /** Enable debug logging */
+  debug?: boolean;
+  /** Custom fetch implementation */
+  fetch?: typeof globalThis.fetch;
+};
+
+// SDK function interface - ready to be mixed into main SDK interface
+export interface ListFieldsSdkFunction {
+  listFields: (options: ListFieldsOptions) => Promise<ActionField[]>;
+}

package/src/functions/runAction/index.ts

@@ -0,0 +1,258 @@
+import { getOrCreateApiClient, generateRequestId } from "../../api";
+import type { ActionExecutionResult } from "../../types/domain";
+import { getAction } from "../getAction";
+import { getApp } from "../getApp";
+import type { RunActionOptions } from "./schemas";
+
+/**
+ * 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 {
+    appKey,
+    actionType,
+    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);
+
+  // Validate that the action exists
+  const actionData = await getAction({
+    ...options,
+    appKey: appKey,
+    actionKey: actionKey,
+    actionType: actionType,
+  });
+
+  // Validate action type matches
+  if (actionData.type !== actionType) {
+    throw new Error(
+      `Action type mismatch: expected ${actionType}, got ${actionData.type}`,
+    );
+  }
+
+  // Execute the action using the appropriate API based on action type
+  const startTime = Date.now();
+  const result = await executeActionWithStrategy({
+    api,
+    appSlug: appKey,
+    actionKey: actionKey,
+    actionType: actionData.type,
+    executionOptions: { inputs: inputs || {} },
+    auth: token
+      ? { token: token, authentication_id: providedAuthenticationId }
+      : 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({
+    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 /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({
+    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/info.ts

@@ -0,0 +1,9 @@
+import { runAction } from "./index";
+import { RunActionSchema } from "./schemas";
+
+// Function registry info - imports both function and schema
+export const runActionInfo = {
+  name: runAction.name,
+  inputSchema: RunActionSchema,
+  implementation: runAction,
+};

package/src/functions/runAction/schemas.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import {
+  AppKeyPropertySchema,
+  ActionTypePropertySchema,
+  ActionKeyPropertySchema,
+  AuthenticationIdPropertySchema,
+  InputsPropertySchema,
+} from "../../types/properties";
+import type { ActionExecutionResult } from "../../types/domain";
+
+// Pure Zod schema - no resolver metadata!
+export const RunActionSchema = z
+  .object({
+    appKey: AppKeyPropertySchema,
+    actionType: ActionTypePropertySchema,
+    actionKey: ActionKeyPropertySchema,
+    inputs: InputsPropertySchema.optional().describe(
+      "Input parameters for the action",
+    ),
+    authenticationId: AuthenticationIdPropertySchema.optional(),
+  })
+  .describe("Execute an action with the given inputs");
+
+// Type inferred from schema + function config
+export type RunActionOptions = z.infer<typeof RunActionSchema> & {
+  /** Base URL for Zapier API */
+  baseUrl?: string;
+  /** Authentication token */
+  token?: string;
+  /** Optional pre-instantiated API client */
+  api?: any;
+  /** Enable debug logging */
+  debug?: boolean;
+  /** Custom fetch implementation */
+  fetch?: typeof globalThis.fetch;
+};
+
+// SDK function interface - ready to be mixed into main SDK interface
+export interface RunActionSdkFunction {
+  runAction: (options: RunActionOptions) => Promise<ActionExecutionResult>;
+}

package/src/index.ts

@@ -1,6 +1,26 @@
-// Export everything from types and actions-sdk
-export * from "./types";
-export * from "./actions-sdk";
+// Export everything from types and plugins
+export * from "./types/domain";
+export * from "./types/properties";
+export * from "./plugins/apps";
+
+// Export resolvers for CLI use
+export * from "./resolvers";
+
+// Note: SdkSchemas is now available via SDK.__registry
+
+// 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";
+export { createZapierSdk, ZapierSdkOptions } from "./sdk";
+
+// Export SDK type from types (not sdk.ts to avoid circular imports)
+export type { ZapierSdk } from "./types/sdk";

package/src/plugins/apps/index.ts

@@ -0,0 +1,144 @@
+import {
+  ActionExecutionOptions,
+  ActionExecutionResult,
+} from "../../types/domain";
+import { type ApiClient } from "../../api";
+import { runAction } from "../../functions/runAction";
+import type { ActionProxy } from "./types";
+
+export interface AppsPluginOptions {
+  api: ApiClient;
+  token?: string;
+}
+
+interface AppFactoryOptions {
+  authenticationId: number;
+}
+
+function createActionFunction(
+  appKey: string,
+  actionType: string,
+  actionKey: string,
+  options: AppsPluginOptions,
+  pinnedAuthId?: number,
+) {
+  return async (
+    actionOptions: ActionExecutionOptions = {},
+  ): Promise<ActionExecutionResult> => {
+    const { api, token } = options;
+    const { inputs, authenticationId: providedAuthenticationId } =
+      actionOptions;
+
+    // Use pinned auth ID first, then provided auth ID
+    const authenticationId = pinnedAuthId || providedAuthenticationId;
+
+    if (!authenticationId) {
+      throw new Error(
+        `Authentication ID is required. Either use the factory pattern: sdk.apps.${appKey}({ authenticationId }) or provide authenticationId in the action call.`,
+      );
+    }
+
+    // Call runAction with the resolved parameters
+    return runAction({
+      appKey,
+      actionType: actionType as any,
+      actionKey,
+      inputs,
+      authenticationId,
+      api: api,
+      token,
+    });
+  };
+}
+
+function createActionTypeProxy(
+  appKey: string,
+  actionType: string,
+  options: AppsPluginOptions,
+  pinnedAuthId?: number,
+) {
+  return new Proxy(
+    {},
+    {
+      get(_, actionKey) {
+        if (typeof actionKey === "string") {
+          return createActionFunction(
+            appKey,
+            actionType,
+            actionKey,
+            options,
+            pinnedAuthId,
+          );
+        }
+        return undefined;
+      },
+    },
+  );
+}
+
+function createPinnedAppProxy(
+  appKey: string,
+  options: AppsPluginOptions,
+  pinnedAuthId: number,
+) {
+  return new Proxy(
+    {},
+    {
+      get(_, actionType) {
+        if (typeof actionType === "string") {
+          return createActionTypeProxy(
+            appKey,
+            actionType,
+            options,
+            pinnedAuthId,
+          );
+        }
+        return undefined;
+      },
+    },
+  );
+}
+
+function createAppProxy(appKey: string, options: AppsPluginOptions) {
+  // Create the factory function that returns a pinned version
+  const appFactory = (factoryOptions: AppFactoryOptions) => {
+    return createPinnedAppProxy(
+      appKey,
+      options,
+      factoryOptions.authenticationId,
+    );
+  };
+
+  // Add properties for direct usage (backward compatibility)
+  return new Proxy(appFactory, {
+    get(_, actionType) {
+      if (typeof actionType === "string") {
+        return createActionTypeProxy(appKey, actionType, options);
+      }
+      return undefined;
+    },
+  });
+}
+
+function createAppsProxy(options: AppsPluginOptions): ActionProxy {
+  // Create a proxy object that intercepts property access
+  const appsProxy = new Proxy({} as ActionProxy, {
+    get(_, prop) {
+      if (typeof prop === "string") {
+        // First level: App names (e.g., 'slack')
+        return createAppProxy(prop, options);
+      }
+      return undefined;
+    },
+  });
+
+  return appsProxy;
+}
+
+// Export the plugin creation function
+export function createAppsPlugin(options: AppsPluginOptions): ActionProxy {
+  return createAppsProxy(options);
+}
+
+// Re-export types
+export type { ActionProxy, AppsPluginSdkExtension } from "./types";

package/src/plugins/apps/info.ts

@@ -0,0 +1,12 @@
+import { createAppsPlugin } from "./index";
+import type { AppsPluginOptions } from "./index";
+
+// Plugin info object for registry (keeping for compatibility)
+export const appsPluginInfo = {
+  plugin: (_sdk: any, options: AppsPluginOptions) => {
+    const appsProxy = createAppsPlugin(options);
+    return {
+      apps: appsProxy,
+    };
+  },
+};