@zapier/zapier-sdk 0.18.3 → 1.0.0

package/dist/api/client.integration.test.js

@@ -1,318 +0,0 @@
-/**
- * Integration tests for API client handler override mechanism
- */
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { createZapierApi } from "./client";
-describe("Handler Override Mechanism Integration", () => {
-    let mockFetch;
-    beforeEach(() => {
-        mockFetch = vi.fn();
-    });
-    describe("listApps handler override", () => {
-        it("should invoke handler instead of making HTTP request to /api/v0/apps", async () => {
-            // Mock the nested API call that the handler makes
-            mockFetch.mockResolvedValueOnce({
-                ok: true,
-                status: 200,
-                json: async () => ({
-                    results: [
-                        {
-                            api: "slack",
-                            name: "Slack",
-                            id: "SlackAPI@1.0.0",
-                            logo_url: "https://example.com/slack.png",
-                            categories: ["communication"],
-                        },
-                    ],
-                    next: null,
-                }),
-            });
-            const api = createZapierApi({
-                fetch: mockFetch,
-                token: "test-token",
-                baseUrl: "https://api.zapier.com",
-            });
-            // Call the path with handler override
-            const result = await api.get("/api/v0/apps", {
-                searchParams: { implementationIds: "SlackAPI@1.0.0" },
-            });
-            // Assert: No direct call to /api/v0/apps (handler intercepted it)
-            const fetchCalls = mockFetch.mock.calls;
-            const appsEndpointCalls = fetchCalls.filter((call) => typeof call[0] === "string" && call[0].includes("/api/v0/apps"));
-            expect(appsEndpointCalls).toHaveLength(0);
-            // Assert: Handler made nested call to lookup endpoint
-            const lookupCalls = fetchCalls.filter((call) => typeof call[0] === "string" &&
-                call[0].includes("/zapier/api/v4/implementations-meta/lookup/"));
-            expect(lookupCalls.length).toBeGreaterThan(0);
-            // Assert: Result has correct structure from handler
-            expect(result).toHaveProperty("data");
-            expect(result).toHaveProperty("nextCursor");
-            expect(Array.isArray(result.data)).toBe(true);
-            expect(result.data).toHaveLength(1);
-            expect(result.data[0]).toMatchObject({
-                key: "SlackAPI",
-                title: "Slack",
-                implementation_id: "SlackAPI@1.0.0",
-            });
-        });
-        it("should pass httpClient to handler for nested API calls", async () => {
-            // Mock response for the nested lookup call
-            mockFetch.mockResolvedValueOnce({
-                ok: true,
-                status: 200,
-                json: async () => ({
-                    results: [
-                        {
-                            api: "github",
-                            name: "GitHub",
-                            id: "GitHubAPI@2.1.0",
-                            logo_url: "https://example.com/github.png",
-                            categories: ["developer-tools"],
-                        },
-                    ],
-                    next: null,
-                }),
-            });
-            const api = createZapierApi({
-                fetch: mockFetch,
-                token: "test-token",
-                baseUrl: "https://api.zapier.com",
-            });
-            // Request with multiple implementation IDs
-            await api.get("/api/v0/apps", {
-                searchParams: {
-                    implementationIds: "GitHubAPI@2.1.0,SlackAPI@1.0.0",
-                },
-            });
-            // Verify that nested API call was made
-            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining("/zapier/api/v4/implementations-meta/lookup/"), expect.any(Object));
-            // Verify the request includes proper configuration
-            const fetchCall = mockFetch.mock.calls[0];
-            expect(fetchCall[0]).toContain("selected_apis=GitHubAPI%402.1.0%2CSlackAPI%401.0.0");
-            expect(fetchCall[1]).toHaveProperty("method", "GET");
-        });
-        it("should handle search augmentation through handler", async () => {
-            // Mock search endpoint response
-            mockFetch
-                .mockResolvedValueOnce({
-                ok: true,
-                status: 200,
-                json: async () => ({
-                    results: [
-                        {
-                            api: "gmail",
-                            name: "Gmail",
-                            id: "GmailAPI@1.5.0",
-                            logo_url: "https://example.com/gmail.png",
-                            categories: ["email"],
-                        },
-                    ],
-                    next: null,
-                }),
-            })
-                // Mock lookup endpoint response
-                .mockResolvedValueOnce({
-                ok: true,
-                status: 200,
-                json: async () => ({
-                    results: [
-                        {
-                            api: "slack",
-                            name: "Slack",
-                            id: "SlackAPI@1.0.0",
-                            logo_url: "https://example.com/slack.png",
-                            categories: ["communication"],
-                        },
-                        {
-                            api: "gmail",
-                            name: "Gmail",
-                            id: "GmailAPI@1.5.0",
-                            logo_url: "https://example.com/gmail.png",
-                            categories: ["email"],
-                        },
-                    ],
-                    next: null,
-                }),
-            });
-            const api = createZapierApi({
-                fetch: mockFetch,
-                token: "test-token",
-                baseUrl: "https://api.zapier.com",
-            });
-            // Request with search term and specific implementation
-            const result = await api.get("/api/v0/apps", {
-                searchParams: {
-                    implementationIds: "SlackAPI@1.0.0",
-                    search: "email",
-                },
-            });
-            // Verify search endpoint was called
-            const searchCalls = mockFetch.mock.calls.filter((call) => typeof call[0] === "string" &&
-                call[0].includes("/zapier/api/v4/implementations-meta/search/"));
-            expect(searchCalls.length).toBeGreaterThan(0);
-            // Verify lookup endpoint was called with augmented IDs
-            const lookupCalls = mockFetch.mock.calls.filter((call) => typeof call[0] === "string" &&
-                call[0].includes("/zapier/api/v4/implementations-meta/lookup/"));
-            expect(lookupCalls.length).toBeGreaterThan(0);
-            // Verify result contains both original and search results
-            expect(result.data).toHaveLength(2);
-        });
-        it("should handle pagination through handler", async () => {
-            // Mock first page response
-            mockFetch.mockResolvedValueOnce({
-                ok: true,
-                status: 200,
-                json: async () => ({
-                    results: [
-                        {
-                            api: "app1",
-                            name: "App 1",
-                            id: "App1API@1.0.0",
-                            logo_url: "https://example.com/app1.png",
-                            categories: ["productivity"],
-                        },
-                    ],
-                    next: "https://example.com/api?offset=20",
-                }),
-            });
-            const api = createZapierApi({
-                fetch: mockFetch,
-                token: "test-token",
-                baseUrl: "https://api.zapier.com",
-            });
-            const result = await api.get("/api/v0/apps", {
-                searchParams: { pageSize: "10" },
-            });
-            // Verify pagination cursor is extracted
-            expect(result.nextCursor).toBe("20");
-            // Mock second page response
-            mockFetch.mockResolvedValueOnce({
-                ok: true,
-                status: 200,
-                json: async () => ({
-                    results: [
-                        {
-                            api: "app2",
-                            name: "App 2",
-                            id: "App2API@1.0.0",
-                            logo_url: "https://example.com/app2.png",
-                            categories: ["productivity"],
-                        },
-                    ],
-                    next: null,
-                }),
-            });
-            // Request second page
-            const secondPageResult = await api.get("/api/v0/apps", {
-                searchParams: { cursor: "20" },
-            });
-            expect(secondPageResult.nextCursor).toBeUndefined();
-        });
-        it("should handle errors from handler correctly", async () => {
-            // Mock an error response from nested API call
-            mockFetch.mockResolvedValueOnce({
-                ok: false,
-                status: 404,
-                statusText: "Not Found",
-                json: async () => ({
-                    errors: [
-                        {
-                            message: "Implementation not found",
-                        },
-                    ],
-                }),
-            });
-            const api = createZapierApi({
-                fetch: mockFetch,
-                token: "test-token",
-                baseUrl: "https://api.zapier.com",
-            });
-            // Request should propagate the error from handler
-            await expect(api.get("/api/v0/apps", {
-                searchParams: { implementationIds: "NonExistentAPI" },
-            })).rejects.toThrow();
-        });
-        it("should handle empty search results correctly", async () => {
-            // Mock empty search response
-            mockFetch.mockResolvedValueOnce({
-                ok: true,
-                status: 200,
-                json: async () => ({
-                    results: [],
-                    next: null,
-                }),
-            });
-            const api = createZapierApi({
-                fetch: mockFetch,
-                token: "test-token",
-                baseUrl: "https://api.zapier.com",
-            });
-            const result = await api.get("/api/v0/apps", {
-                searchParams: {
-                    implementationIds: "",
-                    search: "nonexistentapp",
-                },
-            });
-            // Should return empty results without calling lookup endpoint
-            expect(result.data).toEqual([]);
-            expect(result.nextCursor).toBeUndefined();
-            // Verify only search endpoint was called, not lookup
-            const lookupCalls = mockFetch.mock.calls.filter((call) => typeof call[0] === "string" &&
-                call[0].includes("/zapier/api/v4/implementations-meta/lookup/"));
-            expect(lookupCalls).toHaveLength(0);
-        });
-    });
-    describe("standard path handling (non-override)", () => {
-        it("should make normal HTTP requests for paths without handler override", async () => {
-            mockFetch.mockResolvedValueOnce({
-                ok: true,
-                status: 200,
-                json: async () => ({ result: "direct HTTP response" }),
-            });
-            const api = createZapierApi({
-                fetch: mockFetch,
-                token: "test-token",
-                baseUrl: "https://api.zapier.com",
-            });
-            // Request to a path without handler override
-            await api.get("/zapier/some-other-endpoint");
-            // Verify HTTP request was made directly
-            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining("/zapier/some-other-endpoint"), expect.any(Object));
-        });
-    });
-    describe("handler override type safety", () => {
-        it("should handle handler request transformation correctly", async () => {
-            // Mock response for lookup
-            mockFetch.mockResolvedValueOnce({
-                ok: true,
-                status: 200,
-                json: async () => ({
-                    results: [],
-                    next: null,
-                }),
-            });
-            const api = createZapierApi({
-                fetch: mockFetch,
-                token: "test-token",
-                baseUrl: "https://api.zapier.com",
-            });
-            // Test that string implementationIds are properly handled
-            const result = await api.get("/api/v0/apps", {
-                searchParams: {
-                    implementationIds: "App1,App2,App3",
-                    pageSize: "15",
-                },
-            });
-            // Verify the handler received and processed the request
-            expect(result).toHaveProperty("data");
-            expect(Array.isArray(result.data)).toBe(true);
-            // Check that lookup endpoint was called with proper params
-            const lookupCall = mockFetch.mock.calls.find((call) => typeof call[0] === "string" &&
-                call[0].includes("/zapier/api/v4/implementations-meta/lookup/"));
-            expect(lookupCall).toBeDefined();
-            // Commas are URL-encoded as %2C
-            expect(lookupCall[0]).toContain("selected_apis=App1%2CApp2%2CApp3");
-            expect(lookupCall[0]).toContain("limit=15");
-        });
-    });
-});

