@zapier/zapier-sdk 0.4.1 → 0.5.0

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

@@ -0,0 +1,320 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ZapierValidationError, ZapierActionError } from "../../types/errors";
+import { runActionPlugin } from "./index";
+import { createSdk } from "../../sdk";
+const mockAction = {
+    type: "action",
+    key: "send_message",
+    title: "Send Message",
+    description: "Send a message to a channel",
+    app_key: "slack",
+    action_type: "write",
+};
+const mockActionResponse = {
+    results: [
+        {
+            id: "msg_123",
+            text: "Hello, world!",
+            channel: "#general",
+            user: "user_456",
+        },
+    ],
+    meta: {
+        next_cursor: null,
+    },
+};
+describe("runAction plugin", () => {
+    let mockApiClient;
+    let mockGetAction;
+    let mockGetApp;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockApiClient = {
+            post: vi.fn().mockResolvedValue({ data: { id: "run_123" } }),
+            poll: vi.fn().mockResolvedValue({ results: mockActionResponse.results }),
+        };
+        mockGetAction = vi.fn().mockResolvedValue({
+            data: mockAction,
+        });
+        mockGetApp = vi.fn().mockResolvedValue({
+            data: { current_implementation_id: "SlackCLIAPI" },
+        });
+    });
+    function createTestSdk() {
+        return createSdk({ getAction: mockGetAction, getApp: mockGetApp }, // Provide getAction and getApp in SDK
+        { api: mockApiClient, meta: {} }).addPlugin(runActionPlugin);
+    }
+    describe("schema validation", () => {
+        it("should throw validation error for missing appKey", () => {
+            const sdk = createTestSdk();
+            expect(() => {
+                sdk.runAction({
+                    actionType: "write",
+                    actionKey: "send_message",
+                    inputs: { message: "Hello" },
+                });
+            }).toThrow(ZapierValidationError);
+        });
+        it("should throw validation error for missing actionType", () => {
+            const sdk = createTestSdk();
+            expect(() => {
+                sdk.runAction({
+                    appKey: "slack",
+                    actionKey: "send_message",
+                    inputs: { message: "Hello" },
+                });
+            }).toThrow(ZapierValidationError);
+        });
+        it("should throw validation error for missing actionKey", () => {
+            const sdk = createTestSdk();
+            expect(() => {
+                sdk.runAction({
+                    appKey: "slack",
+                    actionType: "write",
+                    inputs: { message: "Hello" },
+                });
+            }).toThrow(ZapierValidationError);
+        });
+        it("should pass validation with all required fields", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.runAction({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+                inputs: { message: "Hello" },
+            });
+            expect(result.data).toHaveLength(1);
+            expect(result.data[0]).toEqual(mockActionResponse.results[0]);
+        });
+    });
+    describe("action execution", () => {
+        it("should validate action exists using getAction", async () => {
+            const sdk = createTestSdk();
+            await sdk.runAction({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+                inputs: { message: "Hello" },
+            });
+            expect(mockGetAction).toHaveBeenCalledWith({
+                appKey: "slack",
+                actionKey: "send_message",
+                actionType: "write",
+            });
+        });
+        it("should throw error when action type doesn't match", async () => {
+            // Mock getAction to return an action with different type
+            mockGetAction.mockResolvedValue({
+                data: { ...mockAction, action_type: "read" },
+            });
+            const sdk = createTestSdk();
+            await expect(sdk.runAction({
+                appKey: "slack",
+                actionType: "write", // Different from mocked action type
+                actionKey: "send_message",
+                inputs: { message: "Hello" },
+            })).rejects.toThrow(ZapierValidationError);
+        });
+        it("should execute action with correct API call", async () => {
+            const sdk = createTestSdk();
+            await sdk.runAction({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+                inputs: { message: "Hello", channel: "#general" },
+                authenticationId: 12345,
+            });
+            expect(mockApiClient.post).toHaveBeenCalledWith("/api/actions/v1/runs", {
+                data: {
+                    selected_api: "SlackCLIAPI",
+                    action_key: "send_message",
+                    action_type: "write",
+                    inputs: { message: "Hello", channel: "#general" },
+                    authentication_id: 12345,
+                },
+            });
+            expect(mockApiClient.poll).toHaveBeenCalledWith("/api/actions/v1/runs/run_123", {
+                successStatus: 200,
+                pendingStatus: 202,
+                resultExtractor: expect.any(Function),
+            });
+        });
+        it("should execute action without authentication ID", async () => {
+            const sdk = createTestSdk();
+            await sdk.runAction({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+                inputs: { message: "Hello" },
+            });
+            expect(mockApiClient.post).toHaveBeenCalledWith("/api/actions/v1/runs", {
+                data: {
+                    selected_api: "SlackCLIAPI",
+                    action_key: "send_message",
+                    action_type: "write",
+                    inputs: { message: "Hello" },
+                },
+            });
+        });
+        it("should handle pagination cursor", async () => {
+            const sdk = createTestSdk();
+            const runActionResult = sdk.runAction({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+                inputs: { message: "Hello" },
+            });
+            // Simulate pagination by getting an iterator
+            const iterator = runActionResult[Symbol.asyncIterator]();
+            await iterator.next();
+            expect(mockApiClient.post).toHaveBeenCalledWith("/api/actions/v1/runs", expect.objectContaining({
+                data: expect.objectContaining({
+                    inputs: { message: "Hello" },
+                    selected_api: "SlackCLIAPI",
+                    action_key: "send_message",
+                    action_type: "write",
+                }),
+            }));
+        });
+        it("should return results in correct format", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.runAction({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+                inputs: { message: "Hello" },
+            });
+            expect(result.data).toEqual(mockActionResponse.results);
+        });
+        it("should handle single result (not array)", async () => {
+            const singleResult = { id: "msg_123", text: "Hello" };
+            mockApiClient.post = vi
+                .fn()
+                .mockResolvedValue({ data: { id: "run_123" } });
+            mockApiClient.poll = vi.fn().mockResolvedValue({
+                results: [singleResult], // Poll returns the actual results
+            });
+            const sdk = createTestSdk();
+            const result = await sdk.runAction({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+                inputs: { message: "Hello" },
+            });
+            expect(result.data).toEqual([singleResult]); // Should be wrapped in array
+        });
+    });
+    describe("error handling", () => {
+        it("should handle action execution errors", async () => {
+            mockApiClient.post = vi
+                .fn()
+                .mockResolvedValue({ data: { id: "run_123" } });
+            mockApiClient.poll = vi.fn().mockResolvedValue({
+                results: [],
+                errors: [
+                    { title: "Invalid inputs", detail: "Message cannot be empty" },
+                ],
+            });
+            const sdk = createTestSdk();
+            await expect(sdk.runAction({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+                inputs: { message: "" }, // Invalid input
+            })).rejects.toThrow(ZapierActionError);
+        });
+        it("should handle server errors", async () => {
+            mockApiClient.post = vi.fn().mockImplementation((_url, options) => {
+                const error = options.customErrorHandler?.({
+                    status: 500,
+                    data: { message: "Internal server error" },
+                });
+                if (error)
+                    throw error;
+                throw new Error("Server Error");
+            });
+            const sdk = createTestSdk();
+            await expect(sdk.runAction({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+                inputs: { message: "Hello" },
+            })).rejects.toThrow();
+        });
+        it("should propagate getAction errors", async () => {
+            mockGetAction.mockRejectedValue(new Error("Action not found"));
+            const sdk = createTestSdk();
+            await expect(sdk.runAction({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "nonexistent",
+                inputs: { message: "Hello" },
+            })).rejects.toThrow("Action not found");
+        });
+        it("should handle unexpected errors during execution", async () => {
+            mockApiClient.post = vi
+                .fn()
+                .mockRejectedValue(new Error("Network error"));
+            const sdk = createTestSdk();
+            await expect(sdk.runAction({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+                inputs: { message: "Hello" },
+            })).rejects.toThrow("Network error");
+        });
+    });
+    describe("pagination", () => {
+        it("should support maxItems limit", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.runAction({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+                inputs: { message: "Hello" },
+                maxItems: 1,
+            });
+            expect(result.data).toHaveLength(1);
+        });
+        it("should support async iteration over pages", async () => {
+            const sdk = createTestSdk();
+            const runActionResult = sdk.runAction({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+                inputs: { message: "Hello" },
+            });
+            const pages = [];
+            for await (const page of runActionResult) {
+                pages.push(page);
+                break; // Just get first page for testing
+            }
+            expect(pages).toHaveLength(1);
+            expect(pages[0].data).toEqual(mockActionResponse.results);
+        });
+        it("should support async iteration over individual items", async () => {
+            const sdk = createTestSdk();
+            const runActionResult = sdk.runAction({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+                inputs: { message: "Hello" },
+                maxItems: 1,
+            });
+            const items = [];
+            for await (const item of runActionResult.items()) {
+                items.push(item);
+            }
+            expect(items).toHaveLength(1);
+            expect(items[0]).toEqual(mockActionResponse.results[0]);
+        });
+    });
+    describe("context and metadata", () => {
+        it("should provide context with meta information", () => {
+            const sdk = createTestSdk();
+            const context = sdk.getContext();
+            expect(context.meta.runAction).toBeDefined();
+            expect(context.meta.runAction.inputSchema).toBeDefined();
+        });
+    });
+});

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

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import type { PaginatedSdkFunction } from "../../types/functions";
+export declare const RunActionSchema: 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 RunActionOptions = z.infer<typeof RunActionSchema>;
+export interface RunActionPage {
+    data: any[];
+    nextCursor?: string;
+}
+export type RunActionError = import("../../types/errors").ZapierActionError | import("../../types/errors").ZapierValidationError | import("../../types/errors").ZapierConfigurationError | import("../../types/errors").ZapierUnknownError;
+export interface RunActionSdkFunction {
+    runAction: PaginatedSdkFunction<RunActionOptions, any>;
+}
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/runAction/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAGlE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;EAoB0B,CAAC;AAGvD,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAG/D,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAGD,MAAM,MAAM,cAAc,GACtB,OAAO,oBAAoB,EAAE,iBAAiB,GAC9C,OAAO,oBAAoB,EAAE,qBAAqB,GAClD,OAAO,oBAAoB,EAAE,wBAAwB,GACrD,OAAO,oBAAoB,EAAE,kBAAkB,CAAC;AAGpD,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,oBAAoB,CAAC,gBAAgB,EAAE,GAAG,CAAC,CAAC;CACxD"}

