@zapier/zapier-sdk 0.4.1 → 0.5.1

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

@@ -0,0 +1,256 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ZapierValidationError } from "../../types/errors";
+import { requestPlugin } from "./index";
+import { createSdk } from "../../sdk";
+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,
+        };
+    });
+    function createTestSdk() {
+        return createSdk({}, { api: mockApiClient, meta: {} }).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",
+                authenticationTemplate: '{"token": "{{auth.token}}"}',
+            });
+            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",
+                },
+            });
+        });
+        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",
+                authenticationTemplate: '{"token": "{{auth.token}}"}',
+            });
+            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",
+                    "X-Authentication-Template": '{"token": "{{auth.token}}"}',
+                },
+            });
+        });
+        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
+                },
+            });
+        });
+        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",
+                },
+            });
+        });
+    });
+    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: {},
+                });
+            });
+        });
+        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: {},
+            });
+        });
+    });
+    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: {},
+            });
+        });
+    });
+    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();
+        });
+    });
+});

package/dist/plugins/request/schemas.d.ts

@@ -0,0 +1,69 @@
+import { z } from "zod";
+export declare const RelayRequestSchema: z.ZodObject<{
+    url: z.ZodString;
+    method: z.ZodOptional<z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]>>;
+    body: z.ZodOptional<z.ZodAny>;
+    authenticationId: z.ZodOptional<z.ZodNumber>;
+    callbackUrl: z.ZodOptional<z.ZodString>;
+    authenticationTemplate: z.ZodOptional<z.ZodString>;
+    headers: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodString>, z.ZodType<Headers, z.ZodTypeDef, Headers>, z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>, "many">]>>;
+} & {
+    relayBaseUrl: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS" | undefined;
+    body?: any;
+    authenticationId?: number | undefined;
+    callbackUrl?: string | undefined;
+    authenticationTemplate?: string | undefined;
+    headers?: Record<string, string> | [string, string][] | Headers | undefined;
+    relayBaseUrl?: string | undefined;
+}, {
+    url: string;
+    method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS" | undefined;
+    body?: any;
+    authenticationId?: number | undefined;
+    callbackUrl?: string | undefined;
+    authenticationTemplate?: string | undefined;
+    headers?: Record<string, string> | [string, string][] | Headers | undefined;
+    relayBaseUrl?: string | undefined;
+}>;
+export type RelayRequestOptions = z.infer<typeof RelayRequestSchema>;
+export type RelayRequestError = import("../../types/errors").ZapierApiError | import("../../types/errors").ZapierValidationError | import("../../types/errors").ZapierUnknownError;
+export interface RelayRequestSdkFunction {
+    request: (options: RelayRequestOptions) => Promise<Response>;
+}
+export declare const RelayFetchSchema: z.ZodObject<{
+    url: z.ZodString;
+    method: z.ZodOptional<z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]>>;
+    body: z.ZodOptional<z.ZodAny>;
+    authenticationId: z.ZodOptional<z.ZodNumber>;
+    callbackUrl: z.ZodOptional<z.ZodString>;
+    authenticationTemplate: z.ZodOptional<z.ZodString>;
+    headers: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodString>, z.ZodType<Headers, z.ZodTypeDef, Headers>, z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>, "many">]>>;
+} & {
+    relayBaseUrl: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS" | undefined;
+    body?: any;
+    authenticationId?: number | undefined;
+    callbackUrl?: string | undefined;
+    authenticationTemplate?: string | undefined;
+    headers?: Record<string, string> | [string, string][] | Headers | undefined;
+    relayBaseUrl?: string | undefined;
+}, {
+    url: string;
+    method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS" | undefined;
+    body?: any;
+    authenticationId?: number | undefined;
+    callbackUrl?: string | undefined;
+    authenticationTemplate?: string | undefined;
+    headers?: Record<string, string> | [string, string][] | Headers | undefined;
+    relayBaseUrl?: string | undefined;
+}>;
+export type RelayFetchOptions = RelayRequestOptions;
+export interface RelayFetchSdkFunction {
+    fetch: (options: RelayFetchOptions) => Promise<Response>;
+}
+//# sourceMappingURL=schemas.d.ts.map

