@zapier/zapier-sdk 0.4.1 → 0.5.0

package/src/plugins/getProfile/schemas.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { withOutputSchema } from "../../utils/schema-utils";
+import { UserProfileItemSchema } from "../../schemas/UserProfile";
+import type { FunctionOptions } from "../../types/functions";
+import type { UserProfileItem } from "../../types/domain";
+import { ZapierApiError, ZapierValidationError } from "../../types/errors";
+
+// Union of all possible errors for getProfile
+export type GetProfileError = ZapierApiError | ZapierValidationError;
+
+// Pure Zod schema - no resolver metadata!
+export const GetProfileSchema = withOutputSchema(
+  z.object({}).optional().describe("Get current user's profile information"),
+  UserProfileItemSchema,
+);
+
+// Type inferred from schema + function config
+export type GetProfileOptions = z.infer<typeof GetProfileSchema> &
+  FunctionOptions;
+
+// SDK function interface - ready to be mixed into main SDK interface
+export interface GetProfileSdkFunction {
+  getProfile: (
+    options?: GetProfileOptions,
+  ) => Promise<{ data: UserProfileItem }>;
+}

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

@@ -0,0 +1,582 @@
+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 { App } from "../../api/types";
+import { GetAppSchema } from "../getApp/schemas";
+
+const mockAppResponse = {
+  data: {
+    slug: "slack",
+    name: "Slack",
+    current_implementation_id: "SlackCLIAPI@1.20.0",
+    key: "slack",
+    title: "Slack",
+    hex_color: "#4A154B",
+  } as Partial<App> as App & { key: string; title: string; hex_color: string },
+};
+
+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 mockGetApp: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockApiClient = {
+      get: vi.fn().mockResolvedValue(mockImplementationsResponse),
+    } as Partial<ApiClient> as ApiClient;
+
+    mockGetApp = vi.fn().mockResolvedValue(mockAppResponse);
+  });
+
+  function createTestSdk() {
+    // Create a proper plugin chain with context dependencies
+    const mockGetAppPlugin = () => ({
+      getApp: mockGetApp,
+      context: {
+        meta: {
+          getApp: {
+            inputSchema: GetAppSchema,
+          },
+        },
+      },
+    });
+
+    // Build SDK with proper plugin composition, providing API in initial context
+    return createSdk({}, { api: mockApiClient, meta: {} })
+      .addPlugin(mockGetAppPlugin)
+      .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) => 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) => action.action_type === "write"),
+      ).toBe(true);
+      expect(result.data.map((action) => 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(mockGetApp).toHaveBeenCalledWith({
+        appKey: "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", // Extracted from current_implementation_id
+          }),
+        }),
+      );
+    });
+  });
+
+  describe("error handling", () => {
+    it("should throw ZapierConfigurationError when app has no current_implementation_id", async () => {
+      mockGetApp.mockResolvedValue({
+        data: {
+          ...mockAppResponse.data,
+          current_implementation_id: undefined, // Missing implementation ID
+        },
+      });
+
+      const sdk = createTestSdk();
+      await expect(sdk.listActions({ appKey: "slack" })).rejects.toThrow(
+        ZapierConfigurationError,
+      );
+    });
+
+    it("should throw ZapierConfigurationError when current_implementation_id is empty", async () => {
+      mockGetApp.mockResolvedValue({
+        data: {
+          ...mockAppResponse.data,
+          current_implementation_id: "", // Empty implementation ID
+        },
+      });
+
+      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 getApp errors", async () => {
+      mockGetApp.mockRejectedValue(new Error("App not found"));
+
+      const sdk = createTestSdk();
+      await expect(sdk.listActions({ appKey: "nonexistent" })).rejects.toThrow(
+        "App not found",
+      );
+    });
+  });
+
+  describe("implementation ID extraction", () => {
+    it("should extract implementation name from versioned ID", async () => {
+      mockGetApp.mockResolvedValue({
+        data: {
+          ...mockAppResponse.data,
+          current_implementation_id: "CustomAPIName@2.5.0",
+        },
+      });
+
+      const sdk = createTestSdk();
+      await sdk.listActions({ appKey: "slack" });
+
+      expect(mockApiClient.get).toHaveBeenCalledWith(
+        "/api/v4/implementations/",
+        expect.objectContaining({
+          searchParams: expect.objectContaining({
+            selected_apis: "CustomAPIName", // Extracted name without version
+          }),
+        }),
+      );
+    });
+
+    it("should handle implementation ID without version", async () => {
+      mockGetApp.mockResolvedValue({
+        data: {
+          ...mockAppResponse.data,
+          current_implementation_id: "PlainAPIName",
+        },
+      });
+
+      const sdk = createTestSdk();
+      await sdk.listActions({ appKey: "slack" });
+
+      expect(mockApiClient.get).toHaveBeenCalledWith(
+        "/api/v4/implementations/",
+        expect.objectContaining({
+          searchParams: expect.objectContaining({
+            selected_apis: "PlainAPIName", // Used as-is
+          }),
+        }),
+      );
+    });
+  });
+
+  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();
+    });
+  });
+});