@zapier/zapier-sdk 0.13.5 → 0.13.7

package/src/plugins/runAction/index.test.ts

@@ -1,388 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { ZapierValidationError, ZapierActionError } from "../../types/errors";
-import { runActionPlugin } from "./index";
-import { createSdk } from "../../sdk";
-import type { ApiClient } from "../../api";
-import type { RunActionOptions } from "./schemas";
-import type { ActionItem } from "../../types/domain";
-
-const mockAction: ActionItem = {
-  type: "action",
-  key: "send_message",
-  title: "Send Message",
-  description: "Send a message to a channel",
-  app_key: "slack",
-  action_type: "write",
-};
-
-const mockActionResponse = {
-  results: [
-    {
-      id: "msg_123",
-      text: "Hello, world!",
-      channel: "#general",
-      user: "user_456",
-    },
-  ],
-  meta: {
-    next_cursor: null,
-  },
-};
-
-describe("runAction plugin", () => {
-  let mockApiClient: ApiClient;
-  let mockGetAction: any;
-  let mockGetApp: any;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockApiClient = {
-      post: vi.fn().mockResolvedValue({ data: { id: "run_123" } }),
-      poll: vi.fn().mockResolvedValue({ results: mockActionResponse.results }),
-    } as Partial<ApiClient> as ApiClient;
-
-    mockGetAction = vi.fn().mockResolvedValue({
-      data: mockAction,
-    });
-  });
-
-  function createTestSdk() {
-    return createSdk(
-      {},
-      { getAction: mockGetAction, getApp: mockGetApp }, // Provide getAction and getApp in SDK
-      {
-        api: mockApiClient,
-        meta: {},
-        getVersionedImplementationId: () => "SlackCLIAPI@1.21.1",
-      },
-    ).addPlugin(runActionPlugin as any);
-  }
-
-  describe("schema validation", () => {
-    it("should throw validation error for missing appKey", () => {
-      const sdk = createTestSdk();
-      expect(() => {
-        sdk.runAction({
-          actionType: "write",
-          actionKey: "send_message",
-          inputs: { message: "Hello" },
-        } as Partial<RunActionOptions> as RunActionOptions);
-      }).toThrow(ZapierValidationError);
-    });
-
-    it("should throw validation error for missing actionType", () => {
-      const sdk = createTestSdk();
-      expect(() => {
-        sdk.runAction({
-          appKey: "slack",
-          actionKey: "send_message",
-          inputs: { message: "Hello" },
-        } as Partial<RunActionOptions> as RunActionOptions);
-      }).toThrow(ZapierValidationError);
-    });
-
-    it("should throw validation error for missing actionKey", () => {
-      const sdk = createTestSdk();
-      expect(() => {
-        sdk.runAction({
-          appKey: "slack",
-          actionType: "write",
-          inputs: { message: "Hello" },
-        } as Partial<RunActionOptions> as RunActionOptions);
-      }).toThrow(ZapierValidationError);
-    });
-
-    it("should pass validation with all required fields", async () => {
-      const sdk = createTestSdk();
-      const result = await sdk.runAction({
-        appKey: "slack",
-        actionType: "write",
-        actionKey: "send_message",
-        inputs: { message: "Hello" },
-      });
-
-      expect(result.data).toHaveLength(1);
-      expect(result.data[0]).toEqual(mockActionResponse.results[0]);
-    });
-  });
-
-  describe("action execution", () => {
-    it("should validate action exists using getAction", async () => {
-      const sdk = createTestSdk();
-      await sdk.runAction({
-        appKey: "slack",
-        actionType: "write",
-        actionKey: "send_message",
-        inputs: { message: "Hello" },
-      });
-
-      expect(mockGetAction).toHaveBeenCalledWith({
-        appKey: "slack",
-        actionKey: "send_message",
-        actionType: "write",
-      });
-    });
-
-    it("should throw error when action type doesn't match", async () => {
-      // Mock getAction to return an action with different type
-      mockGetAction.mockResolvedValue({
-        data: { ...mockAction, action_type: "read" },
-      });
-
-      const sdk = createTestSdk();
-      await expect(
-        sdk.runAction({
-          appKey: "slack",
-          actionType: "write", // Different from mocked action type
-          actionKey: "send_message",
-          inputs: { message: "Hello" },
-        }),
-      ).rejects.toThrow(ZapierValidationError);
-    });
-
-    it("should execute action with correct API call", async () => {
-      const sdk = createTestSdk();
-      await sdk.runAction({
-        appKey: "slack",
-        actionType: "write",
-        actionKey: "send_message",
-        inputs: { message: "Hello", channel: "#general" },
-        authenticationId: 12345,
-      });
-
-      expect(mockApiClient.post).toHaveBeenCalledWith("/api/actions/v1/runs", {
-        data: {
-          selected_api: "SlackCLIAPI@1.21.1",
-          action_key: "send_message",
-          action_type: "write",
-          inputs: { message: "Hello", channel: "#general" },
-          authentication_id: 12345,
-        },
-      });
-
-      expect(mockApiClient.poll).toHaveBeenCalledWith(
-        "/api/actions/v1/runs/run_123",
-        {
-          successStatus: 200,
-          pendingStatus: 202,
-          resultExtractor: expect.any(Function),
-        },
-      );
-    });
-
-    it("should execute action without authentication ID", async () => {
-      const sdk = createTestSdk();
-      await sdk.runAction({
-        appKey: "slack",
-        actionType: "write",
-        actionKey: "send_message",
-        inputs: { message: "Hello" },
-      });
-
-      expect(mockApiClient.post).toHaveBeenCalledWith("/api/actions/v1/runs", {
-        data: {
-          selected_api: "SlackCLIAPI@1.21.1",
-          action_key: "send_message",
-          action_type: "write",
-          inputs: { message: "Hello" },
-        },
-      });
-    });
-
-    it("should handle pagination cursor", async () => {
-      const sdk = createTestSdk();
-      const runActionResult = sdk.runAction({
-        appKey: "slack",
-        actionType: "write",
-        actionKey: "send_message",
-        inputs: { message: "Hello" },
-      });
-
-      // Simulate pagination by getting an iterator
-      const iterator = runActionResult[Symbol.asyncIterator]();
-      await iterator.next();
-
-      expect(mockApiClient.post).toHaveBeenCalledWith(
-        "/api/actions/v1/runs",
-        expect.objectContaining({
-          data: expect.objectContaining({
-            inputs: { message: "Hello" },
-            selected_api: "SlackCLIAPI@1.21.1",
-            action_key: "send_message",
-            action_type: "write",
-          }),
-        }),
-      );
-    });
-
-    it("should return results in correct format", async () => {
-      const sdk = createTestSdk();
-      const result = await sdk.runAction({
-        appKey: "slack",
-        actionType: "write",
-        actionKey: "send_message",
-        inputs: { message: "Hello" },
-      });
-
-      expect(result.data).toEqual(mockActionResponse.results);
-    });
-
-    it("should handle single result (not array)", async () => {
-      const singleResult = { id: "msg_123", text: "Hello" };
-      mockApiClient.post = vi
-        .fn()
-        .mockResolvedValue({ data: { id: "run_123" } });
-      mockApiClient.poll = vi.fn().mockResolvedValue({
-        results: [singleResult], // Poll returns the actual results
-      });
-
-      const sdk = createTestSdk();
-      const result = await sdk.runAction({
-        appKey: "slack",
-        actionType: "write",
-        actionKey: "send_message",
-        inputs: { message: "Hello" },
-      });
-
-      expect(result.data).toEqual([singleResult]); // Should be wrapped in array
-    });
-  });
-
-  describe("error handling", () => {
-    it("should handle action execution errors", async () => {
-      mockApiClient.post = vi
-        .fn()
-        .mockResolvedValue({ data: { id: "run_123" } });
-      mockApiClient.poll = vi.fn().mockResolvedValue({
-        results: [],
-        errors: [
-          { title: "Invalid inputs", detail: "Message cannot be empty" },
-        ],
-      });
-
-      const sdk = createTestSdk();
-      await expect(
-        sdk.runAction({
-          appKey: "slack",
-          actionType: "write",
-          actionKey: "send_message",
-          inputs: { message: "" }, // Invalid input
-        }),
-      ).rejects.toThrow(ZapierActionError);
-    });
-
-    it("should handle server errors", async () => {
-      mockApiClient.post = vi.fn().mockImplementation((_url, options) => {
-        const error = options.customErrorHandler?.({
-          status: 500,
-          data: { message: "Internal server error" },
-        });
-        if (error) throw error;
-        throw new Error("Server Error");
-      });
-
-      const sdk = createTestSdk();
-      await expect(
-        sdk.runAction({
-          appKey: "slack",
-          actionType: "write",
-          actionKey: "send_message",
-          inputs: { message: "Hello" },
-        }),
-      ).rejects.toThrow();
-    });
-
-    it("should propagate getAction errors", async () => {
-      mockGetAction.mockRejectedValue(new Error("Action not found"));
-
-      const sdk = createTestSdk();
-      await expect(
-        sdk.runAction({
-          appKey: "slack",
-          actionType: "write",
-          actionKey: "nonexistent",
-          inputs: { message: "Hello" },
-        }),
-      ).rejects.toThrow("Action not found");
-    });
-
-    it("should handle unexpected errors during execution", async () => {
-      mockApiClient.post = vi
-        .fn()
-        .mockRejectedValue(new Error("Network error"));
-
-      const sdk = createTestSdk();
-      await expect(
-        sdk.runAction({
-          appKey: "slack",
-          actionType: "write",
-          actionKey: "send_message",
-          inputs: { message: "Hello" },
-        }),
-      ).rejects.toThrow("Network error");
-    });
-  });
-
-  describe("pagination", () => {
-    it("should support maxItems limit", async () => {
-      const sdk = createTestSdk();
-      const result = await sdk.runAction({
-        appKey: "slack",
-        actionType: "write",
-        actionKey: "send_message",
-        inputs: { message: "Hello" },
-        maxItems: 1,
-      });
-
-      expect(result.data).toHaveLength(1);
-    });
-
-    it("should support async iteration over pages", async () => {
-      const sdk = createTestSdk();
-      const runActionResult = sdk.runAction({
-        appKey: "slack",
-        actionType: "write",
-        actionKey: "send_message",
-        inputs: { message: "Hello" },
-      });
-
-      const pages = [];
-      for await (const page of runActionResult) {
-        pages.push(page);
-        break; // Just get first page for testing
-      }
-
-      expect(pages).toHaveLength(1);
-      expect(pages[0].data).toEqual(mockActionResponse.results);
-    });
-
-    it("should support async iteration over individual items", async () => {
-      const sdk = createTestSdk();
-      const runActionResult = sdk.runAction({
-        appKey: "slack",
-        actionType: "write",
-        actionKey: "send_message",
-        inputs: { message: "Hello" },
-        maxItems: 1,
-      });
-
-      const items = [];
-      for await (const item of runActionResult.items()) {
-        items.push(item);
-      }
-
-      expect(items).toHaveLength(1);
-      expect(items[0]).toEqual(mockActionResponse.results[0]);
-    });
-  });
-
-  describe("context and metadata", () => {
-    it("should provide context with meta information", () => {
-      const sdk = createTestSdk();
-      const context = sdk.getContext();
-
-      expect((context.meta as any).runAction).toBeDefined();
-      expect((context.meta as any).runAction.inputSchema).toBeDefined();
-    });
-  });
-});

