@zapier/zapier-sdk 0.4.1 → 0.5.0

package/dist/plugins/listInputFields/index.js

@@ -0,0 +1,133 @@
+import { ListInputFieldsSchema, } from "./schemas";
+import { ZapierConfigurationError, ZapierApiError } from "../../types/errors";
+import { createPaginatedFunction } from "../../utils/function-utils";
+// Enums for input field transformation
+var InputFieldType;
+(function (InputFieldType) {
+    InputFieldType["STRING"] = "STRING";
+    InputFieldType["NUMBER"] = "NUMBER";
+    InputFieldType["INTEGER"] = "INTEGER";
+    InputFieldType["BOOLEAN"] = "BOOLEAN";
+    InputFieldType["OBJECT"] = "OBJECT";
+    InputFieldType["ARRAY"] = "ARRAY";
+})(InputFieldType || (InputFieldType = {}));
+var InputFieldFormat;
+(function (InputFieldFormat) {
+    InputFieldFormat["DATETIME"] = "DATETIME";
+    InputFieldFormat["SELECT"] = "SELECT";
+    InputFieldFormat["MULTILINE"] = "MULTILINE";
+    InputFieldFormat["FILE"] = "FILE";
+    InputFieldFormat["PASSWORD"] = "PASSWORD";
+    InputFieldFormat["CODE"] = "CODE";
+})(InputFieldFormat || (InputFieldFormat = {}));
+var ItemsType;
+(function (ItemsType) {
+    ItemsType["STRING"] = "STRING";
+    ItemsType["NUMBER"] = "NUMBER";
+    ItemsType["INTEGER"] = "INTEGER";
+    ItemsType["BOOLEAN"] = "BOOLEAN";
+    ItemsType["OBJECT"] = "OBJECT";
+})(ItemsType || (ItemsType = {}));
+// Transformation helper functions
+function getInputFieldTypeFromNeed(need) {
+    if (need.list) {
+        return InputFieldType.ARRAY;
+    }
+    const typeMap = {
+        string: InputFieldType.STRING,
+        decimal: InputFieldType.NUMBER,
+        integer: InputFieldType.INTEGER,
+        boolean: InputFieldType.BOOLEAN,
+        dict: InputFieldType.OBJECT,
+    };
+    return typeMap[need.type || ""] || InputFieldType.STRING;
+}
+function getInputFieldFormatFromNeed(need) {
+    if (need.prefill || need.choices) {
+        return InputFieldFormat.SELECT;
+    }
+    const formatMap = {
+        text: InputFieldFormat.MULTILINE,
+        datetime: InputFieldFormat.DATETIME,
+        file: InputFieldFormat.FILE,
+        password: InputFieldFormat.PASSWORD,
+        code: InputFieldFormat.CODE,
+    };
+    return formatMap[need.type || ""];
+}
+function getItemsTypeFromNeed(need) {
+    if (!need.list) {
+        return undefined;
+    }
+    const typeMap = {
+        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) {
+    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 const listInputFieldsPlugin = ({ sdk, context }) => {
+    const listInputFields = createPaginatedFunction(async function listInputFieldsPage(options) {
+        // 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 = {
+            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 = 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 = (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/dist/plugins/listInputFields/index.test.d.ts

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

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

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

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

@@ -0,0 +1,325 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ZapierValidationError, ZapierConfigurationError, ZapierApiError, } from "../../types/errors";
+import { listInputFieldsPlugin } from "./index";
+import { createSdk } from "../../sdk";
+const mockNeeds = [
+    {
+        key: "message",
+        label: "Message",
+        help_text: "The message to send",
+        required: true,
+        type: "string",
+        placeholder: "Enter your message",
+        default: "",
+    },
+    {
+        key: "channel",
+        label: "Channel",
+        help_text: "The channel to send to",
+        required: true,
+        type: "string",
+        choices: [
+            { value: "#general", label: "General", sample: "#general" },
+            { value: "#random", label: "Random", sample: "#random" },
+        ],
+    },
+    {
+        key: "tags",
+        label: "Tags",
+        help_text: "List of tags",
+        type: "string",
+        list: true,
+    },
+];
+const mockNeedsResponse = {
+    success: true,
+    needs: mockNeeds,
+};
+describe("listInputFields plugin", () => {
+    let mockApiClient;
+    let mockGetApp;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockApiClient = {
+            post: vi.fn().mockResolvedValue(mockNeedsResponse),
+        };
+        mockGetApp = vi.fn().mockResolvedValue({
+            data: { current_implementation_id: "SlackCLIAPI@1.21.1" },
+        });
+    });
+    function createTestSdk() {
+        return createSdk({ getApp: mockGetApp }, { api: mockApiClient, meta: {} }).addPlugin(listInputFieldsPlugin);
+    }
+    describe("schema validation", () => {
+        it("should throw validation error for missing required fields", () => {
+            const sdk = createTestSdk();
+            expect(() => {
+                sdk.listInputFields({
+                // Missing required fields
+                });
+            }).toThrow(ZapierValidationError);
+        });
+        it("should throw validation error for invalid field types", () => {
+            const sdk = createTestSdk();
+            expect(() => {
+                sdk.listInputFields({
+                    appKey: 123,
+                    actionType: "write",
+                    actionKey: "send_message",
+                });
+            }).toThrow(ZapierValidationError);
+        });
+        it("should pass validation with all required fields", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.listInputFields({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+            });
+            expect(result.data).toBeDefined();
+        });
+        it("should pass validation with optional fields", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.listInputFields({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+                authenticationId: 123,
+                inputs: { channel: "#general" },
+            });
+            expect(result.data).toBeDefined();
+        });
+    });
+    describe("API integration", () => {
+        it("should call the correct API endpoint", async () => {
+            const sdk = createTestSdk();
+            await sdk.listInputFields({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+            });
+            expect(mockApiClient.post).toHaveBeenCalledWith("/api/v4/implementations/needs/", {
+                selected_api: "SlackCLIAPI@1.21.1",
+                action: "send_message",
+                type_of: "write",
+                params: {},
+            });
+        });
+        it("should include authentication_id when provided", async () => {
+            const sdk = createTestSdk();
+            await sdk.listInputFields({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+                authenticationId: 123,
+            });
+            expect(mockApiClient.post).toHaveBeenCalledWith("/api/v4/implementations/needs/", {
+                selected_api: "SlackCLIAPI@1.21.1",
+                action: "send_message",
+                type_of: "write",
+                params: {},
+                authentication_id: 123,
+            });
+        });
+        it("should exclude authentication_id when null", async () => {
+            const sdk = createTestSdk();
+            await sdk.listInputFields({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+                authenticationId: null,
+            });
+            expect(mockApiClient.post).toHaveBeenCalledWith("/api/v4/implementations/needs/", {
+                selected_api: "SlackCLIAPI@1.21.1",
+                action: "send_message",
+                type_of: "write",
+                params: {},
+                // No authentication_id
+            });
+        });
+        it("should include inputs when provided", async () => {
+            const sdk = createTestSdk();
+            const inputs = { channel: "#general", message: "test" };
+            await sdk.listInputFields({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+                inputs,
+            });
+            expect(mockApiClient.post).toHaveBeenCalledWith("/api/v4/implementations/needs/", {
+                selected_api: "SlackCLIAPI@1.21.1",
+                action: "send_message",
+                type_of: "write",
+                params: inputs,
+            });
+        });
+    });
+    describe("data transformation", () => {
+        it("should transform needs to input field items correctly", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.listInputFields({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+            });
+            expect(result.data).toHaveLength(3);
+            // Check message field transformation
+            expect(result.data[0]).toEqual(expect.objectContaining({
+                id: "message",
+                title: "Message",
+                description: "The message to send",
+                is_required: true,
+                value_type: "STRING",
+                placeholder: "Enter your message",
+                default_value: "",
+            }));
+            // Check channel field with choices (SELECT format)
+            expect(result.data[1]).toEqual(expect.objectContaining({
+                id: "channel",
+                title: "Channel",
+                description: "The channel to send to",
+                is_required: true,
+                value_type: "STRING",
+                format: "SELECT",
+                choices: [
+                    { value: "#general", label: "General", sample: "#general" },
+                    { value: "#random", label: "Random", sample: "#random" },
+                ],
+            }));
+            // Check array field
+            expect(result.data[2]).toEqual(expect.objectContaining({
+                id: "tags",
+                title: "Tags",
+                description: "List of tags",
+                value_type: "ARRAY",
+                items: { type: "STRING" },
+            }));
+        });
+        it("should handle different field types correctly", async () => {
+            const complexNeeds = [
+                {
+                    key: "count",
+                    type: "integer",
+                    label: "Count",
+                    required: false,
+                },
+                {
+                    key: "price",
+                    type: "decimal",
+                    label: "Price",
+                },
+                {
+                    key: "enabled",
+                    type: "boolean",
+                    label: "Enabled",
+                },
+                {
+                    key: "config",
+                    type: "dict",
+                    label: "Configuration",
+                },
+                {
+                    key: "description",
+                    type: "text",
+                    label: "Description",
+                },
+            ];
+            mockApiClient.post = vi.fn().mockResolvedValue({
+                success: true,
+                needs: complexNeeds,
+            });
+            const sdk = createTestSdk();
+            const result = await sdk.listInputFields({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+            });
+            expect(result.data[0].value_type).toBe("INTEGER");
+            expect(result.data[1].value_type).toBe("NUMBER");
+            expect(result.data[2].value_type).toBe("BOOLEAN");
+            expect(result.data[3].value_type).toBe("OBJECT");
+            expect(result.data[4].value_type).toBe("STRING");
+            expect(result.data[4].format).toBe("MULTILINE");
+        });
+    });
+    describe("error handling", () => {
+        it("should throw ZapierConfigurationError when app has no current_implementation_id", async () => {
+            mockGetApp.mockResolvedValue({
+                data: { current_implementation_id: undefined },
+            });
+            const sdk = createTestSdk();
+            await expect(sdk.listInputFields({
+                appKey: "invalid",
+                actionType: "write",
+                actionKey: "send_message",
+            })).rejects.toThrow(ZapierConfigurationError);
+        });
+        it("should throw ZapierApiError when API response indicates failure", async () => {
+            mockApiClient.post = vi.fn().mockResolvedValue({
+                success: false,
+                errors: ["Invalid action", "Missing parameter"],
+            });
+            const sdk = createTestSdk();
+            await expect(sdk.listInputFields({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "invalid_action",
+            })).rejects.toThrow(ZapierApiError);
+            await expect(sdk.listInputFields({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "invalid_action",
+            })).rejects.toThrow("Failed to get action fields: Invalid action, Missing parameter");
+        });
+        it("should handle API errors gracefully", async () => {
+            mockApiClient.post = vi
+                .fn()
+                .mockRejectedValue(new Error("Network error"));
+            const sdk = createTestSdk();
+            await expect(sdk.listInputFields({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+            })).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.listInputFields).toBeDefined();
+            expect(context.meta.listInputFields.inputSchema).toBeDefined();
+        });
+    });
+    describe("pagination", () => {
+        it("should support async iteration over pages", async () => {
+            const sdk = createTestSdk();
+            const listInputFieldsResult = sdk.listInputFields({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+            });
+            const pages = [];
+            for await (const page of listInputFieldsResult) {
+                pages.push(page);
+                break; // Just get first page for testing
+            }
+            expect(pages).toHaveLength(1);
+            expect(pages[0].data).toHaveLength(3);
+        });
+        it("should support async iteration over individual items", async () => {
+            const sdk = createTestSdk();
+            const listInputFieldsResult = sdk.listInputFields({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+            });
+            const items = [];
+            for await (const item of listInputFieldsResult.items()) {
+                items.push(item);
+            }
+            expect(items).toHaveLength(3);
+            expect(items[0].id).toBe("message");
+        });
+    });
+});

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

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import type { InputFieldItem } from "../../types/domain";
+import type { PaginatedSdkFunction } from "../../types/functions";
+export declare const ListInputFieldsSchema: z.ZodObject<{
+    appKey: z.ZodString;
+    actionType: z.ZodEnum<["read", "read_bulk", "write", "run", "search", "search_or_write", "search_and_write", "filter"]>;
+    actionKey: z.ZodString;
+    authenticationId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    maxItems: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    appKey: string;
+    actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+    actionKey: string;
+    authenticationId?: number | null | undefined;
+    maxItems?: number | undefined;
+    pageSize?: number | undefined;
+    inputs?: Record<string, any> | undefined;
+}, {
+    appKey: string;
+    actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+    actionKey: string;
+    authenticationId?: number | null | undefined;
+    maxItems?: number | undefined;
+    pageSize?: number | undefined;
+    inputs?: Record<string, any> | undefined;
+}>;
+export type ListInputFieldsOptions = z.infer<typeof ListInputFieldsSchema>;
+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;
+export interface ListInputFieldsPage {
+    data: InputFieldItem[];
+    nextCursor?: string;
+}
+export interface ListInputFieldsSdkFunction {
+    listInputFields: PaginatedSdkFunction<ListInputFieldsOptions, InputFieldItem>;
+}
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/listInputFields/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAGlE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;EAoBgC,CAAC;AAGnE,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAG3E,MAAM,MAAM,oBAAoB,GAC5B,OAAO,oBAAoB,EAAE,wBAAwB,GACrD,OAAO,oBAAoB,EAAE,cAAc,GAC3C,OAAO,oBAAoB,EAAE,yBAAyB,GACtD,OAAO,oBAAoB,EAAE,sBAAsB,GACnD,OAAO,oBAAoB,EAAE,qBAAqB,GAClD,OAAO,oBAAoB,EAAE,kBAAkB,CAAC;AAGpD,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,cAAc,EAAE,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAGD,MAAM,WAAW,0BAA0B;IACzC,eAAe,EAAE,oBAAoB,CAAC,sBAAsB,EAAE,cAAc,CAAC,CAAC;CAC/E"}

