@zapier/zapier-sdk-cli 0.13.5 → 0.13.6

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

@@ -0,0 +1,612 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { buildManifestPlugin } from "./index";
+import { BuildManifestSchema } from "./schemas";
+import type {
+  AppItem,
+  Manifest,
+  ManifestEntry,
+  UpdateManifestEntryOptions,
+} from "@zapier/zapier-sdk";
+import { createSdk } 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,
+        ): Promise<[string, ManifestEntry, Manifest]> => {
+          const manifestKey = options.entry.implementationName;
+          const updatedManifest: Manifest = {
+            apps: {
+              ...options.manifest?.apps,
+              [manifestKey]: options.entry,
+            },
+          };
+          return [manifestKey, options.entry, 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,
+        },
+      }))
+      .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();
+      expect(result.errors).toEqual([]);
+    });
+
+    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();
+      expect(result.errors).toEqual([]);
+    });
+
+    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();
+      expect(result.errors).toEqual([]);
+    });
+  });
+
+  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",
+      });
+      expect(result.errors).toEqual([]);
+    });
+
+    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 handle apps without version", async () => {
+      const sdk = createTestSdk([mockAppWithoutVersion]);
+
+      const result = await sdk.buildManifest({
+        appKeys: ["broken"],
+        skipWrite: true,
+      });
+
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0]).toEqual({
+        appKey: "BrokenAPI",
+        error: expect.stringContaining("Failed to process app"),
+      });
+    });
+
+    it("should emit app_processing_error event on failure", async () => {
+      const sdk = createTestSdk([mockAppWithoutVersion]);
+      const onProgress = vi.fn();
+
+      await sdk.buildManifest({
+        appKeys: ["broken"],
+        skipWrite: true,
+        onProgress,
+      });
+
+      expect(onProgress).toHaveBeenCalledWith({
+        type: "app_processing_error",
+        appKey: "BrokenAPI",
+        error: expect.stringContaining("Failed to process app"),
+      });
+    });
+
+    it("should continue processing other apps after error", async () => {
+      const sdk = createTestSdk([mockAppWithoutVersion, mockSlackApp]);
+
+      const result = await sdk.buildManifest({
+        appKeys: ["broken", "slack"],
+        skipWrite: true,
+      });
+
+      // Should have one error
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].appKey).toBe("BrokenAPI");
+
+      // Should still process successful app
+      expect(result.manifest?.apps?.SlackCLIAPI).toBeDefined();
+    });
+
+    it("should handle updateManifestEntry failure", async () => {
+      mockUpdateManifestEntry.mockRejectedValueOnce(new Error("Write failed"));
+      const sdk = createTestSdk();
+
+      const result = await sdk.buildManifest({
+        appKeys: ["slack"],
+        skipWrite: false,
+      });
+
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0]).toEqual({
+        appKey: "SlackCLIAPI",
+        error: "Failed to process app: Error: Write failed",
+      });
+    });
+
+    it("should accumulate multiple errors", async () => {
+      mockUpdateManifestEntry
+        .mockRejectedValueOnce(new Error("First error"))
+        .mockRejectedValueOnce(new Error("Second error"));
+
+      const sdk = createTestSdk();
+
+      const result = await sdk.buildManifest({
+        appKeys: ["slack", "gmail"],
+        skipWrite: false,
+      });
+
+      expect(result.errors).toHaveLength(2);
+      expect(result.errors[0].appKey).toBe("SlackCLIAPI");
+      expect(result.errors[1].appKey).toBe("GmailCLIAPI");
+    });
+  });
+
+  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();
+      expect(result.errors).toEqual([]);
+    });
+
+    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,
+      });
+    });
+  });
+});