package/src/plugins/runAction/index.ts

@@ -1,215 +0,0 @@
-import type { Plugin, GetSdkType } from "../../types/plugin";
-import type { ApiClient } from "../../api";
-import {
-  RunActionSchema,
-  type RunActionOptions,
-  type RunActionPage,
-} from "./schemas";
-import { ActionResultItemSchema } from "../../schemas/Run";
-import {
-  ZapierValidationError,
-  ZapierConfigurationError,
-  ZapierActionError,
-} from "../../types/errors";
-import { createPaginatedFunction } from "../../utils/function-utils";
-import type { GetActionPluginProvides } from "../getAction";
-import type { GetAppPluginProvides } from "../getApp";
-import {
-  appKeyResolver,
-  actionTypeResolver,
-  actionKeyResolver,
-  authenticationIdResolver,
-  inputsResolver,
-} from "../../resolvers";
-import type { GetVersionedImplementationId } from "../manifest/schemas";
-
-export interface RunActionPluginProvides {
-  runAction: (options?: RunActionOptions) => Promise<{
-    data: any[];
-    nextCursor?: string;
-  }> &
-    AsyncIterable<{ data: any[]; nextCursor?: string }> & {
-      items(): AsyncIterable<any>;
-    };
-  context: {
-    meta: {
-      runAction: {
-        inputSchema: typeof RunActionSchema;
-      };
-    };
-  };
-}
-
-interface ExecuteActionOptions {
-  api: ApiClient;
-  context: {
-    getVersionedImplementationId: GetVersionedImplementationId;
-  };
-  appKey: string;
-  actionId?: string;
-  actionKey: string;
-  actionType: string;
-  executionOptions: { inputs: Record<string, unknown> };
-  authenticationId?: number | null;
-  options: RunActionOptions;
-}
-
-async function executeAction(actionOptions: ExecuteActionOptions): Promise<{
-  results: unknown[];
-  errors?: Array<{ detail?: string; title?: string }>;
-}> {
-  const {
-    api,
-    context,
-    appKey,
-    actionId,
-    actionKey,
-    actionType,
-    executionOptions,
-    authenticationId,
-  } = actionOptions;
-
-  // Use the manifest plugin to get the current implementation ID
-  const selectedApi = await context.getVersionedImplementationId(appKey);
-
-  if (!selectedApi) {
-    throw new ZapierConfigurationError(
-      "No current_implementation_id found for app",
-      { configType: "current_implementation_id" },
-    );
-  }
-
-  // Step 1: POST to /actions/v1/runs to start execution
-  const runRequestData: {
-    selected_api: string;
-    action_id?: string;
-    action_key: string;
-    action_type: string;
-    inputs: Record<string, unknown>;
-    authentication_id?: number | null;
-  } = {
-    selected_api: selectedApi,
-    action_id: actionId,
-    action_key: actionKey,
-    action_type: actionType,
-    inputs: executionOptions.inputs || {},
-  };
-
-  // Only include authentication_id if it's provided
-  if (authenticationId !== null && authenticationId !== undefined) {
-    runRequestData.authentication_id = authenticationId;
-  }
-
-  const runRequest = {
-    data: runRequestData,
-  };
-
-  const runData = await api.post<{ data: { id: string } }>(
-    "/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: unknown) => (result as { data: unknown }).data,
-  });
-}
-
-export const runActionPlugin: Plugin<
-  GetSdkType<GetActionPluginProvides & GetAppPluginProvides>, // requires getAction and getApp in SDK
-  {
-    api: ApiClient;
-    getVersionedImplementationId: GetVersionedImplementationId;
-  }, // requires api in context
-  RunActionPluginProvides
-> = ({ sdk, context }) => {
-  const runAction = createPaginatedFunction(async function runActionPage(
-    options: RunActionOptions & { cursor?: string } & { pageSize: number },
-  ): Promise<RunActionPage> {
-    const { api } = context;
-    const {
-      appKey,
-      actionKey,
-      actionType,
-      authenticationId,
-      inputs = {},
-    } = options;
-
-    // Validate that the action exists using the getAction plugin
-    const actionData = await sdk.getAction({
-      appKey: appKey,
-      actionKey: actionKey,
-      actionType: actionType,
-    });
-
-    // Validate action type matches
-    if (actionData.data.action_type !== actionType) {
-      throw new ZapierValidationError(
-        `Action type mismatch: expected ${actionType}, got ${actionData.data.action_type}`,
-      );
-    }
-
-    const actionId = actionData.data.id;
-
-    // Execute the action using the Actions API (supports all action types)
-    const result = await executeAction({
-      api,
-      context,
-      appKey,
-      // Some actions require the action ID to run them, but technically the ID is not guaranteed to be available when
-      // we retrieve actions (probably legacy reasons), so we just pass along all the things!
-      actionId,
-      actionKey,
-      actionType,
-      executionOptions: { inputs },
-      authenticationId,
-      options,
-    });
-
-    // Check for errors in the result and throw if present
-    if (result.errors && result.errors.length > 0) {
-      const errorMessage = result.errors
-        .map(
-          (error: { detail?: string; title?: string }) =>
-            error.detail || error.title || "Unknown error",
-        )
-        .join("; ");
-
-      throw new ZapierActionError(`Action execution failed: ${errorMessage}`, {
-        appKey,
-        actionKey,
-      });
-    }
-
-    // Return the results array wrapped in data with empty nextCursor (no pagination for action execution)
-    return {
-      data: result.results || [],
-      nextCursor: undefined, // No pagination implemented yet
-    };
-  }, RunActionSchema);
-
-  return {
-    runAction,
-    context: {
-      meta: {
-        runAction: {
-          categories: ["action"],
-          type: "list",
-          itemType: "ActionResult",
-          inputSchema: RunActionSchema,
-          outputSchema: ActionResultItemSchema,
-          resolvers: {
-            appKey: appKeyResolver,
-            actionType: actionTypeResolver,
-            actionKey: actionKeyResolver,
-            authenticationId: authenticationIdResolver,
-            inputs: inputsResolver,
-          },
-        },
-      },
-    },
-  };
-};

