@zapier/zapier-sdk 0.4.1 → 0.5.0

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

@@ -0,0 +1,152 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ZapierValidationError, ZapierResourceNotFoundError, } from "../../types/errors";
+import { findUniqueAuthenticationPlugin } from "./index";
+import { createSdk } from "../../sdk";
+import { ListAuthenticationsSchema } from "../listAuthentications/schemas";
+const mockAuthentication = {
+    id: 123,
+    title: "My Slack",
+    date: "2021-01-01",
+    account_id: 123,
+    implementation_id: "api_123",
+    is_expired: "false",
+    expired_at: null,
+    is_invite_only: false,
+    is_private: false,
+    shared_with_all: false,
+};
+const mockAuthentications = [
+    mockAuthentication,
+    {
+        id: 456,
+        title: "Slack Workspace 2",
+        is_expired: "false",
+        expired_at: null,
+        date: "2021-01-01",
+        account_id: 123,
+        implementation_id: "api_123",
+        is_invite_only: false,
+        is_private: false,
+        shared_with_all: false,
+    },
+];
+describe("findUniqueAuthentication plugin", () => {
+    let mockListAuthentications;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockListAuthentications = vi.fn().mockResolvedValue({
+            data: [mockAuthentication],
+        });
+    });
+    function createTestSdk() {
+        // Create a proper plugin chain: first add a mock listAuthentications plugin, then add findUniqueAuthentication
+        const mockListAuthenticationsPlugin = () => ({
+            listAuthentications: mockListAuthentications,
+            context: {
+                meta: {
+                    listAuthentications: {
+                        inputSchema: ListAuthenticationsSchema,
+                    },
+                },
+            },
+        });
+        // Build SDK with proper plugin composition
+        return createSdk()
+            .addPlugin(mockListAuthenticationsPlugin)
+            .addPlugin(findUniqueAuthenticationPlugin);
+    }
+    describe("schema validation", () => {
+        it("should pass validation with empty options", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.findUniqueAuthentication({});
+            expect(result.data).toBeDefined();
+        });
+        it("should throw validation error for invalid appKey type", async () => {
+            const sdk = createTestSdk();
+            await expect(sdk.findUniqueAuthentication({
+                appKey: 123,
+            })).rejects.toThrow(ZapierValidationError);
+        });
+        it("should throw validation error for invalid parameter types", async () => {
+            const sdk = createTestSdk();
+            await expect(sdk.findUniqueAuthentication({
+                search: 123,
+                title: 456,
+                account_id: 789,
+                owner: false,
+            })).rejects.toThrow(ZapierValidationError);
+        });
+        it("should pass validation with all valid fields", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.findUniqueAuthentication({
+                appKey: "slack",
+                search: "Workspace",
+                title: "My Slack",
+                account_id: "acc_123",
+                owner: "me",
+            });
+            expect(result.data).toBeDefined();
+        });
+    });
+    describe("business logic", () => {
+        it("should return the first authentication when exactly one is found", async () => {
+            mockListAuthentications.mockResolvedValue({
+                data: [mockAuthentication],
+            });
+            const sdk = createTestSdk();
+            const result = await sdk.findUniqueAuthentication({
+                appKey: "slack",
+            });
+            expect(result.data).toEqual(mockAuthentication);
+        });
+        it("should throw ZapierResourceNotFoundError when no authentications found", async () => {
+            mockListAuthentications.mockResolvedValue({
+                data: [],
+            });
+            const sdk = createTestSdk();
+            await expect(sdk.findUniqueAuthentication({
+                appKey: "nonexistent",
+            })).rejects.toThrow(ZapierResourceNotFoundError);
+            await expect(sdk.findUniqueAuthentication({
+                appKey: "nonexistent",
+            })).rejects.toThrow("No authentication found matching the specified criteria");
+        });
+        it("should throw ZapierValidationError when multiple authentications found", async () => {
+            mockListAuthentications.mockResolvedValue({
+                data: mockAuthentications, // Two authentications
+            });
+            const sdk = createTestSdk();
+            await expect(sdk.findUniqueAuthentication({
+                search: "Workspace",
+            })).rejects.toThrow(ZapierValidationError);
+            await expect(sdk.findUniqueAuthentication({
+                search: "Workspace",
+            })).rejects.toThrow("Multiple authentications found matching the specified criteria. Expected exactly one.");
+        });
+    });
+    describe("options forwarding", () => {
+        it("should forward all options to listAuthentications with maxItems=2", async () => {
+            const sdk = createTestSdk();
+            const options = {
+                appKey: "slack",
+                search: "workspace",
+                title: "My Slack Workspace",
+                account_id: "acc_123",
+                owner: "me",
+            };
+            await sdk.findUniqueAuthentication(options);
+            expect(mockListAuthentications).toHaveBeenCalledWith({
+                ...options,
+                maxItems: 2,
+            });
+        });
+    });
+    describe("context and metadata", () => {
+        it("should provide context with meta information", () => {
+            const sdk = createTestSdk();
+            const context = sdk.getContext();
+            expect(context.meta.findUniqueAuthentication).toBeDefined();
+            expect(context.meta.findUniqueAuthentication.inputSchema).toBeDefined();
+        });
+    });
+});

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

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import type { AuthenticationItem } from "../../types/domain";
+export declare const FindUniqueAuthenticationSchema: z.ZodObject<{
+    appKey: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    account_id: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    title?: string | undefined;
+    search?: string | undefined;
+    account_id?: string | undefined;
+    appKey?: string | undefined;
+    owner?: string | undefined;
+}, {
+    title?: string | undefined;
+    search?: string | undefined;
+    account_id?: string | undefined;
+    appKey?: string | undefined;
+    owner?: string | undefined;
+}>;
+export type FindUniqueAuthenticationOptions = z.infer<typeof FindUniqueAuthenticationSchema>;
+export type FindUniqueAuthenticationError = import("../../types/errors").ZapierAuthenticationError | import("../../types/errors").ZapierApiError | import("../../types/errors").ZapierResourceNotFoundError | import("../../types/errors").ZapierValidationError | import("../../types/errors").ZapierUnknownError;
+export interface FindUniqueAuthenticationSdkFunction {
+    findUniqueAuthentication: (options?: FindUniqueAuthenticationOptions) => Promise<{
+        data: AuthenticationItem;
+    }>;
+}
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/findUniqueAuthentication/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAG7D,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;EAgBsB,CAAC;AAGlE,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CACnD,OAAO,8BAA8B,CACtC,CAAC;AAGF,MAAM,MAAM,6BAA6B,GACrC,OAAO,oBAAoB,EAAE,yBAAyB,GACtD,OAAO,oBAAoB,EAAE,cAAc,GAC3C,OAAO,oBAAoB,EAAE,2BAA2B,GACxD,OAAO,oBAAoB,EAAE,qBAAqB,GAClD,OAAO,oBAAoB,EAAE,kBAAkB,CAAC;AAGpD,MAAM,WAAW,mCAAmC;IAClD,wBAAwB,EAAE,CACxB,OAAO,CAAC,EAAE,+BAA+B,KACtC,OAAO,CAAC;QAAE,IAAI,EAAE,kBAAkB,CAAA;KAAE,CAAC,CAAC;CAC5C"}

