@zapier/zapier-sdk 0.13.6 → 0.13.8

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

@@ -1,526 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import {
-  ZapierValidationError,
-  ZapierAuthenticationError,
-  ZapierConfigurationError,
-} from "../../types/errors";
-import { listActionsPlugin } from "./index";
-import { createSdk } from "../../sdk";
-import type { ApiClient } from "../../api";
-import type { ListActionsOptions } from "./schemas";
-
-import { listAppsPlugin } from "../listApps";
-
-const mockImplementationsResponse = {
-  results: [
-    {
-      slug: "slack",
-      selected_api: "slack",
-      actions: [
-        {
-          key: "user_by_email",
-          name: "Search User by Email",
-          description: "Find a user by email address",
-          type_of: "search",
-          type: "search",
-        },
-        {
-          key: "send_message",
-          name: "Send Message",
-          description: "Send a message to a channel",
-          type_of: "write",
-          type: "write",
-        },
-        {
-          key: "create_channel",
-          name: "Create Channel",
-          description: "Create a new channel",
-          type_of: "write",
-          type: "write",
-        },
-      ],
-    },
-  ],
-  meta: {
-    next_cursor: null,
-  },
-};
-
-const mockEmptyImplementationsResponse = {
-  results: [],
-  meta: {
-    next_cursor: null,
-  },
-};
-
-describe("listActions plugin", () => {
-  let mockApiClient: ApiClient;
-  let mockGetVersionedImplementationId: any;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockApiClient = {
-      get: vi.fn().mockResolvedValue(mockImplementationsResponse),
-    } as Partial<ApiClient> as ApiClient;
-
-    mockGetVersionedImplementationId = vi
-      .fn()
-      .mockResolvedValue("SlackCLIAPI@1.21.1");
-  });
-
-  const mockResolveAppKeys = vi.fn().mockResolvedValue([]);
-
-  function createTestSdk() {
-    // Create a proper plugin chain with context dependencies
-
-    // Build SDK with proper plugin composition, providing API in initial context
-    return createSdk()
-      .addPlugin(() => ({
-        context: {
-          api: mockApiClient,
-        },
-      }))
-      .addPlugin(() => ({
-        context: {
-          manifest: null,
-          getVersionedImplementationId: mockGetVersionedImplementationId,
-          resolveAppKeys: mockResolveAppKeys,
-          updateManifestEntry: vi
-            .fn()
-            .mockResolvedValue(["test-key", {}, { apps: {} }]),
-        },
-      }))
-      .addPlugin(listAppsPlugin)
-      .addPlugin(listActionsPlugin);
-  }
-
-  describe("schema validation", () => {
-    it("should pass validation with valid appKey", async () => {
-      const sdk = createTestSdk();
-      const result = await sdk.listActions({ appKey: "slack" });
-      expect(result.data).toHaveLength(3);
-    });
-
-    it("should throw validation error for missing appKey", () => {
-      const sdk = createTestSdk();
-      expect(() => {
-        sdk.listActions(
-          {} as Partial<ListActionsOptions> as ListActionsOptions,
-        );
-      }).toThrow(ZapierValidationError);
-    });
-
-    it("should throw validation error for invalid appKey type", () => {
-      const sdk = createTestSdk();
-      expect(() => {
-        sdk.listActions({
-          appKey: 123 as any,
-        });
-      }).toThrow(ZapierValidationError);
-    });
-
-    it("should throw validation error for empty appKey", () => {
-      const sdk = createTestSdk();
-      expect(() => {
-        sdk.listActions({ appKey: "" });
-      }).toThrow(ZapierValidationError);
-    });
-
-    it("should throw validation error for invalid pageSize", () => {
-      const sdk = createTestSdk();
-      expect(() => {
-        sdk.listActions({ appKey: "slack", pageSize: 0 });
-      }).toThrow(ZapierValidationError);
-
-      expect(() => {
-        sdk.listActions({ appKey: "slack", pageSize: -5 });
-      }).toThrow(ZapierValidationError);
-    });
-
-    it("should throw validation error for invalid maxItems", () => {
-      const sdk = createTestSdk();
-      expect(() => {
-        sdk.listActions({ appKey: "slack", maxItems: 0 as any });
-      }).toThrow(ZapierValidationError);
-
-      expect(() => {
-        sdk.listActions({ appKey: "slack", maxItems: -10 as any });
-      }).toThrow(ZapierValidationError);
-    });
-
-    it("should throw validation error for invalid actionType", () => {
-      const sdk = createTestSdk();
-      expect(() => {
-        sdk.listActions({
-          appKey: "slack",
-          actionType: "invalid-type" as any,
-        });
-      }).toThrow(ZapierValidationError);
-    });
-
-    it("should pass validation with all valid fields", async () => {
-      const sdk = createTestSdk();
-      const result = await sdk.listActions({
-        appKey: "slack",
-        actionType: "write",
-        pageSize: 10,
-        maxItems: 50,
-      });
-
-      expect(result.data).toHaveLength(2); // Only write actions
-      expect(
-        result.data.every((action: any) => action.action_type === "write"),
-      ).toBe(true);
-    });
-  });
-
-  describe("actionType enum validation", () => {
-    const validActionTypes = [
-      "read",
-      "read_bulk",
-      "write",
-      "run",
-      "search",
-      "search_or_write",
-      "search_and_write",
-      "filter",
-    ] as const;
-
-    validActionTypes.forEach((actionType) => {
-      it(`should accept valid actionType: ${actionType}`, async () => {
-        const mockResponse = {
-          results: [
-            {
-              slug: "slack",
-              actions: [
-                {
-                  key: "test_action",
-                  name: "Test Action",
-                  description: "Test description",
-                  type_of: actionType,
-                  type: actionType,
-                },
-              ],
-            },
-          ],
-          meta: { next_cursor: null },
-        };
-
-        mockApiClient.get = vi.fn().mockResolvedValue(mockResponse);
-
-        const sdk = createTestSdk();
-        const result = await sdk.listActions({
-          appKey: "slack",
-          actionType: actionType,
-        });
-
-        expect(result.data).toHaveLength(1);
-        expect(result.data[0].action_type).toBe(actionType);
-      });
-    });
-  });
-
-  describe("data transformation", () => {
-    it("should transform implementation actions to ActionItem format", async () => {
-      const sdk = createTestSdk();
-      const result = await sdk.listActions({ appKey: "slack" });
-
-      const firstAction = result.data[0];
-
-      // Check all required ActionItem fields are present
-      expect(firstAction).toHaveProperty("key");
-      expect(firstAction).toHaveProperty("type", "action");
-      expect(firstAction).toHaveProperty("action_type");
-      expect(firstAction).toHaveProperty("title");
-      expect(firstAction).toHaveProperty("app_key", "slack");
-      expect(firstAction).toHaveProperty("description");
-
-      // Check that title is mapped from API name field
-      expect(firstAction.title).toBe("Search User by Email");
-      expect(firstAction.app_key).toBe("slack");
-      expect(firstAction.type).toBe("action");
-    });
-
-    it("should map type_of to action_type", async () => {
-      const sdk = createTestSdk();
-      const result = await sdk.listActions({ appKey: "slack" });
-
-      expect(result.data[0].action_type).toBe("search"); // From type_of field
-      expect(result.data[1].action_type).toBe("write"); // From type_of field
-    });
-
-    it("should fall back to type field if type_of is missing", async () => {
-      const mockResponseWithoutTypeOf = {
-        results: [
-          {
-            slug: "slack",
-            actions: [
-              {
-                key: "test_action",
-                name: "Test Action",
-                description: "Test description",
-                type: "read", // Only type field, no type_of
-              },
-            ],
-          },
-        ],
-        meta: { next_cursor: null },
-      };
-
-      mockApiClient.get = vi.fn().mockResolvedValue(mockResponseWithoutTypeOf);
-
-      const sdk = createTestSdk();
-      const result = await sdk.listActions({ appKey: "slack" });
-
-      expect(result.data[0].action_type).toBe("read"); // Falls back to type field
-    });
-
-    it("should handle actions with read type", async () => {
-      const mockResponseWithoutType = {
-        results: [
-          {
-            slug: "slack",
-            actions: [
-              {
-                key: "test_action",
-                name: "Test Action",
-                description: "Test description",
-                type: "read", // Provide the required type field
-              },
-            ],
-          },
-        ],
-        meta: { next_cursor: null },
-      };
-
-      mockApiClient.get = vi.fn().mockResolvedValue(mockResponseWithoutType);
-
-      const sdk = createTestSdk();
-      const result = await sdk.listActions({ appKey: "slack" });
-
-      expect(result.data[0].action_type).toBe("read"); // Should match provided type
-    });
-  });
-
-  describe("filtering", () => {
-    it("should filter actions by actionType", async () => {
-      const sdk = createTestSdk();
-      const result = await sdk.listActions({
-        appKey: "slack",
-        actionType: "write",
-      });
-
-      expect(result.data).toHaveLength(2);
-      expect(
-        result.data.every((action: any) => action.action_type === "write"),
-      ).toBe(true);
-      expect(result.data.map((action: any) => action.key)).toEqual([
-        "send_message",
-        "create_channel",
-      ]);
-    });
-
-    it("should return empty array when no actions match filter", async () => {
-      const sdk = createTestSdk();
-      const result = await sdk.listActions({
-        appKey: "slack",
-        actionType: "filter", // No actions of this type in mock data
-      });
-
-      expect(result.data).toHaveLength(0);
-    });
-
-    it("should return all actions when no actionType filter provided", async () => {
-      const sdk = createTestSdk();
-      const result = await sdk.listActions({ appKey: "slack" });
-
-      expect(result.data).toHaveLength(3); // All actions
-    });
-  });
-
-  describe("pagination", () => {
-    it("should handle maxItems limit", async () => {
-      const sdk = createTestSdk();
-      const result = await sdk.listActions({
-        appKey: "slack",
-        maxItems: 2,
-      });
-
-      expect(result.data).toHaveLength(2); // Limited to maxItems
-    });
-
-    it("should support async iteration over pages", async () => {
-      const sdk = createTestSdk();
-      const listActions = sdk.listActions({ appKey: "slack" });
-
-      const pages = [];
-      for await (const page of listActions) {
-        pages.push(page);
-        break; // Just get first page for testing
-      }
-
-      expect(pages).toHaveLength(1);
-      expect(pages[0].data).toHaveLength(3);
-      expect(pages[0].data[0].key).toBe("user_by_email");
-    });
-
-    it("should support async iteration over individual items", async () => {
-      const sdk = createTestSdk();
-      const listActions = sdk.listActions({
-        appKey: "slack",
-        maxItems: 2,
-      });
-
-      const items = [];
-      for await (const item of listActions.items()) {
-        items.push(item);
-      }
-
-      expect(items).toHaveLength(2);
-      expect(items[0].key).toBe("user_by_email");
-      expect(items[1].key).toBe("send_message");
-    });
-
-    it("should respect pageSize parameter", async () => {
-      const sdk = createTestSdk();
-      await sdk.listActions({
-        appKey: "slack",
-        pageSize: 10,
-      });
-
-      // Note: Since listActions doesn't actually use pagination internally,
-      // we just verify it accepts the parameter without error
-      expect(mockApiClient.get).toHaveBeenCalled();
-    });
-  });
-
-  describe("API integration", () => {
-    it("should call getApp to get implementation ID", async () => {
-      const sdk = createTestSdk();
-      await sdk.listActions({ appKey: "slack" });
-
-      expect(mockGetVersionedImplementationId).toHaveBeenCalledWith("slack");
-    });
-
-    it("should pass correct search parameters to implementations API", async () => {
-      const sdk = createTestSdk();
-      await sdk.listActions({ appKey: "slack" });
-
-      expect(mockApiClient.get).toHaveBeenCalledWith(
-        "/api/v4/implementations/",
-        expect.objectContaining({
-          searchParams: expect.objectContaining({
-            global: "true",
-            public_only: "true",
-            selected_apis: "SlackCLIAPI@1.21.1",
-          }),
-        }),
-      );
-    });
-  });
-
-  describe("error handling", () => {
-    it("should throw ZapierConfigurationError when app has no current_implementation_id", async () => {
-      mockGetVersionedImplementationId.mockResolvedValue(null);
-
-      const sdk = createTestSdk();
-      await expect(sdk.listActions({ appKey: "slack" })).rejects.toThrow(
-        ZapierConfigurationError,
-      );
-    });
-
-    it("should throw ZapierConfigurationError when current_implementation_id is empty", async () => {
-      mockGetVersionedImplementationId.mockResolvedValue("");
-
-      const sdk = createTestSdk();
-      await expect(sdk.listActions({ appKey: "slack" })).rejects.toThrow(
-        ZapierConfigurationError,
-      );
-    });
-
-    it("should handle authentication error (401)", async () => {
-      mockApiClient.get = vi.fn().mockImplementation((_url, options) => {
-        if (options.customErrorHandler) {
-          const error = options.customErrorHandler({ status: 401 });
-          if (error) {
-            throw error;
-          }
-        }
-        throw new Error("Unauthorized");
-      });
-
-      const sdk = createTestSdk();
-      await expect(sdk.listActions({ appKey: "slack" })).rejects.toThrow(
-        ZapierAuthenticationError,
-      );
-    });
-
-    it("should handle forbidden error (403)", async () => {
-      mockApiClient.get = vi.fn().mockImplementation((_url, options) => {
-        if (options.customErrorHandler) {
-          const error = options.customErrorHandler({ status: 403 });
-          if (error) {
-            throw error;
-          }
-        }
-        throw new Error("Forbidden");
-      });
-
-      const sdk = createTestSdk();
-      await expect(sdk.listActions({ appKey: "slack" })).rejects.toThrow(
-        ZapierAuthenticationError,
-      );
-    });
-
-    it("should return empty array when implementations API returns no results", async () => {
-      mockApiClient.get = vi
-        .fn()
-        .mockResolvedValue(mockEmptyImplementationsResponse);
-
-      const sdk = createTestSdk();
-      const result = await sdk.listActions({ appKey: "slack" });
-
-      expect(result.data).toHaveLength(0);
-    });
-
-    it("should handle implementation without actions", async () => {
-      const mockResponseWithoutActions = {
-        results: [
-          {
-            slug: "slack",
-            // No actions property
-          },
-        ],
-        meta: { next_cursor: null },
-      };
-
-      mockApiClient.get = vi.fn().mockResolvedValue(mockResponseWithoutActions);
-
-      const sdk = createTestSdk();
-      const result = await sdk.listActions({ appKey: "slack" });
-
-      expect(result.data).toHaveLength(0);
-    });
-
-    it("should propagate getVersionedImplementationId errors", async () => {
-      mockGetVersionedImplementationId.mockRejectedValue(
-        new Error("App not found"),
-      );
-
-      const sdk = createTestSdk();
-      await expect(sdk.listActions({ appKey: "nonexistent" })).rejects.toThrow(
-        "App not found",
-      );
-    });
-  });
-
-  describe("context and metadata", () => {
-    it("should provide context with meta information", () => {
-      const sdk = createTestSdk();
-      const context = sdk.getContext();
-
-      expect(context.meta.listActions).toBeDefined();
-      expect(context.meta.listActions.inputSchema).toBeDefined();
-    });
-  });
-});