package/dist/plugins/listInputFields/schemas.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { AppKeyPropertySchema, ActionTypePropertySchema, ActionKeyPropertySchema, AuthenticationIdPropertySchema, InputsPropertySchema, } from "../../types/properties";
+// 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");

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

@@ -0,0 +1,11 @@
+import type { Plugin } from "../../types/plugin";
+import { FunctionRegistryEntry } from "../../types/sdk";
+export interface RegisterPluginFunctionOptions {
+}
+export interface RegistryPluginProvides {
+    __registry: FunctionRegistryEntry[];
+}
+export declare const registryPlugin: Plugin<{}, // accepts any SDK shape
+{}, // requires no context
+RegistryPluginProvides>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/registry/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAExD,MAAM,WAAW,6BAA6B;CAAG;AAGjD,MAAM,WAAW,sBAAsB;IACrC,UAAU,EAAE,qBAAqB,EAAE,CAAC;CACrC;AAGD,eAAO,MAAM,cAAc,EAAE,MAAM,CACjC,EAAE,EAAE,wBAAwB;AAC5B,EAAE,EAAE,sBAAsB;AAC1B,sBAAsB,CAevB,CAAC"}

package/dist/plugins/registry/index.js

@@ -0,0 +1,14 @@
+// Registry plugin requires no context but collects SDK metadata
+export const registryPlugin = ({ sdk, context }) => {
+    const metaKeys = Object.keys(context.meta || {});
+    const registryEntries = metaKeys.map((key) => {
+        return {
+            ...context.meta[key],
+            name: key,
+            implementation: sdk[key],
+        };
+    });
+    return {
+        __registry: registryEntries,
+    };
+};

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

