@zapier/zapier-sdk-cli 0.16.1 → 0.16.3

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

@@ -1,679 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { buildManifestPlugin } from "./index";
-import { BuildManifestSchema } from "./schemas";
-import type {
-  AppItem,
-  Manifest,
-  UpdateManifestEntryOptions,
-} from "@zapier/zapier-sdk";
-import {
-  createSdk,
-  ZapierUnknownError,
-  ZapierValidationError,
-} from "@zapier/zapier-sdk";
-
-const mockSlackApp: AppItem = {
-  key: "SlackCLIAPI",
-  slug: "slack",
-  title: "Slack",
-  description: "Slack is a collaboration hub",
-  version: "1.30.0",
-  implementation_id: "SlackCLIAPI@1.30.0",
-};
-
-const mockGmailApp: AppItem = {
-  key: "GmailCLIAPI",
-  slug: "gmail",
-  title: "Gmail",
-  description: "Gmail is an email service",
-  version: "2.5.0",
-  implementation_id: "GmailCLIAPI@2.5.0",
-};
-
-const mockAppWithoutVersion: AppItem = {
-  key: "BrokenAPI",
-  slug: "broken",
-  title: "Broken App",
-  description: "An app without version",
-  version: undefined,
-  implementation_id: "BrokenAPI",
-};
-
-describe("buildManifest plugin", () => {
-  let mockUpdateManifestEntry: unknown;
-  let mockListAppsItems: unknown;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-
-    mockUpdateManifestEntry = vi
-      .fn()
-      .mockImplementation(async (options: UpdateManifestEntryOptions) => {
-        const manifestKey = options.entry.implementationName;
-        const updatedManifest: Manifest = {
-          apps: {
-            ...options.manifest?.apps,
-            [manifestKey]: options.entry,
-          },
-        };
-        return {
-          key: manifestKey,
-          entry: options.entry,
-          manifest: updatedManifest,
-        };
-      });
-
-    mockListAppsItems = vi.fn();
-  });
-
-  function createTestSdk(apps: AppItem[] = [mockSlackApp, mockGmailApp]) {
-    // Mock async iterator for listApps
-    mockListAppsItems.mockReturnValue({
-      async *[Symbol.asyncIterator]() {
-        for (const app of apps) {
-          yield app;
-        }
-      },
-    });
-
-    return createSdk()
-      .addPlugin(() => ({
-        context: {
-          updateManifestEntry: mockUpdateManifestEntry,
-          addActionEntry: vi
-            .fn()
-            .mockResolvedValue(["test-key", {}, { apps: {} }]),
-          findActionEntry: vi.fn().mockResolvedValue({
-            key: "test-key",
-            entry: {},
-            manifest: { apps: {} },
-          }),
-          hasActionEntry: vi.fn().mockResolvedValue(true),
-          listActionEntries: vi
-            .fn()
-            .mockResolvedValue([
-              [
-                "test-key",
-                { key: "test-key", entry: {}, manifest: { apps: {} } },
-              ],
-            ]),
-          deleteActionEntry: vi.fn().mockResolvedValue({ apps: {} }),
-          findManifestEntry: vi
-            .fn()
-            .mockResolvedValue([
-              "test-key",
-              { key: "test-key", entry: {}, manifest: { apps: {} } },
-            ]),
-          readManifestFromFile: vi.fn().mockResolvedValue({ apps: {} }),
-        },
-      }))
-      .addPlugin(() => ({
-        listApps: vi.fn().mockReturnValue({
-          items: mockListAppsItems,
-        }),
-      }))
-      .addPlugin(buildManifestPlugin);
-  }
-
-  describe("schema validation", () => {
-    it("should accept valid options with skipWrite true", () => {
-      const result = BuildManifestSchema.safeParse({
-        appKeys: ["slack", "gmail"],
-        skipWrite: true,
-      });
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.data.skipWrite).toBe(true);
-      }
-    });
-
-    it("should accept valid options with skipWrite false and configPath", () => {
-      const result = BuildManifestSchema.safeParse({
-        appKeys: ["slack"],
-        skipWrite: false,
-        configPath: "/path/to/.zapierrc",
-      });
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.data.skipWrite).toBe(false);
-        expect(result.data.configPath).toBe("/path/to/.zapierrc");
-      }
-    });
-
-    it("should accept options without skipWrite (defaults to false)", () => {
-      const result = BuildManifestSchema.safeParse({
-        appKeys: ["slack"],
-      });
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.data.skipWrite).toBeUndefined();
-      }
-    });
-
-    it("should require at least one appKey", () => {
-      const result = BuildManifestSchema.safeParse({
-        appKeys: [],
-      });
-
-      expect(result.success).toBe(false);
-    });
-
-    it("should reject empty string appKeys", () => {
-      const result = BuildManifestSchema.safeParse({
-        appKeys: ["slack", ""],
-      });
-
-      expect(result.success).toBe(false);
-    });
-
-    it("should reject non-array appKeys", () => {
-      const result = BuildManifestSchema.safeParse({
-        appKeys: "slack",
-      });
-
-      expect(result.success).toBe(false);
-    });
-  });
-
-  describe("manifest building with skipWrite: true", () => {
-    it("should build manifest entries without writing to disk", async () => {
-      const sdk = createTestSdk();
-
-      const result = await sdk.buildManifest({
-        appKeys: ["slack", "gmail"],
-        skipWrite: true,
-      });
-
-      // Should still call updateManifestEntry with skipWrite: true
-      expect(mockUpdateManifestEntry).toHaveBeenCalledTimes(2);
-      expect(mockUpdateManifestEntry).toHaveBeenCalledWith(
-        expect.objectContaining({
-          skipWrite: true,
-        }),
-      );
-
-      // Should return manifest with entries
-      expect(result.manifest).toBeDefined();
-      expect(result.manifest?.apps).toBeDefined();
-    });
-
-    it("should process apps and create manifest entries", async () => {
-      const sdk = createTestSdk();
-
-      const result = await sdk.buildManifest({
-        appKeys: ["slack"],
-        skipWrite: true,
-      });
-
-      expect(result.manifest?.apps).toBeDefined();
-    });
-
-    it("should return empty result when no apps found", async () => {
-      const sdk = createTestSdk([]);
-
-      const result = await sdk.buildManifest({
-        appKeys: ["nonexistent"],
-        skipWrite: true,
-      });
-
-      expect(result.manifest).toBeUndefined();
-    });
-  });
-
-  describe("manifest building with skipWrite: false", () => {
-    it("should build manifest and write to disk", async () => {
-      const sdk = createTestSdk();
-
-      const result = await sdk.buildManifest({
-        appKeys: ["slack", "gmail"],
-        skipWrite: false,
-        configPath: "/path/to/.zapierrc",
-      });
-
-      // Should call updateManifestEntry for each app
-      expect(mockUpdateManifestEntry).toHaveBeenCalledTimes(2);
-
-      // First call for slack
-      expect(mockUpdateManifestEntry).toHaveBeenNthCalledWith(1, {
-        appKey: "SlackCLIAPI",
-        entry: {
-          implementationName: "SlackCLIAPI",
-          version: "1.30.0",
-        },
-        configPath: "/path/to/.zapierrc",
-        skipWrite: false,
-        manifest: undefined,
-      });
-
-      // Second call for gmail (with manifest from first call)
-      expect(mockUpdateManifestEntry).toHaveBeenNthCalledWith(2, {
-        appKey: "GmailCLIAPI",
-        entry: {
-          implementationName: "GmailCLIAPI",
-          version: "2.5.0",
-        },
-        configPath: "/path/to/.zapierrc",
-        skipWrite: false,
-        manifest: {
-          apps: {
-            SlackCLIAPI: {
-              implementationName: "SlackCLIAPI",
-              version: "1.30.0",
-            },
-          },
-        },
-      });
-
-      // Should return updated manifest
-      expect(result.manifest).toBeDefined();
-      expect(result.manifest?.apps?.SlackCLIAPI).toEqual({
-        implementationName: "SlackCLIAPI",
-        version: "1.30.0",
-      });
-      expect(result.manifest?.apps?.GmailCLIAPI).toEqual({
-        implementationName: "GmailCLIAPI",
-        version: "2.5.0",
-      });
-    });
-
-    it("should accumulate manifest entries across multiple apps", async () => {
-      const sdk = createTestSdk();
-
-      const result = await sdk.buildManifest({
-        appKeys: ["slack", "gmail"],
-        skipWrite: false,
-      });
-
-      // Verify that the second call received the manifest from the first call
-      const secondCallArgs = mockUpdateManifestEntry.mock.calls[1][0];
-      expect(secondCallArgs.manifest).toEqual({
-        apps: {
-          SlackCLIAPI: {
-            implementationName: "SlackCLIAPI",
-            version: "1.30.0",
-          },
-        },
-      });
-
-      // Final result should have both apps
-      expect(Object.keys(result.manifest?.apps || {})).toHaveLength(2);
-    });
-  });
-
-  describe("progress events", () => {
-    it("should emit apps_lookup_start event", async () => {
-      const sdk = createTestSdk();
-      const onProgress = vi.fn();
-
-      await sdk.buildManifest({
-        appKeys: ["slack", "gmail"],
-        skipWrite: true,
-        onProgress,
-      });
-
-      expect(onProgress).toHaveBeenCalledWith({
-        type: "apps_lookup_start",
-        count: 2,
-      });
-    });
-
-    it("should emit app_found event for each app", async () => {
-      const sdk = createTestSdk();
-      const onProgress = vi.fn();
-
-      await sdk.buildManifest({
-        appKeys: ["slack", "gmail"],
-        skipWrite: true,
-        onProgress,
-      });
-
-      expect(onProgress).toHaveBeenCalledWith({
-        type: "app_found",
-        app: mockSlackApp,
-      });
-
-      expect(onProgress).toHaveBeenCalledWith({
-        type: "app_found",
-        app: mockGmailApp,
-      });
-    });
-
-    it("should emit apps_lookup_complete event", async () => {
-      const sdk = createTestSdk();
-      const onProgress = vi.fn();
-
-      await sdk.buildManifest({
-        appKeys: ["slack", "gmail"],
-        skipWrite: true,
-        onProgress,
-      });
-
-      expect(onProgress).toHaveBeenCalledWith({
-        type: "apps_lookup_complete",
-        count: 2,
-      });
-    });
-
-    it("should emit app_processing_start event for each app", async () => {
-      const sdk = createTestSdk();
-      const onProgress = vi.fn();
-
-      await sdk.buildManifest({
-        appKeys: ["slack"],
-        skipWrite: true,
-        onProgress,
-      });
-
-      expect(onProgress).toHaveBeenCalledWith({
-        type: "app_processing_start",
-        appKey: "SlackCLIAPI",
-        slug: "slack",
-      });
-    });
-
-    it("should emit manifest_entry_built event", async () => {
-      const sdk = createTestSdk();
-      const onProgress = vi.fn();
-
-      await sdk.buildManifest({
-        appKeys: ["slack"],
-        skipWrite: true,
-        onProgress,
-      });
-
-      expect(onProgress).toHaveBeenCalledWith({
-        type: "manifest_entry_built",
-        appKey: "SlackCLIAPI",
-        manifestKey: "SlackCLIAPI",
-        version: "1.30.0",
-      });
-    });
-
-    it("should emit manifest_updated event when skipWrite is false", async () => {
-      const sdk = createTestSdk();
-      const onProgress = vi.fn();
-
-      await sdk.buildManifest({
-        appKeys: ["slack"],
-        skipWrite: false,
-        onProgress,
-      });
-
-      expect(onProgress).toHaveBeenCalledWith({
-        type: "manifest_updated",
-        appKey: "SlackCLIAPI",
-        manifestKey: "SlackCLIAPI",
-        version: "1.30.0",
-      });
-    });
-
-    it("should emit app_processing_complete event", async () => {
-      const sdk = createTestSdk();
-      const onProgress = vi.fn();
-
-      await sdk.buildManifest({
-        appKeys: ["slack"],
-        skipWrite: true,
-        onProgress,
-      });
-
-      expect(onProgress).toHaveBeenCalledWith({
-        type: "app_processing_complete",
-        appKey: "SlackCLIAPI",
-      });
-    });
-
-    it("should emit events in correct order", async () => {
-      const sdk = createTestSdk([mockSlackApp]);
-      const onProgress = vi.fn();
-
-      await sdk.buildManifest({
-        appKeys: ["slack"],
-        skipWrite: false,
-        onProgress,
-      });
-
-      const eventTypes = onProgress.mock.calls.map((call) => call[0].type);
-      expect(eventTypes).toEqual([
-        "apps_lookup_start",
-        "app_found",
-        "apps_lookup_complete",
-        "app_processing_start",
-        "manifest_entry_built",
-        "manifest_updated",
-        "app_processing_complete",
-      ]);
-    });
-  });
-
-  describe("error handling", () => {
-    it("should throw ZapierUnknownError when createManifestEntry fails", async () => {
-      const sdk = createTestSdk([mockAppWithoutVersion]);
-
-      await expect(
-        sdk.buildManifest({
-          appKeys: ["broken"],
-          skipWrite: true,
-        }),
-      ).rejects.toThrow(ZapierUnknownError);
-    });
-
-    it("should include app key in error message when processing fails", async () => {
-      const sdk = createTestSdk([mockAppWithoutVersion]);
-
-      await expect(
-        sdk.buildManifest({
-          appKeys: ["broken"],
-          skipWrite: true,
-        }),
-      ).rejects.toThrow(/Failed to process app BrokenAPI/);
-    });
-
-    it("should emit app_processing_error event before throwing", async () => {
-      const sdk = createTestSdk([mockAppWithoutVersion]);
-      const onProgress = vi.fn();
-
-      await expect(
-        sdk.buildManifest({
-          appKeys: ["broken"],
-          skipWrite: true,
-          onProgress,
-        }),
-      ).rejects.toThrow();
-
-      expect(onProgress).toHaveBeenCalledWith({
-        type: "app_processing_error",
-        appKey: "BrokenAPI",
-        error: expect.stringContaining("Failed to process app BrokenAPI"),
-      });
-    });
-
-    it("should throw immediately on first error and not continue processing", async () => {
-      const sdk = createTestSdk([mockAppWithoutVersion, mockSlackApp]);
-
-      await expect(
-        sdk.buildManifest({
-          appKeys: ["broken", "slack"],
-          skipWrite: true,
-        }),
-      ).rejects.toThrow(ZapierUnknownError);
-
-      // updateManifestEntry should not be called since first app failed
-      expect(mockUpdateManifestEntry).not.toHaveBeenCalled();
-    });
-
-    it("should throw ZapierUnknownError when updateManifestEntry fails", async () => {
-      mockUpdateManifestEntry.mockRejectedValueOnce(new Error("Write failed"));
-      const sdk = createTestSdk();
-
-      await expect(
-        sdk.buildManifest({
-          appKeys: ["slack"],
-          skipWrite: false,
-        }),
-      ).rejects.toThrow(ZapierUnknownError);
-    });
-
-    it("should include original error as cause", async () => {
-      const originalError = new Error("Write failed");
-      mockUpdateManifestEntry.mockRejectedValueOnce(originalError);
-      const sdk = createTestSdk();
-
-      try {
-        await sdk.buildManifest({
-          appKeys: ["slack"],
-          skipWrite: false,
-        });
-        expect.fail("Should have thrown");
-      } catch (error) {
-        expect(error).toBeInstanceOf(ZapierUnknownError);
-        if (error instanceof ZapierUnknownError) {
-          expect(error.cause).toBe(originalError);
-          expect(error.message).toContain("Failed to process app SlackCLIAPI");
-          expect(error.message).toContain("Write failed");
-        }
-      }
-    });
-
-    it("should preserve ZapierValidationError if thrown from underlying code", async () => {
-      const validationError = new ZapierValidationError(
-        "Invalid manifest entry",
-      );
-      mockUpdateManifestEntry.mockRejectedValueOnce(validationError);
-      const sdk = createTestSdk();
-
-      await expect(
-        sdk.buildManifest({
-          appKeys: ["slack"],
-          skipWrite: false,
-        }),
-      ).rejects.toThrow(ZapierValidationError);
-    });
-
-    it("should stop processing after first app error", async () => {
-      mockUpdateManifestEntry
-        .mockRejectedValueOnce(new Error("First error"))
-        .mockResolvedValueOnce([
-          "GmailCLIAPI",
-          { implementationName: "GmailCLIAPI", version: "2.5.0" },
-          { apps: {} },
-        ]);
-
-      const sdk = createTestSdk();
-
-      await expect(
-        sdk.buildManifest({
-          appKeys: ["slack", "gmail"],
-          skipWrite: false,
-        }),
-      ).rejects.toThrow(ZapierUnknownError);
-
-      // Should only call once (for first app that fails)
-      expect(mockUpdateManifestEntry).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe("manifest entry creation", () => {
-    it("should create correct manifest entry structure", async () => {
-      const sdk = createTestSdk([mockSlackApp]);
-
-      await sdk.buildManifest({
-        appKeys: ["slack"],
-        skipWrite: false,
-      });
-
-      expect(mockUpdateManifestEntry).toHaveBeenCalledWith(
-        expect.objectContaining({
-          entry: {
-            implementationName: "SlackCLIAPI",
-            version: "1.30.0",
-          },
-        }),
-      );
-    });
-
-    it("should use app.key as implementationName", async () => {
-      const sdk = createTestSdk([mockGmailApp]);
-
-      await sdk.buildManifest({
-        appKeys: ["gmail"],
-        skipWrite: false,
-      });
-
-      expect(mockUpdateManifestEntry).toHaveBeenCalledWith(
-        expect.objectContaining({
-          entry: {
-            implementationName: "GmailCLIAPI",
-            version: "2.5.0",
-          },
-        }),
-      );
-    });
-  });
-
-  describe("context and metadata", () => {
-    it("should provide context with meta information", () => {
-      const sdk = createTestSdk();
-      const context = sdk.getContext();
-
-      expect(context.meta.buildManifest).toBeDefined();
-      expect(context.meta.buildManifest.inputSchema).toBeDefined();
-      expect(context.meta.buildManifest.categories).toEqual(["utility"]);
-    });
-
-    it("should expose BuildManifestSchema in metadata", () => {
-      const sdk = createTestSdk();
-      const context = sdk.getContext();
-
-      expect(context.meta.buildManifest.inputSchema).toBe(BuildManifestSchema);
-    });
-  });
-
-  describe("edge cases", () => {
-    it("should handle empty apps array when no apps are found", async () => {
-      const sdk = createTestSdk([]);
-
-      const result = await sdk.buildManifest({
-        appKeys: ["nonexistent"],
-        skipWrite: true,
-      });
-
-      expect(result.manifest).toBeUndefined();
-    });
-
-    it("should not call updateManifestEntry when no apps found", async () => {
-      const sdk = createTestSdk([]);
-
-      await sdk.buildManifest({
-        appKeys: ["nonexistent"],
-        skipWrite: false,
-      });
-
-      expect(mockUpdateManifestEntry).not.toHaveBeenCalled();
-    });
-
-    it("should handle apps without slug", async () => {
-      const appWithoutSlug: AppItem = {
-        ...mockSlackApp,
-        slug: undefined as unknown as string,
-      };
-      const sdk = createTestSdk([appWithoutSlug]);
-      const onProgress = vi.fn();
-
-      await sdk.buildManifest({
-        appKeys: ["slack"],
-        skipWrite: true,
-        onProgress,
-      });
-
-      expect(onProgress).toHaveBeenCalledWith({
-        type: "app_processing_start",
-        appKey: "SlackCLIAPI",
-        slug: undefined,
-      });
-    });
-  });
-});