@zapier/zapier-sdk 0.15.0 → 0.15.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @zapier/zapier-sdk
 
+## 0.15.2
+
+### Patch Changes
+
+- e4a3457: Extract listApps API and schemas
+
+## 0.15.1
+
+### Patch Changes
+
+- 4c78fb0: Added `getInputFieldsSchema` plugin to retrieve JSON Schema for action inputs
+
 ## 0.15.0
 
 ### Minor Changes

package/README.md

@@ -9,6 +9,7 @@
   - [`getProfile`](#getprofile)
 - [Actions](#actions)
   - [`getAction`](#getaction)
+  - [`getInputFieldsSchema`](#getinputfieldsschema)
   - [`listActions`](#listactions)
   - [`listInputFieldChoices`](#listinputfieldchoices)
   - [`listInputFields`](#listinputfields)
@@ -256,6 +257,33 @@ const { data: action } = await sdk.getAction({
 });
 ```
 
+#### `getInputFieldsSchema`
+
+Get the JSON Schema representation of input fields for an action. Returns a JSON Schema object describing the structure, types, and validation rules for the action's input parameters.
+
+**Parameters:**
+
+| Name                 | Type     | Required | Default | Possible Values                                                                                | Description                                                                                                                   |
+| -------------------- | -------- | -------- | ------- | ---------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
+| `options`            | `object` | ✅       | —       | —                                                                                              |                                                                                                                               |
+| ↳ `appKey`           | `string` | ✅       | —       | —                                                                                              | App key (e.g., 'SlackCLIAPI' or slug like 'github') to get the input schema for                                               |
+| ↳ `actionType`       | `string` | ✅       | —       | `read`, `read_bulk`, `write`, `run`, `search`, `search_or_write`, `search_and_write`, `filter` | Action type that matches the action's defined type                                                                            |
+| ↳ `actionKey`        | `string` | ✅       | —       | —                                                                                              | Action key to get the input schema for                                                                                        |
+| ↳ `authenticationId` | `string` | ❌       | —       | —                                                                                              | Authentication ID to use when fetching the schema. Required if the action needs authentication to determine available fields. |
+| ↳ `inputs`           | `object` | ❌       | —       | —                                                                                              | Current input values that may affect the schema (e.g., when fields depend on other field values)                              |
+
+**Returns:** `Promise<InputSchemaItem>`
+
+**Example:**
+
+```typescript
+const { data: inputSchema } = await sdk.getInputFieldsSchema({
+  appKey: "example-key",
+  actionType: "read",
+  actionKey: "example-key",
+});
+```
+
 #### `listActions`
 
 List all actions for a specific app

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") {

package/dist/api/schemas.d.ts

@@ -972,6 +972,7 @@ export declare const NeedsResponseSchema: z.ZodObject<{
     }>, "many">>;
     errors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     last_fetched_at: z.ZodOptional<z.ZodString>;
+    schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, "strip", z.ZodTypeAny, {
     success: boolean;
     needs?: {
@@ -1008,6 +1009,7 @@ export declare const NeedsResponseSchema: z.ZodObject<{
     }[] | undefined;
     errors?: string[] | undefined;
     last_fetched_at?: string | undefined;
+    schema?: Record<string, unknown> | undefined;
 }, {
     success: boolean;
     needs?: {
@@ -1044,6 +1046,7 @@ export declare const NeedsResponseSchema: z.ZodObject<{
     }[] | undefined;
     errors?: string[] | undefined;
     last_fetched_at?: string | undefined;
+    schema?: Record<string, unknown> | undefined;
 }>;
 export declare const ImplementationSchema: z.ZodObject<{
     selected_api: z.ZodString;

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

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/api/schemas.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/api/schemas.ts"],"names":[],"mappings":"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"}

package/dist/api/schemas.js

@@ -272,6 +272,7 @@ export const NeedsResponseSchema = z.object({
     needs: z.array(NeedSchema).optional(),
     errors: z.array(z.string()).optional(),
     last_fetched_at: z.string().optional(),
+    schema: z.record(z.unknown()).optional(),
 });
 // ============================================================================
 // Implementation Schema