@zapier/zapier-sdk 0.33.0 → 0.33.2

package/dist/plugins/eventEmission/transport.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * Tests for Event Transport Layer
- */
-export {};
-//# sourceMappingURL=transport.test.d.ts.map

package/dist/plugins/eventEmission/transport.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"transport.test.d.ts","sourceRoot":"","sources":["../../../src/plugins/eventEmission/transport.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/plugins/eventEmission/transport.test.js

@@ -1,164 +0,0 @@
-/**
- * Tests for Event Transport Layer
- */
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { createHttpTransport, createConsoleTransport, createNoopTransport, createTransport, } from "./transport";
-// Mock fetch globally
-const mockFetch = vi.fn();
-global.fetch = mockFetch;
-// Mock console.log
-const mockConsoleLog = vi.spyOn(console, "log").mockImplementation(() => { });
-describe("Transport Layer", () => {
-    const sampleEvent = {
-        event_id: "test-123",
-        timestamp_ms: Date.now(),
-        release_id: "test-release",
-        error_message: "Test error",
-        is_user_facing: false,
-    };
-    const sampleSubject = "platform.sdk.ErrorOccurredEvent";
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    describe("createHttpTransport", () => {
-        it("should emit events via HTTP successfully", async () => {
-            mockFetch.mockResolvedValueOnce({
-                ok: true,
-                status: 200,
-            });
-            const transport = createHttpTransport({
-                endpoint: "https://telemetry.example.com/events",
-                headers: { "x-api-key": "test-key" },
-            });
-            await transport.emit(sampleSubject, sampleEvent);
-            expect(mockFetch).toHaveBeenCalledWith("https://telemetry.example.com/events", {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    "x-api-key": "test-key",
-                },
-                body: JSON.stringify({
-                    subject: sampleSubject,
-                    properties: sampleEvent,
-                }),
-            });
-        });
-        it("should retry on HTTP failures", async () => {
-            // Fail twice, then succeed
-            mockFetch
-                .mockResolvedValueOnce({ ok: false, status: 500 })
-                .mockResolvedValueOnce({ ok: false, status: 500 })
-                .mockResolvedValueOnce({ ok: true, status: 200 });
-            const transport = createHttpTransport({
-                endpoint: "https://telemetry.example.com/events",
-                retryAttempts: 3,
-                retryDelayMs: 10, // Short delay for testing
-            });
-            await transport.emit(sampleSubject, sampleEvent);
-            expect(mockFetch).toHaveBeenCalledTimes(3);
-        });
-        it("should handle network errors silently", async () => {
-            mockFetch.mockRejectedValue(new Error("Network error"));
-            const transport = createHttpTransport({
-                endpoint: "https://telemetry.example.com/events",
-                retryAttempts: 1,
-                retryDelayMs: 1,
-            });
-            // Should not throw despite network error
-            await expect(transport.emit(sampleSubject, sampleEvent)).resolves.toBeUndefined();
-        });
-        it("should stop retrying after max attempts", async () => {
-            mockFetch.mockResolvedValue({ ok: false, status: 500 });
-            const transport = createHttpTransport({
-                endpoint: "https://telemetry.example.com/events",
-                retryAttempts: 2,
-                retryDelayMs: 1,
-            });
-            await transport.emit(sampleSubject, sampleEvent);
-            expect(mockFetch).toHaveBeenCalledTimes(2);
-        });
-    });
-    describe("createConsoleTransport", () => {
-        it("should log events to console", async () => {
-            const transport = createConsoleTransport();
-            await transport.emit(sampleSubject, sampleEvent);
-            expect(mockConsoleLog).toHaveBeenCalledWith("[SDK Telemetry]", JSON.stringify({ subject: sampleSubject, properties: sampleEvent }, null, 2));
-        });
-        it("should handle console errors silently", async () => {
-            mockConsoleLog.mockImplementation(() => {
-                throw new Error("Console error");
-            });
-            const transport = createConsoleTransport();
-            // Should not throw despite console error
-            await expect(transport.emit(sampleSubject, sampleEvent)).resolves.toBeUndefined();
-        });
-    });
-    describe("createNoopTransport", () => {
-        it("should do nothing when emitting events", async () => {
-            const transport = createNoopTransport();
-            await transport.emit(sampleSubject, sampleEvent);
-            // Verify no side effects
-            expect(mockFetch).not.toHaveBeenCalled();
-            expect(mockConsoleLog).not.toHaveBeenCalled();
-        });
-    });
-    describe("createTransport", () => {
-        it("should create HTTP transport with valid config", async () => {
-            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
-            const transport = createTransport({
-                type: "http",
-                endpoint: "https://example.com",
-                headers: { "x-key": "value" },
-                retryAttempts: 5,
-                retryDelayMs: 2000,
-            });
-            expect(transport.emit).toBeTypeOf("function");
-            await transport.emit(sampleSubject, sampleEvent);
-            expect(mockFetch).toHaveBeenCalledWith("https://example.com", expect.any(Object));
-        });
-        it("should create console transport", async () => {
-            const transport = createTransport({
-                type: "console",
-            });
-            expect(transport.emit).toBeTypeOf("function");
-            await transport.emit(sampleSubject, sampleEvent);
-            expect(mockConsoleLog).toHaveBeenCalled();
-        });
-        it("should create noop transport by default", async () => {
-            const transport = createTransport({
-                type: "noop",
-            });
-            expect(transport.emit).toBeTypeOf("function");
-            await transport.emit(sampleSubject, sampleEvent);
-            expect(mockFetch).not.toHaveBeenCalled();
-            expect(mockConsoleLog).not.toHaveBeenCalled();
-        });
-        it("should fallback to noop transport on invalid HTTP config", async () => {
-            const transport = createTransport({
-                type: "http",
-                // Missing endpoint
-            });
-            expect(transport.emit).toBeTypeOf("function");
-            await transport.emit(sampleSubject, sampleEvent);
-            expect(mockFetch).not.toHaveBeenCalled();
-        });
-        it("should fallback to noop transport on unknown type", async () => {
-            const transport = createTransport({
-                type: "unknown",
-            });
-            expect(transport.emit).toBeTypeOf("function");
-            await transport.emit(sampleSubject, sampleEvent);
-            expect(mockFetch).not.toHaveBeenCalled();
-            expect(mockConsoleLog).not.toHaveBeenCalled();
-        });
-        it("should handle transport creation errors gracefully", async () => {
-            expect(() => {
-                const transport = createTransport({
-                    type: "http",
-                    // Missing required endpoint - should fallback to noop
-                });
-                expect(transport.emit).toBeTypeOf("function");
-            }).not.toThrow();
-        });
-    });
-});

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

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

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

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

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

