@zapier/zapier-sdk 0.4.0 → 0.5.0

package/src/functions/runAction/index.ts

@@ -1,127 +0,0 @@
-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,
-  } = options;
-
-  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 Actions API (supports all action types)
-  const startTime = Date.now();
-  const result = await executeAction({
-    api,
-    appSlug: appKey,
-    actionKey: actionKey,
-    actionType: actionData.type,
-    executionOptions: { inputs: inputs || {} },
-    authenticationId: providedAuthenticationId,
-    options,
-  });
-  const executionTime = Date.now() - startTime;
-
-  return {
-    success: true,
-    data: result,
-    metadata: {
-      executionTime,
-      requestId: generateRequestId(),
-    },
-  };
-}
-
-interface ExecuteActionOptions {
-  api: any;
-  appSlug: string;
-  actionKey: string;
-  actionType: string;
-  executionOptions: { inputs: Record<string, any> };
-  authenticationId?: number;
-  options: RunActionOptions;
-}
-
-async function executeAction(
-  actionOptions: ExecuteActionOptions,
-): Promise<any> {
-  const {
-    api,
-    appSlug,
-    actionKey,
-    actionType,
-    executionOptions,
-    authenticationId,
-    options,
-  } = actionOptions;
-
-  // 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");
-  }
-
-  // Step 1: POST to /actions/v1/runs to start execution
-  const runRequest = {
-    data: {
-      authentication_id: authenticationId || 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,
-  });
-}
-
-// No registry info here - moved to info.ts for proper tree-shaking

package/src/functions/runAction/info.ts

@@ -1,9 +0,0 @@
-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

@@ -1,34 +0,0 @@
-import { z } from "zod";
-import {
-  AppKeyPropertySchema,
-  ActionTypePropertySchema,
-  ActionKeyPropertySchema,
-  AuthenticationIdPropertySchema,
-  InputsPropertySchema,
-} from "../../types/properties";
-import type {
-  ActionExecutionResult,
-  FunctionOptions,
-} 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> &
-  FunctionOptions;
-
-// SDK function interface - ready to be mixed into main SDK interface
-export interface RunActionSdkFunction {
-  runAction: (options: RunActionOptions) => Promise<ActionExecutionResult>;
-}

package/src/plugins/apps/info.ts

@@ -1,12 +0,0 @@
-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,
-    };
-  },
-};