@zapier/zapier-sdk 0.33.0 → 0.33.2

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

@@ -1,350 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { ZapierValidationError, ZapierActionError } from "../../types/errors";
-import { runActionPlugin } from "./index";
-import { createSdk } from "../../sdk";
-import { DEFAULT_ACTION_TIMEOUT_MS } from "../../constants";
-const mockAction = {
-    type: "action",
-    key: "send_message",
-    title: "Send Message",
-    description: "Send a message to a channel",
-    app_key: "slack",
-    action_type: "write",
-};
-const mockActionResponse = {
-    results: [
-        {
-            id: "msg_123",
-            text: "Hello, world!",
-            channel: "#general",
-            user: "user_456",
-        },
-    ],
-    meta: {
-        next_cursor: null,
-    },
-};
-describe("runAction plugin", () => {
-    let mockApiClient;
-    let mockGetAction;
-    let mockGetApp;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockApiClient = {
-            post: vi.fn().mockResolvedValue({ data: { id: "run_123" } }),
-            poll: vi.fn().mockResolvedValue({ results: mockActionResponse.results }),
-        };
-        mockGetAction = vi.fn().mockResolvedValue({
-            data: mockAction,
-        });
-    });
-    function createTestSdk() {
-        return createSdk()
-            .addPlugin(() => ({
-            context: {
-                options: {},
-            },
-        }))
-            .addPlugin(() => ({
-            getAction: mockGetAction,
-            getApp: mockGetApp,
-            context: {
-                api: mockApiClient,
-                getVersionedImplementationId: () => "SlackCLIAPI@1.21.1",
-                eventEmission: {
-                    emitMethodCalled: vi.fn(),
-                },
-            },
-        }))
-            .addPlugin(runActionPlugin);
-    }
-    describe("schema validation", () => {
-        it("should throw validation error for missing appKey", () => {
-            const sdk = createTestSdk();
-            expect(() => {
-                sdk.runAction({
-                    actionType: "write",
-                    actionKey: "send_message",
-                    inputs: { message: "Hello" },
-                });
-            }).toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for missing actionType", () => {
-            const sdk = createTestSdk();
-            expect(() => {
-                sdk.runAction({
-                    appKey: "slack",
-                    actionKey: "send_message",
-                    inputs: { message: "Hello" },
-                });
-            }).toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for missing actionKey", () => {
-            const sdk = createTestSdk();
-            expect(() => {
-                sdk.runAction({
-                    appKey: "slack",
-                    actionType: "write",
-                    inputs: { message: "Hello" },
-                });
-            }).toThrow(ZapierValidationError);
-        });
-        it("should pass validation with all required fields", async () => {
-            const sdk = createTestSdk();
-            const result = await sdk.runAction({
-                appKey: "slack",
-                actionType: "write",
-                actionKey: "send_message",
-                inputs: { message: "Hello" },
-            });
-            expect(result.data).toHaveLength(1);
-            expect(result.data[0]).toEqual(mockActionResponse.results[0]);
-        });
-    });
-    describe("action execution", () => {
-        it("should validate action exists using getAction", async () => {
-            const sdk = createTestSdk();
-            await sdk.runAction({
-                appKey: "slack",
-                actionType: "write",
-                actionKey: "send_message",
-                inputs: { message: "Hello" },
-            });
-            expect(mockGetAction).toHaveBeenCalledWith(expect.objectContaining({
-                appKey: "slack",
-                actionKey: "send_message",
-                actionType: "write",
-            }));
-        });
-        it("should throw error when action type doesn't match", async () => {
-            // Mock getAction to return an action with different type
-            mockGetAction.mockResolvedValue({
-                data: { ...mockAction, action_type: "read" },
-            });
-            const sdk = createTestSdk();
-            await expect(sdk.runAction({
-                appKey: "slack",
-                actionType: "write", // Different from mocked action type
-                actionKey: "send_message",
-                inputs: { message: "Hello" },
-            })).rejects.toThrow(ZapierValidationError);
-        });
-        it("should execute action with correct API call", async () => {
-            const sdk = createTestSdk();
-            await sdk.runAction({
-                appKey: "slack",
-                actionType: "write",
-                actionKey: "send_message",
-                inputs: { message: "Hello", channel: "#general" },
-                authenticationId: 12345,
-            });
-            expect(mockApiClient.post).toHaveBeenCalledWith("/zapier/api/actions/v1/runs", {
-                data: {
-                    selected_api: "SlackCLIAPI@1.21.1",
-                    action_key: "send_message",
-                    action_type: "write",
-                    inputs: { message: "Hello", channel: "#general" },
-                    authentication_id: 12345,
-                },
-            });
-            expect(mockApiClient.poll).toHaveBeenCalledWith("/zapier/api/actions/v1/runs/run_123", {
-                successStatus: 200,
-                pendingStatus: 202,
-                timeoutMs: DEFAULT_ACTION_TIMEOUT_MS,
-                isPending: expect.any(Function),
-                resultExtractor: expect.any(Function),
-            });
-        });
-        it("should execute action without authentication ID", async () => {
-            const sdk = createTestSdk();
-            await sdk.runAction({
-                appKey: "slack",
-                actionType: "write",
-                actionKey: "send_message",
-                inputs: { message: "Hello" },
-            });
-            expect(mockApiClient.post).toHaveBeenCalledWith("/zapier/api/actions/v1/runs", {
-                data: {
-                    selected_api: "SlackCLIAPI@1.21.1",
-                    action_key: "send_message",
-                    action_type: "write",
-                    inputs: { message: "Hello" },
-                },
-            });
-        });
-        it("should pass custom timeoutMs to poll", async () => {
-            const customTimeout = 300000; // 5 minutes
-            const sdk = createTestSdk();
-            await sdk.runAction({
-                appKey: "slack",
-                actionType: "write",
-                actionKey: "send_message",
-                inputs: { message: "Hello" },
-                timeoutMs: customTimeout,
-            });
-            expect(mockApiClient.poll).toHaveBeenCalledWith("/zapier/api/actions/v1/runs/run_123", expect.objectContaining({
-                timeoutMs: customTimeout,
-            }));
-        });
-        it("should handle pagination cursor", async () => {
-            const sdk = createTestSdk();
-            const runActionResult = sdk.runAction({
-                appKey: "slack",
-                actionType: "write",
-                actionKey: "send_message",
-                inputs: { message: "Hello" },
-            });
-            // Simulate pagination by getting an iterator
-            const iterator = runActionResult[Symbol.asyncIterator]();
-            await iterator.next();
-            expect(mockApiClient.post).toHaveBeenCalledWith("/zapier/api/actions/v1/runs", expect.objectContaining({
-                data: expect.objectContaining({
-                    inputs: { message: "Hello" },
-                    selected_api: "SlackCLIAPI@1.21.1",
-                    action_key: "send_message",
-                    action_type: "write",
-                }),
-            }));
-        });
-        it("should return results in correct format", async () => {
-            const sdk = createTestSdk();
-            const result = await sdk.runAction({
-                appKey: "slack",
-                actionType: "write",
-                actionKey: "send_message",
-                inputs: { message: "Hello" },
-            });
-            expect(result.data).toEqual(mockActionResponse.results);
-        });
-        it("should handle single result (not array)", async () => {
-            const singleResult = { id: "msg_123", text: "Hello" };
-            mockApiClient.post = vi
-                .fn()
-                .mockResolvedValue({ data: { id: "run_123" } });
-            mockApiClient.poll = vi.fn().mockResolvedValue({
-                results: [singleResult], // Poll returns the actual results
-            });
-            const sdk = createTestSdk();
-            const result = await sdk.runAction({
-                appKey: "slack",
-                actionType: "write",
-                actionKey: "send_message",
-                inputs: { message: "Hello" },
-            });
-            expect(result.data).toEqual([singleResult]); // Should be wrapped in array
-        });
-    });
-    describe("error handling", () => {
-        it("should handle action execution errors", async () => {
-            mockApiClient.post = vi
-                .fn()
-                .mockResolvedValue({ data: { id: "run_123" } });
-            mockApiClient.poll = vi.fn().mockResolvedValue({
-                results: [],
-                errors: [
-                    { title: "Invalid inputs", detail: "Message cannot be empty" },
-                ],
-            });
-            const sdk = createTestSdk();
-            await expect(sdk.runAction({
-                appKey: "slack",
-                actionType: "write",
-                actionKey: "send_message",
-                inputs: { message: "" }, // Invalid input
-            })).rejects.toThrow(ZapierActionError);
-        });
-        it("should handle server errors", async () => {
-            mockApiClient.post = vi.fn().mockImplementation((_url, options) => {
-                const error = options.customErrorHandler?.({
-                    status: 500,
-                    data: { message: "Internal server error" },
-                });
-                if (error)
-                    throw error;
-                throw new Error("Server Error");
-            });
-            const sdk = createTestSdk();
-            await expect(sdk.runAction({
-                appKey: "slack",
-                actionType: "write",
-                actionKey: "send_message",
-                inputs: { message: "Hello" },
-            })).rejects.toThrow();
-        });
-        it("should propagate getAction errors", async () => {
-            mockGetAction.mockRejectedValue(new Error("Action not found"));
-            const sdk = createTestSdk();
-            await expect(sdk.runAction({
-                appKey: "slack",
-                actionType: "write",
-                actionKey: "nonexistent",
-                inputs: { message: "Hello" },
-            })).rejects.toThrow("Action not found");
-        });
-        it("should handle unexpected errors during execution", async () => {
-            mockApiClient.post = vi
-                .fn()
-                .mockRejectedValue(new Error("Network error"));
-            const sdk = createTestSdk();
-            await expect(sdk.runAction({
-                appKey: "slack",
-                actionType: "write",
-                actionKey: "send_message",
-                inputs: { message: "Hello" },
-            })).rejects.toThrow("Network error");
-        });
-    });
-    describe("pagination", () => {
-        it("should support maxItems limit", async () => {
-            const sdk = createTestSdk();
-            const result = await sdk.runAction({
-                appKey: "slack",
-                actionType: "write",
-                actionKey: "send_message",
-                inputs: { message: "Hello" },
-                maxItems: 1,
-            });
-            expect(result.data).toHaveLength(1);
-        });
-        it("should support async iteration over pages", async () => {
-            const sdk = createTestSdk();
-            const runActionResult = sdk.runAction({
-                appKey: "slack",
-                actionType: "write",
-                actionKey: "send_message",
-                inputs: { message: "Hello" },
-            });
-            const pages = [];
-            for await (const page of runActionResult) {
-                pages.push(page);
-                break; // Just get first page for testing
-            }
-            expect(pages).toHaveLength(1);
-            expect(pages[0].data).toEqual(mockActionResponse.results);
-        });
-        it("should support async iteration over individual items", async () => {
-            const sdk = createTestSdk();
-            const runActionResult = sdk.runAction({
-                appKey: "slack",
-                actionType: "write",
-                actionKey: "send_message",
-                inputs: { message: "Hello" },
-                maxItems: 1,
-            });
-            const items = [];
-            for await (const item of runActionResult.items()) {
-                items.push(item);
-            }
-            expect(items).toHaveLength(1);
-            expect(items[0]).toEqual(mockActionResponse.results[0]);
-        });
-    });
-    describe("context and metadata", () => {
-        it("should provide context with meta information", () => {
-            const sdk = createTestSdk();
-            const context = sdk.getContext();
-            expect(context.meta.runAction).toBeDefined();
-            expect(context.meta.runAction.inputSchema).toBeDefined();
-        });
-    });
-});

