@zapier/zapier-sdk 0.33.0 → 0.33.2

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

@@ -1,177 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { ZapierValidationError } from "../../types/errors";
-import { findFirstConnectionPlugin } from "./index";
-import { createSdk } from "../../sdk";
-import { ListConnectionsQuerySchema } from "../listConnections/schemas";
-import { eventEmissionPlugin } from "../eventEmission";
-const mockConnections = [
-    {
-        id: "123",
-        title: "My Slack",
-        date: "2021-01-01",
-        account_id: "123",
-        implementation_id: "api_123",
-        is_expired: "false",
-        expired_at: null,
-        is_invite_only: false,
-        is_private: false,
-        shared_with_all: false,
-    },
-    {
-        id: "456",
-        title: "Slack Workspace 2",
-        is_expired: "false",
-        expired_at: null,
-        date: "2021-01-01",
-        account_id: "123",
-        implementation_id: "api_123",
-        is_invite_only: false,
-        is_private: false,
-        shared_with_all: false,
-    },
-];
-describe("findFirstConnection plugin", () => {
-    let mockListConnections;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockListConnections = vi.fn().mockResolvedValue({
-            data: mockConnections,
-        });
-    });
-    function createTestSdk() {
-        // Create a proper plugin chain: first add a mock listConnections plugin, then add findFirstConnection
-        const mockListConnectionsPlugin = () => ({
-            listConnections: mockListConnections,
-            context: {
-                meta: {
-                    listConnections: {
-                        inputSchema: ListConnectionsQuerySchema,
-                    },
-                },
-            },
-        });
-        // Build SDK with proper plugin composition
-        return createSdk()
-            .addPlugin(() => ({
-            context: {
-                options: {},
-            },
-        }))
-            .addPlugin(eventEmissionPlugin)
-            .addPlugin(mockListConnectionsPlugin)
-            .addPlugin(findFirstConnectionPlugin);
-    }
-    describe("schema validation", () => {
-        it("should pass validation with empty options", async () => {
-            const sdk = createTestSdk();
-            const result = await sdk.findFirstConnection({});
-            expect(result.data).toBeDefined();
-        });
-        it("should pass validation with undefined options", async () => {
-            const sdk = createTestSdk();
-            const result = await sdk.findFirstConnection();
-            expect(result.data).toBeDefined();
-        });
-        it("should throw validation error for invalid appKey type", async () => {
-            const sdk = createTestSdk();
-            await expect(sdk.findFirstConnection({
-                appKey: 123, // intentionally wrong type for testing
-            })).rejects.toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for invalid search type", async () => {
-            const sdk = createTestSdk();
-            await expect(sdk.findFirstConnection({
-                search: 123,
-            })).rejects.toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for invalid parameter types", async () => {
-            const sdk = createTestSdk();
-            await expect(sdk.findFirstConnection({
-                title: 123,
-                accountId: 456,
-                owner: true,
-            })).rejects.toThrow(ZapierValidationError);
-        });
-        it("should pass validation with all valid fields", async () => {
-            const sdk = createTestSdk();
-            const result = await sdk.findFirstConnection({
-                appKey: "slack",
-                search: "workspace",
-                title: "My Slack Workspace",
-                accountId: "acc_123",
-                owner: "me",
-            });
-            expect(result.data).toBeDefined();
-        });
-    });
-    describe("business logic", () => {
-        it("should return first connection when found", async () => {
-            const mockConnection = mockConnections[0];
-            mockListConnections.mockResolvedValue({
-                data: [mockConnection],
-            });
-            const sdk = createTestSdk();
-            const result = await sdk.findFirstConnection({
-                appKey: "slack",
-            });
-            expect(result.data).toEqual(mockConnection);
-        });
-        it("should throw error when no connections found", async () => {
-            mockListConnections.mockResolvedValue({
-                data: [],
-            });
-            const sdk = createTestSdk();
-            await expect(sdk.findFirstConnection({
-                appKey: "nonexistent",
-            })).rejects.toThrow("No connection found matching the specified criteria");
-        });
-        it("should return first connection when multiple found", async () => {
-            const mockConnection = mockConnections[0];
-            mockListConnections.mockResolvedValue({
-                data: [mockConnection, mockConnections[1]],
-            });
-            const sdk = createTestSdk();
-            const result = await sdk.findFirstConnection({
-                search: "Slack",
-            });
-            expect(result.data).toEqual(mockConnection);
-        });
-    });
-    describe("options forwarding", () => {
-        it("should forward all options to listConnections", async () => {
-            const sdk = createTestSdk();
-            const options = {
-                appKey: "slack",
-                search: "workspace",
-                title: "My Slack Workspace",
-                accountId: "acc_123",
-                owner: "me",
-            };
-            await sdk.findFirstConnection(options);
-            expect(mockListConnections).toHaveBeenCalledWith(expect.objectContaining({
-                ...options,
-                maxItems: 1,
-            }));
-        });
-    });
-    describe("limit enforcement", () => {
-        it("should automatically set maxItems to 1", async () => {
-            const sdk = createTestSdk();
-            await sdk.findFirstConnection({
-                appKey: "slack",
-            });
-            expect(mockListConnections).toHaveBeenCalledWith(expect.objectContaining({
-                appKey: "slack",
-                maxItems: 1,
-            }));
-        });
-    });
-    describe("context and metadata", () => {
-        it("should provide context with meta information", () => {
-            const sdk = createTestSdk();
-            const context = sdk.getContext();
-            expect(context.meta.findFirstConnection).toBeDefined();
-            expect(context.meta.findFirstConnection.inputSchema).toBeDefined();
-        });
-    });
-});

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

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

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

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

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

