@zapier/zapier-sdk 0.33.0 → 0.33.2

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

@@ -1,157 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { ZapierValidationError, ZapierAppNotFoundError, } from "../../types/errors";
-import { getAppPlugin } from "./index";
-import { createSdk } from "../../sdk";
-import { apiPlugin } from "../api/index";
-import { listAppsPlugin } from "../listApps";
-import { manifestPlugin } from "../manifest";
-import { eventEmissionPlugin } from "../eventEmission";
-function createTestSdk() {
-    return createSdk()
-        .addPlugin(() => ({
-        context: {
-            options: {},
-        },
-    }))
-        .addPlugin(apiPlugin, { fetch: global.fetch })
-        .addPlugin(eventEmissionPlugin)
-        .addPlugin(manifestPlugin)
-        .addPlugin(listAppsPlugin)
-        .addPlugin(getAppPlugin);
-}
-describe("getApp plugin", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    describe("schema validation", () => {
-        it("should throw validation error for missing appKey", async () => {
-            const sdk = createTestSdk();
-            await expect(sdk.getApp({})).rejects.toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for invalid appKey type", async () => {
-            const sdk = createTestSdk();
-            await expect(sdk.getApp({
-                appKey: 123,
-            })).rejects.toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for empty string appKey", async () => {
-            const sdk = createTestSdk();
-            await expect(sdk.getApp({
-                appKey: "",
-            })).rejects.toThrow(ZapierValidationError);
-        });
-        it("should pass validation with valid appKey", async () => {
-            const sdk = createTestSdk();
-            const context = sdk.getContext();
-            // Mock the API client to handle both resolveAppKeys and listApps calls
-            context.api.get = vi
-                .fn()
-                // First call: resolveAppKeys calls listAppsForSlugsPage which expects raw API format
-                .mockResolvedValueOnce({
-                results: [
-                    {
-                        id: "SlackCLIAPI@1.0.0",
-                        name: "Slack",
-                        description: "Team communication",
-                        primary_color: "#4A154B",
-                        categories: ["communication"],
-                        slug: "slack",
-                    },
-                ],
-                next: null,
-            })
-                // Second call: listApps goes through handler which returns transformed format
-                .mockResolvedValueOnce({
-                data: [
-                    {
-                        title: "Slack",
-                        key: "SlackCLIAPI",
-                        implementation_id: "SlackCLIAPI@1.0.0",
-                        description: "Team communication",
-                        primary_color: "#4A154B",
-                        categories: ["communication"],
-                        slug: "slack",
-                        version: "1.0.0",
-                    },
-                ],
-                nextCursor: undefined,
-            });
-            const result = await sdk.getApp({
-                appKey: "slack",
-            });
-            expect(result.data.title).toBe("Slack");
-            expect(result.data.key).toBe("SlackCLIAPI");
-            expect(result.data.implementation_id).toBe("SlackCLIAPI@1.0.0");
-            expect(result.data.version).toBe("1.0.0");
-        });
-    });
-    describe("error handling", () => {
-        it("should throw ZapierAppNotFoundError when app does not exist", async () => {
-            const sdk = createTestSdk();
-            const context = sdk.getContext();
-            // Mock API to return empty results for both potential calls
-            context.api.get = vi
-                .fn()
-                // First call: resolveAppKeys may call to resolve slug
-                .mockResolvedValueOnce({
-                results: [],
-                next: null,
-            })
-                // Second call: listApps main API call (returns transformed format)
-                .mockResolvedValueOnce({
-                data: [],
-                nextCursor: undefined,
-            });
-            await expect(sdk.getApp({
-                appKey: "nonexistent-app",
-            })).rejects.toThrow(ZapierAppNotFoundError);
-        });
-    });
-    describe("data mapping", () => {
-        it("should return essential app properties", async () => {
-            const sdk = createTestSdk();
-            const context = sdk.getContext();
-            // Mock the API client to handle both resolveAppKeys and listApps calls
-            context.api.get = vi
-                .fn()
-                // First call: resolveAppKeys calls listAppsForSlugsPage which expects raw API format
-                .mockResolvedValueOnce({
-                results: [
-                    {
-                        id: "TestCLIAPI@1.0.0",
-                        name: "Test App",
-                        description: "Test description",
-                        primary_color: "#FF0000",
-                        categories: ["testing"],
-                        slug: "test",
-                    },
-                ],
-                next: null,
-            })
-                // Second call: listApps goes through handler which returns transformed format
-                .mockResolvedValueOnce({
-                data: [
-                    {
-                        title: "Test App",
-                        key: "TestCLIAPI",
-                        implementation_id: "TestCLIAPI@1.0.0",
-                        description: "Test description",
-                        primary_color: "#FF0000",
-                        categories: ["testing"],
-                        slug: "test",
-                        version: "1.0.0",
-                    },
-                ],
-                nextCursor: undefined,
-            });
-            const result = await sdk.getApp({
-                appKey: "test",
-            });
-            expect(result.data.title).toBeDefined();
-            expect(result.data.key).toBeDefined();
-            expect(result.data.implementation_id).toBeDefined();
-            expect(result.data.title).toBe("Test App");
-            expect(result.data.key).toBe("TestCLIAPI");
-        });
-    });
-});

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

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

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

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

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