@@ -0,0 +1,19 @@
+import type { Plugin } from "../../types/plugin";
+import type { ApiClient } from "../../api";
+import { RelayRequestSchema, type RelayRequestOptions } from "./schemas";
+export interface RequestPluginProvides {
+    request: (options: RelayRequestOptions) => Promise<Response>;
+    context: {
+        meta: {
+            request: {
+                inputSchema: typeof RelayRequestSchema;
+            };
+        };
+    };
+}
+export declare const requestPlugin: Plugin<{}, // no SDK dependencies
+{
+    api: ApiClient;
+}, // requires api in context
+RequestPluginProvides>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/request/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,kBAAkB,EAAE,KAAK,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAmBzE,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,CAAC,OAAO,EAAE,mBAAmB,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC7D,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,OAAO,EAAE;gBACP,WAAW,EAAE,OAAO,kBAAkB,CAAC;aACxC,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,aAAa,EAAE,MAAM,CAChC,EAAE,EAAE,sBAAsB;AAC1B;IAAE,GAAG,EAAE,SAAS,CAAA;CAAE,EAAE,0BAA0B;AAC9C,qBAAqB,CAmEtB,CAAC"}

package/dist/plugins/request/index.js

@@ -0,0 +1,62 @@
+import { RelayRequestSchema } 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) {
+    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 const requestPlugin = ({ context }) => {
+    const request = createFunction(async function request(options) {
+        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 = {};
+        // 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: {
+                    inputSchema: RelayRequestSchema,
+                },
+            },
+        },
+    };
+};

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

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

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

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