package/src/plugins/listActions/index.ts

@@ -1,132 +0,0 @@
-import type { Plugin, GetSdkType } from "../../types/plugin";
-import type { ApiClient, Implementation } from "../../api";
-import type { ActionItem } from "../../types/domain";
-import { normalizeActionItem } from "../../utils/domain-utils";
-import {
-  ListActionsSchema,
-  type ListActionsOptions,
-  type ListActionsPage,
-} from "./schemas";
-import { ActionItemSchema } from "../../schemas/Action";
-import {
-  ZapierConfigurationError,
-  ZapierAuthenticationError,
-} from "../../types/errors";
-import { createPaginatedFunction } from "../../utils/function-utils";
-import type { ManifestPluginProvides } from "../manifest";
-import type { GetVersionedImplementationId } from "../manifest/schemas";
-import { appKeyResolver, actionTypeResolver } from "../../resolvers";
-
-export interface ListActionsPluginProvides {
-  listActions: (options?: ListActionsOptions) => Promise<{
-    data: ActionItem[];
-    nextCursor?: string;
-  }> &
-    AsyncIterable<{ data: ActionItem[]; nextCursor?: string }> & {
-      items(): AsyncIterable<ActionItem>;
-    };
-  context: {
-    meta: {
-      listActions: {
-        inputSchema: typeof ListActionsSchema;
-      };
-    };
-  };
-}
-
-export const listActionsPlugin: Plugin<
-  GetSdkType<ManifestPluginProvides>,
-  {
-    api: ApiClient;
-    getVersionedImplementationId: GetVersionedImplementationId;
-  },
-  ListActionsPluginProvides
-> = ({ context }) => {
-  const listActions = createPaginatedFunction(async function listActionsPage(
-    options: ListActionsOptions & { cursor?: string } & { pageSize: number },
-  ): Promise<ListActionsPage> {
-    const { api, getVersionedImplementationId } = context;
-
-    // Use getVersionedImplementationId (optimized to check manifest first)
-    const selectedApi = await getVersionedImplementationId(options.appKey);
-
-    if (!selectedApi) {
-      throw new ZapierConfigurationError(
-        "No current_implementation_id found for app",
-        { configType: "current_implementation_id" },
-      );
-    }
-
-    const searchParams: Record<string, string> = {
-      global: "true",
-      public_only: "true",
-      selected_apis: selectedApi,
-    };
-
-    const data = await api.get<{ results: Implementation[] }>(
-      "/api/v4/implementations/",
-      {
-        searchParams,
-        customErrorHandler: ({ status }) => {
-          if (status === 401) {
-            return new ZapierAuthenticationError(
-              `Authentication failed. Your token may not have permission to access implementations or may be expired. (HTTP ${status})`,
-              { statusCode: status },
-            );
-          }
-          if (status === 403) {
-            return new ZapierAuthenticationError(
-              `Access forbidden. Your token may not have the required scopes to list implementations. (HTTP ${status})`,
-              { statusCode: status },
-            );
-          }
-          return undefined;
-        },
-      },
-    );
-
-    let allActions: ActionItem[] = [];
-
-    for (const implementation of data.results || []) {
-      if (implementation.actions) {
-        for (const action of implementation.actions) {
-          const actionWithContext = {
-            ...action,
-            selected_api: action.selected_api || implementation.selected_api,
-          };
-          allActions.push(normalizeActionItem(actionWithContext));
-        }
-      }
-    }
-
-    if (options.actionType) {
-      allActions = allActions.filter(
-        (action) => action.action_type === options.actionType,
-      );
-    }
-
-    return {
-      data: allActions,
-      nextCursor: undefined,
-    };
-  }, ListActionsSchema);
-
-  return {
-    listActions,
-    context: {
-      meta: {
-        listActions: {
-          categories: ["action"],
-          type: "list",
-          itemType: "Action",
-          inputSchema: ListActionsSchema,
-          outputSchema: ActionItemSchema,
-          resolvers: {
-            appKey: appKeyResolver,
-            actionType: actionTypeResolver,
-          },
-        },
-      },
-    },
-  };
-};