@@ -1,124 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { ZapierValidationError } from "../../types/errors";
-import { getConnectionPlugin } from "./index";
-import { createSdk } from "../../sdk";
-import { eventEmissionPlugin } from "../eventEmission";
-const mockConnectionItem = {
-    id: "123",
-    date: "2021-01-01",
-    account_id: "456",
-    implementation_id: "SlackCLIAPI@1.21.1",
-    is_invite_only: false,
-    is_private: false,
-    shared_with_all: false,
-    is_expired: "false",
-    expired_at: null,
-    label: "My Slack Workspace",
-    title: "My Slack Workspace",
-    app_key: "SlackCLIAPI",
-    app_version: "1.21.1",
-};
-describe("getConnection plugin", () => {
-    let mockApiClient;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockApiClient = {
-            get: vi.fn().mockResolvedValue({ data: mockConnectionItem }),
-        };
-    });
-    const apiPlugin = () => ({
-        context: {
-            api: mockApiClient,
-        },
-    });
-    function createTestSdk() {
-        return createSdk()
-            .addPlugin(() => ({
-            context: {
-                options: {},
-            },
-        }))
-            .addPlugin(apiPlugin)
-            .addPlugin(eventEmissionPlugin)
-            .addPlugin(getConnectionPlugin);
-    }
-    describe("input validation", () => {
-        it("should throw validation error for missing connectionId", async () => {
-            const sdk = createTestSdk();
-            await expect(sdk.getConnection({})).rejects.toThrow("connectionId is required");
-        });
-        it("should throw validation error for invalid connectionId type", async () => {
-            const sdk = createTestSdk();
-            await expect(sdk.getConnection({
-                connectionId: true,
-            })).rejects.toThrow(ZapierValidationError);
-        });
-        it("should accept valid connectionId", async () => {
-            const sdk = createTestSdk();
-            const result = await sdk.getConnection({
-                connectionId: "123",
-            });
-            expect(result.data).toBeDefined();
-            expect(result.data.id).toBe("123");
-        });
-    });
-    describe("SDK API endpoint routing", () => {
-        it("should call the correct SDK API endpoint with path params", async () => {
-            const sdk = createTestSdk();
-            await sdk.getConnection({ connectionId: "123" });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/connections/123");
-        });
-        it("should URI encode string connectionId in path", async () => {
-            const sdk = createTestSdk();
-            await sdk.getConnection({ connectionId: "test/with spaces" });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/connections/test%2Fwith%20spaces");
-        });
-        it("should return data from API response", async () => {
-            const sdk = createTestSdk();
-            const result = await sdk.getConnection({ connectionId: "123" });
-            expect(result.data).toEqual(mockConnectionItem);
-        });
-    });
-    describe("deprecated authenticationId support", () => {
-        it("should accept deprecated authenticationId parameter", async () => {
-            const sdk = createTestSdk();
-            const result = await sdk.getConnection({
-                authenticationId: "123",
-            });
-            expect(result.data).toBeDefined();
-            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/connections/123");
-        });
-        it("should prefer connectionId over authenticationId when both provided", async () => {
-            const sdk = createTestSdk();
-            await sdk.getConnection({
-                connectionId: "new-id",
-                authenticationId: "old-id",
-            });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/connections/new-id");
-        });
-    });
-    describe("error propagation", () => {
-        it("should propagate errors from API client", async () => {
-            mockApiClient.get = vi.fn().mockRejectedValue(new Error("API error"));
-            const sdk = createTestSdk();
-            await expect(sdk.getConnection({ connectionId: "123" })).rejects.toThrow("API error");
-        });
-    });
-    describe("plugin metadata", () => {
-        it("should provide metadata in SDK context", () => {
-            const sdk = createTestSdk();
-            const context = sdk.getContext();
-            expect(context.meta.getConnection).toBeDefined();
-            expect(context.meta.getConnection.inputSchema).toBeDefined();
-            expect(context.meta.getConnection.outputSchema).toBeDefined();
-            expect(context.meta.getConnection.type).toBe("item");
-            expect(context.meta.getConnection.itemType).toBe("Connection");
-        });
-        it("should include resolvers in metadata", () => {
-            const sdk = createTestSdk();
-            const context = sdk.getContext();
-            expect(context.meta.getConnection.resolvers).toBeDefined();
-            expect(context.meta.getConnection.resolvers.connectionId).toBeDefined();
-        });
-    });
-});

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

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

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

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

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