package/dist/resolvers/connectionId.test.d.ts

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

package/dist/resolvers/connectionId.test.d.ts.map

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

package/dist/resolvers/connectionId.test.js

@@ -1,61 +0,0 @@
-import { describe, it, expect, vi, beforeAll } from "vitest";
-import { connectionIdResolver } from "./connectionId";
-describe("connectionIdResolver.tryResolveWithoutPrompt", () => {
-    let tryResolveWithoutPrompt;
-    beforeAll(() => {
-        if (!connectionIdResolver.tryResolveWithoutPrompt) {
-            throw new Error("connectionIdResolver.tryResolveWithoutPrompt is not defined");
-        }
-        tryResolveWithoutPrompt = connectionIdResolver.tryResolveWithoutPrompt;
-    });
-    it("returns null when no appKey is provided, deferring to the normal prompt", async () => {
-        const result = await tryResolveWithoutPrompt({}, {});
-        expect(result).toBeNull();
-    });
-    it("returns { resolvedValue: null } when the app has no auth_type, skipping the connection prompt", async () => {
-        const mockSdk = {
-            getApp: vi.fn().mockResolvedValue({ data: { auth_type: null } }),
-        };
-        const result = await tryResolveWithoutPrompt(mockSdk, {
-            appKey: "web-search-by-zapier",
-        });
-        expect(mockSdk.getApp).toHaveBeenCalledWith({
-            appKey: "web-search-by-zapier",
-        });
-        expect(result).toEqual({ resolvedValue: null });
-    });
-    it("returns { resolvedValue: null } when auth_type is absent from the app data", async () => {
-        const mockSdk = {
-            getApp: vi.fn().mockResolvedValue({ data: {} }),
-        };
-        const result = await tryResolveWithoutPrompt(mockSdk, {
-            appKey: "web-search-by-zapier",
-        });
-        expect(result).toEqual({ resolvedValue: null });
-    });
-    it("returns { resolvedValue: null } when auth_type is an empty string", async () => {
-        const mockSdk = {
-            getApp: vi.fn().mockResolvedValue({ data: { auth_type: "" } }),
-        };
-        const result = await tryResolveWithoutPrompt(mockSdk, {
-            appKey: "formatter",
-        });
-        expect(result).toEqual({ resolvedValue: null });
-    });
-    it("returns null for an app with auth_type set, allowing the connection picker to appear", async () => {
-        const mockSdk = {
-            getApp: vi.fn().mockResolvedValue({ data: { auth_type: "oauth" } }),
-        };
-        const result = await tryResolveWithoutPrompt(mockSdk, { appKey: "slack" });
-        expect(result).toBeNull();
-    });
-    it("returns null when getApp throws, falling back gracefully to the normal connection prompt", async () => {
-        const mockSdk = {
-            getApp: vi.fn().mockRejectedValue(new Error("App not found")),
-        };
-        const result = await tryResolveWithoutPrompt(mockSdk, {
-            appKey: "unknown-app",
-        });
-        expect(result).toBeNull();
-    });
-});

