@zapier/zapier-sdk 0.33.0 → 0.33.2

package/dist/plugins/listInputFieldChoices/index.test.js

@@ -1,717 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { ZapierValidationError, ZapierApiError } from "../../types/errors";
-import { listInputFieldChoicesPlugin } from "./index";
-import { createSdk } from "../../sdk";
-import { GetActionSchema } from "../getAction/schemas";
-import { eventEmissionPlugin } from "../eventEmission";
-const mockChoices = [
-    {
-        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 = {
-    success: true,
-    choices: mockChoices,
-};
-const mockPaginatedChoicesResponse = {
-    success: true,
-    choices: mockChoices.slice(0, 2),
-    next_page: 1,
-};
-const mockExternalChoicesResponse = {
-    success: true,
-    choices: mockChoices,
-    meta: { page: "0" },
-    links: {
-        next: "https://api.zapier.com/api/v4/implementations/choices/?page=1",
-        prev: null,
-    },
-};
-// Mock needs data for static choices
-const mockNeedsWithStaticChoices = [
-    {
-        key: "priority",
-        label: "Priority",
-        help_text: "Select priority",
-        required: true,
-        type: "string",
-        choices: [
-            {
-                key: "high",
-                sample: "high",
-                label: "High Priority",
-                value: "high",
-            },
-            {
-                key: "medium",
-                sample: "medium",
-                label: "Medium Priority",
-                value: "medium",
-            },
-        ],
-    },
-];
-const mockNeedsWithoutChoices = [
-    {
-        key: "channel",
-        label: "Channel",
-        help_text: "Select a channel",
-        required: true,
-        type: "string",
-        choices: [], // Empty choices
-    },
-];
-const mockNeedsResponse = {
-    success: true,
-    needs: mockNeedsWithoutChoices,
-};
-const mockNeedsResponseWithStaticChoices = {
-    success: true,
-    needs: mockNeedsWithStaticChoices,
-};
-describe("listInputFieldChoices plugin", () => {
-    let mockApiClient;
-    let mockGetAction;
-    let mockGetVersionedImplementationId;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        // Mock api.post to handle both endpoints
-        const mockPost = vi.fn().mockImplementation((path) => {
-            if (path === "/zapier/api/v4/implementations/needs/") {
-                return Promise.resolve(mockNeedsResponse);
-            }
-            else if (path === "/zapier/api/v4/implementations/choices/") {
-                return Promise.resolve(mockChoicesResponse);
-            }
-            return Promise.reject(new Error(`Unexpected endpoint: ${path}`));
-        });
-        mockApiClient = {
-            post: mockPost,
-        };
-        mockGetAction = vi.fn().mockResolvedValue({
-            data: { id: "core:123", key: "send_message", action_type: "read" },
-        });
-        mockGetVersionedImplementationId = vi
-            .fn()
-            .mockResolvedValue("SlackCLIAPI@1.21.1");
-    });
-    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: {},
-            options: {},
-            getVersionedImplementationId: mockGetVersionedImplementationId,
-        })
-            .addPlugin(eventEmissionPlugin)
-            .addPlugin(mockGetActionPlugin)
-            .addPlugin(listInputFieldChoicesPlugin);
-    }
-    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
-                });
-                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
-                });
-                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",
-                });
-                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
-                });
-                expect.fail("Expected ZapierValidationError to be thrown");
-            }
-            catch (error) {
-                expect(error).toBeInstanceOf(ZapierValidationError);
-            }
-        });
-    });
-    describe("static choices from needs endpoint", () => {
-        it("should return static choices when field has them", async () => {
-            // Mock api.post to return needs with static choices
-            const mockPost = vi.fn().mockImplementation((path) => {
-                if (path === "/zapier/api/v4/implementations/needs/") {
-                    return Promise.resolve(mockNeedsResponseWithStaticChoices);
-                }
-                else if (path === "/zapier/api/v4/implementations/choices/") {
-                    return Promise.resolve(mockChoicesResponse);
-                }
-                return Promise.reject(new Error(`Unexpected endpoint: ${path}`));
-            });
-            mockApiClient.post = mockPost;
-            const sdk = createTestSdk();
-            const result = await sdk.listInputFieldChoices({
-                appKey: "slack",
-                actionType: "read",
-                actionKey: "send_message",
-                inputFieldKey: "priority",
-            });
-            // Should return static choices
-            expect(result.data).toHaveLength(2);
-            expect(result.data[0]).toEqual({
-                key: "high",
-                label: "High Priority",
-                sample: "high",
-                value: "high",
-            });
-            expect(result.data[1]).toEqual({
-                key: "medium",
-                label: "Medium Priority",
-                sample: "medium",
-                value: "medium",
-            });
-            // Should have called needs endpoint to check for static choices
-            expect(mockApiClient.post).toHaveBeenCalledWith("/zapier/api/v4/implementations/needs/", {
-                selected_api: "SlackCLIAPI@1.21.1",
-                action: "send_message",
-                type_of: "read",
-                params: {},
-            });
-            // Should not call choices endpoint since static choices were found
-            expect(mockApiClient.post).not.toHaveBeenCalledWith("/zapier/api/v4/implementations/choices/", expect.anything());
-        });
-        it("should fall back to dynamic choices when field has empty choices array", async () => {
-            // Mock api.post - needs endpoint returns field with empty choices
-            const mockPost = vi.fn().mockImplementation((path) => {
-                if (path === "/zapier/api/v4/implementations/needs/") {
-                    return Promise.resolve(mockNeedsResponse); // Has empty choices
-                }
-                else if (path === "/zapier/api/v4/implementations/choices/") {
-                    return Promise.resolve(mockChoicesResponse);
-                }
-                return Promise.reject(new Error(`Unexpected endpoint: ${path}`));
-            });
-            mockApiClient.post = mockPost;
-            const sdk = createTestSdk();
-            const result = await sdk.listInputFieldChoices({
-                appKey: "slack",
-                actionType: "read",
-                actionKey: "send_message",
-                inputFieldKey: "channel",
-            });
-            // Should first call needs endpoint
-            expect(mockApiClient.post).toHaveBeenCalledWith("/zapier/api/v4/implementations/needs/", {
-                selected_api: "SlackCLIAPI@1.21.1",
-                action: "send_message",
-                type_of: "read",
-                params: {},
-            });
-            // Should then call choices endpoint for dynamic choices
-            expect(mockApiClient.post).toHaveBeenCalledWith("/zapier/api/v4/implementations/choices/", expect.objectContaining({
-                action_id: "core:123",
-                input_field_id: "channel",
-            }));
-            // Should return dynamic choices
-            expect(result.data).toHaveLength(3);
-        });
-        it("should fall back to dynamic choices when field is not found", async () => {
-            // Mock api.post - needs endpoint returns different field
-            const mockNeedsWithOtherField = {
-                success: true,
-                needs: [
-                    {
-                        key: "other_field",
-                        label: "Other Field",
-                        help_text: "Some other field",
-                        required: false,
-                        type: "string",
-                        choices: [],
-                    },
-                ],
-            };
-            const mockPost = vi.fn().mockImplementation((path) => {
-                if (path === "/zapier/api/v4/implementations/needs/") {
-                    return Promise.resolve(mockNeedsWithOtherField);
-                }
-                else if (path === "/zapier/api/v4/implementations/choices/") {
-                    return Promise.resolve(mockChoicesResponse);
-                }
-                return Promise.reject(new Error(`Unexpected endpoint: ${path}`));
-            });
-            mockApiClient.post = mockPost;
-            const sdk = createTestSdk();
-            await sdk.listInputFieldChoices({
-                appKey: "slack",
-                actionType: "read",
-                actionKey: "send_message",
-                inputFieldKey: "channel",
-            });
-            // Should call needs endpoint first
-            expect(mockApiClient.post).toHaveBeenCalledWith("/zapier/api/v4/implementations/needs/", expect.anything());
-            // Should call choices endpoint since field was not found in needs
-            expect(mockApiClient.post).toHaveBeenCalledWith("/zapier/api/v4/implementations/choices/", expect.anything());
-        });
-    });
-    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(expect.objectContaining({
-                appKey: "slack",
-                actionType: "read",
-                actionKey: "send_message",
-            }));
-            expect(mockApiClient.post).toHaveBeenCalledWith("/zapier/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("/zapier/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("/zapier/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("/zapier/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("/zapier/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 = [
-                { 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 = {
-                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 = {
-                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);
-            // Error comes from needs endpoint (first call) with user-friendly message
-            await expect(sdk.listInputFieldChoices({
-                appKey: "slack",
-                actionType: "read",
-                actionKey: "send_message",
-                inputFieldKey: "invalid_field",
-            })).rejects.toThrow("Failed to get input fields: 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 fields: 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 fields: 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 fields: Unknown error");
-        });
-    });
-    describe("context and metadata", () => {
-        it("should provide context with meta information", () => {
-            const sdk = createTestSdk();
-            const context = sdk.getContext();
-            expect(context.meta.listInputFieldChoices).toBeDefined();
-            expect(context.meta.listInputFieldChoices.inputSchema).toBeDefined();
-        });
-    });
-});