@@ -1,291 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { ZapierValidationError, ZapierConfigurationError, ZapierApiError, } from "../../types/errors";
-import { getInputFieldsSchemaPlugin } from "./index";
-import { getActionPlugin } from "../getAction";
-import { getAppPlugin } from "../getApp";
-import { listActionsPlugin } from "../listActions";
-import { listAppsPlugin } from "../listApps";
-import { createSdk } from "../../sdk";
-import { eventEmissionPlugin } from "../eventEmission";
-const mockSchema = {
-    type: "object",
-    properties: {
-        message: {
-            type: "string",
-            title: "Message",
-            description: "The message to send",
-        },
-        channel: {
-            type: "string",
-            title: "Channel",
-            description: "The channel to send to",
-        },
-        tags: {
-            type: "array",
-            items: {
-                type: "string",
-            },
-            title: "Tags",
-            description: "List of tags",
-        },
-    },
-    required: ["message", "channel"],
-};
-const mockNeedsResponse = {
-    success: true,
-    needs: [],
-    schema: mockSchema,
-};
-const mockActionsResponse = {
-    results: [
-        {
-            slug: "slack",
-            selected_api: "slack",
-            actions: [
-                {
-                    key: "send_message",
-                    name: "Send Message",
-                    description: "Send a message to a channel",
-                    type_of: "write",
-                    type: "write",
-                    id: "core:12345",
-                },
-            ],
-        },
-    ],
-    meta: {
-        next_cursor: null,
-    },
-};
-describe("getInputFieldsSchema plugin", () => {
-    let mockApiClient;
-    let mockGetVersionedImplementationId;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockApiClient = {
-            get: vi.fn().mockResolvedValue(mockActionsResponse),
-            post: vi.fn().mockResolvedValue(mockNeedsResponse),
-        };
-        mockGetVersionedImplementationId = vi
-            .fn()
-            .mockResolvedValue("SlackCLIAPI@1.21.1");
-    });
-    function createTestSdk() {
-        return createSdk({}, {}, {
-            api: mockApiClient,
-            meta: {},
-            options: {},
-            getVersionedImplementationId: mockGetVersionedImplementationId,
-        })
-            .addPlugin(eventEmissionPlugin)
-            .addPlugin(listAppsPlugin)
-            .addPlugin(listActionsPlugin)
-            .addPlugin(getAppPlugin)
-            .addPlugin(getActionPlugin)
-            .addPlugin(getInputFieldsSchemaPlugin);
-    }
-    describe("schema validation", () => {
-        it("should throw validation error for missing required fields", async () => {
-            const sdk = createTestSdk();
-            await expect(sdk.getInputFieldsSchema({
-            // Missing required fields
-            })).rejects.toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for invalid field types", async () => {
-            const sdk = createTestSdk();
-            await expect(sdk.getInputFieldsSchema({
-                appKey: 123,
-                actionType: "write",
-                actionKey: "send_message",
-            })).rejects.toThrow(ZapierValidationError);
-        });
-        it("should pass validation with all required fields", async () => {
-            const sdk = createTestSdk();
-            const result = await sdk.getInputFieldsSchema({
-                appKey: "slack",
-                actionType: "write",
-                actionKey: "send_message",
-            });
-            expect(result.data).toBeDefined();
-        });
-        it("should pass validation with optional fields", async () => {
-            const sdk = createTestSdk();
-            const result = await sdk.getInputFieldsSchema({
-                appKey: "slack",
-                actionType: "write",
-                actionKey: "send_message",
-                authenticationId: 123,
-                inputs: { channel: "#general" },
-            });
-            expect(result.data).toBeDefined();
-        });
-    });
-    describe("API integration", () => {
-        it("should call the correct API endpoint", async () => {
-            const sdk = createTestSdk();
-            await sdk.getInputFieldsSchema({
-                appKey: "slack",
-                actionType: "write",
-                actionKey: "send_message",
-            });
-            expect(mockApiClient.post).toHaveBeenCalledWith("/zapier/api/v4/implementations/needs/", {
-                selected_api: "SlackCLIAPI@1.21.1",
-                action: "send_message",
-                type_of: "write",
-                params: {},
-            });
-        });
-        it("should include authentication_id when provided", async () => {
-            const sdk = createTestSdk();
-            await sdk.getInputFieldsSchema({
-                appKey: "slack",
-                actionType: "write",
-                actionKey: "send_message",
-                authenticationId: 123,
-            });
-            expect(mockApiClient.post).toHaveBeenCalledWith("/zapier/api/v4/implementations/needs/", {
-                selected_api: "SlackCLIAPI@1.21.1",
-                action: "send_message",
-                type_of: "write",
-                params: {},
-                authentication_id: 123,
-            });
-        });
-        it("should exclude authentication_id when null", async () => {
-            const sdk = createTestSdk();
-            await sdk.getInputFieldsSchema({
-                appKey: "slack",
-                actionType: "write",
-                actionKey: "send_message",
-                authenticationId: null,
-            });
-            expect(mockApiClient.post).toHaveBeenCalledWith("/zapier/api/v4/implementations/needs/", {
-                selected_api: "SlackCLIAPI@1.21.1",
-                action: "send_message",
-                type_of: "write",
-                params: {},
-                // No authentication_id
-            });
-        });
-        it("should include inputs when provided", async () => {
-            const sdk = createTestSdk();
-            const inputs = { channel: "#general", message: "test" };
-            await sdk.getInputFieldsSchema({
-                appKey: "slack",
-                actionType: "write",
-                actionKey: "send_message",
-                inputs,
-            });
-            expect(mockApiClient.post).toHaveBeenCalledWith("/zapier/api/v4/implementations/needs/", {
-                selected_api: "SlackCLIAPI@1.21.1",
-                action: "send_message",
-                type_of: "write",
-                params: inputs,
-            });
-        });
-    });
-    describe("data return", () => {
-        it("should return the schema object from the API response", async () => {
-            const sdk = createTestSdk();
-            const result = await sdk.getInputFieldsSchema({
-                appKey: "slack",
-                actionType: "write",
-                actionKey: "send_message",
-            });
-            expect(result.data).toEqual(mockSchema);
-        });
-        it("should return empty object when schema is not present", async () => {
-            mockApiClient.post = vi.fn().mockResolvedValue({
-                success: true,
-                needs: [],
-                // No schema field
-            });
-            const sdk = createTestSdk();
-            const result = await sdk.getInputFieldsSchema({
-                appKey: "slack",
-                actionType: "write",
-                actionKey: "send_message",
-            });
-            expect(result.data).toEqual({});
-        });
-        it("should handle complex schema structures", async () => {
-            const complexSchema = {
-                type: "object",
-                properties: {
-                    user: {
-                        type: "object",
-                        properties: {
-                            name: { type: "string" },
-                            age: { type: "number" },
-                        },
-                        required: ["name"],
-                    },
-                    tags: {
-                        type: "array",
-                        items: { type: "string" },
-                    },
-                },
-                required: ["user"],
-            };
-            mockApiClient.post = vi.fn().mockResolvedValue({
-                success: true,
-                needs: [],
-                schema: complexSchema,
-            });
-            const sdk = createTestSdk();
-            const result = await sdk.getInputFieldsSchema({
-                appKey: "slack",
-                actionType: "write",
-                actionKey: "send_message",
-            });
-            expect(result.data).toEqual(complexSchema);
-        });
-    });
-    describe("error handling", () => {
-        it("should throw ZapierConfigurationError when app has no current_implementation_id", async () => {
-            mockGetVersionedImplementationId.mockResolvedValue(null);
-            const sdk = createTestSdk();
-            await expect(sdk.getInputFieldsSchema({
-                appKey: "invalid",
-                actionType: "write",
-                actionKey: "send_message",
-            })).rejects.toThrow(ZapierConfigurationError);
-        });
-        it("should throw ZapierApiError when API response indicates failure", async () => {
-            mockApiClient.post = vi.fn().mockResolvedValue({
-                success: false,
-                errors: ["Authentication failed", "Invalid credentials"],
-            });
-            const sdk = createTestSdk();
-            await expect(sdk.getInputFieldsSchema({
-                appKey: "slack",
-                actionType: "write",
-                actionKey: "send_message",
-            })).rejects.toThrow(ZapierApiError);
-            await expect(sdk.getInputFieldsSchema({
-                appKey: "slack",
-                actionType: "write",
-                actionKey: "send_message",
-            })).rejects.toThrow("Failed to get input fields: Authentication failed, Invalid credentials");
-        });
-        it("should handle API errors gracefully", async () => {
-            mockApiClient.post = vi
-                .fn()
-                .mockRejectedValue(new Error("Network error"));
-            const sdk = createTestSdk();
-            await expect(sdk.getInputFieldsSchema({
-                appKey: "slack",
-                actionType: "write",
-                actionKey: "send_message",
-            })).rejects.toThrow("Network error");
-        });
-    });
-    describe("context and metadata", () => {
-        it("should provide context with meta information", () => {
-            const sdk = createTestSdk();
-            const context = sdk.getContext();
-            expect(context.meta.getInputFieldsSchema).toBeDefined();
-            expect(context.meta.getInputFieldsSchema.inputSchema).toBeDefined();
-        });
-    });
-});

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

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

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

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