@zapier/zapier-sdk 0.13.6 → 0.13.8

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

@@ -1,239 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import {
-  ZapierValidationError,
-  ZapierResourceNotFoundError,
-} from "../../types/errors";
-import { getActionPlugin } from "./index";
-import { createSdk } from "../../sdk";
-import type { GetActionOptions } from "./schemas";
-import type { ActionItem } from "../../types/domain";
-import type { ApiClient } from "../../api";
-import { ListActionsSchema } from "../listActions/schemas";
-
-const mockActions: ActionItem[] = [
-  {
-    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: any;
-  let mockApiClient: ApiClient;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockListActions = vi.fn().mockResolvedValue({
-      data: mockActions,
-    });
-    mockApiClient = {} as ApiClient;
-  });
-
-  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",
-        } as Partial<GetActionOptions> as GetActionOptions),
-      ).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",
-        } as Partial<GetActionOptions> as GetActionOptions),
-      ).rejects.toThrow(ZapierValidationError);
-    });
-
-    it("should throw validation error for missing actionKey", async () => {
-      const sdk = createTestSdk();
-      await expect(
-        sdk.getAction({
-          appKey: "slack",
-          actionType: "search",
-        } as Partial<GetActionOptions> as GetActionOptions),
-      ).rejects.toThrow(ZapierValidationError);
-    });
-
-    it("should throw validation error for invalid appKey type", async () => {
-      const sdk = createTestSdk();
-      await expect(
-        sdk.getAction({
-          appKey: 123 as any,
-          actionType: "search",
-          actionKey: "user_by_email",
-        } as any),
-      ).rejects.toThrow(ZapierValidationError);
-    });
-
-    it("should throw validation error for invalid actionType", async () => {
-      const sdk = createTestSdk();
-      await expect(
-        sdk.getAction({
-          appKey: "slack",
-          actionType: "invalid-type" as any,
-          actionKey: "user_by_email",
-        } as any),
-      ).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,
-        } as any),
-      ).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/src/plugins/getAction/index.ts