package/dist/plugins/runAction/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 RunActionSchema = z
+    .object({
+    appKey: AppKeyPropertySchema,
+    actionType: ActionTypePropertySchema,
+    actionKey: ActionKeyPropertySchema,
+    authenticationId: AuthenticationIdPropertySchema.nullable().optional(),
+    inputs: InputsPropertySchema.optional().describe("Input parameters for the action"),
+    pageSize: z
+        .number()
+        .min(1)
+        .optional()
+        .describe("Number of results per page"),
+    maxItems: z
+        .number()
+        .min(1)
+        .optional()
+        .describe("Maximum total items to return across all pages"),
+})
+    .describe("Execute an action with the given inputs");

package/dist/resolvers/actionKey.d.ts

@@ -0,0 +1,9 @@
+import type { ZapierSdk } from "../types/sdk";
+export interface ActionKeyResolver {
+    type: "dynamic";
+    depends: readonly string[];
+    fetch: (sdk: ZapierSdk, resolvedParams: Record<string, any>) => Promise<any[]>;
+    prompt: (items: any[], params: Record<string, any>) => any;
+}
+export declare const actionKeyResolver: ActionKeyResolver;
+//# sourceMappingURL=actionKey.d.ts.map

package/dist/resolvers/actionKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actionKey.d.ts","sourceRoot":"","sources":["../../src/resolvers/actionKey.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,SAAS,CAAC;IAChB,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,KAAK,EAAE,CACL,GAAG,EAAE,SAAS,EACd,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAChC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;IACpB,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,GAAG,CAAC;CAC5D;AAED,eAAO,MAAM,iBAAiB,EAAE,iBAsB/B,CAAC"}