package/dist/plugins/findUniqueAuthentication/schemas.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { AppKeyPropertySchema } from "../../types/properties";
+// Pure Zod schema - no resolver metadata!
+export const FindUniqueAuthenticationSchema = z
+    .object({
+    appKey: AppKeyPropertySchema.optional().describe("App key of authentication to find (e.g., 'SlackCLIAPI')"),
+    search: z
+        .string()
+        .optional()
+        .describe("Search term to filter authentications by title"),
+    title: z
+        .string()
+        .optional()
+        .describe("Filter authentications by exact title match"),
+    account_id: z.string().optional().describe("Filter by account ID"),
+    owner: z.string().optional().describe("Filter by owner"),
+})
+    .describe("Find a unique authentication matching the criteria");

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

@@ -0,0 +1,23 @@
+import type { Plugin, GetSdkType } from "../../types/plugin";
+import type { ApiClient } from "../../api";
+import type { ActionItem } from "../../types/domain";
+import { GetActionSchema, type GetActionOptions } from "./schemas";
+import type { ListActionsPluginProvides } from "../listActions";
+export interface GetActionPluginProvides {
+    getAction: (options: GetActionOptions) => Promise<{
+        data: ActionItem;
+    }>;
+    context: {
+        meta: {
+            getAction: {
+                inputSchema: typeof GetActionSchema;
+            };
+        };
+    };
+}
+export declare const getActionPlugin: Plugin<GetSdkType<ListActionsPluginProvides>, // requires listActions in SDK
+{
+    api: ApiClient;
+}, // requires api in context
+GetActionPluginProvides>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/getAction/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,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,KAAK,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAGnE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAEhE,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC;QAAE,IAAI,EAAE,UAAU,CAAA;KAAE,CAAC,CAAC;IACxE,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,SAAS,EAAE;gBACT,WAAW,EAAE,OAAO,eAAe,CAAC;aACrC,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,eAAe,EAAE,MAAM,CAClC,UAAU,CAAC,yBAAyB,CAAC,EAAE,8BAA8B;AACrE;IAAE,GAAG,EAAE,SAAS,CAAA;CAAE,EAAE,0BAA0B;AAC9C,uBAAuB,CAkCxB,CAAC"}

