@zapier/zapier-sdk 0.4.1 → 0.5.1

package/src/plugins/listInputFields/index.ts

@@ -0,0 +1,204 @@
+import type { Plugin, GetSdkType } from "../../types/plugin";
+import type { ApiClient } from "../../api";
+import type { NeedsRequest, NeedsResponse, Need } from "../../api/types";
+import type { InputFieldItem } from "../../types/domain";
+import {
+  ListInputFieldsSchema,
+  type ListInputFieldsOptions,
+  type ListInputFieldsPage,
+} from "./schemas";
+import { ZapierConfigurationError, ZapierApiError } from "../../types/errors";
+import { createPaginatedFunction } from "../../utils/function-utils";
+import type { GetAppPluginProvides } from "../getApp";
+
+// Enums for input field transformation
+enum InputFieldType {
+  STRING = "STRING",
+  NUMBER = "NUMBER",
+  INTEGER = "INTEGER",
+  BOOLEAN = "BOOLEAN",
+  OBJECT = "OBJECT",
+  ARRAY = "ARRAY",
+}
+
+enum InputFieldFormat {
+  DATETIME = "DATETIME",
+  SELECT = "SELECT",
+  MULTILINE = "MULTILINE",
+  FILE = "FILE",
+  PASSWORD = "PASSWORD",
+  CODE = "CODE",
+}
+
+enum ItemsType {
+  STRING = "STRING",
+  NUMBER = "NUMBER",
+  INTEGER = "INTEGER",
+  BOOLEAN = "BOOLEAN",
+  OBJECT = "OBJECT",
+}
+
+// Transformation helper functions
+function getInputFieldTypeFromNeed(need: Need): InputFieldType {
+  if (need.list) {
+    return InputFieldType.ARRAY;
+  }
+
+  const typeMap: Record<string, InputFieldType> = {
+    string: InputFieldType.STRING,
+    decimal: InputFieldType.NUMBER,
+    integer: InputFieldType.INTEGER,
+    boolean: InputFieldType.BOOLEAN,
+    dict: InputFieldType.OBJECT,
+  };
+
+  return typeMap[need.type || ""] || InputFieldType.STRING;
+}
+
+function getInputFieldFormatFromNeed(need: Need): InputFieldFormat | undefined {
+  if (need.prefill || need.choices) {
+    return InputFieldFormat.SELECT;
+  }
+
+  const formatMap: Record<string, InputFieldFormat> = {
+    text: InputFieldFormat.MULTILINE,
+    datetime: InputFieldFormat.DATETIME,
+    file: InputFieldFormat.FILE,
+    password: InputFieldFormat.PASSWORD,
+    code: InputFieldFormat.CODE,
+  };
+
+  return formatMap[need.type || ""];
+}
+
+function getItemsTypeFromNeed(need: Need): ItemsType | undefined {
+  if (!need.list) {
+    return undefined;
+  }
+
+  const typeMap: Record<string, ItemsType> = {
+    string: ItemsType.STRING,
+    decimal: ItemsType.NUMBER,
+    integer: ItemsType.INTEGER,
+    boolean: ItemsType.BOOLEAN,
+    dict: ItemsType.OBJECT,
+  };
+
+  return typeMap[need.type || ""] || ItemsType.STRING;
+}
+
+// Transform Need to InputFieldItem
+function transformNeedToInputFieldItem(need: Need): InputFieldItem {
+  const itemsType = getItemsTypeFromNeed(need);
+
+  return {
+    ...need, // Pass through all original Need fields
+    id: need.key,
+    default_value: need.default || "",
+    depends_on: need.depends_on || [],
+    description: need.help_text || "",
+    invalidates_input_fields: need.alters_custom_fields || false,
+    is_required: need.required || false,
+    placeholder: need.placeholder || "",
+    title: need.label || "",
+    value_type: getInputFieldTypeFromNeed(need),
+    format: getInputFieldFormatFromNeed(need),
+    items: itemsType ? { type: itemsType } : undefined,
+  };
+}
+
+export interface ListInputFieldsPluginProvides {
+  listInputFields: (options?: ListInputFieldsOptions) => Promise<{
+    data: InputFieldItem[];
+  }> &
+    AsyncIterable<{ data: InputFieldItem[]; nextCursor?: string }> & {
+      items(): AsyncIterable<InputFieldItem>;
+    };
+  context: {
+    meta: {
+      listInputFields: {
+        inputSchema: typeof ListInputFieldsSchema;
+      };
+    };
+  };
+}
+
+export const listInputFieldsPlugin: Plugin<
+  GetSdkType<GetAppPluginProvides>, // requires getApp in SDK
+  { api: ApiClient }, // requires api in context
+  ListInputFieldsPluginProvides
+> = ({ sdk, context }) => {
+  const listInputFields = createPaginatedFunction(
+    async function listInputFieldsPage(
+      options: ListInputFieldsOptions & { cursor?: string } & {
+        pageSize: number;
+      },
+    ): Promise<ListInputFieldsPage> {
+      // Note: This function ignores pageSize and cursor since it's not actually paginated internally
+      const { api } = context;
+
+      // Extract parameters
+      const { appKey, actionKey, actionType, authenticationId, inputs } =
+        options;
+
+      // Use the getApp plugin
+      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" },
+        );
+      }
+
+      // Build needs request
+      const needsRequest: NeedsRequest = {
+        selected_api: selectedApi,
+        action: actionKey,
+        type_of: actionType,
+        params: inputs || {},
+      };
+
+      // Only include authentication_id if it's not null (skip authentication when null)
+      if (authenticationId !== null) {
+        needsRequest.authentication_id = authenticationId;
+      }
+
+      const needsData: NeedsResponse = await api.post(
+        "/api/v4/implementations/needs/",
+        needsRequest,
+      );
+
+      if (!needsData.success) {
+        throw new ZapierApiError(
+          `Failed to get action fields: ${
+            needsData.errors?.join(", ") || "Unknown error"
+          }`,
+        );
+      }
+
+      // Transform Need objects to InputFieldItem objects
+      const inputFields: InputFieldItem[] = (needsData.needs || []).map(
+        transformNeedToInputFieldItem,
+      );
+
+      return {
+        data: inputFields,
+        nextCursor: undefined, // No pagination needed since we return all input fields
+      };
+    },
+    ListInputFieldsSchema,
+  );
+
+  return {
+    listInputFields,
+    context: {
+      meta: {
+        listInputFields: {
+          inputSchema: ListInputFieldsSchema,
+        },
+      },
+    },
+  };
+};