package/dist/resolvers/actionKey.js

@@ -0,0 +1,19 @@
+export const actionKeyResolver = {
+    type: "dynamic",
+    depends: ["appKey", "actionType"],
+    fetch: async (sdk, resolvedParams) => {
+        const actionsResponse = await sdk.listActions({
+            appKey: resolvedParams.appKey,
+        });
+        return actionsResponse.data.filter((action) => action.action_type === resolvedParams.actionType);
+    },
+    prompt: (actions) => ({
+        type: "list",
+        name: "actionKey",
+        message: "Select action:",
+        choices: actions.map((action) => ({
+            name: `${action.title || action.name || action.key} - ${action.description || "No description"}`,
+            value: action.key,
+        })),
+    }),
+};

package/dist/resolvers/actionType.d.ts

@@ -0,0 +1,9 @@
+import type { ZapierSdk } from "../types/sdk";
+export interface ActionTypeResolver {
+    type: "dynamic";
+    depends: readonly string[];
+    fetch: (sdk: ZapierSdk, resolvedParams: Record<string, any>) => Promise<any[]>;
+    prompt: (items: any[], params: Record<string, any>) => any;
+}
+export declare const actionTypeResolver: ActionTypeResolver;
+//# sourceMappingURL=actionType.d.ts.map

package/dist/resolvers/actionType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actionType.d.ts","sourceRoot":"","sources":["../../src/resolvers/actionType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,SAAS,CAAC;IAChB,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,KAAK,EAAE,CACL,GAAG,EAAE,SAAS,EACd,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAChC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;IACpB,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,GAAG,CAAC;CAC5D;AAED,eAAO,MAAM,kBAAkB,EAAE,kBAsBhC,CAAC"}