package/dist/plugins/getAction/index.js

@@ -0,0 +1,28 @@
+import { GetActionSchema } from "./schemas";
+import { ZapierResourceNotFoundError } from "../../types/errors";
+import { createFunction } from "../../utils/function-utils";
+export const getActionPlugin = ({ sdk }) => {
+    const getAction = createFunction(async function getAction(options) {
+        const { actionKey, actionType, appKey } = options;
+        // Use the listActions function from the SDK to search for the specific action
+        const actionsResult = await sdk.listActions({ appKey });
+        // Search through all actions to find the matching one
+        for (const action of actionsResult.data) {
+            if (action.key === actionKey && action.action_type === actionType) {
+                return { data: action };
+            }
+        }
+        // If we get here, action was not found
+        throw new ZapierResourceNotFoundError(`Action not found: ${actionKey} with type ${actionType}`, { resourceType: "Action", resourceId: `${actionKey} (${actionType})` });
+    }, GetActionSchema);
+    return {
+        getAction,
+        context: {
+            meta: {
+                getAction: {
+                    inputSchema: GetActionSchema,
+                },
+            },
+        },
+    };
+};

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

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

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

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

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

@@ -0,0 +1,186 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ZapierValidationError, ZapierResourceNotFoundError, } from "../../types/errors";
+import { getActionPlugin } from "./index";
+import { createSdk } from "../../sdk";
+import { ListActionsSchema } from "../listActions/schemas";
+const mockActions = [
+    {
+        type: "action",
+        key: "user_by_email",
+        title: "Search User by Email",
+        description: "Find a user by email address",
+        app_key: "slack",
+        action_type: "search",
+    },
+    {
+        type: "action",
+        key: "search_messages",
+        title: "Search Messages",
+        description: "Search for messages in channels",
+        app_key: "slack",
+        action_type: "search",
+    },
+    {
+        type: "action",
+        key: "user_by_email",
+        title: "Search User by Email",
+        description: "Find a user by email address",
+        app_key: "slack",
+        action_type: "write", // Different action type for testing mismatch
+    },
+];
+describe("getAction plugin", () => {
+    let mockListActions;
+    let mockApiClient;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockListActions = vi.fn().mockResolvedValue({
+            data: mockActions,
+        });
+        mockApiClient = {};
+    });
+    function createTestSdk() {
+        // Create a proper plugin chain with context dependencies
+        const mockListActionsPlugin = () => ({
+            listActions: mockListActions,
+            context: {
+                meta: {
+                    listActions: {
+                        inputSchema: ListActionsSchema,
+                    },
+                },
+            },
+        });
+        // Build SDK with proper plugin composition, providing API in initial context
+        return createSdk({}, { api: mockApiClient, meta: {} })
+            .addPlugin(mockListActionsPlugin)
+            .addPlugin(getActionPlugin);
+    }
+    describe("schema validation", () => {
+        it("should throw validation error for missing appKey", async () => {
+            const sdk = createTestSdk();
+            await expect(sdk.getAction({
+                actionType: "search",
+                actionKey: "user_by_email",
+            })).rejects.toThrow(ZapierValidationError);
+        });
+        it("should throw validation error for missing actionType", async () => {
+            const sdk = createTestSdk();
+            await expect(sdk.getAction({
+                appKey: "slack",
+                actionKey: "user_by_email",
+            })).rejects.toThrow(ZapierValidationError);
+        });
+        it("should throw validation error for missing actionKey", async () => {
+            const sdk = createTestSdk();
+            await expect(sdk.getAction({
+                appKey: "slack",
+                actionType: "search",
+            })).rejects.toThrow(ZapierValidationError);
+        });
+        it("should throw validation error for invalid appKey type", async () => {
+            const sdk = createTestSdk();
+            await expect(sdk.getAction({
+                appKey: 123,
+                actionType: "search",
+                actionKey: "user_by_email",
+            })).rejects.toThrow(ZapierValidationError);
+        });
+        it("should throw validation error for invalid actionType", async () => {
+            const sdk = createTestSdk();
+            await expect(sdk.getAction({
+                appKey: "slack",
+                actionType: "invalid-type",
+                actionKey: "user_by_email",
+            })).rejects.toThrow(ZapierValidationError);
+        });
+        it("should throw validation error for invalid actionKey type", async () => {
+            const sdk = createTestSdk();
+            await expect(sdk.getAction({
+                appKey: "slack",
+                actionType: "search",
+                actionKey: 123,
+            })).rejects.toThrow(ZapierValidationError);
+        });
+        it("should throw validation error for empty appKey", async () => {
+            const sdk = createTestSdk();
+            await expect(sdk.getAction({
+                appKey: "",
+                actionType: "search",
+                actionKey: "user_by_email",
+            })).rejects.toThrow(ZapierValidationError);
+        });
+        it("should throw validation error for empty actionKey", async () => {
+            const sdk = createTestSdk();
+            await expect(sdk.getAction({
+                appKey: "slack",
+                actionType: "search",
+                actionKey: "",
+            })).rejects.toThrow(ZapierValidationError);
+        });
+        it("should pass validation with all required fields", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.getAction({
+                appKey: "slack",
+                actionType: "search",
+                actionKey: "user_by_email",
+            });
+            expect(result.data).toEqual(mockActions[0]);
+        });
+    });
+    describe("action lookup", () => {
+        it("should call listActions with correct parameters", async () => {
+            const sdk = createTestSdk();
+            await sdk.getAction({
+                appKey: "slack",
+                actionType: "search",
+                actionKey: "user_by_email",
+            });
+            expect(mockListActions).toHaveBeenCalledWith({
+                appKey: "slack",
+            });
+        });
+        it("should return the correct action when found", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.getAction({
+                appKey: "slack",
+                actionType: "search",
+                actionKey: "user_by_email",
+            });
+            expect(result.data).toEqual(mockActions[0]);
+        });
+        it("should throw error when action key not found", async () => {
+            const sdk = createTestSdk();
+            await expect(sdk.getAction({
+                appKey: "slack",
+                actionType: "search",
+                actionKey: "nonexistent_action",
+            })).rejects.toThrow(ZapierResourceNotFoundError);
+        });
+        it("should throw error when action type doesn't match", async () => {
+            const sdk = createTestSdk();
+            await expect(sdk.getAction({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "search_messages", // This action is type "search" in mock
+            })).rejects.toThrow(ZapierResourceNotFoundError);
+        });
+        it("should handle listActions errors", async () => {
+            mockListActions.mockRejectedValue(new Error("API Error"));
+            const sdk = createTestSdk();
+            await expect(sdk.getAction({
+                appKey: "slack",
+                actionType: "search",
+                actionKey: "user_by_email",
+            })).rejects.toThrow("API Error");
+        });
+    });
+    describe("plugin integration", () => {
+        it("should provide metadata in context", () => {
+            const sdk = createTestSdk();
+            const context = sdk.getContext();
+            expect(context.meta.getAction).toBeDefined();
+            expect(context.meta.getAction.inputSchema).toBeDefined();
+        });
+    });
+});

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

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import type { ActionItem } from "../../types/domain";
+export declare const GetActionSchema: z.ZodObject<{
+    appKey: z.ZodString;
+    actionType: z.ZodEnum<["read", "read_bulk", "write", "run", "search", "search_or_write", "search_and_write", "filter"]>;
+    actionKey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    appKey: string;
+    actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+    actionKey: string;
+}, {
+    appKey: string;
+    actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+    actionKey: string;
+}>;
+export type GetActionOptions = z.infer<typeof GetActionSchema>;
+export type GetActionError = import("../../types/errors").ZapierAuthenticationError | import("../../types/errors").ZapierApiError | import("../../types/errors").ZapierAppNotFoundError | import("../../types/errors").ZapierValidationError | import("../../types/errors").ZapierResourceNotFoundError | import("../../types/errors").ZapierUnknownError;
+export interface GetActionSdkFunction {
+    getAction: (options: GetActionOptions) => Promise<{
+        data: ActionItem;
+    }>;
+}
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/getAction/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAGrD,eAAO,MAAM,eAAe;;;;;;;;;;;;EAMmC,CAAC;AAGhE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAG/D,MAAM,MAAM,cAAc,GACtB,OAAO,oBAAoB,EAAE,yBAAyB,GACtD,OAAO,oBAAoB,EAAE,cAAc,GAC3C,OAAO,oBAAoB,EAAE,sBAAsB,GACnD,OAAO,oBAAoB,EAAE,qBAAqB,GAClD,OAAO,oBAAoB,EAAE,2BAA2B,GACxD,OAAO,oBAAoB,EAAE,kBAAkB,CAAC;AAGpD,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC;QAAE,IAAI,EAAE,UAAU,CAAA;KAAE,CAAC,CAAC;CACzE"}

