@zapier/zapier-sdk 0.33.0 → 0.33.2

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

@@ -1,454 +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 { listAppsPlugin } from "../listApps";
-import { eventEmissionPlugin } from "../eventEmission";
-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;
-    let mockGetVersionedImplementationId;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockApiClient = {
-            get: vi.fn().mockResolvedValue(mockImplementationsResponse),
-        };
-        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: {
-                options: {},
-            },
-        }))
-            .addPlugin(() => ({
-            context: {
-                api: mockApiClient,
-                resolveCredentials: vi.fn().mockResolvedValue(undefined),
-            },
-        }))
-            .addPlugin(eventEmissionPlugin)
-            .addPlugin(() => ({
-            context: {
-                manifest: null,
-                getVersionedImplementationId: mockGetVersionedImplementationId,
-                resolveAppKeys: mockResolveAppKeys,
-                updateManifestEntry: vi
-                    .fn()
-                    .mockResolvedValue(["test-key", {}, { apps: {} }]),
-                addActionEntry: vi
-                    .fn()
-                    .mockResolvedValue(["test-key", {}, { apps: {} }]),
-                findActionEntry: vi.fn().mockResolvedValue({
-                    key: "test-key",
-                    entry: {},
-                    manifest: { apps: {} },
-                }),
-                hasActionEntry: vi.fn().mockResolvedValue(true),
-                listActionEntries: vi
-                    .fn()
-                    .mockResolvedValue([
-                    [
-                        "test-key",
-                        { key: "test-key", entry: {}, manifest: { apps: {} } },
-                    ],
-                ]),
-                deleteActionEntry: vi.fn().mockResolvedValue({ apps: {} }),
-                findManifestEntry: vi
-                    .fn()
-                    .mockResolvedValue([
-                    "test-key",
-                    { key: "test-key", entry: {}, manifest: { apps: {} } },
-                ]),
-                readManifestFromFile: vi.fn().mockResolvedValue({ 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({});
-            }).toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for invalid appKey type", () => {
-            const sdk = createTestSdk();
-            expect(() => {
-                sdk.listActions({
-                    appKey: 123,
-                });
-            }).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 });
-            }).toThrow(ZapierValidationError);
-            expect(() => {
-                sdk.listActions({ appKey: "slack", maxItems: -10 });
-            }).toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for invalid actionType", () => {
-            const sdk = createTestSdk();
-            expect(() => {
-                sdk.listActions({
-                    appKey: "slack",
-                    actionType: "invalid-type",
-                });
-            }).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",
-        ];
-        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(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("/zapier/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/dist/plugins/listApps/index.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=index.test.d.ts.map

package/dist/plugins/listApps/index.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../../src/plugins/listApps/index.test.ts"],"names":[],"mappings":""}

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

@@ -1,124 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { ZapierValidationError } from "../../types/errors";
-import { listAppsPlugin } from "./index";
-import { createSdk } from "../../sdk";
-import { eventEmissionPlugin } from "../eventEmission";
-// Mock transport for testing - prevents real HTTP telemetry requests
-const mockTransport = {
-    emit: vi.fn().mockResolvedValue(undefined),
-    close: vi.fn().mockResolvedValue(undefined),
-};
-vi.mock("../eventEmission/transport", () => ({
-    createTransport: vi.fn(() => mockTransport),
-}));
-// Mock CLI login packages - prevents real token resolution requests
-vi.mock("@zapier/zapier-sdk-cli/login", () => ({
-    getToken: vi.fn().mockResolvedValue(undefined),
-}));
-vi.mock("@zapier/zapier-sdk-cli-login", () => ({
-    getToken: vi.fn().mockResolvedValue(undefined),
-}));
-const mockResolveAppKeys = vi
-    .fn()
-    .mockImplementation(async ({ appKeys }) => {
-    return appKeys.map((appKey) => ({
-        lookupAppKey: appKey,
-        implementationName: appKey,
-        slug: appKey.toLowerCase(),
-        version: undefined,
-    }));
-});
-describe("listApps plugin", () => {
-    let mockApiClient;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockApiClient = {
-            get: vi.fn().mockResolvedValue({
-                data: [
-                    {
-                        title: "Slack",
-                        key: "SlackCLIAPI",
-                        implementation_id: "SlackCLIAPI@1.0.0",
-                        version: "1.0.0",
-                        slug: "slack",
-                        description: "Team communication",
-                        primary_color: "#4A154B",
-                    },
-                    {
-                        title: "Google Sheets",
-                        key: "GoogleSheetsCLIAPI",
-                        implementation_id: "GoogleSheetsCLIAPI@1.0.0",
-                        version: "1.0.0",
-                        slug: "google-sheets",
-                        description: "Online spreadsheets",
-                        primary_color: "#34A853",
-                    },
-                ],
-                links: { next: null },
-                meta: { count: 2, limit: 100, offset: 0 },
-            }),
-        };
-    });
-    const apiPlugin = () => ({
-        context: {
-            api: mockApiClient,
-        },
-    });
-    function createTestSdk() {
-        return createSdk()
-            .addPlugin(() => ({
-            context: {
-                options: {},
-            },
-        }))
-            .addPlugin(apiPlugin)
-            .addPlugin(eventEmissionPlugin)
-            .addPlugin(() => ({
-            context: {
-                resolveAppKeys: mockResolveAppKeys,
-            },
-        }))
-            .addPlugin(listAppsPlugin);
-    }
-    describe("basic functionality", () => {
-        it("should provide listApps method that returns apps", async () => {
-            const sdk = createTestSdk();
-            const result = await sdk.listApps({ pageSize: 2 });
-            // Just verify the structure - handler tests verify correct data
-            expect(result.data.length).toBeGreaterThan(0);
-            expect(result.data[0]).toHaveProperty("title");
-            expect(result.data[0]).toHaveProperty("key");
-            expect(result.data[0]).toHaveProperty("implementation_id");
-            expect(result.data[0]).toHaveProperty("version");
-        });
-    });
-    describe("plugin integration", () => {
-        it("should provide metadata in context for CLI introspection", () => {
-            const sdk = createTestSdk();
-            const context = sdk.getContext();
-            expect(context.meta.listApps).toBeDefined();
-            expect(context.meta.listApps.inputSchema).toBeDefined();
-        });
-        it("should integrate with resolveAppKeys", async () => {
-            const sdk = createTestSdk();
-            await sdk.listApps({ appKeys: ["SlackCLIAPI"] });
-            // Verify resolveAppKeys was called with the provided appKeys
-            expect(mockResolveAppKeys).toHaveBeenCalledWith(expect.objectContaining({
-                appKeys: ["SlackCLIAPI"],
-            }));
-        });
-    });
-    describe("validation", () => {
-        it("should throw validation error for invalid input", () => {
-            const sdk = createTestSdk();
-            // Invalid pageSize
-            expect(() => {
-                sdk.listApps({ pageSize: 0 });
-            }).toThrow(ZapierValidationError);
-            // Invalid appKeys type
-            expect(() => {
-                sdk.listApps({ appKeys: 123 });
-            }).toThrow(ZapierValidationError);
-        });
-    });
-});

package/dist/plugins/listConnections/index.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=index.test.d.ts.map

package/dist/plugins/listConnections/index.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../../src/plugins/listConnections/index.test.ts"],"names":[],"mappings":""}