@zapier/zapier-sdk 0.18.4 → 0.19.0

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

@@ -1,337 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { ZapierValidationError } from "../../types/errors";
-import { requestPlugin } from "./index";
-import { createSdk } from "../../sdk";
-import { eventEmissionPlugin } from "../eventEmission";
-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,
-        };
-    });
-    const apiPlugin = () => ({
-        context: {
-            api: mockApiClient,
-        },
-    });
-    function createTestSdk() {
-        return createSdk()
-            .addPlugin(() => ({
-            context: {
-                options: {},
-            },
-        }))
-            .addPlugin(apiPlugin)
-            .addPlugin(eventEmissionPlugin)
-            .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: {
-                    "Content-Type": "application/json; charset=utf-8",
-                },
-            });
-        });
-        it("should auto-set Content-Type for JSON object bodies", async () => {
-            const sdk = createTestSdk();
-            const body = '{"key": "value"}';
-            await sdk.request({
-                url: "https://api.example.com/data",
-                method: "POST",
-                body,
-            });
-            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/data", {
-                method: "POST",
-                body,
-                headers: {
-                    "Content-Type": "application/json; charset=utf-8",
-                },
-            });
-        });
-        it("should auto-set Content-Type for JSON array bodies", async () => {
-            const sdk = createTestSdk();
-            const body = '[{"id": 1}, {"id": 2}]';
-            await sdk.request({
-                url: "https://api.example.com/data",
-                method: "POST",
-                body,
-            });
-            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/data", {
-                method: "POST",
-                body,
-                headers: {
-                    "Content-Type": "application/json; charset=utf-8",
-                },
-            });
-        });
-        it("should not override explicit Content-Type header", async () => {
-            const sdk = createTestSdk();
-            const body = '{"key": "value"}';
-            await sdk.request({
-                url: "https://api.example.com/data",
-                method: "POST",
-                body,
-                headers: {
-                    "Content-Type": "text/plain",
-                },
-            });
-            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/data", {
-                method: "POST",
-                body,
-                headers: {
-                    "Content-Type": "text/plain",
-                },
-            });
-        });
-        it("should not set Content-Type for non-JSON bodies", async () => {
-            const sdk = createTestSdk();
-            const body = "plain text body";
-            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

@@ -1,54 +0,0 @@
-import { z } from "zod";
-import type { ZapierApiError, ZapierValidationError, ZapierUnknownError } from "../../types/errors";
-export declare const RelayRequestSchema: z.ZodObject<{
-    url: z.ZodString;
-    method: z.ZodOptional<z.ZodEnum<{
-        POST: "POST";
-        GET: "GET";
-        PUT: "PUT";
-        DELETE: "DELETE";
-        PATCH: "PATCH";
-        HEAD: "HEAD";
-        OPTIONS: "OPTIONS";
-    }>>;
-    body: z.ZodOptional<z.ZodAny>;
-    authenticationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-    callbackUrl: z.ZodOptional<z.ZodString>;
-    authenticationTemplate: z.ZodOptional<z.ZodString>;
-    headers: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodString>, z.ZodCustom<Headers, Headers>, z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>>]>>;
-    relayBaseUrl: z.ZodOptional<z.ZodString>;
-    _telemetry: z.ZodOptional<z.ZodObject<{
-        isNested: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type RelayRequestOptions = z.infer<typeof RelayRequestSchema>;
-export type RelayRequestError = ZapierApiError | ZapierValidationError | ZapierUnknownError;
-export interface RelayRequestSdkFunction {
-    request: (options: RelayRequestOptions) => Promise<Response>;
-}
-export declare const RelayFetchSchema: z.ZodObject<{
-    url: z.ZodString;
-    method: z.ZodOptional<z.ZodEnum<{
-        POST: "POST";
-        GET: "GET";
-        PUT: "PUT";
-        DELETE: "DELETE";
-        PATCH: "PATCH";
-        HEAD: "HEAD";
-        OPTIONS: "OPTIONS";
-    }>>;
-    body: z.ZodOptional<z.ZodAny>;
-    authenticationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-    callbackUrl: z.ZodOptional<z.ZodString>;
-    authenticationTemplate: z.ZodOptional<z.ZodString>;
-    headers: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodString>, z.ZodCustom<Headers, Headers>, z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>>]>>;
-    relayBaseUrl: z.ZodOptional<z.ZodString>;
-    _telemetry: z.ZodOptional<z.ZodObject<{
-        isNested: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-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

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/request/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EACV,cAAc,EACd,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,oBAAoB,CAAC;AAK5B,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;iBAoC+C,CAAC;AAG/E,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAGrE,MAAM,MAAM,iBAAiB,GACzB,cAAc,GACd,qBAAqB,GACrB,kBAAkB,CAAC;AAGvB,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,CAAC,OAAO,EAAE,mBAAmB,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;CAC9D;AAGD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;iBAAqB,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

@@ -1,41 +0,0 @@
-import { z } from "zod";
-import { TelemetryMarkerSchema } from "../../utils/function-utils";
-import { AuthenticationIdPropertySchema } from "../../types/properties";
-// 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: AuthenticationIdPropertySchema.optional(),
-    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.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"),
-})
-    .merge(TelemetryMarkerSchema)
-    .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

@@ -1,33 +0,0 @@
-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";
-import type { GetVersionedImplementationId } from "../manifest/schemas";
-import type { EventEmissionContext } from "../eventEmission";
-export interface RunActionPluginProvides {
-    runAction: (options?: RunActionOptions) => Promise<{
-        data: any[];
-        nextCursor?: string;
-    }> & 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
-// requires getAction and getApp in SDK
-{
-    api: ApiClient;
-    getVersionedImplementationId: GetVersionedImplementationId;
-} & EventEmissionContext, // requires api and eventEmission in context
-RunActionPluginProvides>;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"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;AAQnB,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAC5D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAQtD,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAExE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAG7D,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE,CAAC,OAAO,CAAC,EAAE,gBAAgB,KAAK,OAAO,CAAC;QACjD,IAAI,EAAE,GAAG,EAAE,CAAC;QACZ,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC,GACA,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;AAgFD,eAAO,MAAM,eAAe,EAAE,MAAM,CAClC,UAAU,CAAC,uBAAuB,GAAG,oBAAoB,CAAC,EAAE,uCAAuC;AACnG,AAD4D,uCAAuC;AACnG;IACE,GAAG,EAAE,SAAS,CAAC;IACf,4BAA4B,EAAE,4BAA4B,CAAC;CAC5D,GAAG,oBAAoB,EAAE,4CAA4C;AACtE,uBAAuB,CAkGxB,CAAC"}

package/dist/plugins/runAction/index.js

@@ -1,108 +0,0 @@
-import { RunActionSchema, } from "./schemas";
-import { ActionResultItemSchema } from "../../schemas/Run";
-import { ZapierValidationError, ZapierConfigurationError, ZapierActionError, } from "../../types/errors";
-import { createPaginatedFunction } from "../../utils/function-utils";
-import { appKeyResolver, actionTypeResolver, actionKeyResolver, authenticationIdResolver, inputsResolver, } from "../../resolvers";
-import { createTelemetryCallback } from "../../utils/telemetry-utils";
-import { stripPageSuffix } from "../../utils/string-utils";
-async function executeAction(actionOptions) {
-    const { api, context, appKey, actionId, actionKey, actionType, executionOptions, authenticationId, } = actionOptions;
-    // Use the manifest plugin to get the current implementation ID
-    const selectedApi = await context.getVersionedImplementationId(appKey);
-    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_id: actionId,
-        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("/zapier/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(`/zapier/api/actions/v1/runs/${runId}`, {
-        successStatus: 200,
-        pendingStatus: 202,
-        resultExtractor: (result) => result.data,
-    });
-}
-export const runActionPlugin = ({ sdk, context }) => {
-    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,
-            _telemetry: { isNested: true },
-        });
-        // Validate action type matches
-        if (actionData.data.action_type !== actionType) {
-            throw new ZapierValidationError(`Action type mismatch: expected ${actionType}, got ${actionData.data.action_type}`);
-        }
-        const actionId = actionData.data.id;
-        // Execute the action using the Actions API (supports all action types)
-        const result = await executeAction({
-            api,
-            context,
-            appKey,
-            // Some actions require the action ID to run them, but technically the ID is not guaranteed to be available when
-            // we retrieve actions (probably legacy reasons), so we just pass along all the things!
-            actionId,
-            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
-        };
-    }
-    const methodName = stripPageSuffix(runActionPage.name);
-    const runActionDefinition = createPaginatedFunction(runActionPage, RunActionSchema, createTelemetryCallback(context.eventEmission.emitMethodCalled, methodName), methodName);
-    return {
-        runAction: runActionDefinition,
-        context: {
-            meta: {
-                runAction: {
-                    categories: ["action"],
-                    type: "list",
-                    itemType: "ActionResult",
-                    inputSchema: RunActionSchema,
-                    outputSchema: ActionResultItemSchema,
-                    resolvers: {
-                        appKey: appKeyResolver,
-                        actionType: actionTypeResolver,
-                        actionKey: actionKeyResolver,
-                        authenticationId: authenticationIdResolver,
-                        inputs: inputsResolver,
-                    },
-                },
-            },
-        },
-    };
-};

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

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

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

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