package/dist/plugins/getAction/schemas.js

@@ -0,0 +1,10 @@
+import { z } from "zod";
+import { AppKeyPropertySchema, ActionTypePropertySchema, ActionKeyPropertySchema, } from "../../types/properties";
+// Pure Zod schema - no resolver metadata!
+export const GetActionSchema = z
+    .object({
+    appKey: AppKeyPropertySchema,
+    actionType: ActionTypePropertySchema,
+    actionKey: ActionKeyPropertySchema,
+})
+    .describe("Get detailed information about a specific action");

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

@@ -0,0 +1,22 @@
+import type { Plugin } from "../../types/plugin";
+import { GetAppSchema } from "./schemas";
+import type { GetAppOptions } from "./schemas";
+import type { AppItem } from "../../types/domain";
+import type { ListAppsPluginProvides } from "../listApps";
+import type { GetSdkType } from "../../types/plugin";
+export interface GetAppPluginProvides {
+    getApp: (options: GetAppOptions) => Promise<{
+        data: AppItem;
+    }>;
+    context: {
+        meta: {
+            getApp: {
+                inputSchema: typeof GetAppSchema;
+            };
+        };
+    };
+}
+export declare const getAppPlugin: Plugin<GetSdkType<ListAppsPluginProvides>, // depends on listApps
+{}, // no additional context dependencies
+GetAppPluginProvides>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/getApp/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAElD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAGrD,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,OAAO,CAAC;QAAE,IAAI,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IAC/D,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,MAAM,EAAE;gBACN,WAAW,EAAE,OAAO,YAAY,CAAC;aAClC,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAGD,eAAO,MAAM,YAAY,EAAE,MAAM,CAC/B,UAAU,CAAC,sBAAsB,CAAC,EAAE,sBAAsB;AAC1D,EAAE,EAAE,qCAAqC;AACzC,oBAAoB,CAwCrB,CAAC"}

package/dist/plugins/getApp/index.js

@@ -0,0 +1,39 @@
+import { createFunction } from "../../utils/function-utils";
+import { GetAppSchema } from "./schemas";
+import { ZapierAppNotFoundError } from "../../types/errors";
+// GetApp plugin depends on listApps SDK function
+export const getAppPlugin = ({ sdk }) => {
+    const getApp = createFunction(async function getApp(options) {
+        const { appKey } = options;
+        // Use listApps to get the app by key
+        const appsIterator = sdk
+            .listApps({
+            ...options,
+            appKeys: [appKey],
+        })
+            .items();
+        // Get the first (and should be only) result
+        const apps = [];
+        for await (const app of appsIterator) {
+            apps.push(app);
+            break; // Only need the first result
+        }
+        if (apps.length === 0) {
+            throw new ZapierAppNotFoundError(appKey);
+        }
+        return {
+            data: apps[0],
+        };
+    }, GetAppSchema);
+    // Return flat structure - getApp goes directly to SDK
+    return {
+        getApp,
+        context: {
+            meta: {
+                getApp: {
+                    inputSchema: GetAppSchema,
+                },
+            },
+        },
+    };
+};

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

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

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

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