package/dist/sdk.test.d.ts

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

package/dist/sdk.test.d.ts.map

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

package/dist/sdk.test.js

@@ -1,260 +0,0 @@
-// Test the flat plugin system
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { createZapierSdk, createSdk } from "./sdk";
-describe("Flat Plugin System", () => {
-    it("should create SDK with all expected methods", () => {
-        const sdk = createZapierSdk();
-        // Test that methods are available (one from each category)
-        expect(sdk.listApps).toBeDefined(); // app
-        expect(sdk.runAction).toBeDefined(); // action
-        expect(sdk.listConnections).toBeDefined(); // connection
-        expect(sdk.fetch).toBeDefined(); // http
-        expect(sdk.listClientCredentials).toBeDefined(); // client-credentials
-        expect(sdk.getProfile).toBeDefined(); // account
-        expect(sdk.apps).toBeDefined(); // apps proxy
-        // Deprecated methods (kept for backward compatibility)
-        expect(sdk.listAuthentications).toBeDefined();
-        expect(sdk.request).toBeDefined();
-        // Test that getContext method is available
-        expect(sdk.getContext).toBeDefined();
-        expect(typeof sdk.getContext).toBe("function");
-    });
-    it("should have getContext method that returns context", () => {
-        const sdk = createZapierSdk();
-        const context = sdk.getContext(); // Type assertion to work around complex context inference
-        // Context should be an object
-        expect(typeof context).toBe("object");
-        expect(context).not.toBeNull();
-        // Context should have some properties (specific properties depend on plugin composition)
-        expect(Object.keys(context).length).toBeGreaterThan(0);
-        // Should have meta object
-        expect(context.meta).toBeDefined();
-        expect(typeof context.meta).toBe("object");
-        // Should have getProfile metadata from the plugin (verify it exists in meta)
-        expect("getProfile" in context.meta).toBe(true);
-        expect(context.meta.getProfile).toBeDefined();
-        expect(context.meta.getProfile.inputSchema).toBeDefined();
-    });
-    it("should have plugins return flat structure", () => {
-        const sdk = createZapierSdk();
-        // fetch should be directly available (not sdk.plugins.fetch or sdk.fetch.fetch)
-        expect(typeof sdk.fetch).toBe("function");
-        // apps should be directly available
-        expect(typeof sdk.apps).toBe("object");
-        // getProfile should be directly available
-        expect(typeof sdk.getProfile).toBe("function");
-    });
-    it("should support fluent plugin chaining with createSdk", () => {
-        // Test that createSdk().addPlugin().addPlugin() works and returns properly typed SDK
-        const testPlugin = () => ({
-            testMethod: () => "test result",
-        });
-        const sdk = createSdk().addPlugin(testPlugin);
-        // Should have getContext method
-        expect(typeof sdk.getContext).toBe("function");
-        // Should have addPlugin method for further chaining
-        expect(typeof sdk.addPlugin).toBe("function");
-        // Should have the plugin method
-        expect(typeof sdk.testMethod).toBe("function");
-        expect(sdk.testMethod()).toBe("test result");
-    });
-    it("should support fluent plugin chaining without .getSdk()", () => {
-        // This demonstrates the simplified API - no .getSdk() needed!
-        const plugin1 = () => ({ method1: () => "method1" });
-        const plugin2 = () => ({ method2: () => "method2" });
-        // Fluent chaining - each addPlugin returns a new SDK
-        const sdk = createSdk().addPlugin(plugin1).addPlugin(plugin2);
-        expect(sdk.method1()).toBe("method1");
-        expect(sdk.method2()).toBe("method2");
-        expect(typeof sdk.getContext).toBe("function");
-        expect(typeof sdk.addPlugin).toBe("function"); // Can still add more plugins!
-    });
-    it("should support plugins with options", () => {
-        // Test that addPlugin(pluginFn, options) works correctly
-        const pluginWithOptions = (params) => ({
-            getMessage: () => params.message,
-        });
-        const sdk = createSdk().addPlugin(pluginWithOptions, {
-            message: "Hello from options!",
-        });
-        expect(typeof sdk.getMessage).toBe("function");
-        expect(sdk.getMessage()).toBe("Hello from options!");
-    });
-    it("should merge context.meta from multiple plugins", () => {
-        // Test that multiple plugins can provide meta without overwriting each other
-        const plugin1 = () => ({
-            method1: () => "method1",
-            context: {
-                meta: {
-                    plugin1: { info: "Plugin 1 metadata" },
-                },
-            },
-        });
-        const plugin2 = () => ({
-            method2: () => "method2",
-            context: {
-                meta: {
-                    plugin2: { info: "Plugin 2 metadata" },
-                },
-            },
-        });
-        const sdk = createSdk().addPlugin(plugin1).addPlugin(plugin2);
-        const context = sdk.getContext();
-        // Both plugins should have their meta preserved
-        expect(context.meta.plugin1.info).toBe("Plugin 1 metadata");
-        expect(context.meta.plugin2.info).toBe("Plugin 2 metadata");
-        // Both methods should work
-        expect(sdk.method1()).toBe("method1");
-        expect(sdk.method2()).toBe("method2");
-    });
-    it("should support context requirements for cleaner plugin definitions", () => {
-        // Test context requirements work correctly
-        const pluginWithHelper = ({ sdk, context }) => ({
-            helperMethod: () => `Helper: ${sdk.existingMethod()} + ${context.customContext}`,
-        });
-        const baseSdk = { existingMethod: () => "base" };
-        const baseContext = { customContext: "custom", meta: {} };
-        const sdk = createSdk({}, baseSdk, baseContext).addPlugin(pluginWithHelper);
-        expect(sdk.helperMethod()).toBe("Helper: base + custom");
-        expect(sdk.existingMethod()).toBe("base"); // Original method still works
-    });
-    it("should ensure context.meta is always available", () => {
-        // Test that context.meta is always at least an empty object, even without explicit initialization
-        const plugin = ({ context }) => ({
-            testMethod: () => `Meta keys: ${Object.keys(context.meta).length}`,
-        });
-        // Create SDK without explicitly providing meta
-        const sdk = createSdk({}).addPlugin(plugin);
-        // Should work without error - meta should be at least an empty object
-        expect(sdk.testMethod()).toBe("Meta keys: 0");
-        // getContext() should also provide meta
-        const context = sdk.getContext();
-        expect(context.meta).toBeDefined();
-        expect(typeof context.meta).toBe("object");
-        expect(context.meta).not.toBeNull();
-    });
-});
-describe("Environment Variable Support", () => {
-    let originalEnv;
-    beforeEach(() => {
-        // Save original environment variable
-        originalEnv = process.env.ZAPIER_BASE_URL;
-    });
-    afterEach(() => {
-        // Restore original environment variable
-        if (originalEnv !== undefined) {
-            process.env.ZAPIER_BASE_URL = originalEnv;
-        }
-        else {
-            delete process.env.ZAPIER_BASE_URL;
-        }
-        // Clear module cache to ensure constants are re-evaluated
-        vi.resetModules();
-    });
-    it("should use custom base URL from ZAPIER_BASE_URL environment variable", async () => {
-        // Set custom base URL via environment variable
-        const customBaseUrl = "https://custom-zapier.example.com";
-        process.env.ZAPIER_BASE_URL = customBaseUrl;
-        // Clear module cache and re-import to get fresh constants
-        vi.resetModules();
-        const { createZapierSdk } = await import("./sdk");
-        // Create mock fetch function to capture requests
-        const mockFetch = vi.fn().mockResolvedValue({
-            ok: true,
-            status: 200,
-            text: async () => JSON.stringify({
-                data: [],
-                links: { next: null },
-                meta: { count: 0, limit: 100, offset: 0 },
-            }),
-            headers: new Headers(),
-        });
-        // Create SDK instance with mock fetch
-        const sdk = createZapierSdk({
-            token: "test-token",
-            fetch: mockFetch,
-        });
-        // Make an API call that should use the custom base URL
-        await sdk.listApps();
-        // Verify that the request was made to the custom base URL
-        expect(mockFetch).toHaveBeenCalledTimes(1);
-        const [actualUrl] = mockFetch.mock.calls[0];
-        expect(actualUrl).toMatch(new RegExp(`^${customBaseUrl}`));
-        expect(actualUrl).toContain("/api/v0/");
-    });
-    it("should use default base URL when ZAPIER_BASE_URL is not set", async () => {
-        // Ensure environment variable is not set
-        delete process.env.ZAPIER_BASE_URL;
-        // Clear module cache and re-import to get fresh constants
-        vi.resetModules();
-        const { createZapierSdk } = await import("./sdk");
-        // Create mock fetch function to capture requests
-        const mockFetch = vi.fn().mockResolvedValue({
-            ok: true,
-            status: 200,
-            text: async () => JSON.stringify({
-                data: [],
-                links: { next: null },
-                meta: { count: 0, limit: 100, offset: 0 },
-            }),
-            headers: new Headers(),
-        });
-        // Create SDK instance with mock fetch
-        const sdk = createZapierSdk({
-            token: "test-token",
-            fetch: mockFetch,
-        });
-        // Make an API call that should use the default base URL
-        await sdk.listApps();
-        // Verify that the request was made to the default base URL
-        expect(mockFetch).toHaveBeenCalledTimes(1);
-        const [actualUrl] = mockFetch.mock.calls[0];
-        expect(actualUrl).toMatch(/^https:\/\/sdkapi\.zapier\.com/);
-        expect(actualUrl).toContain("/api/v0/");
-    });
-    it("should use explicit baseUrl option for SDK API requests", async () => {
-        // Clear environment variable to ensure we're testing the explicit option
-        delete process.env.ZAPIER_BASE_URL;
-        // Clear module cache and re-import to get fresh constants
-        vi.resetModules();
-        const { createZapierSdk } = await import("./sdk");
-        const customBaseUrl = "https://staging.zapier.com";
-        // Create mock fetch function to capture requests
-        const mockFetch = vi.fn().mockResolvedValue({
-            ok: true,
-            status: 200,
-            text: async () => JSON.stringify({
-                data: [],
-                links: { next: null },
-                meta: { count: 0, limit: 100, offset: 0 },
-            }),
-            headers: new Headers(),
-        });
-        // Create SDK instance with explicit baseUrl option and mock fetch
-        const sdk = createZapierSdk({
-            baseUrl: customBaseUrl,
-            token: "test-token",
-            fetch: mockFetch,
-        });
-        // Make an API call that should use the custom base URL
-        await sdk.listApps();
-        // Verify that the request was made to the custom base URL
-        expect(mockFetch).toHaveBeenCalledTimes(1);
-        const [actualUrl] = mockFetch.mock.calls[0];
-        expect(actualUrl).toMatch(new RegExp(`^${customBaseUrl}`));
-        expect(actualUrl).toContain("/api/v0/");
-    });
-    it("should accept credentials with clientId in SDK options", async () => {
-        delete process.env.ZAPIER_BASE_URL;
-        vi.resetModules();
-        const { createZapierSdk } = await import("./sdk");
-        const sdk = createZapierSdk({
-            credentials: {
-                clientId: "test-client-id",
-            },
-        });
-        // Verify SDK was created successfully with credentials option
-        expect(sdk).toBeDefined();
-        expect(sdk.listApps).toBeDefined();
-    });
-});