package/src/plugins/runAction/schemas.ts

@@ -1,60 +0,0 @@
-import { z } from "zod";
-import {
-  AppKeyPropertySchema,
-  ActionTypePropertySchema,
-  ActionKeyPropertySchema,
-  AuthenticationIdPropertySchema,
-  InputsPropertySchema,
-} from "../../types/properties";
-import type { PaginatedSdkFunction } from "../../types/functions";
-import type {
-  ZapierActionError,
-  ZapierValidationError,
-  ZapierConfigurationError,
-  ZapierUnknownError,
-} from "../../types/errors";
-
-// Pure Zod schema - no resolver metadata!
-export const RunActionSchema = z
-  .object({
-    appKey: AppKeyPropertySchema,
-    actionType: ActionTypePropertySchema,
-    actionKey: ActionKeyPropertySchema,
-    authenticationId: AuthenticationIdPropertySchema.nullable().optional(),
-    inputs: InputsPropertySchema.optional().describe(
-      "Input parameters for the action",
-    ),
-    pageSize: z
-      .number()
-      .min(1)
-      .optional()
-      .describe("Number of results per page"),
-    maxItems: z
-      .number()
-      .min(1)
-      .optional()
-      .describe("Maximum total items to return across all pages"),
-    cursor: z.string().optional().describe("Cursor to start from"),
-  })
-  .describe("Execute an action with the given inputs");
-
-// Type inferred from schema
-export type RunActionOptions = z.infer<typeof RunActionSchema>;
-
-// Page result structure (for consistency with other paginated functions)
-export interface RunActionPage {
-  data: unknown[];
-  nextCursor?: string;
-}
-
-// Error union for this function
-export type RunActionError =
-  | ZapierActionError
-  | ZapierValidationError
-  | ZapierConfigurationError
-  | ZapierUnknownError;
-
-// SDK function interface - ready to be mixed into main SDK interface
-export interface RunActionSdkFunction {
-  runAction: PaginatedSdkFunction<RunActionOptions, unknown>;
-}

package/src/resolvers/actionKey.ts

@@ -1,37 +0,0 @@
-import type { DynamicResolver } from "../utils/schema-utils";
-import type { ActionTypeProperty } from "../types/properties";
-
-interface ActionItem {
-  key: string;
-  title?: string;
-  name?: string;
-  description?: string;
-  action_type: string;
-}
-
-export const actionKeyResolver: DynamicResolver<
-  ActionItem,
-  { appKey: string; actionType: ActionTypeProperty }
-> = {
-  type: "dynamic",
-  depends: ["appKey", "actionType"] as const,
-  fetch: async (sdk, resolvedParams) => {
-    const actionsResponse = await sdk.listActions({
-      appKey: resolvedParams.appKey,
-    });
-    return actionsResponse.data.filter(
-      (action: ActionItem) => action.action_type === resolvedParams.actionType,
-    );
-  },
-  prompt: (actions) => ({
-    type: "list",
-    name: "actionKey",
-    message: "Select action:",
-    choices: actions.map((action) => ({
-      name: `${action.title || action.name || action.key} - ${
-        action.description || "No description"
-      }`,
-      value: action.key,
-    })),
-  }),
-};