@@ -1,75 +0,0 @@
-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 { ZapierResourceNotFoundError } from "../../types/errors";
-import { createFunction } from "../../utils/function-utils";
-import type { ListActionsPluginProvides } from "../listActions";
-import {
-  appKeyResolver,
-  actionTypeResolver,
-  actionKeyResolver,
-} from "../../resolvers";
-import { ActionItemSchema } from "../../schemas/Action";
-
-export interface GetActionPluginProvides {
-  getAction: (options: GetActionOptions) => Promise<{ data: ActionItem }>;
-  context: {
-    meta: {
-      getAction: {
-        inputSchema: typeof GetActionSchema;
-      };
-    };
-  };
-}
-
-export const getActionPlugin: Plugin<
-  GetSdkType<ListActionsPluginProvides>, // requires listActions in SDK
-  { api: ApiClient }, // requires api in context
-  GetActionPluginProvides
-> = ({ sdk }) => {
-  const getAction = createFunction(async function getAction(
-    options: GetActionOptions,
-  ) {
-    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 (by key or ID)
-    for (const action of actionsResult.data) {
-      if (
-        (action.key === actionKey || action.id === 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: {
-          categories: ["action"],
-          type: "item",
-          itemType: "Action",
-          inputSchema: GetActionSchema,
-          outputSchema: ActionItemSchema,
-          resolvers: {
-            appKey: appKeyResolver,
-            actionType: actionTypeResolver,
-            actionKey: actionKeyResolver,
-          },
-        },
-      },
-    },
-  };
-};

package/src/plugins/getAction/schemas.ts

@@ -1,41 +0,0 @@
-import { z } from "zod";
-import {
-  AppKeyPropertySchema,
-  ActionTypePropertySchema,
-  ActionKeyPropertySchema,
-} from "../../types/properties";
-import type { ActionItem } from "../../types/domain";
-import type {
-  ZapierAuthenticationError,
-  ZapierApiError,
-  ZapierAppNotFoundError,
-  ZapierValidationError,
-  ZapierResourceNotFoundError,
-  ZapierUnknownError,
-} from "../../types/errors";
-
-// 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");
-
-// Type inferred from schema
-export type GetActionOptions = z.infer<typeof GetActionSchema>;
-
-// Error union for this function (inherits from listActionsSafe + resource not found)
-export type GetActionError =
-  | ZapierAuthenticationError
-  | ZapierApiError
-  | ZapierAppNotFoundError
-  | ZapierValidationError
-  | ZapierResourceNotFoundError
-  | ZapierUnknownError;
-
-// SDK function interface
-export interface GetActionSdkFunction {
-  getAction: (options: GetActionOptions) => Promise<{ data: ActionItem }>;
-}

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

@@ -1,181 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import {
-  ZapierValidationError,
-  ZapierAppNotFoundError,
-} from "../../types/errors";
-import { getAppPlugin } from "./index";
-import { createSdk } from "../../sdk";
-import { apiPlugin } from "../api/index";
-import { listAppsPlugin } from "../listApps";
-import { manifestPlugin } from "../manifest";
-
-function createTestSdk() {
-  return createSdk()
-    .addPlugin(apiPlugin, { fetch: global.fetch })
-    .addPlugin(manifestPlugin)
-    .addPlugin(listAppsPlugin)
-    .addPlugin(getAppPlugin);
-}
-
-describe("getApp plugin", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe("schema validation", () => {
-    it("should throw validation error for missing appKey", async () => {
-      const sdk = createTestSdk();
-      await expect(sdk.getApp({} as any)).rejects.toThrow(
-        ZapierValidationError,
-      );
-    });
-
-    it("should throw validation error for invalid appKey type", async () => {
-      const sdk = createTestSdk();
-      await expect(
-        sdk.getApp({
-          appKey: 123 as any,
-        } as any),
-      ).rejects.toThrow(ZapierValidationError);
-    });
-
-    it("should throw validation error for empty string appKey", async () => {
-      const sdk = createTestSdk();
-      await expect(
-        sdk.getApp({
-          appKey: "",
-        }),
-      ).rejects.toThrow(ZapierValidationError);
-    });
-
-    it("should pass validation with valid appKey", async () => {
-      const sdk = createTestSdk();
-      const context = sdk.getContext();
-
-      // Mock the API client to handle both resolveAppKeys and listApps calls
-      (context.api as any).get = vi
-        .fn()
-        // First call: resolveAppKeys may call to resolve slug to implementation name
-        .mockResolvedValueOnce({
-          results: [
-            {
-              id: "SlackCLIAPI@1.0.0",
-              name: "Slack",
-              description: "Team communication",
-              primary_color: "#4A154B",
-              categories: ["communication"],
-              slug: "slack",
-              key: "SlackCLIAPI",
-              version: "1.0.0",
-            },
-          ],
-          next: null,
-        })
-        // Second call: listApps main API call
-        .mockResolvedValueOnce({
-          results: [
-            {
-              id: "SlackCLIAPI@1.0.0",
-              name: "Slack",
-              description: "Team communication",
-              primary_color: "#4A154B",
-              categories: ["communication"],
-              slug: "slack",
-              key: "SlackCLIAPI",
-              version: "1.0.0",
-            },
-          ],
-          next: null,
-        });
-
-      const result = await sdk.getApp({
-        appKey: "slack",
-      });
-
-      expect(result.data.title).toBe("Slack");
-      expect(result.data.key).toBe("SlackCLIAPI");
-      expect(result.data.implementation_id).toBe("SlackCLIAPI@1.0.0");
-      expect(result.data.version).toBe("1.0.0");
-    });
-  });
-
-  describe("error handling", () => {
-    it("should throw ZapierAppNotFoundError when app does not exist", async () => {
-      const sdk = createTestSdk();
-      const context = sdk.getContext();
-
-      // Mock API to return empty results for both potential calls
-      (context.api as any).get = vi
-        .fn()
-        // First call: resolveAppKeys may call to resolve slug
-        .mockResolvedValueOnce({
-          results: [],
-          next: null,
-        })
-        // Second call: listApps main API call
-        .mockResolvedValueOnce({
-          results: [],
-          next: null,
-        });
-
-      await expect(
-        sdk.getApp({
-          appKey: "nonexistent-app",
-        }),
-      ).rejects.toThrow(ZapierAppNotFoundError);
-    });
-  });
-
-  describe("data mapping", () => {
-    it("should return essential app properties", async () => {
-      const sdk = createTestSdk();
-      const context = sdk.getContext();
-
-      // Mock the API client to handle both resolveAppKeys and listApps calls
-      (context.api as any).get = vi
-        .fn()
-        // First call: resolveAppKeys may call to resolve slug to implementation name
-        .mockResolvedValueOnce({
-          results: [
-            {
-              id: "TestCLIAPI@1.0.0",
-              name: "Test App",
-              description: "Test description",
-              primary_color: "#FF0000",
-              categories: ["testing"],
-              slug: "test",
-              key: "TestCLIAPI",
-              version: "1.0.0",
-            },
-          ],
-          next: null,
-        })
-        // Second call: listApps main API call
-        .mockResolvedValueOnce({
-          results: [
-            {
-              id: "TestCLIAPI@1.0.0",
-              name: "Test App",
-              description: "Test description",
-              primary_color: "#FF0000",
-              categories: ["testing"],
-              slug: "test",
-              key: "TestCLIAPI",
-              version: "1.0.0",
-            },
-          ],
-          next: null,
-        });
-
-      const result = await sdk.getApp({
-        appKey: "test",
-      });
-
-      expect(result.data.title).toBeDefined();
-      expect(result.data.key).toBeDefined();
-      expect(result.data.implementation_id).toBeDefined();
-      expect(result.data.title).toBe("Test App");
-      expect(result.data.key).toBe("TestCLIAPI");
-    });
-  });
-});

package/src/plugins/getApp/index.ts

@@ -1,60 +0,0 @@
-import type { Plugin } from "../../types/plugin";
-import { createFunction } from "../../utils/function-utils";
-import { GetAppSchema } from "./schemas";
-import type { GetAppOptions } from "./schemas";
-import type { AppItem } from "../../types/domain";
-import { AppItemSchema } from "../../schemas/App";
-import { ZapierAppNotFoundError } from "../../types/errors";
-import type { GetSdkType } from "../../types/plugin";
-import type { ListAppsPluginProvides } from "../listApps";
-import { appKeyResolver } from "../../resolvers";
-
-// GetApp plugin provides interface - getApp goes directly to SDK root
-export interface GetAppPluginProvides {
-  getApp: (options: GetAppOptions) => Promise<{ data: AppItem }>;
-  context: {
-    meta: {
-      getApp: {
-        inputSchema: typeof GetAppSchema;
-      };
-    };
-  };
-}
-
-// GetApp plugin depends on listApps SDK function
-export const getAppPlugin: Plugin<
-  GetSdkType<ListAppsPluginProvides>,
-  {},
-  GetAppPluginProvides
-> = ({ sdk }) => {
-  const getApp = createFunction(async function getApp(options: GetAppOptions) {
-    const appsIterator = sdk.listApps({ appKeys: [options.appKey] }).items();
-    for await (const app of appsIterator) {
-      return {
-        data: app,
-      };
-    }
-    throw new ZapierAppNotFoundError("App not found", {
-      appKey: options.appKey,
-    });
-  }, GetAppSchema);
-
-  // Return flat structure - getApp goes directly to SDK
-  return {
-    getApp,
-    context: {
-      meta: {
-        getApp: {
-          categories: ["app"],
-          type: "item",
-          itemType: "App",
-          inputSchema: GetAppSchema,
-          outputSchema: AppItemSchema,
-          resolvers: {
-            appKey: appKeyResolver,
-          },
-        },
-      },
-    },
-  };
-};

package/src/plugins/getApp/schemas.ts

@@ -1,33 +0,0 @@
-import { z } from "zod";
-import { AppKeyPropertySchema } from "../../types/properties";
-import type { AppItem } from "../../types/domain";
-import type {
-  ZapierApiError,
-  ZapierAppNotFoundError,
-  ZapierValidationError,
-} from "../../types/errors";
-
-// Error types (now imported from types/errors)
-
-// Union of all possible errors for getApp
-export type GetAppError =
-  | ZapierAppNotFoundError
-  | ZapierApiError
-  | ZapierValidationError;
-
-// Pure Zod schema - no resolver metadata!
-export const GetAppSchema = z
-  .object({
-    appKey: AppKeyPropertySchema.describe(
-      "App key of app to fetch (e.g., 'SlackCLIAPI' or slug like 'github')",
-    ),
-  })
-  .describe("Get detailed information about a specific app");
-
-// Type inferred from schema
-export type GetAppOptions = z.infer<typeof GetAppSchema>;
-
-// SDK function interface - ready to be mixed into main SDK interface
-export interface GetAppSdkFunction {
-  getApp: (options: GetAppOptions) => Promise<{ data: AppItem }>;
-}