package/dist/resolvers/actionType.js

@@ -0,0 +1,22 @@
+export const actionTypeResolver = {
+    type: "dynamic",
+    depends: ["appKey"],
+    fetch: async (sdk, resolvedParams) => {
+        const actionsResponse = await sdk.listActions({
+            appKey: resolvedParams.appKey,
+        });
+        const types = [
+            ...new Set(actionsResponse.data.map((action) => action.action_type)),
+        ];
+        return types.map((type) => ({ key: type, name: type }));
+    },
+    prompt: (types) => ({
+        type: "list",
+        name: "actionType",
+        message: "Select action type:",
+        choices: types.map((type) => ({
+            name: type.name,
+            value: type.key,
+        })),
+    }),
+};

package/dist/resolvers/appKey.d.ts

@@ -0,0 +1,7 @@
+export interface AppKeyResolver {
+    type: "static";
+    inputType?: "text" | "password" | "email";
+    placeholder?: string;
+}
+export declare const appKeyResolver: AppKeyResolver;
+//# sourceMappingURL=appKey.d.ts.map

package/dist/resolvers/appKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"appKey.d.ts","sourceRoot":"","sources":["../../src/resolvers/appKey.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,OAAO,CAAC;IAC1C,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,eAAO,MAAM,cAAc,EAAE,cAI5B,CAAC"}

package/dist/resolvers/appKey.js

@@ -0,0 +1,5 @@
+export const appKeyResolver = {
+    type: "static",
+    inputType: "text",
+    placeholder: "Enter app key (e.g., 'SlackCLIAPI' or slug like 'github')",
+};

package/dist/resolvers/authenticationId.d.ts

@@ -0,0 +1,9 @@
+import type { ZapierSdk } from "../types/sdk";
+export interface AuthenticationIdResolver {
+    type: "dynamic";
+    depends: readonly string[];
+    fetch: (sdk: ZapierSdk, resolvedParams: Record<string, any>) => Promise<any[]>;
+    prompt: (items: any[], params: Record<string, any>) => any;
+}
+export declare const authenticationIdResolver: AuthenticationIdResolver;
+//# sourceMappingURL=authenticationId.d.ts.map

package/dist/resolvers/authenticationId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authenticationId.d.ts","sourceRoot":"","sources":["../../src/resolvers/authenticationId.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,SAAS,CAAC;IAChB,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,KAAK,EAAE,CACL,GAAG,EAAE,SAAS,EACd,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAChC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;IACpB,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,GAAG,CAAC;CAC5D;AAED,eAAO,MAAM,wBAAwB,EAAE,wBAkCtC,CAAC"}

package/dist/resolvers/authenticationId.js

@@ -0,0 +1,33 @@
+export const authenticationIdResolver = {
+    type: "dynamic",
+    depends: ["appKey"],
+    fetch: async (sdk, resolvedParams) => {
+        const myAuths = await sdk.listAuthentications({
+            appKey: resolvedParams.appKey,
+            maxItems: 1000,
+            owner: "me",
+        });
+        const allAuths = await sdk.listAuthentications({
+            appKey: resolvedParams.appKey,
+            maxItems: 1000,
+        });
+        // Filter out myAuths from allAuths
+        const otherAuths = allAuths.data.filter((auth) => !myAuths.data.some((myAuth) => myAuth.id === auth.id));
+        return [...myAuths.data, ...otherAuths];
+    },
+    prompt: (auths, params) => ({
+        type: "list",
+        name: "authenticationId",
+        message: `Select authentication for ${params.appKey}:`,
+        choices: [
+            ...auths.map((auth) => ({
+                name: `${auth.title || auth.label || "Authentication"} (ID: ${auth.id})`,
+                value: auth.id,
+            })),
+            {
+                name: "↗ Skip authentication (may fail)",
+                value: null,
+            },
+        ],
+    }),
+};

package/dist/resolvers/index.d.ts

