@zapier/zapier-sdk 0.15.1 → 0.15.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @zapier/zapier-sdk
 
+## 0.15.2
+
+### Patch Changes
+
+- e4a3457: Extract listApps API and schemas
+
 ## 0.15.1
 
 ### Patch Changes

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

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/api/client.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,SAAS,EACT,gBAAgB,EAGjB,MAAM,SAAS,CAAC;AAwejB,eAAO,MAAM,eAAe,GAAI,SAAS,gBAAgB,KAAG,SAW3D,CAAC"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/api/client.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,SAAS,EACT,gBAAgB,EAGjB,MAAM,SAAS,CAAC;AA2hBjB,eAAO,MAAM,eAAe,GAAI,SAAS,gBAAgB,KAAG,SAW3D,CAAC"}

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

@@ -0,0 +1,5 @@
+/**
+ * Integration tests for API client handler override mechanism
+ */
+export {};
+//# sourceMappingURL=client.integration.test.d.ts.map

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

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

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

@@ -0,0 +1,318 @@
+/**
+ * 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.js

@@ -10,6 +10,8 @@ import { pollUntilComplete } from "./polling";
 import { getTokenFromEnvOrConfig } from "../auth";
 import { getZapierBaseUrl } from "../utils/url-utils";
 import { ZapierApiError, ZapierAuthenticationError, ZapierValidationError, ZapierNotFoundError, } from "../types/errors";
+import { handleListApps } from "../temporary-internal-core";
+// Configuration for paths
 const pathConfig = {
     // e.g. /relay -> https://sdkapi.zapier.com/api/v0/sdk/relay/...
     "/relay": {
@@ -21,6 +23,9 @@ const pathConfig = {
         authHeader: "Authorization",
         pathPrefix: "/api/v0/sdk/zapier",
     },
+    "/api/v0/apps": {
+        handlerOverride: handleListApps,
+    },
 };
 class ZapierApiClient {
     constructor(options) {
@@ -195,6 +200,16 @@ class ZapierApiClient {
         }
         return undefined;
     }
+    // Helper to check if a path config has a handler override
+    hasHandlerOverride(pathConfig) {
+        return (pathConfig !== undefined &&
+            "handlerOverride" in pathConfig &&
+            typeof pathConfig.handlerOverride === "function");
+    }
+    // Helper to check if a path config is a standard path config
+    isStandardPathConfig(pathConfig) {
+        return pathConfig !== undefined && !this.hasHandlerOverride(pathConfig);
+    }
     // Helper to parse API error response
     parseErrorResponse(errorInfo) {
         // If we can't parse data, use status text
@@ -284,7 +299,9 @@ class ZapierApiClient {
         // session!
         const authToken = await this.getAuthToken();
         if (authToken) {
-            const authHeaderName = pathConfig?.authHeader || "Authorization";
+            const authHeaderName = this.isStandardPathConfig(pathConfig) && pathConfig.authHeader
+                ? pathConfig.authHeader
+                : "Authorization";
             headers.set(authHeaderName, getAuthorizationHeader(authToken));
         }
         // If we know auth is required, and we don't have a token, throw an error
@@ -298,6 +315,19 @@ class ZapierApiClient {
     }
     // Helper to perform HTTP requests with JSON handling
     async fetchJson(method, path, data, options = {}) {
+        // Check if this path has a handler override
+        const { pathConfig } = this.buildUrl(path, options.searchParams);
+        if (this.hasHandlerOverride(pathConfig)) {
+            // Invoke the handler instead of making an HTTP request
+            // Pass searchParams for GET requests, data for other methods
+            const handlerRequest = method === "GET" ? options.searchParams : data;
+            return pathConfig.handlerOverride({
+                request: handlerRequest,
+                deps: {
+                    httpClient: this,
+                },
+            });
+        }
         const headers = { ...options.headers };
         // Add Content-Type for JSON requests with body data
         if (data && typeof data === "object") {