@@ -1,159 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { ZapierValidationError, ZapierResourceNotFoundError, } from "../../types/errors";
-import { findUniqueConnectionPlugin } from "./index";
-import { createSdk } from "../../sdk";
-import { ListConnectionsQuerySchema } from "../listConnections/schemas";
-import { eventEmissionPlugin } from "../eventEmission";
-const mockConnection = {
-    id: "123",
-    title: "My Slack",
-    date: "2021-01-01",
-    account_id: "123",
-    implementation_id: "api_123",
-    is_expired: "false",
-    expired_at: null,
-    is_invite_only: false,
-    is_private: false,
-    shared_with_all: false,
-};
-const mockConnections = [
-    mockConnection,
-    {
-        id: "456",
-        title: "Slack Workspace 2",
-        is_expired: "false",
-        expired_at: null,
-        date: "2021-01-01",
-        account_id: "123",
-        implementation_id: "api_123",
-        is_invite_only: false,
-        is_private: false,
-        shared_with_all: false,
-    },
-];
-describe("findUniqueConnection plugin", () => {
-    let mockListConnections;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockListConnections = vi.fn().mockResolvedValue({
-            data: [mockConnection],
-        });
-    });
-    function createTestSdk() {
-        // Create a proper plugin chain: first add a mock listConnections plugin, then add findUniqueConnection
-        const mockListConnectionsPlugin = () => ({
-            listConnections: mockListConnections,
-            context: {
-                meta: {
-                    listConnections: {
-                        inputSchema: ListConnectionsQuerySchema,
-                    },
-                },
-            },
-        });
-        // Build SDK with proper plugin composition
-        return createSdk()
-            .addPlugin(() => ({
-            context: {
-                options: {},
-            },
-        }))
-            .addPlugin(eventEmissionPlugin)
-            .addPlugin(mockListConnectionsPlugin)
-            .addPlugin(findUniqueConnectionPlugin);
-    }
-    describe("schema validation", () => {
-        it("should pass validation with empty options", async () => {
-            const sdk = createTestSdk();
-            const result = await sdk.findUniqueConnection({});
-            expect(result.data).toBeDefined();
-        });
-        it("should throw validation error for invalid appKey type", async () => {
-            const sdk = createTestSdk();
-            await expect(sdk.findUniqueConnection({
-                appKey: 123,
-            })).rejects.toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for invalid parameter types", async () => {
-            const sdk = createTestSdk();
-            await expect(sdk.findUniqueConnection({
-                search: 123,
-                title: 456,
-                accountId: 789,
-                owner: false,
-            })).rejects.toThrow(ZapierValidationError);
-        });
-        it("should pass validation with all valid fields", async () => {
-            const sdk = createTestSdk();
-            const result = await sdk.findUniqueConnection({
-                appKey: "slack",
-                search: "Workspace",
-                title: "My Slack",
-                accountId: "acc_123",
-                owner: "me",
-            });
-            expect(result.data).toBeDefined();
-        });
-    });
-    describe("business logic", () => {
-        it("should return the first connection when exactly one is found", async () => {
-            mockListConnections.mockResolvedValue({
-                data: [mockConnection],
-            });
-            const sdk = createTestSdk();
-            const result = await sdk.findUniqueConnection({
-                appKey: "slack",
-            });
-            expect(result.data).toEqual(mockConnection);
-        });
-        it("should throw ZapierResourceNotFoundError when no connections found", async () => {
-            mockListConnections.mockResolvedValue({
-                data: [],
-            });
-            const sdk = createTestSdk();
-            await expect(sdk.findUniqueConnection({
-                appKey: "nonexistent",
-            })).rejects.toThrow(ZapierResourceNotFoundError);
-            await expect(sdk.findUniqueConnection({
-                appKey: "nonexistent",
-            })).rejects.toThrow("No connection found matching the specified criteria");
-        });
-        it("should throw ZapierValidationError when multiple connections found", async () => {
-            mockListConnections.mockResolvedValue({
-                data: mockConnections, // Two connections
-            });
-            const sdk = createTestSdk();
-            await expect(sdk.findUniqueConnection({
-                search: "Workspace",
-            })).rejects.toThrow(ZapierValidationError);
-            await expect(sdk.findUniqueConnection({
-                search: "Workspace",
-            })).rejects.toThrow("Multiple connections found matching the specified criteria. Expected exactly one.");
-        });
-    });
-    describe("options forwarding", () => {
-        it("should forward all options to listConnections with maxItems=2", async () => {
-            const sdk = createTestSdk();
-            const options = {
-                appKey: "slack",
-                search: "workspace",
-                title: "My Slack Workspace",
-                accountId: "acc_123",
-                owner: "me",
-            };
-            await sdk.findUniqueConnection(options);
-            expect(mockListConnections).toHaveBeenCalledWith(expect.objectContaining({
-                ...options,
-                maxItems: 2,
-            }));
-        });
-    });
-    describe("context and metadata", () => {
-        it("should provide context with meta information", () => {
-            const sdk = createTestSdk();
-            const context = sdk.getContext();
-            expect(context.meta.findUniqueConnection).toBeDefined();
-            expect(context.meta.findUniqueConnection.inputSchema).toBeDefined();
-        });
-    });
-});

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

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

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

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

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