package/src/plugins/listActions/schemas.ts

@@ -1,55 +0,0 @@
-import { z } from "zod";
-import {
-  AppKeyPropertySchema,
-  ActionTypePropertySchema,
-} from "../../types/properties";
-import type { ActionItem } from "../../types/domain";
-import type { PaginatedSdkFunction } from "../../types/functions";
-import type {
-  ZapierAuthenticationError,
-  ZapierValidationError,
-  ZapierUnknownError,
-} from "../../types/errors";
-
-// Pure Zod schema - no resolver metadata!
-export const ListActionsSchema = z
-  .object({
-    appKey: AppKeyPropertySchema.describe(
-      "App key of actions to list (e.g., 'SlackCLIAPI' or slug like 'github')",
-    ),
-    actionType: ActionTypePropertySchema.optional().describe(
-      "Filter actions by type",
-    ),
-    pageSize: z
-      .number()
-      .min(1)
-      .optional()
-      .describe("Number of actions 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("List all actions for a specific app");
-
-// Type inferred from schema
-export type ListActionsOptions = z.infer<typeof ListActionsSchema>;
-
-// Page result structure
-export interface ListActionsPage {
-  data: ActionItem[];
-  nextCursor?: string;
-}
-
-// Error union for this function
-export type ListActionsError =
-  | ZapierAuthenticationError
-  | ZapierValidationError
-  | ZapierUnknownError;
-
-// SDK function interface
-export interface ListActionsSdkFunction {
-  listActions: PaginatedSdkFunction<ListActionsOptions, ActionItem>;
-}