@@ -1,428 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { fetchPlugin } from "./index";
-import { createSdk } from "../../sdk";
-import { eventEmissionPlugin } from "../eventEmission";
-import { ZapierRelayError } from "../../types/errors";
-describe("fetch plugin", () => {
-    let mockApiClient;
-    let mockFetch;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockFetch = vi.fn().mockResolvedValue(new Response('{"success": true}', {
-            status: 200,
-            headers: { "Content-Type": "application/json" },
-        }));
-        mockApiClient = {
-            fetch: mockFetch,
-        };
-    });
-    const apiPlugin = () => ({
-        context: {
-            api: mockApiClient,
-        },
-    });
-    function createTestSdk() {
-        return createSdk()
-            .addPlugin(() => ({
-            context: {
-                options: {},
-            },
-        }))
-            .addPlugin(apiPlugin)
-            .addPlugin(eventEmissionPlugin)
-            .addPlugin(fetchPlugin);
-    }
-    describe("URL transformation", () => {
-        it("should transform full URLs to relay path format", async () => {
-            const sdk = createTestSdk();
-            await sdk.fetch("https://api.github.com/user");
-            expect(mockFetch).toHaveBeenCalledWith("/relay/api.github.com/user", expect.any(Object));
-        });
-        it("should preserve query parameters and fragments", async () => {
-            const sdk = createTestSdk();
-            await sdk.fetch("https://api.example.com/search?q=test&limit=10#section");
-            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/search?q=test&limit=10#section", expect.any(Object));
-        });
-        it("should handle URLs with ports", async () => {
-            const sdk = createTestSdk();
-            await sdk.fetch("https://api.example.com:8443/data");
-            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com:8443/data", expect.any(Object));
-        });
-        it("should handle URL objects", async () => {
-            const sdk = createTestSdk();
-            await sdk.fetch(new URL("https://api.example.com/data"));
-            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/data", expect.any(Object));
-        });
-    });
-    describe("headers handling", () => {
-        it("should pass through regular headers", async () => {
-            const sdk = createTestSdk();
-            const headers = {
-                "Content-Type": "application/json",
-                "X-Custom-Header": "test-value",
-            };
-            await sdk.fetch("https://api.example.com/data", {
-                method: "POST",
-                headers,
-            });
-            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/data", {
-                method: "POST",
-                body: undefined,
-                headers: {
-                    "Content-Type": "application/json",
-                    "X-Custom-Header": "test-value",
-                },
-                authRequired: true,
-            });
-        });
-        it("should add relay-specific headers when provided", async () => {
-            const sdk = createTestSdk();
-            await sdk.fetch("https://api.example.com/data", {
-                method: "POST",
-                authenticationId: 123,
-                callbackUrl: "https://webhook.example.com/callback",
-            });
-            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/data", {
-                method: "POST",
-                body: undefined,
-                headers: {
-                    "X-Relay-Authentication-Id": "123",
-                    "X-Relay-Callback-Url": "https://webhook.example.com/callback",
-                },
-                authRequired: true,
-            });
-        });
-        it("should handle Headers object", async () => {
-            const sdk = createTestSdk();
-            const headers = new Headers();
-            headers.set("Content-Type", "application/json");
-            headers.set("Authorization", "Bearer token");
-            await sdk.fetch("https://api.example.com/data", { headers });
-            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/data", {
-                method: "GET",
-                body: undefined,
-                headers: {
-                    "content-type": "application/json",
-                    authorization: "Bearer token",
-                },
-                authRequired: true,
-            });
-        });
-        it("should handle headers as array of tuples", async () => {
-            const sdk = createTestSdk();
-            const headers = [
-                ["Content-Type", "application/json"],
-                ["X-Api-Key", "secret"],
-            ];
-            await sdk.fetch("https://api.example.com/data", { headers });
-            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/data", {
-                method: "GET",
-                body: undefined,
-                headers: {
-                    "Content-Type": "application/json",
-                    "X-Api-Key": "secret",
-                },
-                authRequired: true,
-            });
-        });
-    });
-    describe("HTTP methods", () => {
-        const methods = [
-            "GET",
-            "POST",
-            "PUT",
-            "DELETE",
-            "PATCH",
-            "HEAD",
-            "OPTIONS",
-        ];
-        methods.forEach((method) => {
-            it(`should support ${method} method`, async () => {
-                const sdk = createTestSdk();
-                await sdk.fetch("https://api.example.com/data", { method });
-                expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/data", {
-                    method,
-                    body: undefined,
-                    headers: {},
-                    authRequired: true,
-                });
-            });
-        });
-        it("should default to GET method", async () => {
-            const sdk = createTestSdk();
-            await sdk.fetch("https://api.example.com/data");
-            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/data", {
-                method: "GET",
-                body: undefined,
-                headers: {},
-                authRequired: true,
-            });
-        });
-    });
-    describe("request body", () => {
-        it("should pass through request body", async () => {
-            const sdk = createTestSdk();
-            const body = '{"name": "test", "value": 42}';
-            await sdk.fetch("https://api.example.com/data", {
-                method: "POST",
-                body,
-            });
-            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/data", {
-                method: "POST",
-                body,
-                headers: {
-                    "Content-Type": "application/json; charset=utf-8",
-                },
-                authRequired: true,
-            });
-        });
-        it("should auto-set Content-Type for JSON object bodies", async () => {
-            const sdk = createTestSdk();
-            const body = '{"key": "value"}';
-            await sdk.fetch("https://api.example.com/data", {
-                method: "POST",
-                body,
-            });
-            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/data", {
-                method: "POST",
-                body,
-                headers: {
-                    "Content-Type": "application/json; charset=utf-8",
-                },
-                authRequired: true,
-            });
-        });
-        it("should auto-set Content-Type for JSON array bodies", async () => {
-            const sdk = createTestSdk();
-            const body = '[{"id": 1}, {"id": 2}]';
-            await sdk.fetch("https://api.example.com/data", {
-                method: "POST",
-                body,
-            });
-            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/data", {
-                method: "POST",
-                body,
-                headers: {
-                    "Content-Type": "application/json; charset=utf-8",
-                },
-                authRequired: true,
-            });
-        });
-        it("should not override explicit Content-Type header", async () => {
-            const sdk = createTestSdk();
-            const body = '{"key": "value"}';
-            await sdk.fetch("https://api.example.com/data", {
-                method: "POST",
-                body,
-                headers: {
-                    "Content-Type": "text/plain",
-                },
-            });
-            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/data", {
-                method: "POST",
-                body,
-                headers: {
-                    "Content-Type": "text/plain",
-                },
-                authRequired: true,
-            });
-        });
-        it("should not set Content-Type for non-JSON bodies", async () => {
-            const sdk = createTestSdk();
-            const body = "plain text body";
-            await sdk.fetch("https://api.example.com/data", {
-                method: "POST",
-                body,
-            });
-            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/data", {
-                method: "POST",
-                body,
-                headers: {},
-                authRequired: true,
-            });
-        });
-        it("should not set Content-Type for FormData bodies", async () => {
-            const sdk = createTestSdk();
-            const body = new FormData();
-            body.append("file", "contents");
-            await sdk.fetch("https://api.example.com/upload", {
-                method: "POST",
-                body,
-            });
-            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/upload", {
-                method: "POST",
-                body,
-                headers: {},
-                authRequired: true,
-            });
-        });
-        it("should set Content-Type for URLSearchParams bodies", async () => {
-            const sdk = createTestSdk();
-            const body = new URLSearchParams({ key: "value", foo: "bar" });
-            await sdk.fetch("https://api.example.com/form", {
-                method: "POST",
-                body,
-            });
-            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/form", {
-                method: "POST",
-                body,
-                headers: {
-                    "Content-Type": "application/x-www-form-urlencoded; charset=utf-8",
-                },
-                authRequired: true,
-            });
-        });
-        it("should not set Content-Type for invalid JSON-like strings", async () => {
-            const sdk = createTestSdk();
-            const body = "{ this is not json";
-            await sdk.fetch("https://api.example.com/data", {
-                method: "POST",
-                body,
-            });
-            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/data", {
-                method: "POST",
-                body,
-                headers: {},
-                authRequired: true,
-            });
-        });
-        it("should auto-set Content-Type for plain object bodies", async () => {
-            const sdk = createTestSdk();
-            const body = { channel: "C0123456789", text: "Hello, world!" };
-            await sdk.fetch("https://api.example.com/data", {
-                method: "POST",
-                body: body,
-            });
-            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/data", {
-                method: "POST",
-                body,
-                headers: {
-                    "Content-Type": "application/json; charset=utf-8",
-                },
-                authRequired: true,
-            });
-        });
-        it("should auto-set Content-Type for plain array bodies", async () => {
-            const sdk = createTestSdk();
-            const body = [{ id: 1 }, { id: 2 }];
-            await sdk.fetch("https://api.example.com/data", {
-                method: "POST",
-                body: body,
-            });
-            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/data", {
-                method: "POST",
-                body,
-                headers: {
-                    "Content-Type": "application/json; charset=utf-8",
-                },
-                authRequired: true,
-            });
-        });
-        it("should not set Content-Type for Blob bodies", async () => {
-            const sdk = createTestSdk();
-            const body = new Blob(["binary data"], {
-                type: "application/octet-stream",
-            });
-            await sdk.fetch("https://api.example.com/upload", {
-                method: "POST",
-                body,
-            });
-            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/upload", {
-                method: "POST",
-                body,
-                headers: {},
-                authRequired: true,
-            });
-        });
-    });
-    describe("authentication", () => {
-        it("should set authRequired to true in API call options", async () => {
-            const sdk = createTestSdk();
-            await sdk.fetch("https://api.example.com/data");
-            expect(mockFetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
-                authRequired: true,
-            }));
-        });
-    });
-    describe("response handling", () => {
-        it("should return the response from api.fetch", async () => {
-            const mockResponse = new Response('{"result": "success"}', {
-                status: 200,
-                statusText: "OK",
-                headers: { "Content-Type": "application/json" },
-            });
-            mockFetch.mockResolvedValue(mockResponse);
-            const sdk = createTestSdk();
-            const response = await sdk.fetch("https://api.example.com/data");
-            expect(response).toBe(mockResponse);
-            expect(response.status).toBe(200);
-        });
-        it("should handle API errors", async () => {
-            const error = new Error("Network error");
-            mockFetch.mockRejectedValue(error);
-            const sdk = createTestSdk();
-            await expect(sdk.fetch("https://api.example.com/data")).rejects.toThrow("Network error");
-        });
-    });
-    describe("relay errors", () => {
-        it("should throw ZapierRelayError with the x-relay-error header message", async () => {
-            const friendlyMessage = "Ashby does not support direct HTTP requests. Use zapier.apps.{appKey} or zapier.runAction() to use Actions built for this app.";
-            mockFetch.mockResolvedValue(new Response("", {
-                status: 404,
-                headers: { "x-relay-error": friendlyMessage },
-            }));
-            const sdk = createTestSdk();
-            const error = await sdk
-                .fetch("https://api.example.com/data")
-                .catch((e) => e);
-            expect(error).toBeInstanceOf(ZapierRelayError);
-            expect(error.message).toBe(friendlyMessage);
-            expect(error.statusCode).toBe(404);
-        });
-        it("should throw ZapierRelayError for non-matching x-relay-error", async () => {
-            mockFetch.mockResolvedValue(new Response("", {
-                status: 404,
-                headers: { "x-relay-error": "Some other relay error" },
-            }));
-            const sdk = createTestSdk();
-            const error = await sdk
-                .fetch("https://api.example.com/data")
-                .catch((e) => e);
-            expect(error).toBeInstanceOf(ZapierRelayError);
-            expect(error.message).toBe("Some other relay error");
-        });
-        it("should throw ZapierRelayError regardless of status code", async () => {
-            mockFetch.mockResolvedValue(new Response("", {
-                status: 502,
-                headers: { "x-relay-error": "upstream timeout" },
-            }));
-            const sdk = createTestSdk();
-            const error = await sdk
-                .fetch("https://api.example.com/data")
-                .catch((e) => e);
-            expect(error).toBeInstanceOf(ZapierRelayError);
-            expect(error.statusCode).toBe(502);
-        });
-    });
-    describe("context and metadata", () => {
-        it("should provide context with meta information", () => {
-            const sdk = createTestSdk();
-            const context = sdk.getContext();
-            expect(context.meta.fetch).toBeDefined();
-            expect(context.meta.fetch.inputParameters).toBeDefined();
-            expect(context.meta.fetch.inputParameters).toHaveLength(2);
-        });
-        it("should include cli and mcp in packages", () => {
-            const sdk = createTestSdk();
-            const context = sdk.getContext();
-            expect(context.meta.fetch.packages).toContain("cli");
-            expect(context.meta.fetch.packages).toContain("mcp");
-            expect(context.meta.fetch.packages).toContain("sdk");
-        });
-        it("should be in the http category", () => {
-            const sdk = createTestSdk();
-            const context = sdk.getContext();
-            expect(context.meta.fetch.categories).toContain("http");
-        });
-    });
-});

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

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

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

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