@zapier/zapier-sdk-cli 0.16.1 → 0.16.4

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

@@ -1,679 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { generateAppTypesPlugin } from "./index";
-import { GenerateAppTypesSchema } from "./schemas";
-import type { AppItem, Authentication } from "@zapier/zapier-sdk";
-import {
-  createSdk,
-  ZapierUnknownError,
-  ZapierValidationError,
-} from "@zapier/zapier-sdk";
-import { mkdir, writeFile } from "fs/promises";
-
-vi.mock("fs/promises", () => ({
-  mkdir: vi.fn(),
-  writeFile: vi.fn(),
-}));
-
-let mockGenerateTypesImpl: ReturnType<typeof vi.fn>;
-
-vi.mock("../../generators/ast-generator", () => {
-  const mockClass = vi.fn();
-  return {
-    AstTypeGenerator: mockClass,
-  };
-});
-
-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",
-};
-
-const mockAuthentication: Authentication = {
-  id: 123,
-  date: "2024-01-01T00:00:00Z",
-  account_id: 456,
-  is_invite_only: false,
-  is_private: false,
-  shared_with_all: false,
-  selected_api: "SlackCLIAPI",
-  app_key: "SlackCLIAPI",
-  title: "Test Slack Auth",
-};
-
-describe("generateAppTypes plugin", () => {
-  let mockListAppsItems: unknown;
-  let mockListAuthenticationsItems: unknown;
-
-  beforeEach(async () => {
-    vi.clearAllMocks();
-
-    mockGenerateTypesImpl = vi.fn().mockResolvedValue("// Generated types");
-    const { AstTypeGenerator } = await import("../../generators/ast-generator");
-    vi.mocked(AstTypeGenerator).mockImplementation(() => ({
-      generateTypes: mockGenerateTypesImpl,
-    }));
-
-    mockListAppsItems = vi.fn();
-    mockListAuthenticationsItems = vi.fn();
-
-    vi.mocked(mkdir).mockResolvedValue(undefined);
-    vi.mocked(writeFile).mockResolvedValue(undefined);
-  });
-
-  function createTestSdk(
-    apps: AppItem[] = [mockSlackApp, mockGmailApp],
-    authentications: Authentication[] = [],
-  ) {
-    // Mock async iterator for listApps
-    mockListAppsItems.mockReturnValue({
-      async *[Symbol.asyncIterator]() {
-        for (const app of apps) {
-          yield app;
-        }
-      },
-    });
-
-    // Mock async iterator for listAuthentications
-    mockListAuthenticationsItems.mockReturnValue({
-      async *[Symbol.asyncIterator]() {
-        for (const auth of authentications) {
-          yield auth;
-        }
-      },
-    });
-
-    return createSdk()
-      .addPlugin(() => ({
-        listApps: vi.fn().mockReturnValue({
-          items: mockListAppsItems,
-        }),
-        listAuthentications: vi.fn().mockReturnValue({
-          items: mockListAuthenticationsItems,
-        }),
-        listActions: vi.fn(),
-        listInputFields: vi.fn(),
-      }))
-      .addPlugin(generateAppTypesPlugin);
-  }
-
-  describe("schema validation", () => {
-    it("should accept valid options with skipWrite true", () => {
-      const result = GenerateAppTypesSchema.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 typesOutputDirectory", () => {
-      const result = GenerateAppTypesSchema.safeParse({
-        appKeys: ["slack"],
-        skipWrite: false,
-        typesOutputDirectory: "/path/to/types",
-      });
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.data.skipWrite).toBe(false);
-        expect(result.data.typesOutputDirectory).toBe("/path/to/types");
-      }
-    });
-
-    it("should accept options with authenticationIds", () => {
-      const result = GenerateAppTypesSchema.safeParse({
-        appKeys: ["slack"],
-        authenticationIds: ["123", "456"],
-        skipWrite: true,
-      });
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.data.authenticationIds).toEqual(["123", "456"]);
-      }
-    });
-
-    it("should require at least one appKey", () => {
-      const result = GenerateAppTypesSchema.safeParse({
-        appKeys: [],
-      });
-
-      expect(result.success).toBe(false);
-    });
-
-    it("should reject empty string appKeys", () => {
-      const result = GenerateAppTypesSchema.safeParse({
-        appKeys: ["slack", ""],
-      });
-
-      expect(result.success).toBe(false);
-    });
-  });
-
-  describe("type generation with skipWrite: true", () => {
-    it("should generate types without writing to disk", async () => {
-      const sdk = createTestSdk();
-
-      const result = await sdk.generateAppTypes({
-        appKeys: ["slack", "gmail"],
-        skipWrite: true,
-      });
-
-      expect(result.typeDefinitions).toBeDefined();
-      expect(result.typeDefinitions.slack).toBe("// Generated types");
-      expect(result.typeDefinitions.gmail).toBe("// Generated types");
-      expect(result.writtenFiles).toBeUndefined();
-
-      // Should not write files
-      expect(mkdir).not.toHaveBeenCalled();
-      expect(writeFile).not.toHaveBeenCalled();
-    });
-
-    it("should return empty result when no apps found", async () => {
-      const sdk = createTestSdk([]);
-
-      const result = await sdk.generateAppTypes({
-        appKeys: ["nonexistent"],
-        skipWrite: true,
-      });
-
-      expect(result.typeDefinitions).toEqual({});
-      expect(result.writtenFiles).toBeUndefined();
-    });
-  });
-
-  describe("type generation with skipWrite: false", () => {
-    it("should generate types and write to disk at default directory", async () => {
-      const sdk = createTestSdk();
-
-      const result = await sdk.generateAppTypes({
-        appKeys: ["slack", "gmail"],
-      });
-
-      expect(result.typeDefinitions).toBeDefined();
-      expect(result.typeDefinitions.slack).toBe("// Generated types");
-      expect(result.typeDefinitions.gmail).toBe("// Generated types");
-
-      expect(result.writtenFiles).toBeDefined();
-      expect(result.writtenFiles?.slack).toMatch(
-        /\/zapier\/apps\/slack\.d\.ts$/,
-      );
-      expect(result.writtenFiles?.gmail).toMatch(
-        /\/zapier\/apps\/gmail\.d\.ts$/,
-      );
-
-      // Should create directory
-      expect(mkdir).toHaveBeenCalledWith(
-        expect.stringContaining("/zapier/apps"),
-        { recursive: true },
-      );
-
-      // Should write files (test only that the path contains /zapier/apps/slack.d.ts and /zapier/apps/gmail.d.ts)
-      expect(writeFile).toHaveBeenCalledWith(
-        expect.stringContaining("/zapier/apps/slack.d.ts"),
-        "// Generated types",
-        "utf8",
-      );
-      expect(writeFile).toHaveBeenCalledWith(
-        expect.stringContaining("/zapier/apps/gmail.d.ts"),
-        "// Generated types",
-        "utf8",
-      );
-    });
-
-    it("should generate types and write to disk at specified directory", async () => {
-      const sdk = createTestSdk();
-
-      const result = await sdk.generateAppTypes({
-        appKeys: ["slack", "gmail"],
-        typesOutputDirectory: "/path/to/types",
-      });
-
-      expect(result.typeDefinitions).toBeDefined();
-      expect(result.typeDefinitions.slack).toBe("// Generated types");
-      expect(result.typeDefinitions.gmail).toBe("// Generated types");
-
-      expect(result.writtenFiles).toBeDefined();
-      expect(result.writtenFiles?.slack).toBe("/path/to/types/slack.d.ts");
-      expect(result.writtenFiles?.gmail).toBe("/path/to/types/gmail.d.ts");
-
-      // Should create directory
-      expect(mkdir).toHaveBeenCalledWith("/path/to/types", { recursive: true });
-
-      // Should write files
-      expect(writeFile).toHaveBeenCalledWith(
-        "/path/to/types/slack.d.ts",
-        "// Generated types",
-        "utf8",
-      );
-      expect(writeFile).toHaveBeenCalledWith(
-        "/path/to/types/gmail.d.ts",
-        "// Generated types",
-        "utf8",
-      );
-    });
-  });
-
-  describe("authentication handling", () => {
-    it("should fetch and match authentications", async () => {
-      const sdk = createTestSdk([mockSlackApp], [mockAuthentication]);
-      const onProgress = vi.fn();
-
-      await sdk.generateAppTypes({
-        appKeys: ["slack"],
-        authenticationIds: ["123"],
-        skipWrite: true,
-        onProgress,
-      });
-
-      expect(onProgress).toHaveBeenCalledWith({
-        type: "authentications_lookup_start",
-        count: 1,
-      });
-
-      expect(onProgress).toHaveBeenCalledWith({
-        type: "authentications_lookup_complete",
-        count: 1,
-      });
-
-      expect(onProgress).toHaveBeenCalledWith({
-        type: "authentication_matched",
-        appKey: "SlackCLIAPI",
-        authenticationId: 123,
-        authenticationTitle: "Test Slack Auth",
-      });
-    });
-
-    it("should emit authentication_not_matched when no match found", async () => {
-      const authWithDifferentApp = {
-        ...mockAuthentication,
-        app_key: "DifferentAPI",
-      };
-      const sdk = createTestSdk([mockSlackApp], [authWithDifferentApp]);
-      const onProgress = vi.fn();
-
-      await sdk.generateAppTypes({
-        appKeys: ["slack"],
-        authenticationIds: ["123"],
-        skipWrite: true,
-        onProgress,
-      });
-
-      expect(onProgress).toHaveBeenCalledWith({
-        type: "authentication_not_matched",
-        appKey: "SlackCLIAPI",
-      });
-    });
-
-    it("should not fetch authentications when authenticationIds not provided", async () => {
-      const sdk = createTestSdk();
-      const onProgress = vi.fn();
-
-      await sdk.generateAppTypes({
-        appKeys: ["slack"],
-        skipWrite: true,
-        onProgress,
-      });
-
-      const progressEvents = onProgress.mock.calls.map((call) => call[0].type);
-      expect(progressEvents).not.toContain("authentications_lookup_start");
-    });
-  });
-
-  describe("progress events", () => {
-    it("should emit apps_lookup_start event", async () => {
-      const sdk = createTestSdk();
-      const onProgress = vi.fn();
-
-      await sdk.generateAppTypes({
-        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.generateAppTypes({
-        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 type_generated event", async () => {
-      const sdk = createTestSdk([mockSlackApp]);
-      const onProgress = vi.fn();
-
-      await sdk.generateAppTypes({
-        appKeys: ["slack"],
-        skipWrite: true,
-        onProgress,
-      });
-
-      expect(onProgress).toHaveBeenCalledWith({
-        type: "type_generated",
-        manifestKey: "slack",
-        sizeBytes: "// Generated types".length,
-      });
-    });
-
-    it("should emit file_written event when writing to disk", async () => {
-      const sdk = createTestSdk([mockSlackApp]);
-      const onProgress = vi.fn();
-
-      await sdk.generateAppTypes({
-        appKeys: ["slack"],
-        skipWrite: false,
-        typesOutputDirectory: "/path/to/types",
-        onProgress,
-      });
-
-      expect(onProgress).toHaveBeenCalledWith({
-        type: "file_written",
-        manifestKey: "slack",
-        filePath: "/path/to/types/slack.d.ts",
-      });
-    });
-
-    it("should emit app_processing_complete event", async () => {
-      const sdk = createTestSdk([mockSlackApp]);
-      const onProgress = vi.fn();
-
-      await sdk.generateAppTypes({
-        appKeys: ["slack"],
-        skipWrite: true,
-        onProgress,
-      });
-
-      expect(onProgress).toHaveBeenCalledWith({
-        type: "app_processing_complete",
-        appKey: "SlackCLIAPI",
-      });
-    });
-  });
-
-  describe("error handling", () => {
-    it("should throw ZapierValidationError when app.version is missing", async () => {
-      const sdk = createTestSdk([mockAppWithoutVersion]);
-
-      await expect(
-        sdk.generateAppTypes({
-          appKeys: ["broken"],
-          skipWrite: true,
-        }),
-      ).rejects.toThrow(ZapierValidationError);
-
-      await expect(
-        sdk.generateAppTypes({
-          appKeys: ["broken"],
-          skipWrite: true,
-        }),
-      ).rejects.toThrow(/Invalid implementation ID format/);
-    });
-
-    it("should include implementation_id in validation error details", async () => {
-      const sdk = createTestSdk([mockAppWithoutVersion]);
-
-      try {
-        await sdk.generateAppTypes({
-          appKeys: ["broken"],
-          skipWrite: true,
-        });
-        expect.fail("Should have thrown");
-      } catch (error) {
-        expect(error).toBeInstanceOf(ZapierValidationError);
-        if (error instanceof ZapierValidationError) {
-          expect(error.details).toMatchObject({
-            appKey: "BrokenAPI",
-            implementationId: "BrokenAPI",
-          });
-        }
-      }
-    });
-
-    it("should emit app_processing_error event before throwing", async () => {
-      const sdk = createTestSdk([mockAppWithoutVersion]);
-      const onProgress = vi.fn();
-
-      await expect(
-        sdk.generateAppTypes({
-          appKeys: ["broken"],
-          skipWrite: true,
-          onProgress,
-        }),
-      ).rejects.toThrow();
-
-      expect(onProgress).toHaveBeenCalledWith({
-        type: "app_processing_error",
-        appKey: "BrokenAPI",
-        error: expect.stringContaining("Invalid implementation ID format"),
-      });
-    });
-
-    it("should throw immediately on first error and not continue processing", async () => {
-      const sdk = createTestSdk([mockAppWithoutVersion, mockSlackApp]);
-
-      await expect(
-        sdk.generateAppTypes({
-          appKeys: ["broken", "slack"],
-          skipWrite: true,
-        }),
-      ).rejects.toThrow(ZapierValidationError);
-
-      // AstTypeGenerator should not be called at all since validation happens first
-      const { AstTypeGenerator } = await import(
-        "../../generators/ast-generator"
-      );
-      expect(vi.mocked(AstTypeGenerator)).not.toHaveBeenCalled();
-    });
-
-    it("should throw ZapierUnknownError when type generation fails", async () => {
-      const { AstTypeGenerator } = await import(
-        "../../generators/ast-generator"
-      );
-      vi.mocked(AstTypeGenerator).mockImplementationOnce(() => ({
-        generateTypes: vi
-          .fn()
-          .mockRejectedValue(new Error("Generation failed")),
-      }));
-
-      const sdk = createTestSdk([mockSlackApp]);
-
-      await expect(
-        sdk.generateAppTypes({
-          appKeys: ["slack"],
-          skipWrite: true,
-        }),
-      ).rejects.toThrow(ZapierUnknownError);
-    });
-
-    it("should include original error as cause", async () => {
-      const originalError = new Error("Generation failed");
-      const { AstTypeGenerator } = await import(
-        "../../generators/ast-generator"
-      );
-      vi.mocked(AstTypeGenerator).mockImplementationOnce(() => ({
-        generateTypes: vi.fn().mockRejectedValue(originalError),
-      }));
-
-      const sdk = createTestSdk([mockSlackApp]);
-
-      try {
-        await sdk.generateAppTypes({
-          appKeys: ["slack"],
-          skipWrite: true,
-        });
-        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("Generation failed");
-        }
-      }
-    });
-
-    it("should throw ZapierUnknownError when file writing fails", async () => {
-      vi.mocked(writeFile).mockRejectedValueOnce(new Error("Write failed"));
-      const sdk = createTestSdk([mockSlackApp]);
-
-      await expect(
-        sdk.generateAppTypes({
-          appKeys: ["slack"],
-          skipWrite: false,
-          typesOutputDirectory: "/path/to/types",
-        }),
-      ).rejects.toThrow(ZapierUnknownError);
-    });
-
-    it("should preserve ZapierValidationError if thrown from underlying code", async () => {
-      const validationError = new ZapierValidationError(
-        "Invalid type definition",
-      );
-      const { AstTypeGenerator } = await import(
-        "../../generators/ast-generator"
-      );
-      vi.mocked(AstTypeGenerator).mockImplementationOnce(() => ({
-        generateTypes: vi.fn().mockRejectedValue(validationError),
-      }));
-
-      const sdk = createTestSdk([mockSlackApp]);
-
-      await expect(
-        sdk.generateAppTypes({
-          appKeys: ["slack"],
-          skipWrite: true,
-        }),
-      ).rejects.toThrow(ZapierValidationError);
-    });
-
-    it("should stop processing after first app error", async () => {
-      const { AstTypeGenerator } = await import(
-        "../../generators/ast-generator"
-      );
-      vi.mocked(AstTypeGenerator)
-        .mockImplementationOnce(() => ({
-          generateTypes: vi.fn().mockRejectedValue(new Error("First error")),
-        }))
-        .mockImplementationOnce(() => ({
-          generateTypes: vi.fn().mockResolvedValue("// Types for second app"),
-        }));
-
-      const sdk = createTestSdk([mockSlackApp, mockGmailApp]);
-
-      await expect(
-        sdk.generateAppTypes({
-          appKeys: ["slack", "gmail"],
-          skipWrite: true,
-        }),
-      ).rejects.toThrow(ZapierUnknownError);
-
-      // Should only instantiate generator once (for first app that fails)
-      expect(vi.mocked(AstTypeGenerator)).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe("context and metadata", () => {
-    it("should provide context with meta information", () => {
-      const sdk = createTestSdk();
-      const context = sdk.getContext();
-
-      expect(context.meta.generateAppTypes).toBeDefined();
-      expect(context.meta.generateAppTypes.inputSchema).toBeDefined();
-      expect(context.meta.generateAppTypes.categories).toEqual(["utility"]);
-    });
-
-    it("should expose GenerateAppTypesSchema in metadata", () => {
-      const sdk = createTestSdk();
-      const context = sdk.getContext();
-
-      expect(context.meta.generateAppTypes.inputSchema).toBe(
-        GenerateAppTypesSchema,
-      );
-    });
-  });
-
-  describe("edge cases", () => {
-    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.generateAppTypes({
-        appKeys: ["slack"],
-        skipWrite: true,
-        onProgress,
-      });
-
-      expect(onProgress).toHaveBeenCalledWith({
-        type: "app_processing_start",
-        appKey: "SlackCLIAPI",
-        slug: undefined,
-      });
-    });
-
-    it("should not emit authentication_not_matched when authenticationIds provided but returns empty", async () => {
-      const sdk = createTestSdk([mockSlackApp], []);
-      const onProgress = vi.fn();
-
-      await sdk.generateAppTypes({
-        appKeys: ["slack"],
-        authenticationIds: ["123"],
-        skipWrite: true,
-        onProgress,
-      });
-
-      // When authentications are fetched but the array is empty (no authentications found),
-      // the code checks if authentications.length > 0, which is false, so it skips the matching logic entirely
-      const progressEvents = onProgress.mock.calls.map((call) => call[0].type);
-      expect(progressEvents).not.toContain("authentication_not_matched");
-    });
-  });
-});