@@ -1,211 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { ZapierValidationError, ZapierResourceNotFoundError, } from "../../types/errors";
-import { getActionPlugin } from "./index";
-import { createSdk } from "../../sdk";
-import { ListActionsSchema } from "../listActions/schemas";
-import { eventEmissionPlugin } from "../eventEmission";
-const mockActions = [
-    {
-        type: "action",
-        key: "user_by_email",
-        title: "Search User by Email",
-        description: "Find a user by email address",
-        app_key: "slack",
-        action_type: "search",
-    },
-    {
-        type: "action",
-        key: "search_messages",
-        title: "Search Messages",
-        description: "Search for messages in channels",
-        app_key: "slack",
-        action_type: "search",
-    },
-    {
-        type: "action",
-        key: "user_by_email",
-        title: "Search User by Email",
-        description: "Find a user by email address",
-        app_key: "slack",
-        action_type: "write", // Different action type for testing mismatch
-    },
-];
-describe("getAction plugin", () => {
-    let mockListActions;
-    let mockApiClient;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        // Mock listActions to return a promise with .items() method
-        mockListActions = vi.fn().mockImplementation(() => {
-            const promise = Promise.resolve({
-                data: mockActions,
-            });
-            // Add .items() method that returns an async iterable
-            return Object.assign(promise, {
-                items: () => ({
-                    async *[Symbol.asyncIterator]() {
-                        for (const action of mockActions) {
-                            yield action;
-                        }
-                    },
-                }),
-            });
-        });
-        mockApiClient = {};
-    });
-    function createTestSdk() {
-        // Create a proper plugin chain with context dependencies
-        const mockListActionsPlugin = () => ({
-            listActions: mockListActions,
-            context: {
-                meta: {
-                    listActions: {
-                        inputSchema: ListActionsSchema,
-                    },
-                },
-            },
-        });
-        // Build SDK with proper plugin composition, providing API in initial context
-        return createSdk({}, {}, { api: mockApiClient, meta: {}, options: {} })
-            .addPlugin(eventEmissionPlugin)
-            .addPlugin(mockListActionsPlugin)
-            .addPlugin(getActionPlugin);
-    }
-    describe("schema validation", () => {
-        it("should throw validation error for missing appKey", async () => {
-            const sdk = createTestSdk();
-            await expect(sdk.getAction({
-                actionType: "search",
-                actionKey: "user_by_email",
-            })).rejects.toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for missing actionType", async () => {
-            const sdk = createTestSdk();
-            await expect(sdk.getAction({
-                appKey: "slack",
-                actionKey: "user_by_email",
-            })).rejects.toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for missing actionKey", async () => {
-            const sdk = createTestSdk();
-            await expect(sdk.getAction({
-                appKey: "slack",
-                actionType: "search",
-            })).rejects.toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for invalid appKey type", async () => {
-            const sdk = createTestSdk();
-            await expect(sdk.getAction({
-                appKey: 123,
-                actionType: "search",
-                actionKey: "user_by_email",
-            })).rejects.toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for invalid actionType", async () => {
-            const sdk = createTestSdk();
-            await expect(sdk.getAction({
-                appKey: "slack",
-                actionType: "invalid-type",
-                actionKey: "user_by_email",
-            })).rejects.toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for invalid actionKey type", async () => {
-            const sdk = createTestSdk();
-            await expect(sdk.getAction({
-                appKey: "slack",
-                actionType: "search",
-                actionKey: 123,
-            })).rejects.toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for empty appKey", async () => {
-            const sdk = createTestSdk();
-            await expect(sdk.getAction({
-                appKey: "",
-                actionType: "search",
-                actionKey: "user_by_email",
-            })).rejects.toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for empty actionKey", async () => {
-            const sdk = createTestSdk();
-            await expect(sdk.getAction({
-                appKey: "slack",
-                actionType: "search",
-                actionKey: "",
-            })).rejects.toThrow(ZapierValidationError);
-        });
-        it("should pass validation with all required fields", async () => {
-            const sdk = createTestSdk();
-            const result = await sdk.getAction({
-                appKey: "slack",
-                actionType: "search",
-                actionKey: "user_by_email",
-            });
-            expect(result.data).toEqual(mockActions[0]);
-        });
-    });
-    describe("action lookup", () => {
-        it("should call listActions with correct parameters", async () => {
-            const sdk = createTestSdk();
-            await sdk.getAction({
-                appKey: "slack",
-                actionType: "search",
-                actionKey: "user_by_email",
-            });
-            expect(mockListActions).toHaveBeenCalledWith(expect.objectContaining({
-                appKey: "slack",
-            }));
-        });
-        it("should return the correct action when found", async () => {
-            const sdk = createTestSdk();
-            const result = await sdk.getAction({
-                appKey: "slack",
-                actionType: "search",
-                actionKey: "user_by_email",
-            });
-            expect(result.data).toEqual(mockActions[0]);
-        });
-        it("should throw error when action key not found", async () => {
-            const sdk = createTestSdk();
-            await expect(sdk.getAction({
-                appKey: "slack",
-                actionType: "search",
-                actionKey: "nonexistent_action",
-            })).rejects.toThrow(ZapierResourceNotFoundError);
-        });
-        it("should throw error when action type doesn't match", async () => {
-            const sdk = createTestSdk();
-            await expect(sdk.getAction({
-                appKey: "slack",
-                actionType: "write",
-                actionKey: "search_messages", // This action is type "search" in mock
-            })).rejects.toThrow(ZapierResourceNotFoundError);
-        });
-        it("should handle listActions errors", async () => {
-            mockListActions.mockImplementation(() => {
-                const promise = Promise.reject(new Error("API Error"));
-                // Add .items() method that also rejects
-                return Object.assign(promise, {
-                    items: () => ({
-                        async *[Symbol.asyncIterator]() {
-                            throw new Error("API Error");
-                        },
-                    }),
-                });
-            });
-            const sdk = createTestSdk();
-            await expect(sdk.getAction({
-                appKey: "slack",
-                actionType: "search",
-                actionKey: "user_by_email",
-            })).rejects.toThrow("API Error");
-        });
-    });
-    describe("plugin integration", () => {
-        it("should provide metadata in context", () => {
-            const sdk = createTestSdk();
-            const context = sdk.getContext();
-            expect(context.meta.getAction).toBeDefined();
-            expect(context.meta.getAction.inputSchema).toBeDefined();
-        });
-    });
-});

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

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

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

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