package/dist/api/client.methods.test.d.ts

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

package/dist/api/client.methods.test.d.ts.map

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

package/dist/api/client.methods.test.js

@@ -1,158 +0,0 @@
-import { describe, it, expect, vi, beforeEach, } from "vitest";
-import { createZapierApi } from "./client";
-import * as router from "./router";
-vi.mock("./router");
-describe("ZapierApiClient Methods & Routing", () => {
-    let mockFetch;
-    let mockMatchRoute;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockFetch = vi.fn();
-        mockMatchRoute = vi.mocked(router.matchRoute);
-        // Default fetch implementation
-        mockFetch.mockResolvedValue({
-            ok: true,
-            status: 200,
-            json: async () => ({ data: "default-response" }),
-        });
-    });
-    const createClient = () => createZapierApi({
-        baseUrl: "https://api.zapier.com",
-        token: "test-token",
-        fetch: mockFetch,
-    });
-    describe("GET requests", () => {
-        it("should route GET requests to handler when matched", async () => {
-            const client = createClient();
-            const mockHandler = vi.fn().mockResolvedValue({ id: 1, name: "Test" });
-            mockMatchRoute.mockReturnValue({
-                handler: mockHandler,
-                params: { id: "123" },
-            });
-            const result = await client.get("/api/resource/123", {
-                searchParams: { include: "details" },
-            });
-            expect(mockMatchRoute).toHaveBeenCalledWith("GET", "/api/resource/123");
-            expect(mockHandler).toHaveBeenCalledWith({
-                request: {
-                    id: "123",
-                    include: "details",
-                },
-                deps: expect.objectContaining({
-                    httpClient: expect.any(Object),
-                }),
-            });
-            expect(result).toEqual({ id: 1, name: "Test" });
-            expect(mockFetch).not.toHaveBeenCalled();
-        });
-        it("should fallback to plain fetch when no route matches", async () => {
-            const client = createClient();
-            mockMatchRoute.mockReturnValue(null);
-            await client.get("/api/unknown");
-            expect(mockMatchRoute).toHaveBeenCalledWith("GET", "/api/unknown");
-            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining("/api/unknown"), expect.objectContaining({
-                method: "GET",
-            }));
-        });
-    });
-    describe("POST requests", () => {
-        it("should route POST requests to handler with body", async () => {
-            const client = createClient();
-            const mockHandler = vi.fn().mockResolvedValue({ success: true });
-            const body = { name: "New Item" };
-            mockMatchRoute.mockReturnValue({
-                handler: mockHandler,
-                params: {},
-            });
-            await client.post("/api/resource", body);
-            expect(mockMatchRoute).toHaveBeenCalledWith("POST", "/api/resource");
-            expect(mockHandler).toHaveBeenCalledWith({
-                request: {
-                    name: "New Item",
-                },
-                deps: expect.objectContaining({
-                    httpClient: expect.any(Object),
-                }),
-            });
-            expect(mockFetch).not.toHaveBeenCalled();
-        });
-        it("should merge body, params, and query params for handler", async () => {
-            const client = createClient();
-            const mockHandler = vi.fn().mockResolvedValue({ success: true });
-            const body = { name: "Updated Item" };
-            mockMatchRoute.mockReturnValue({
-                handler: mockHandler,
-                params: { id: "456" },
-            });
-            await client.post("/api/resource/456", body, {
-                searchParams: { version: "2" },
-            });
-            expect(mockHandler).toHaveBeenCalledWith({
-                request: {
-                    name: "Updated Item", // from body
-                    id: "456", // from route params
-                    version: "2", // from query params
-                },
-                deps: expect.any(Object),
-            });
-        });
-    });
-    describe("PUT requests", () => {
-        it("should route PUT requests to handler", async () => {
-            const client = createClient();
-            const mockHandler = vi.fn().mockResolvedValue({ updated: true });
-            const body = { status: "active" };
-            mockMatchRoute.mockReturnValue({
-                handler: mockHandler,
-                params: { id: "789" },
-            });
-            await client.put("/api/resource/789", body);
-            expect(mockMatchRoute).toHaveBeenCalledWith("PUT", "/api/resource/789");
-            expect(mockHandler).toHaveBeenCalledWith({
-                request: {
-                    status: "active",
-                    id: "789",
-                },
-                deps: expect.any(Object),
-            });
-        });
-    });
-    describe("DELETE requests", () => {
-        it("should route DELETE requests to handler", async () => {
-            const client = createClient();
-            const mockHandler = vi.fn().mockResolvedValue({ deleted: true });
-            mockMatchRoute.mockReturnValue({
-                handler: mockHandler,
-                params: { id: "999" },
-            });
-            await client.delete("/api/resource/999");
-            expect(mockMatchRoute).toHaveBeenCalledWith("DELETE", "/api/resource/999");
-            expect(mockHandler).toHaveBeenCalledWith({
-                request: {
-                    id: "999",
-                },
-                deps: expect.any(Object),
-            });
-        });
-    });
-    describe("Header handling", () => {
-        it("should pass headers to plain fetch but NOT to handler request object (by default)", async () => {
-            const client = createClient();
-            const mockHandler = vi.fn().mockResolvedValue({});
-            mockMatchRoute.mockReturnValue({
-                handler: mockHandler,
-                params: {},
-            });
-            await client.get("/api/test", {
-                headers: { "X-Custom": "Value" },
-            });
-            // The handler request object only includes params/body, not headers
-            // based on client.ts implementation:
-            // const handlerRequest = { ...data, ...options.searchParams, ...routeMatch.params };
-            expect(mockHandler).toHaveBeenCalledWith({
-                request: {},
-                deps: expect.any(Object),
-            });
-        });
-    });
-});

