@zapier/zapier-sdk 0.6.3 → 0.8.0

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

@@ -0,0 +1,653 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ZapierValidationError, ZapierApiError } from "../../types/errors";
+import { listInputFieldChoicesPlugin } from "./index";
+import { createSdk } from "../../sdk";
+import type { ApiClient } from "../../api";
+import type { ListInputFieldChoicesOptions } from "./schemas";
+import type { NeedChoicesResponse, NeedChoices } from "../../api/types";
+import { GetActionSchema } from "../getAction/schemas";
+
+const mockChoices: NeedChoices[] = [
+  {
+    key: "general",
+    label: "General Channel",
+    sample: "#general",
+    value: "general",
+  },
+  {
+    key: "random",
+    label: "Random Channel",
+    sample: "#random",
+    value: "random",
+  },
+  {
+    key: "dev",
+    label: "Development Channel",
+    sample: "#dev",
+    value: "dev",
+  },
+];
+
+const mockChoicesResponse: NeedChoicesResponse = {
+  success: true,
+  choices: mockChoices,
+};
+
+const mockPaginatedChoicesResponse: NeedChoicesResponse = {
+  success: true,
+  choices: mockChoices.slice(0, 2),
+  next_page: 1,
+};
+
+const mockExternalChoicesResponse: NeedChoicesResponse = {
+  success: true,
+  choices: mockChoices,
+  meta: { page: "0" },
+  links: {
+    next: "https://api.zapier.com/api/v4/implementations/choices/?page=1",
+    prev: null,
+  },
+};
+
+describe("listInputFieldChoices plugin", () => {
+  let mockApiClient: ApiClient;
+  let mockGetAction: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockApiClient = {
+      post: vi.fn().mockResolvedValue(mockChoicesResponse),
+    } as Partial<ApiClient> as ApiClient;
+
+    mockGetAction = vi.fn().mockResolvedValue({
+      data: { id: "core:123", key: "send_message", action_type: "read" },
+    });
+  });
+
+  function createTestSdk() {
+    // Create a mock getAction plugin
+    const mockGetActionPlugin = () => ({
+      getAction: mockGetAction,
+      context: {
+        meta: {
+          getAction: {
+            inputSchema: GetActionSchema,
+          },
+        },
+      },
+    });
+
+    // Build SDK with proper plugin composition
+    return createSdk({}, {}, { api: mockApiClient, meta: {} })
+      .addPlugin(mockGetActionPlugin)
+      .addPlugin(listInputFieldChoicesPlugin as any);
+  }
+
+  describe("schema validation", () => {
+    it("should throw validation error for missing inputFieldKey", async () => {
+      const sdk = createTestSdk();
+
+      try {
+        await sdk.listInputFieldChoices({
+          appKey: "slack",
+          actionType: "read",
+          actionKey: "send_message",
+          // Missing inputFieldKey
+        } as ListInputFieldChoicesOptions);
+        expect.fail("Expected ZapierValidationError to be thrown");
+      } catch (error) {
+        expect(error).toBeInstanceOf(ZapierValidationError);
+      }
+    });
+
+    it("should throw validation error for missing actionKey", async () => {
+      const sdk = createTestSdk();
+
+      try {
+        await sdk.listInputFieldChoices({
+          appKey: "slack",
+          actionType: "read",
+          inputFieldKey: "channel",
+          // Missing actionKey
+        } as ListInputFieldChoicesOptions);
+        expect.fail("Expected ZapierValidationError to be thrown");
+      } catch (error) {
+        expect(error).toBeInstanceOf(ZapierValidationError);
+      }
+    });
+
+    it("should pass validation with action method", async () => {
+      const sdk = createTestSdk();
+      const result = await sdk.listInputFieldChoices({
+        appKey: "slack",
+        actionType: "read",
+        actionKey: "send_message",
+        inputFieldKey: "channel",
+      });
+
+      expect(result.data).toBeDefined();
+    });
+
+    it("should pass validation with optional fields", async () => {
+      const sdk = createTestSdk();
+      const result = await sdk.listInputFieldChoices({
+        appKey: "slack",
+        actionType: "read",
+        actionKey: "send_message",
+        inputFieldKey: "channel",
+        authenticationId: 456,
+        inputs: { workspace: "my-team" },
+        page: 0,
+      });
+
+      expect(result.data).toBeDefined();
+    });
+
+    it("should throw validation error for empty string actionKey", async () => {
+      const sdk = createTestSdk();
+
+      try {
+        await sdk.listInputFieldChoices({
+          appKey: "slack",
+          actionType: "read",
+          actionKey: "", // Empty string
+          inputFieldKey: "channel",
+        } as ListInputFieldChoicesOptions);
+        expect.fail("Expected ZapierValidationError to be thrown");
+      } catch (error) {
+        expect(error).toBeInstanceOf(ZapierValidationError);
+      }
+    });
+
+    it("should throw validation error for empty string inputFieldKey", async () => {
+      const sdk = createTestSdk();
+
+      try {
+        await sdk.listInputFieldChoices({
+          appKey: "slack",
+          actionType: "read",
+          actionKey: "send_message",
+          inputFieldKey: "", // Empty string
+        } as ListInputFieldChoicesOptions);
+        expect.fail("Expected ZapierValidationError to be thrown");
+      } catch (error) {
+        expect(error).toBeInstanceOf(ZapierValidationError);
+      }
+    });
+  });
+
+  describe("API integration - action method", () => {
+    it("should call the correct API endpoint with action method", async () => {
+      const sdk = createTestSdk();
+      await sdk.listInputFieldChoices({
+        appKey: "slack",
+        actionType: "read",
+        actionKey: "send_message",
+        inputFieldKey: "channel",
+      });
+
+      expect(mockGetAction).toHaveBeenCalledWith({
+        appKey: "slack",
+        actionType: "read",
+        actionKey: "send_message",
+      });
+      expect(mockApiClient.post).toHaveBeenCalledWith(
+        "/api/v4/implementations/choices/",
+        {
+          action_id: "core:123",
+          input_field_id: "channel",
+          page: 0,
+          params: {},
+        },
+      );
+    });
+
+    it("should include authentication_id when provided", async () => {
+      const sdk = createTestSdk();
+      await sdk.listInputFieldChoices({
+        appKey: "slack",
+        actionType: "read",
+        actionKey: "send_message",
+        inputFieldKey: "channel",
+        authenticationId: 456,
+      });
+
+      expect(mockApiClient.post).toHaveBeenCalledWith(
+        "/api/v4/implementations/choices/",
+        {
+          action_id: "core:123",
+          input_field_id: "channel",
+          authentication_id: 456,
+          page: 0,
+          params: {},
+        },
+      );
+    });
+
+    it("should exclude authentication_id when null", async () => {
+      const sdk = createTestSdk();
+      await sdk.listInputFieldChoices({
+        appKey: "slack",
+        actionType: "read",
+        actionKey: "send_message",
+        inputFieldKey: "channel",
+        authenticationId: null,
+      });
+
+      expect(mockApiClient.post).toHaveBeenCalledWith(
+        "/api/v4/implementations/choices/",
+        {
+          action_id: "core:123",
+          input_field_id: "channel",
+          page: 0,
+          params: {},
+          // No authentication_id
+        },
+      );
+    });
+
+    it("should include inputs when provided", async () => {
+      const sdk = createTestSdk();
+      const inputs = { workspace: "my-team", board: "project" };
+
+      await sdk.listInputFieldChoices({
+        appKey: "slack",
+        actionType: "read",
+        actionKey: "send_message",
+        inputFieldKey: "channel",
+        inputs,
+      });
+
+      expect(mockApiClient.post).toHaveBeenCalledWith(
+        "/api/v4/implementations/choices/",
+        {
+          action_id: "core:123",
+          input_field_id: "channel",
+          page: 0,
+          params: inputs,
+        },
+      );
+    });
+
+    it("should include page when provided", async () => {
+      const sdk = createTestSdk();
+
+      await sdk.listInputFieldChoices({
+        appKey: "slack",
+        actionType: "read",
+        actionKey: "send_message",
+        inputFieldKey: "channel",
+        page: 2,
+      });
+
+      expect(mockApiClient.post).toHaveBeenCalledWith(
+        "/api/v4/implementations/choices/",
+        {
+          action_id: "core:123",
+          input_field_id: "channel",
+          page: 2,
+          params: {},
+        },
+      );
+    });
+  });
+
+  describe("data transformation", () => {
+    it("should transform choices to input field choice items correctly", async () => {
+      const sdk = createTestSdk();
+      const result = await sdk.listInputFieldChoices({
+        appKey: "slack",
+        actionType: "read",
+        actionKey: "send_message",
+        inputFieldKey: "channel",
+      });
+
+      expect(result.data).toHaveLength(3);
+
+      // Check first choice transformation
+      expect(result.data[0]).toEqual({
+        key: "general",
+        label: "General Channel",
+        sample: "#general",
+        value: "general",
+      });
+
+      // Check second choice transformation
+      expect(result.data[1]).toEqual({
+        key: "random",
+        label: "Random Channel",
+        sample: "#random",
+        value: "random",
+      });
+    });
+
+    it("should handle choices with missing fields gracefully", async () => {
+      const sparseChoices: NeedChoices[] = [
+        { key: "item1", label: "Item 1" },
+        { value: "item2", sample: "item2" },
+        { label: "Item 3" },
+      ];
+
+      mockApiClient.post = vi.fn().mockResolvedValue({
+        success: true,
+        choices: sparseChoices,
+      });
+
+      const sdk = createTestSdk();
+      const result = await sdk.listInputFieldChoices({
+        appKey: "slack",
+        actionType: "read",
+        actionKey: "send_message",
+        inputFieldKey: "item",
+      });
+
+      expect(result.data).toHaveLength(3);
+      expect(result.data[0]).toEqual({
+        key: "item1",
+        label: "Item 1",
+        sample: undefined,
+        value: undefined,
+      });
+      expect(result.data[1]).toEqual({
+        key: undefined,
+        label: undefined,
+        sample: "item2",
+        value: "item2",
+      });
+    });
+  });
+
+  describe("pagination handling", () => {
+    it("should handle next_page pagination correctly in the plugin", async () => {
+      mockApiClient.post = vi
+        .fn()
+        .mockResolvedValue(mockPaginatedChoicesResponse);
+
+      const sdk = createTestSdk();
+
+      // Test that the plugin correctly sets nextCursor when next_page is present
+      const listChoicesResult = sdk.listInputFieldChoices({
+        appKey: "slack",
+        actionType: "read",
+        actionKey: "send_message",
+        inputFieldKey: "channel",
+        pageSize: 2, // Set a small page size to test pagination behavior
+      });
+
+      const pages = [];
+      for await (const page of listChoicesResult) {
+        pages.push(page);
+        break; // Just get first page for testing
+      }
+
+      expect(pages).toHaveLength(1);
+      expect(pages[0].nextCursor).toBe("1");
+    });
+
+    it("should handle external action link-based pagination correctly in the plugin", async () => {
+      mockApiClient.post = vi
+        .fn()
+        .mockResolvedValue(mockExternalChoicesResponse);
+
+      const sdk = createTestSdk();
+
+      // Test that the plugin correctly extracts cursor from links.next
+      const listChoicesResult = sdk.listInputFieldChoices({
+        appKey: "slack",
+        actionType: "read",
+        actionKey: "send_message",
+        inputFieldKey: "option",
+        pageSize: 3, // Set a small page size to test pagination behavior
+      });
+
+      const pages = [];
+      for await (const page of listChoicesResult) {
+        pages.push(page);
+        break; // Just get first page for testing
+      }
+
+      expect(pages).toHaveLength(1);
+      expect(pages[0].nextCursor).toBe("1"); // Extracted from links.next URL
+    });
+
+    it("should handle no pagination", async () => {
+      const sdk = createTestSdk();
+      const listChoicesResult = sdk.listInputFieldChoices({
+        appKey: "slack",
+        actionType: "read",
+        actionKey: "send_message",
+        inputFieldKey: "channel",
+      });
+
+      const pages = [];
+      for await (const page of listChoicesResult) {
+        pages.push(page);
+        break; // Just get first page for testing
+      }
+
+      expect(pages).toHaveLength(1);
+      expect(pages[0].nextCursor).toBeUndefined();
+    });
+
+    it("should support async iteration over individual items", async () => {
+      const sdk = createTestSdk();
+      const listChoicesResult = sdk.listInputFieldChoices({
+        appKey: "slack",
+        actionType: "read",
+        actionKey: "send_message",
+        inputFieldKey: "channel",
+      });
+
+      const items = [];
+      for await (const item of listChoicesResult.items()) {
+        items.push(item);
+      }
+
+      expect(items).toHaveLength(3);
+      expect(items[0].key).toBe("general");
+    });
+
+    it("should handle malformed links.next URL gracefully", async () => {
+      const malformedExternalResponse: NeedChoicesResponse = {
+        success: true,
+        choices: mockChoices,
+        links: {
+          next: "invalid-url-format", // Malformed URL
+          prev: null,
+        },
+      };
+
+      mockApiClient.post = vi.fn().mockResolvedValue(malformedExternalResponse);
+
+      const sdk = createTestSdk();
+      const listChoicesResult = sdk.listInputFieldChoices({
+        appKey: "slack",
+        actionType: "read",
+        actionKey: "send_message",
+        inputFieldKey: "option",
+      });
+
+      const pages = [];
+      for await (const page of listChoicesResult) {
+        pages.push(page);
+        break;
+      }
+
+      expect(pages).toHaveLength(1);
+      expect(pages[0].nextCursor).toBeUndefined(); // Should handle gracefully
+    });
+
+    it("should handle links.next URL without page parameter", async () => {
+      const noPageResponse: NeedChoicesResponse = {
+        success: true,
+        choices: mockChoices,
+        links: {
+          next: "https://api.zapier.com/api/v4/implementations/choices/", // No page param
+          prev: null,
+        },
+      };
+
+      mockApiClient.post = vi.fn().mockResolvedValue(noPageResponse);
+
+      const sdk = createTestSdk();
+      const listChoicesResult = sdk.listInputFieldChoices({
+        appKey: "slack",
+        actionType: "read",
+        actionKey: "send_message",
+        inputFieldKey: "option",
+      });
+
+      const pages = [];
+      for await (const page of listChoicesResult) {
+        pages.push(page);
+        break;
+      }
+
+      expect(pages).toHaveLength(1);
+      expect(pages[0].nextCursor).toBeUndefined();
+    });
+  });
+
+  describe("error handling", () => {
+    it("should throw ZapierApiError when API response indicates failure", async () => {
+      mockApiClient.post = vi.fn().mockResolvedValue({
+        success: false,
+        errors: ["Invalid field", "Missing authentication"],
+      });
+
+      const sdk = createTestSdk();
+      await expect(
+        sdk.listInputFieldChoices({
+          appKey: "slack",
+          actionType: "read",
+          actionKey: "send_message",
+          inputFieldKey: "invalid_field",
+        }),
+      ).rejects.toThrow(ZapierApiError);
+
+      await expect(
+        sdk.listInputFieldChoices({
+          appKey: "slack",
+          actionType: "read",
+          actionKey: "send_message",
+          inputFieldKey: "invalid_field",
+        }),
+      ).rejects.toThrow(
+        "Failed to get input field choices: Invalid field, Missing authentication",
+      );
+    });
+
+    it("should handle API errors gracefully", async () => {
+      mockApiClient.post = vi
+        .fn()
+        .mockRejectedValue(new Error("Network error"));
+
+      const sdk = createTestSdk();
+      await expect(
+        sdk.listInputFieldChoices({
+          appKey: "slack",
+          actionType: "read",
+          actionKey: "send_message",
+          inputFieldKey: "channel",
+        }),
+      ).rejects.toThrow("Network error");
+    });
+
+    it("should handle empty choices array response", async () => {
+      mockApiClient.post = vi.fn().mockResolvedValue({
+        success: true,
+        choices: [], // Empty choices
+      });
+
+      const sdk = createTestSdk();
+      const result = await sdk.listInputFieldChoices({
+        appKey: "slack",
+        actionType: "read",
+        actionKey: "send_message",
+        inputFieldKey: "channel",
+      });
+
+      expect(result.data).toEqual([]);
+    });
+
+    it("should handle missing choices field in response", async () => {
+      mockApiClient.post = vi.fn().mockResolvedValue({
+        success: true,
+        // Missing choices field
+      });
+
+      const sdk = createTestSdk();
+      const result = await sdk.listInputFieldChoices({
+        appKey: "slack",
+        actionType: "read",
+        actionKey: "send_message",
+        inputFieldKey: "channel",
+      });
+
+      expect(result.data).toEqual([]);
+    });
+
+    it("should treat missing success field as failure", async () => {
+      mockApiClient.post = vi.fn().mockResolvedValue({
+        // Missing success field (undefined)
+        choices: mockChoices,
+      });
+
+      const sdk = createTestSdk();
+      await expect(
+        sdk.listInputFieldChoices({
+          appKey: "slack",
+          actionType: "read",
+          actionKey: "send_message",
+          inputFieldKey: "channel",
+        }),
+      ).rejects.toThrow("Failed to get input field choices: Unknown error");
+    });
+
+    it("should handle API response with errors but no error messages", async () => {
+      mockApiClient.post = vi.fn().mockResolvedValue({
+        success: false,
+        // Missing errors field
+      });
+
+      const sdk = createTestSdk();
+      await expect(
+        sdk.listInputFieldChoices({
+          appKey: "slack",
+          actionType: "read",
+          actionKey: "send_message",
+          inputFieldKey: "channel",
+        }),
+      ).rejects.toThrow("Failed to get input field choices: Unknown error");
+    });
+
+    it("should handle API response with empty errors array", async () => {
+      mockApiClient.post = vi.fn().mockResolvedValue({
+        success: false,
+        errors: [], // Empty errors array
+      });
+
+      const sdk = createTestSdk();
+      await expect(
+        sdk.listInputFieldChoices({
+          appKey: "slack",
+          actionType: "read",
+          actionKey: "send_message",
+          inputFieldKey: "channel",
+        }),
+      ).rejects.toThrow("Failed to get input field choices: Unknown error");
+    });
+  });
+
+  describe("context and metadata", () => {
+    it("should provide context with meta information", () => {
+      const sdk = createTestSdk();
+      const context = sdk.getContext();
+
+      expect((context.meta as any).listInputFieldChoices).toBeDefined();
+      expect(
+        (context.meta as any).listInputFieldChoices.inputSchema,
+      ).toBeDefined();
+    });
+  });
+});