package/src/plugins/listInputFields/schemas.ts

@@ -0,0 +1,56 @@
+import { z } from "zod";
+import {
+  AppKeyPropertySchema,
+  ActionTypePropertySchema,
+  ActionKeyPropertySchema,
+  AuthenticationIdPropertySchema,
+  InputsPropertySchema,
+} from "../../types/properties";
+import type { InputFieldItem } from "../../types/domain";
+import type { PaginatedSdkFunction } from "../../types/functions";
+
+// Pure Zod schema - no resolver metadata!
+export const ListInputFieldsSchema = z
+  .object({
+    appKey: AppKeyPropertySchema,
+    actionType: ActionTypePropertySchema,
+    actionKey: ActionKeyPropertySchema,
+    authenticationId: AuthenticationIdPropertySchema.nullable().optional(),
+    inputs: InputsPropertySchema.optional().describe(
+      "Current input values that may affect available fields",
+    ),
+    pageSize: z
+      .number()
+      .min(1)
+      .optional()
+      .describe("Number of input fields per page"),
+    maxItems: z
+      .number()
+      .min(1)
+      .optional()
+      .describe("Maximum total items to return across all pages"),
+  })
+  .describe("Get the input fields required for a specific action");
+
+// Type inferred from schema
+export type ListInputFieldsOptions = z.infer<typeof ListInputFieldsSchema>;
+
+// Error union for this function
+export type ListInputFieldsError =
+  | import("../../types/errors").ZapierConfigurationError
+  | import("../../types/errors").ZapierApiError
+  | import("../../types/errors").ZapierAuthenticationError
+  | import("../../types/errors").ZapierAppNotFoundError
+  | import("../../types/errors").ZapierValidationError
+  | import("../../types/errors").ZapierUnknownError;
+
+// Page result structure
+export interface ListInputFieldsPage {
+  data: InputFieldItem[];
+  nextCursor?: string;
+}
+
+// SDK function interface
+export interface ListInputFieldsSdkFunction {
+  listInputFields: PaginatedSdkFunction<ListInputFieldsOptions, InputFieldItem>;
+}

package/src/plugins/registry/index.ts

@@ -0,0 +1,30 @@
+import type { Plugin } from "../../types/plugin";
+import { FunctionRegistryEntry } from "../../types/sdk";
+
+export interface RegisterPluginFunctionOptions {}
+
+// Registry plugin creates and populates __registry for CLI backward compatibility
+export interface RegistryPluginProvides {
+  __registry: FunctionRegistryEntry[];
+}
+
+// Registry plugin requires no context but collects SDK metadata
+export const registryPlugin: Plugin<
+  {}, // accepts any SDK shape
+  {}, // requires no context
+  RegistryPluginProvides
+> = ({ sdk, context }) => {
+  const metaKeys = Object.keys(context.meta || {});
+
+  const registryEntries = metaKeys.map((key) => {
+    return {
+      ...context.meta[key],
+      name: key,
+      implementation: sdk[key as keyof typeof sdk],
+    };
+  });
+
+  return {
+    __registry: registryEntries,
+  };
+};

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

@@ -0,0 +1,329 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ZapierValidationError } from "../../types/errors";
+import { requestPlugin } from "./index";
+import { createSdk } from "../../sdk";
+import type { ApiClient } from "../../api";
+import type { RelayRequestOptions } from "./schemas";
+
+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;
+  });
+
+  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({} 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();
+    });
+  });
+});