package/dist/api/router.d.ts

@@ -1,16 +0,0 @@
-import { type Handler } from "../temporary-internal-core";
-export interface Route {
-    method: string;
-    pattern: RegExp;
-    handler: Handler<any, any, any>;
-    paramMap: string[];
-}
-export declare function findMatchingRoute(routeList: Route[], method: string, path: string): {
-    handler: Handler<any, any, any>;
-    params: Record<string, string>;
-} | null;
-export declare function matchRoute(method: string, path: string): {
-    handler: Handler<any, any, any>;
-    params: Record<string, string>;
-} | null;
-//# sourceMappingURL=router.d.ts.map

package/dist/api/router.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../src/api/router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,OAAO,EAAE,MAAM,4BAA4B,CAAC;AAE1E,MAAM,WAAW,KAAK;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;IAChC,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAWD,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,KAAK,EAAE,EAClB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM;;;SAsBb;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;;;SAEtD"}

package/dist/api/router.js

@@ -1,31 +0,0 @@
-import { handleListApps } from "../temporary-internal-core";
-const routes = [
-    {
-        method: "GET",
-        pattern: /^\/api\/v0\/apps$/,
-        handler: handleListApps,
-        paramMap: [],
-    },
-];
-export function findMatchingRoute(routeList, method, path) {
-    for (const route of routeList) {
-        if (route.method !== method) {
-            continue;
-        }
-        const match = path.match(route.pattern);
-        if (match) {
-            const params = {};
-            route.paramMap.forEach((name, index) => {
-                params[name] = match[index + 1];
-            });
-            return {
-                handler: route.handler,
-                params,
-            };
-        }
-    }
-    return null;
-}
-export function matchRoute(method, path) {
-    return findMatchingRoute(routes, method, path);
-}