package/dist/plugins/request/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/request/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuC+C,CAAC;AAG/E,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAGrE,MAAM,MAAM,iBAAiB,GACzB,OAAO,oBAAoB,EAAE,cAAc,GAC3C,OAAO,oBAAoB,EAAE,qBAAqB,GAClD,OAAO,oBAAoB,EAAE,kBAAkB,CAAC;AAGpD,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,CAAC,OAAO,EAAE,mBAAmB,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;CAC9D;AAGD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAqB,CAAC;AACnD,MAAM,MAAM,iBAAiB,GAAG,mBAAmB,CAAC;AACpD,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;CAC1D"}

package/dist/plugins/request/schemas.js

@@ -0,0 +1,42 @@
+import { z } from "zod";
+// Pure Zod schema for the request function
+export const RelayRequestSchema = z
+    .object({
+    url: z
+        .string()
+        .url()
+        .describe("The URL to request (will be proxied through Relay)"),
+    method: z
+        .enum(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
+        .optional()
+        .describe("HTTP method"),
+    body: z.any().optional().describe("Request body as a string"),
+    authenticationId: z
+        .number()
+        .int()
+        .optional()
+        .describe("Zapier authentication ID to use for the request"),
+    callbackUrl: z
+        .string()
+        .url()
+        .optional()
+        .describe("URL to send async response to (makes request async)"),
+    authenticationTemplate: z
+        .string()
+        .optional()
+        .describe("Optional JSON string authentication template to bypass Notary lookup"),
+    headers: z
+        .union([
+        z.record(z.string()),
+        z.instanceof(Headers),
+        z.array(z.tuple([z.string(), z.string()])),
+    ])
+        .optional()
+        .describe("Request headers"),
+})
+    .extend({
+    relayBaseUrl: z.string().optional().describe("Base URL for Relay service"),
+})
+    .describe("Make authenticated HTTP requests through Zapier's Relay service");
+// Legacy exports for compatibility
+export const RelayFetchSchema = RelayRequestSchema;

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

@@ -0,0 +1,28 @@
+import type { Plugin, GetSdkType } from "../../types/plugin";
+import type { ApiClient } from "../../api";
+import { RunActionSchema, type RunActionOptions } from "./schemas";
+import type { GetActionPluginProvides } from "../getAction";
+import type { GetAppPluginProvides } from "../getApp";
+export interface RunActionPluginProvides {
+    runAction: (options?: RunActionOptions) => Promise<{
+        data: any[];
+    }> & AsyncIterable<{
+        data: any[];
+        nextCursor?: string;
+    }> & {
+        items(): AsyncIterable<any>;
+    };
+    context: {
+        meta: {
+            runAction: {
+                inputSchema: typeof RunActionSchema;
+            };
+        };
+    };
+}
+export declare const runActionPlugin: Plugin<GetSdkType<GetActionPluginProvides & GetAppPluginProvides>, // requires getAction and getApp in SDK
+{
+    api: ApiClient;
+}, // requires api in context
+RunActionPluginProvides>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/runAction/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EACL,eAAe,EACf,KAAK,gBAAgB,EAEtB,MAAM,WAAW,CAAC;AAOnB,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAC5D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAEtD,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE,CAAC,OAAO,CAAC,EAAE,gBAAgB,KAAK,OAAO,CAAC;QAAE,IAAI,EAAE,GAAG,EAAE,CAAA;KAAE,CAAC,GACjE,aAAa,CAAC;QAAE,IAAI,EAAE,GAAG,EAAE,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG;QACpD,KAAK,IAAI,aAAa,CAAC,GAAG,CAAC,CAAC;KAC7B,CAAC;IACJ,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,SAAS,EAAE;gBACT,WAAW,EAAE,OAAO,eAAe,CAAC;aACrC,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAwED,eAAO,MAAM,eAAe,EAAE,MAAM,CAClC,UAAU,CAAC,uBAAuB,GAAG,oBAAoB,CAAC,EAAE,uCAAuC;AACnG;IAAE,GAAG,EAAE,SAAS,CAAA;CAAE,EAAE,0BAA0B;AAC9C,uBAAuB,CAwExB,CAAC"}

package/dist/plugins/runAction/index.js

@@ -0,0 +1,86 @@
+import { RunActionSchema, } from "./schemas";
+import { ZapierValidationError, ZapierConfigurationError, ZapierActionError, } from "../../types/errors";
+import { createPaginatedFunction } from "../../utils/function-utils";
+async function executeAction(actionOptions) {
+    const { api, sdk, appKey, actionKey, actionType, executionOptions, authenticationId, } = actionOptions;
+    // Use the getApp plugin to get the current implementation ID
+    const appData = await sdk.getApp({ appKey });
+    const selectedApi = appData.data.current_implementation_id;
+    if (!selectedApi) {
+        throw new ZapierConfigurationError("No current_implementation_id found for app", { configType: "current_implementation_id" });
+    }
+    // Step 1: POST to /actions/v1/runs to start execution
+    const runRequestData = {
+        selected_api: selectedApi,
+        action_key: actionKey,
+        action_type: actionType,
+        inputs: executionOptions.inputs || {},
+    };
+    // Only include authentication_id if it's provided
+    if (authenticationId !== null && authenticationId !== undefined) {
+        runRequestData.authentication_id = authenticationId;
+    }
+    const runRequest = {
+        data: runRequestData,
+    };
+    const runData = await api.post("/api/actions/v1/runs", runRequest);
+    const runId = runData.data.id;
+    // Step 2: Poll GET /actions/v1/runs/{run_id} for results
+    return await api.poll(`/api/actions/v1/runs/${runId}`, {
+        successStatus: 200,
+        pendingStatus: 202,
+        resultExtractor: (result) => result.data,
+    });
+}
+export const runActionPlugin = ({ sdk, context }) => {
+    const runAction = createPaginatedFunction(async function runActionPage(options) {
+        const { api } = context;
+        const { appKey, actionKey, actionType, authenticationId, inputs = {}, } = options;
+        // Validate that the action exists using the getAction plugin
+        const actionData = await sdk.getAction({
+            appKey: appKey,
+            actionKey: actionKey,
+            actionType: actionType,
+        });
+        // Validate action type matches
+        if (actionData.data.action_type !== actionType) {
+            throw new ZapierValidationError(`Action type mismatch: expected ${actionType}, got ${actionData.data.action_type}`);
+        }
+        // Execute the action using the Actions API (supports all action types)
+        const result = await executeAction({
+            api,
+            sdk,
+            appKey,
+            actionKey,
+            actionType,
+            executionOptions: { inputs },
+            authenticationId,
+            options,
+        });
+        // Check for errors in the result and throw if present
+        if (result.errors && result.errors.length > 0) {
+            const errorMessage = result.errors
+                .map((error) => error.detail || error.title || "Unknown error")
+                .join("; ");
+            throw new ZapierActionError(`Action execution failed: ${errorMessage}`, {
+                appKey,
+                actionKey,
+            });
+        }
+        // Return the results array wrapped in data with empty nextCursor (no pagination for action execution)
+        return {
+            data: result.results || [],
+            nextCursor: undefined, // No pagination implemented yet
+        };
+    }, RunActionSchema);
+    return {
+        runAction,
+        context: {
+            meta: {
+                runAction: {
+                    inputSchema: RunActionSchema,
+                },
+            },
+        },
+    };
+};

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

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

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

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