@zapier/zapier-sdk 0.13.6 → 0.13.8

package/src/plugins/request/index.test.ts

@@ -1,333 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { ZapierValidationError } from "../../types/errors";
-import { requestPlugin } from "./index";
-import { createSdk } from "../../sdk";
-import type { RelayRequestOptions } from "./schemas";
-import type { ApiClient } from "../../api";
-
-describe("request plugin", () => {
-  let mockApiClient: ApiClient;
-  let mockFetch: any;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockFetch = vi.fn().mockResolvedValue(
-      new Response('{"success": true}', {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      }),
-    );
-
-    mockApiClient = {
-      fetch: mockFetch,
-    } as Partial<ApiClient> as ApiClient;
-  });
-
-  const apiPlugin = () => ({
-    context: {
-      api: mockApiClient,
-    },
-  });
-
-  function createTestSdk() {
-    return createSdk().addPlugin(apiPlugin).addPlugin(requestPlugin);
-  }
-
-  describe("schema validation", () => {
-    it("should throw validation error for missing url", async () => {
-      const sdk = createTestSdk();
-      await expect(sdk.request({} as RelayRequestOptions)).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" as any,
-        }),
-      ).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" as any,
-        }),
-      ).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: [string, string][] = [
-        ["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",
-    ] as const;
-
-    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 as any).request).toBeDefined();
-      expect((context.meta as any).request.inputSchema).toBeDefined();
-    });
-  });
-});

package/src/plugins/request/index.ts

@@ -1,105 +0,0 @@
-import type { Plugin } from "../../types/plugin";
-import type { ApiClient } from "../../api";
-import { RelayRequestSchema, type RelayRequestOptions } from "./schemas";
-import { createFunction } from "../../utils/function-utils";
-
-/**
- * Transforms full URLs into Relay format: /relay/{domain}/{path}
- *
- * @param url - The full URL to transform (e.g., "https://api.github.com/user")
- * @returns The relay path format (e.g., "/relay/api.github.com/user")
- */
-function transformUrlToRelayPath(url: string | URL): string {
-  const targetUrl = new URL(url);
-
-  // Build the Relay path: /relay/{host}{pathname}{search}{hash}
-  // Use host instead of hostname to include port if present
-  const relayPath = `/relay/${targetUrl.host}${targetUrl.pathname}${targetUrl.search}${targetUrl.hash}`;
-
-  return relayPath;
-}
-
-export interface RequestPluginProvides {
-  request: (options: RelayRequestOptions) => Promise<Response>;
-  context: {
-    meta: {
-      request: {
-        inputSchema: typeof RelayRequestSchema;
-      };
-    };
-  };
-}
-
-export const requestPlugin: Plugin<
-  {}, // no SDK dependencies
-  { api: ApiClient }, // requires api in context
-  RequestPluginProvides
-> = ({ context }) => {
-  const request = createFunction(async function request(
-    options: RelayRequestOptions,
-  ): Promise<Response> {
-    const { api } = context;
-    const {
-      url,
-      method = "GET",
-      body,
-      headers: optionsHeaders,
-      authenticationId,
-      callbackUrl,
-      authenticationTemplate,
-    } = options;
-
-    // Transform full URL to relay path format
-    const relayPath = transformUrlToRelayPath(url);
-
-    // Build headers for the request
-    const headers: Record<string, string> = {};
-
-    // Copy existing headers
-    if (optionsHeaders) {
-      const headerEntries =
-        optionsHeaders instanceof Headers
-          ? Array.from(optionsHeaders.entries())
-          : Array.isArray(optionsHeaders)
-            ? optionsHeaders
-            : Object.entries(optionsHeaders);
-
-      for (const [key, value] of headerEntries) {
-        headers[key] = value;
-      }
-    }
-
-    // Add Relay-specific headers
-    if (authenticationId) {
-      headers["X-Relay-Authentication-Id"] = authenticationId.toString();
-    }
-
-    if (callbackUrl) {
-      headers["X-Relay-Callback-Url"] = callbackUrl;
-    }
-
-    if (authenticationTemplate) {
-      headers["X-Authentication-Template"] = authenticationTemplate;
-    }
-
-    // Use the API client's fetch method directly - let it handle auth automatically
-    return await api.fetch(relayPath, {
-      method,
-      body,
-      headers,
-    });
-  }, RelayRequestSchema);
-
-  return {
-    request,
-    context: {
-      meta: {
-        request: {
-          categories: ["http"],
-          returnType: "Response",
-          inputSchema: RelayRequestSchema,
-        },
-      },
-    },
-  };
-};

package/src/plugins/request/schemas.ts

@@ -1,69 +0,0 @@
-import { z } from "zod";
-import type {
-  ZapierApiError,
-  ZapierValidationError,
-  ZapierUnknownError,
-} from "../../types/errors";
-
-// 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");
-
-// Type inferred from schema
-export type RelayRequestOptions = z.infer<typeof RelayRequestSchema>;
-
-// Error union for this function
-export type RelayRequestError =
-  | ZapierApiError
-  | ZapierValidationError
-  | ZapierUnknownError;
-
-// SDK function interface
-export interface RelayRequestSdkFunction {
-  request: (options: RelayRequestOptions) => Promise<Response>;
-}
-
-// Legacy exports for compatibility
-export const RelayFetchSchema = RelayRequestSchema;
-export type RelayFetchOptions = RelayRequestOptions;
-export interface RelayFetchSdkFunction {
-  fetch: (options: RelayFetchOptions) => Promise<Response>;
-}