package/dist/api/router.test.d.ts

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

package/dist/api/router.test.d.ts.map

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

package/dist/api/router.test.js

@@ -1,103 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { matchRoute, findMatchingRoute } from "./router";
-import { handleListApps } from "../temporary-internal-core";
-describe("Router", () => {
-    describe("matchRoute (Integration)", () => {
-        it("should match GET /api/v0/apps", () => {
-            const match = matchRoute("GET", "/api/v0/apps");
-            expect(match).not.toBeNull();
-            expect(match?.handler).toBe(handleListApps);
-            expect(match?.params).toEqual({});
-        });
-        it("should not match POST /api/v0/apps", () => {
-            const match = matchRoute("POST", "/api/v0/apps");
-            expect(match).toBeNull();
-        });
-        it("should not match unknown paths", () => {
-            expect(matchRoute("GET", "/api/v0/unknown")).toBeNull();
-            expect(matchRoute("GET", "/")).toBeNull();
-        });
-        it("should not match partial paths if regex is anchored", () => {
-            // The regex is /^\/api\/v0\/apps$/ so it shouldn't match suffix
-            expect(matchRoute("GET", "/api/v0/apps/something")).toBeNull();
-        });
-    });
-    describe("findMatchingRoute (Unit)", () => {
-        const mockHandler = vi.fn();
-        const testRoutes = [
-            {
-                method: "GET",
-                pattern: /^\/items$/,
-                handler: mockHandler,
-                paramMap: [],
-            },
-            {
-                method: "GET",
-                pattern: /^\/items\/(\d+)$/,
-                handler: mockHandler,
-                paramMap: ["id"],
-            },
-            {
-                method: "POST",
-                pattern: /^\/items$/,
-                handler: mockHandler,
-                paramMap: [],
-            },
-            {
-                method: "GET",
-                pattern: /^\/users\/(\w+)\/posts\/(\d+)$/,
-                handler: mockHandler,
-                paramMap: ["userId", "postId"],
-            },
-        ];
-        it("should match exact path", () => {
-            const match = findMatchingRoute(testRoutes, "GET", "/items");
-            expect(match).not.toBeNull();
-            expect(match?.handler).toBe(mockHandler);
-            expect(match?.params).toEqual({});
-        });
-        it("should extract single parameter", () => {
-            const match = findMatchingRoute(testRoutes, "GET", "/items/123");
-            expect(match).not.toBeNull();
-            expect(match?.params).toEqual({ id: "123" });
-        });
-        it("should extract multiple parameters", () => {
-            const match = findMatchingRoute(testRoutes, "GET", "/users/alice/posts/456");
-            expect(match).not.toBeNull();
-            expect(match?.params).toEqual({ userId: "alice", postId: "456" });
-        });
-        it("should respect HTTP method", () => {
-            // GET /items exists
-            expect(findMatchingRoute(testRoutes, "GET", "/items")).not.toBeNull();
-            // POST /items exists
-            expect(findMatchingRoute(testRoutes, "POST", "/items")).not.toBeNull();
-            // PUT /items does not exist
-            expect(findMatchingRoute(testRoutes, "PUT", "/items")).toBeNull();
-        });
-        it("should not match if regex does not match", () => {
-            // /items/abc does not match /^\/items\/(\d+)$/ (\d+ is digits only)
-            expect(findMatchingRoute(testRoutes, "GET", "/items/abc")).toBeNull();
-        });
-        it("should handle empty route list", () => {
-            expect(findMatchingRoute([], "GET", "/anything")).toBeNull();
-        });
-        it("should return first matching route", () => {
-            const overlappingRoutes = [
-                {
-                    method: "GET",
-                    pattern: /^\/overlapping$/,
-                    handler: mockHandler,
-                    paramMap: [],
-                },
-                {
-                    method: "GET",
-                    pattern: /^\/overlapping$/, // duplicate pattern
-                    handler: () => Promise.resolve("second"),
-                    paramMap: [],
-                },
-            ];
-            const match = findMatchingRoute(overlappingRoutes, "GET", "/overlapping");
-            expect(match?.handler).toBe(mockHandler); // Should match the first one
-        });
-    });
-});