@zapier/zapier-sdk 0.33.0 → 0.33.2

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

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

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

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

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

@@ -1,458 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { ZapierValidationError } from "../../types/errors";
-import { requestPlugin } from "./index";
-import { fetchPlugin } from "../fetch";
-import { createSdk } from "../../sdk";
-import { eventEmissionPlugin, } from "../eventEmission";
-import { resetDeprecationWarnings } from "../../utils/logging";
-describe("request 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)
-            .addPlugin(requestPlugin);
-    }
-    describe("schema validation", () => {
-        it("should throw validation error for missing url", async () => {
-            const sdk = createTestSdk();
-            await expect(sdk.request({})).rejects.toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for invalid url", async () => {
-            const sdk = createTestSdk();
-            await expect(sdk.request({ url: "not-a-url" })).rejects.toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for invalid method", async () => {
-            const sdk = createTestSdk();
-            await expect(sdk.request({
-                url: "https://api.example.com/data",
-                method: "INVALID",
-            })).rejects.toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for invalid authenticationId type", async () => {
-            const sdk = createTestSdk();
-            await expect(sdk.request({
-                url: "https://api.example.com/data",
-                authenticationId: "not-a-number",
-            })).rejects.toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for invalid callbackUrl", async () => {
-            const sdk = createTestSdk();
-            await expect(sdk.request({
-                url: "https://api.example.com/data",
-                callbackUrl: "not-a-url",
-            })).rejects.toThrow(ZapierValidationError);
-        });
-        it("should pass validation with valid minimal options", async () => {
-            const sdk = createTestSdk();
-            await sdk.request({ url: "https://api.example.com/data" });
-            expect(mockFetch).toHaveBeenCalled();
-        });
-        it("should pass validation with all valid options", async () => {
-            const sdk = createTestSdk();
-            await sdk.request({
-                url: "https://api.example.com/data",
-                method: "POST",
-                body: '{"test": true}',
-                headers: { "Content-Type": "application/json" },
-                authenticationId: 123,
-                callbackUrl: "https://webhook.example.com/callback",
-            });
-            expect(mockFetch).toHaveBeenCalled();
-        });
-    });
-    describe("URL transformation", () => {
-        it("should transform full URLs to relay path format", async () => {
-            const sdk = createTestSdk();
-            await sdk.request({
-                url: "https://api.github.com/user",
-                method: "GET",
-            });
-            expect(mockFetch).toHaveBeenCalledWith("/relay/api.github.com/user", expect.any(Object));
-        });
-        it("should preserve query parameters and fragments", async () => {
-            const sdk = createTestSdk();
-            await sdk.request({
-                url: "https://api.example.com/search?q=test&limit=10#section",
-                method: "GET",
-            });
-            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.request({
-                url: "https://api.example.com:8443/data",
-                method: "GET",
-            });
-            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com:8443/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.request({
-                url: "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.request({
-                url: "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.request({
-                url: "https://api.example.com/data",
-                headers,
-            });
-            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/data", {
-                method: "GET",
-                body: undefined,
-                headers: {
-                    "content-type": "application/json", // Headers constructor lowercases names
-                    authorization: "Bearer token", // Headers constructor lowercases names
-                },
-                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.request({
-                url: "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.request({
-                    url: "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.request({
-                url: "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.request({
-                url: "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.request({
-                url: "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.request({
-                url: "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.request({
-                url: "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.request({
-                url: "https://api.example.com/data",
-                method: "POST",
-                body,
-            });
-            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/data", {
-                method: "POST",
-                body,
-                headers: {},
-                authRequired: true,
-            });
-        });
-    });
-    describe("authentication", () => {
-        it("should set authRequired to true in API call options", async () => {
-            const sdk = createTestSdk();
-            await sdk.request({ url: "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.request({
-                url: "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.request({ url: "https://api.example.com/data" })).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.request).toBeDefined();
-            expect(context.meta.request.inputSchema).toBeDefined();
-        });
-        it("should be in both cli and mcp packages for backward compat", () => {
-            const sdk = createTestSdk();
-            const context = sdk.getContext();
-            expect(context.meta.request.packages).toContain("cli");
-            expect(context.meta.request.packages).toContain("mcp");
-        });
-        it("should be marked as deprecated", () => {
-            const sdk = createTestSdk();
-            const context = sdk.getContext();
-            expect(context.meta.request.categories).toContain("deprecated");
-            expect(context.meta.request.categories).toContain("http");
-        });
-    });
-    describe("deprecation warning", () => {
-        let warnSpy;
-        beforeEach(() => {
-            resetDeprecationWarnings();
-            warnSpy = vi.spyOn(console, "warn").mockImplementation(() => { });
-        });
-        afterEach(() => {
-            warnSpy.mockRestore();
-        });
-        it("should log a deprecation warning when called", async () => {
-            const sdk = createTestSdk();
-            await sdk.request({ url: "https://api.example.com/data" });
-            expect(warnSpy).toHaveBeenCalledWith("[zapier-sdk] Deprecation: request() is deprecated. Use fetch() instead.");
-        });
-        it("should only log the deprecation warning once", async () => {
-            const sdk = createTestSdk();
-            await sdk.request({ url: "https://api.example.com/data" });
-            await sdk.request({ url: "https://api.example.com/other" });
-            const deprecationCalls = warnSpy.mock.calls.filter((call) => typeof call[0] === "string" && call[0].includes("Deprecation"));
-            expect(deprecationCalls).toHaveLength(1);
-        });
-    });
-    describe("backward compatibility with fetch", () => {
-        it("should produce the same api.fetch call as sdk.fetch for a simple GET", async () => {
-            const sdk = createTestSdk();
-            await sdk.request({ url: "https://api.example.com/data" });
-            const requestCall = mockFetch.mock.calls[0];
-            mockFetch.mockClear();
-            await sdk.fetch("https://api.example.com/data");
-            const fetchCall = mockFetch.mock.calls[0];
-            expect(requestCall).toEqual(fetchCall);
-        });
-        it("should produce the same api.fetch call as sdk.fetch for a POST with body and auth", async () => {
-            const sdk = createTestSdk();
-            const body = '{"key": "value"}';
-            await sdk.request({
-                url: "https://api.example.com/data",
-                method: "POST",
-                body,
-                headers: { "X-Custom": "header" },
-                authenticationId: 456,
-                callbackUrl: "https://callback.example.com/hook",
-            });
-            const requestCall = mockFetch.mock.calls[0];
-            mockFetch.mockClear();
-            await sdk.fetch("https://api.example.com/data", {
-                method: "POST",
-                body,
-                headers: { "X-Custom": "header" },
-                authenticationId: 456,
-                callbackUrl: "https://callback.example.com/hook",
-            });
-            const fetchCall = mockFetch.mock.calls[0];
-            expect(requestCall).toEqual(fetchCall);
-        });
-        it("should propagate errors from fetch through request", async () => {
-            const error = new Error("Network error");
-            mockFetch.mockRejectedValue(error);
-            const sdk = createTestSdk();
-            await expect(sdk.request({ url: "https://api.example.com/data" })).rejects.toThrow("Network error");
-        });
-        it("should not emit double telemetry when request delegates to fetch", async () => {
-            const emitSpy = vi.fn();
-            const mockEventEmissionPlugin = () => ({
-                context: {
-                    eventEmission: {
-                        transport: {},
-                        config: {},
-                        emit: () => { },
-                        createBaseEvent: (() => ({})),
-                        emitMethodCalled: emitSpy,
-                        flush: async () => { },
-                        close: async () => { },
-                    },
-                },
-            });
-            const sdk = createSdk()
-                .addPlugin(() => ({
-                context: { options: {} },
-            }))
-                .addPlugin(apiPlugin)
-                .addPlugin(mockEventEmissionPlugin)
-                .addPlugin(fetchPlugin)
-                .addPlugin(requestPlugin);
-            await sdk.request({ url: "https://api.example.com/data" });
-            const methodCalledEvents = emitSpy.mock.calls.map((c) => c[0].method_name);
-            expect(methodCalledEvents).toEqual(["request"]);
-        });
-    });
-});

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

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

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

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