@@ -0,0 +1,40 @@
+export declare const resolverRegistry: {
+    readonly appKey: import("./appKey").AppKeyResolver;
+    readonly actionType: import("./actionType").ActionTypeResolver;
+    readonly actionKey: import("./actionKey").ActionKeyResolver;
+    readonly authenticationId: import("./authenticationId").AuthenticationIdResolver;
+    readonly inputs: import("./inputs").InputsResolver;
+};
+export type ResolverName = keyof typeof resolverRegistry;
+export type ResolverType = (typeof resolverRegistry)[ResolverName];
+/**
+ * Get a resolver by name
+ */
+export declare function getResolver(name: string): ResolverType | undefined;
+/**
+ * Get all resolvers for a list of missing parameters
+ */
+export declare function getResolversForMissingParams(missingParams: string[]): Record<string, ResolverType>;
+/**
+ * Check if a parameter has a resolver
+ */
+export declare function hasResolver(paramName: string): boolean;
+/**
+ * Get all parameter names that have resolvers
+ */
+export declare function getResolvableParams(): string[];
+/**
+ * Resolve dependency chain for a parameter
+ * Returns parameters in the order they need to be resolved
+ */
+export declare function getResolutionOrder(paramName: string, resolved?: Set<string>): string[];
+/**
+ * Get resolution order for multiple parameters
+ */
+export declare function getResolutionOrderForParams(paramNames: string[]): string[];
+export { appKeyResolver } from "./appKey";
+export { actionTypeResolver } from "./actionType";
+export { actionKeyResolver } from "./actionKey";
+export { authenticationIdResolver } from "./authenticationId";
+export { inputsResolver } from "./inputs";
+//# sourceMappingURL=index.d.ts.map

package/dist/resolvers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/resolvers/index.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,gBAAgB;;;;;;CAMnB,CAAC;AAGX,MAAM,MAAM,YAAY,GAAG,MAAM,OAAO,gBAAgB,CAAC;AACzD,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,YAAY,CAAC,CAAC;AAInE;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAElE;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAC1C,aAAa,EAAE,MAAM,EAAE,GACtB,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAW9B;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAEtD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,EAAE,CAE9C;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,EACjB,QAAQ,GAAE,GAAG,CAAC,MAAM,CAAa,GAChC,MAAM,EAAE,CAuBV;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAc1E;AAGD,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC"}

package/dist/resolvers/index.js

@@ -0,0 +1,91 @@
+import { appKeyResolver } from "./appKey";
+import { actionTypeResolver } from "./actionType";
+import { actionKeyResolver } from "./actionKey";
+import { authenticationIdResolver } from "./authenticationId";
+import { inputsResolver } from "./inputs";
+// Centralized resolver registry
+export const resolverRegistry = {
+    appKey: appKeyResolver,
+    actionType: actionTypeResolver,
+    actionKey: actionKeyResolver,
+    authenticationId: authenticationIdResolver,
+    inputs: inputsResolver,
+};
+// Utility functions for working with resolvers
+/**
+ * Get a resolver by name
+ */
+export function getResolver(name) {
+    return resolverRegistry[name];
+}
+/**
+ * Get all resolvers for a list of missing parameters
+ */
+export function getResolversForMissingParams(missingParams) {
+    const resolvers = {};
+    for (const param of missingParams) {
+        const resolver = resolverRegistry[param];
+        if (resolver) {
+            resolvers[param] = resolver;
+        }
+    }
+    return resolvers;
+}
+/**
+ * Check if a parameter has a resolver
+ */
+export function hasResolver(paramName) {
+    return paramName in resolverRegistry;
+}
+/**
+ * Get all parameter names that have resolvers
+ */
+export function getResolvableParams() {
+    return Object.keys(resolverRegistry);
+}
+/**
+ * Resolve dependency chain for a parameter
+ * Returns parameters in the order they need to be resolved
+ */
+export function getResolutionOrder(paramName, resolved = new Set()) {
+    const resolver = getResolver(paramName);
+    if (!resolver || resolver.type === "static") {
+        return [paramName];
+    }
+    const order = [];
+    if ("depends" in resolver && resolver.depends) {
+        for (const dependency of resolver.depends) {
+            if (!resolved.has(dependency)) {
+                order.push(...getResolutionOrder(dependency, resolved));
+                resolved.add(dependency);
+            }
+        }
+    }
+    if (!resolved.has(paramName)) {
+        order.push(paramName);
+        resolved.add(paramName);
+    }
+    return order;
+}
+/**
+ * Get resolution order for multiple parameters
+ */
+export function getResolutionOrderForParams(paramNames) {
+    const resolved = new Set();
+    const order = [];
+    for (const paramName of paramNames) {
+        const paramOrder = getResolutionOrder(paramName, resolved);
+        for (const param of paramOrder) {
+            if (!order.includes(param)) {
+                order.push(param);
+            }
+        }
+    }
+    return order;
+}
+// Re-export individual resolvers for direct access if needed
+export { appKeyResolver } from "./appKey";
+export { actionTypeResolver } from "./actionType";
+export { actionKeyResolver } from "./actionKey";
+export { authenticationIdResolver } from "./authenticationId";
+export { inputsResolver } from "./inputs";