@zapier/zapier-sdk-cli 0.16.1 → 0.16.3

package/src/generators/ast-generator.test.ts

@@ -1,908 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import type { MockInstance } from "vitest";
-import { AstTypeGenerator } from "./ast-generator";
-import type { ActionItem, InputFieldItem, AppItem } from "@zapier/zapier-sdk";
-
-interface MockSdk {
-  listActions: MockInstance;
-  listInputFields: MockInstance;
-  getContext: MockInstance;
-}
-
-interface MockContext {
-  api: {
-    batch: MockInstance;
-  };
-}
-
-type SdkType = Parameters<
-  typeof AstTypeGenerator.prototype.generateTypes
->[0]["sdk"];
-
-// Helper to create InputFieldItem with all required fields
-function createInputFieldItem(
-  partial: Partial<InputFieldItem> & { key: string; value_type: string },
-): InputFieldItem {
-  return {
-    type: "input_field",
-    key: partial.key,
-    title: partial.title || "",
-    value_type: partial.value_type,
-    is_required: partial.is_required ?? false,
-    description: partial.description || "",
-    depends_on: partial.depends_on || [],
-    placeholder: partial.placeholder || "",
-    default_value: partial.default_value || "",
-    invalidates_input_fields: partial.invalidates_input_fields ?? false,
-    ...partial,
-  };
-}
-
-describe("AstTypeGenerator", () => {
-  let generator: AstTypeGenerator;
-  let mockSdk: MockSdk;
-  let mockContext: MockContext;
-  let consoleWarnSpy: MockInstance;
-
-  const mockApp: AppItem = {
-    key: "test-app",
-    slug: "test-app",
-    implementation_id: "test-app@1.0.0",
-    title: "Test App",
-    description: "Test app description",
-  };
-
-  beforeEach(() => {
-    generator = new AstTypeGenerator();
-    consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
-
-    mockSdk = {
-      listActions: vi.fn(),
-      listInputFields: vi.fn(),
-      getContext: vi.fn(),
-    };
-
-    // Mock context with batch API that mimics Promise.allSettled behavior
-    mockContext = {
-      api: {
-        batch: vi.fn(async (tasks) => {
-          const results = await Promise.allSettled(
-            tasks.map((task: () => Promise<unknown>) => task()),
-          );
-          return results;
-        }),
-      },
-    };
-  });
-
-  describe("generateTypes", () => {
-    it("should generate types with all input fields successfully resolved", async () => {
-      const mockActions: ActionItem[] = [
-        {
-          key: "search_user",
-          title: "Search User",
-          action_type: "search",
-          app_key: "test-app",
-          description: "Search for a user",
-          type: "action",
-        },
-        {
-          key: "create_task",
-          title: "Create Task",
-          action_type: "write",
-          app_key: "test-app",
-          description: "Create a new task",
-          type: "action",
-        },
-      ];
-
-      const mockInputFields: Record<string, InputFieldItem[]> = {
-        search_user: [
-          {
-            key: "email",
-            title: "Email",
-            value_type: "string",
-            is_required: true,
-            description: "User email address",
-            type: "input_field",
-            depends_on: [],
-            placeholder: "",
-            default_value: "",
-            invalidates_input_fields: false,
-          },
-          {
-            key: "age",
-            title: "Age",
-            value_type: "integer",
-            is_required: false,
-            description: "User age",
-            type: "input_field",
-            depends_on: [],
-            placeholder: "",
-            default_value: "",
-            invalidates_input_fields: false,
-          },
-        ],
-        create_task: [
-          {
-            key: "title",
-            title: "Title",
-            value_type: "string",
-            is_required: true,
-            description: "Task title",
-            type: "input_field",
-            depends_on: [],
-            placeholder: "",
-            default_value: "",
-            invalidates_input_fields: false,
-          },
-          {
-            key: "completed",
-            title: "Completed",
-            value_type: "boolean",
-            is_required: false,
-            description: "Task completion status",
-            type: "input_field",
-            depends_on: [],
-            placeholder: "",
-            default_value: "",
-            invalidates_input_fields: false,
-          },
-        ],
-      };
-
-      mockSdk.listActions.mockResolvedValue({ data: mockActions });
-      mockSdk.listInputFields.mockImplementation(
-        ({ actionKey }: { actionKey: string }) =>
-          Promise.resolve({ data: mockInputFields[actionKey] }),
-      );
-
-      const result = await generator.generateTypes({
-        app: mockApp,
-        authenticationId: 123,
-        sdk: mockSdk as unknown as SdkType,
-        context: mockContext as Parameters<
-          typeof generator.generateTypes
-        >[0]["context"],
-      });
-
-      expect(result).toContain("TestAppSearchActions");
-      expect(result).toContain("TestAppWriteActions");
-      expect(result).toContain("TestAppSearchSearchuserInputs");
-      expect(result).toContain("TestAppWriteCreatetaskInputs");
-      expect(result).toContain("email");
-      expect(result).toContain("age?");
-      expect(result).toContain("title");
-      expect(result).toContain("completed?");
-      expect(result).toContain("User email address");
-      expect(result).toContain("Task completion status");
-      expect(consoleWarnSpy).not.toHaveBeenCalled();
-    });
-
-    it("should handle failed HTTP requests and log warnings", async () => {
-      const mockActions: ActionItem[] = [
-        {
-          key: "search_user",
-          title: "Search User",
-          action_type: "search",
-          app_key: "test-app",
-          description: "Search for a user",
-          type: "action",
-        },
-        {
-          key: "create_task",
-          title: "Create Task",
-          action_type: "write",
-          app_key: "test-app",
-          description: "Create a new task",
-          type: "action",
-        },
-        {
-          key: "delete_task",
-          title: "Delete Task",
-          action_type: "write",
-          app_key: "test-app",
-          description: "Delete a task",
-          type: "action",
-        },
-      ];
-
-      mockSdk.listActions.mockResolvedValue({ data: mockActions });
-      mockSdk.listInputFields.mockImplementation(
-        ({ actionKey }: { actionKey: string }) => {
-          if (actionKey === "search_user") {
-            return Promise.resolve({
-              data: [
-                createInputFieldItem({
-                  key: "email",
-                  title: "Email",
-                  value_type: "string",
-                  is_required: true,
-                }),
-              ],
-            });
-          } else if (actionKey === "create_task") {
-            return Promise.reject(new Error("Network timeout"));
-          } else {
-            return Promise.reject(new Error("Authentication failed"));
-          }
-        },
-      );
-
-      const result = await generator.generateTypes({
-        app: mockApp,
-        authenticationId: 123,
-        sdk: mockSdk as unknown as SdkType,
-        context: mockContext as Parameters<
-          typeof generator.generateTypes
-        >[0]["context"],
-      });
-
-      expect(result).toContain("TestAppSearchActions");
-      expect(result).toContain("TestAppWriteActions");
-      expect(result).toContain("TestAppSearchSearchuserInputs");
-      expect(result).toContain("email");
-
-      expect(consoleWarnSpy).toHaveBeenCalledWith(
-        "Failed to fetch input fields for 2 action(s):",
-      );
-      expect(consoleWarnSpy).toHaveBeenCalledWith(
-        "  - create_task (write): Network timeout",
-      );
-      expect(consoleWarnSpy).toHaveBeenCalledWith(
-        "  - delete_task (write): Authentication failed",
-      );
-    });
-
-    it("should fetch input fields even when authenticationId is not provided", async () => {
-      const mockActions: ActionItem[] = [
-        {
-          key: "search_user",
-          title: "Search User",
-          action_type: "search",
-          app_key: "test-app",
-          description: "Search for a user",
-          type: "action",
-        },
-      ];
-
-      const mockInputFields: InputFieldItem[] = [
-        createInputFieldItem({
-          key: "email",
-          title: "Email",
-          value_type: "string",
-          is_required: true,
-          description: "User email",
-        }),
-      ];
-
-      mockSdk.listActions.mockResolvedValue({ data: mockActions });
-      mockSdk.listInputFields.mockResolvedValue({ data: mockInputFields });
-
-      const result = await generator.generateTypes({
-        app: mockApp,
-        sdk: mockSdk as unknown as SdkType,
-        context: mockContext as Parameters<
-          typeof generator.generateTypes
-        >[0]["context"],
-      });
-
-      expect(result).toContain("TestAppSearchActions");
-      expect(result).toContain("search_user");
-      expect(result).toContain("email: string");
-      expect(mockSdk.listInputFields).toHaveBeenCalledWith({
-        appKey: "test-app@1.0.0",
-        actionKey: "search_user",
-        actionType: "search",
-        authenticationId: undefined,
-      });
-      expect(consoleWarnSpy).not.toHaveBeenCalled();
-    });
-
-    it("should include auth-specific input fields only when authenticationId is provided", async () => {
-      const mockActions: ActionItem[] = [
-        {
-          key: "create_task",
-          title: "Create Task",
-          action_type: "write",
-          app_key: "test-app",
-          description: "Create a task",
-          type: "action",
-        },
-      ];
-
-      mockSdk.listActions.mockResolvedValue({ data: mockActions });
-
-      // Mock listInputFields to return different fields based on authenticationId
-      mockSdk.listInputFields.mockImplementation(
-        ({ authenticationId }: { authenticationId?: number }) => {
-          if (authenticationId === 123) {
-            // With authentication, return personalized fields
-            return Promise.resolve({
-              data: [
-                createInputFieldItem({
-                  key: "title",
-                  title: "Title",
-                  value_type: "string",
-                  is_required: true,
-                  description: "Task title",
-                }),
-                createInputFieldItem({
-                  key: "assigned_user",
-                  title: "Assigned User",
-                  value_type: "string",
-                  is_required: false,
-                  description: "User from your account to assign",
-                }),
-                createInputFieldItem({
-                  key: "project_id",
-                  title: "Project",
-                  value_type: "string",
-                  is_required: false,
-                  description: "Project from your workspace",
-                }),
-              ],
-            });
-          } else {
-            // Without authentication, return only basic fields
-            return Promise.resolve({
-              data: [
-                createInputFieldItem({
-                  key: "title",
-                  title: "Title",
-                  value_type: "string",
-                  is_required: true,
-                  description: "Task title",
-                }),
-              ],
-            });
-          }
-        },
-      );
-
-      // Generate types without authenticationId
-      const resultWithoutAuth = await generator.generateTypes({
-        app: mockApp,
-        sdk: mockSdk as unknown as SdkType,
-        context: mockContext as Parameters<
-          typeof generator.generateTypes
-        >[0]["context"],
-      });
-
-      // Should contain basic field
-      expect(resultWithoutAuth).toContain("title: string");
-      // Should NOT contain auth-specific fields
-      expect(resultWithoutAuth).not.toContain("assigned_user");
-      expect(resultWithoutAuth).not.toContain("project_id");
-      expect(resultWithoutAuth).not.toContain("User from your account");
-      expect(resultWithoutAuth).not.toContain("Project from your workspace");
-
-      // Generate types with authenticationId
-      const resultWithAuth = await generator.generateTypes({
-        app: mockApp,
-        authenticationId: 123,
-        sdk: mockSdk as unknown as SdkType,
-        context: mockContext as Parameters<
-          typeof generator.generateTypes
-        >[0]["context"],
-      });
-
-      // Should contain basic field
-      expect(resultWithAuth).toContain("title: string");
-      // Should contain auth-specific fields
-      expect(resultWithAuth).toContain("assigned_user?: string");
-      expect(resultWithAuth).toContain("project_id?: string");
-      expect(resultWithAuth).toContain("User from your account");
-      expect(resultWithAuth).toContain("Project from your workspace");
-
-      // Verify the SDK was called with correct parameters
-      expect(mockSdk.listInputFields).toHaveBeenCalledWith({
-        appKey: "test-app@1.0.0",
-        actionKey: "create_task",
-        actionType: "write",
-        authenticationId: undefined,
-      });
-
-      expect(mockSdk.listInputFields).toHaveBeenCalledWith({
-        appKey: "test-app@1.0.0",
-        actionKey: "create_task",
-        actionType: "write",
-        authenticationId: 123,
-      });
-
-      expect(consoleWarnSpy).not.toHaveBeenCalled();
-    });
-
-    it("should handle empty actions list", async () => {
-      mockSdk.listActions.mockResolvedValue({ data: [] });
-
-      const result = await generator.generateTypes({
-        app: mockApp,
-        authenticationId: 123,
-        sdk: mockSdk as unknown as SdkType,
-        context: mockContext as Parameters<
-          typeof generator.generateTypes
-        >[0]["context"],
-      });
-
-      expect(result).toContain("import");
-      expect(result).toContain("@zapier/zapier-sdk");
-      expect(result).toContain("declare module");
-      expect(consoleWarnSpy).not.toHaveBeenCalled();
-    });
-
-    it("should handle all field types correctly", async () => {
-      const mockActions: ActionItem[] = [
-        {
-          key: "test_action",
-          title: "Test Action",
-          action_type: "write",
-          app_key: "test-app",
-          description: "Test all field types",
-          type: "action",
-        },
-      ];
-
-      const mockInputFields: InputFieldItem[] = [
-        createInputFieldItem({
-          key: "string_field",
-          title: "String Field",
-          value_type: "string",
-          is_required: true,
-        }),
-        createInputFieldItem({
-          key: "number_field",
-          title: "Number Field",
-          value_type: "number",
-          is_required: true,
-        }),
-        createInputFieldItem({
-          key: "integer_field",
-          title: "Integer Field",
-          value_type: "integer",
-          is_required: true,
-        }),
-        createInputFieldItem({
-          key: "boolean_field",
-          title: "Boolean Field",
-          value_type: "boolean",
-          is_required: true,
-        }),
-        createInputFieldItem({
-          key: "array_field",
-          title: "Array Field",
-          value_type: "array",
-          is_required: false,
-        }),
-        createInputFieldItem({
-          key: "object_field",
-          title: "Object Field",
-          value_type: "object",
-          is_required: false,
-        }),
-        createInputFieldItem({
-          key: "email_field",
-          title: "Email Field",
-          value_type: "email",
-          is_required: false,
-        }),
-        createInputFieldItem({
-          key: "url_field",
-          title: "URL Field",
-          value_type: "url",
-          is_required: false,
-        }),
-        createInputFieldItem({
-          key: "datetime_field",
-          title: "DateTime Field",
-          value_type: "datetime",
-          is_required: false,
-        }),
-        createInputFieldItem({
-          key: "unknown_field",
-          title: "Unknown Field",
-          value_type: "custom_type" as InputFieldItem["value_type"],
-          is_required: false,
-        }),
-      ];
-
-      mockSdk.listActions.mockResolvedValue({ data: mockActions });
-      mockSdk.listInputFields.mockResolvedValue({ data: mockInputFields });
-
-      const result = await generator.generateTypes({
-        app: mockApp,
-        authenticationId: 123,
-        sdk: mockSdk as unknown as SdkType,
-        context: mockContext as Parameters<
-          typeof generator.generateTypes
-        >[0]["context"],
-      });
-
-      expect(result).toContain("string_field: string");
-      expect(result).toContain("number_field: number");
-      expect(result).toContain("integer_field: number");
-      expect(result).toContain("boolean_field: boolean");
-      expect(result).toContain("array_field?: any[]");
-      expect(result).toContain("object_field?: Record<string, any>");
-      expect(result).toContain("email_field?: string");
-      expect(result).toContain("url_field?: string");
-      expect(result).toContain("datetime_field?: string");
-      expect(result).toContain("unknown_field?: string | number | boolean");
-    });
-
-    it("should sanitize invalid field names", async () => {
-      const mockActions: ActionItem[] = [
-        {
-          key: "test-action",
-          title: "Test Action",
-          action_type: "write",
-          app_key: "test-app",
-          description: "Test field sanitization",
-          type: "action",
-        },
-      ];
-
-      const mockInputFields: InputFieldItem[] = [
-        createInputFieldItem({
-          key: "field-with-dashes",
-          title: "Field with dashes",
-          value_type: "string",
-          is_required: true,
-        }),
-        createInputFieldItem({
-          key: "field.with.dots",
-          title: "Field with dots",
-          value_type: "string",
-          is_required: true,
-        }),
-        createInputFieldItem({
-          key: "123-starts-with-number",
-          title: "Starts with number",
-          value_type: "string",
-          is_required: true,
-        }),
-      ];
-
-      mockSdk.listActions.mockResolvedValue({ data: mockActions });
-      mockSdk.listInputFields.mockResolvedValue({ data: mockInputFields });
-
-      const result = await generator.generateTypes({
-        app: mockApp,
-        authenticationId: 123,
-        sdk: mockSdk as unknown as SdkType,
-        context: mockContext as Parameters<
-          typeof generator.generateTypes
-        >[0]["context"],
-      });
-
-      expect(result).toContain("field_with_dashes: string");
-      expect(result).toContain("field_with_dots: string");
-      expect(result).toContain("_123_starts_with_number: string");
-    });
-
-    it("should group actions by type", async () => {
-      const mockActions: ActionItem[] = [
-        {
-          key: "search_user",
-          title: "Search User",
-          action_type: "search",
-          app_key: "test-app",
-          description: "Search for a user",
-          type: "action",
-        },
-        {
-          key: "find_user",
-          title: "Find User",
-          action_type: "search",
-          app_key: "test-app",
-          description: "Find a user",
-          type: "action",
-        },
-        {
-          key: "create_task",
-          title: "Create Task",
-          action_type: "write",
-          app_key: "test-app",
-          description: "Create a task",
-          type: "action",
-        },
-      ];
-
-      mockSdk.listActions.mockResolvedValue({ data: mockActions });
-      mockSdk.listInputFields.mockResolvedValue({ data: [] });
-
-      const result = await generator.generateTypes({
-        app: mockApp,
-        authenticationId: 123,
-        sdk: mockSdk as unknown as SdkType,
-        context: mockContext as Parameters<
-          typeof generator.generateTypes
-        >[0]["context"],
-      });
-
-      expect(result).toContain("interface TestAppSearchActions");
-      expect(result).toContain("interface TestAppWriteActions");
-      expect(result).toContain("search_user");
-      expect(result).toContain("find_user");
-      expect(result).toContain("create_task");
-    });
-
-    it("should generate module augmentation with all app keys", async () => {
-      const appWithMultipleKeys: AppItem = {
-        ...mockApp,
-        key: "my-app",
-        slug: "my-app-slug",
-      };
-
-      mockSdk.listActions.mockResolvedValue({ data: [] });
-
-      const result = await generator.generateTypes({
-        app: appWithMultipleKeys,
-        authenticationId: 123,
-        sdk: mockSdk as unknown as SdkType,
-        context: mockContext as Parameters<
-          typeof generator.generateTypes
-        >[0]["context"],
-      });
-
-      expect(result).toContain('declare module "@zapier/zapier-sdk"');
-      expect(result).toContain("interface ZapierSdkApps");
-      expect(result).toContain("my_app_slug");
-      expect(result).toContain("MyAppSlugAppWithFactory");
-    });
-
-    it("should include fetch method in generated types", async () => {
-      mockSdk.listActions.mockResolvedValue({ data: [] });
-
-      const result = await generator.generateTypes({
-        app: mockApp,
-        authenticationId: 123,
-        sdk: mockSdk as unknown as SdkType,
-        context: mockContext as Parameters<
-          typeof generator.generateTypes
-        >[0]["context"],
-      });
-
-      expect(result).toContain("fetch");
-      expect(result).toContain("ZapierFetchInitOptions");
-      expect(result).toContain(
-        "Make authenticated HTTP requests through Zapier's Relay service",
-      );
-    });
-
-    it("should add JSDoc comments from field descriptions", async () => {
-      const mockActions: ActionItem[] = [
-        {
-          key: "test_action",
-          title: "Test Action",
-          action_type: "write",
-          app_key: "test-app",
-          description: "This is the action description",
-          type: "action",
-        },
-      ];
-
-      const mockInputFields: InputFieldItem[] = [
-        createInputFieldItem({
-          key: "field_with_comment",
-          title: "Field with comment",
-          value_type: "string",
-          is_required: true,
-          description: "This is a helpful comment for the field",
-        }),
-      ];
-
-      mockSdk.listActions.mockResolvedValue({ data: mockActions });
-      mockSdk.listInputFields.mockResolvedValue({ data: mockInputFields });
-
-      const result = await generator.generateTypes({
-        app: mockApp,
-        authenticationId: 123,
-        sdk: mockSdk as unknown as SdkType,
-        context: mockContext as Parameters<
-          typeof generator.generateTypes
-        >[0]["context"],
-      });
-
-      expect(result).toContain("This is a helpful comment for the field");
-      expect(result).toContain("This is the action description");
-    });
-
-    it("should escape special characters in comments", async () => {
-      const mockActions: ActionItem[] = [
-        {
-          key: "test_action",
-          title: "Test Action",
-          action_type: "write",
-          app_key: "test-app",
-          description: "Description with */ closing comment",
-          type: "action",
-        },
-      ];
-
-      const mockInputFields: InputFieldItem[] = [
-        createInputFieldItem({
-          key: "field",
-          title: "Field",
-          value_type: "string",
-          is_required: true,
-          description: "Field with */ and\nmultiple\nlines",
-        }),
-      ];
-
-      mockSdk.listActions.mockResolvedValue({ data: mockActions });
-      mockSdk.listInputFields.mockResolvedValue({ data: mockInputFields });
-
-      const result = await generator.generateTypes({
-        app: mockApp,
-        authenticationId: 123,
-        sdk: mockSdk as unknown as SdkType,
-        context: mockContext as Parameters<
-          typeof generator.generateTypes
-        >[0]["context"],
-      });
-
-      expect(result).toContain("*\\/");
-      expect(result).not.toContain("\n *\n");
-    });
-
-    it("should generate proper TypeScript syntax", async () => {
-      const mockActions: ActionItem[] = [
-        {
-          key: "test_action",
-          title: "Test Action",
-          action_type: "write",
-          app_key: "test-app",
-          description: "Test action",
-          type: "action",
-        },
-      ];
-
-      mockSdk.listActions.mockResolvedValue({ data: mockActions });
-      mockSdk.listInputFields.mockResolvedValue({ data: [] });
-
-      const result = await generator.generateTypes({
-        app: mockApp,
-        authenticationId: 123,
-        sdk: mockSdk as unknown as SdkType,
-        context: mockContext as Parameters<
-          typeof generator.generateTypes
-        >[0]["context"],
-      });
-
-      expect(result).toContain('import "@zapier/zapier-sdk"');
-      expect(result).toContain("import type");
-      expect(result).toContain("ActionExecutionOptions");
-      expect(result).toContain("ActionExecutionResult");
-      expect(result).toContain("Promise<ActionExecutionResult>");
-      expect(result).toContain("interface");
-      expect(result).toContain("type TestAppAppWithFactory");
-      expect(result).toContain("export {};");
-    });
-
-    it("should handle actions without title", async () => {
-      const mockActions: ActionItem[] = [
-        {
-          key: "action_without_title",
-          action_type: "write",
-          app_key: "test-app",
-          type: "action",
-        } as ActionItem,
-      ];
-
-      mockSdk.listActions.mockResolvedValue({ data: mockActions });
-      mockSdk.listInputFields.mockResolvedValue({ data: [] });
-
-      const result = await generator.generateTypes({
-        app: mockApp,
-        authenticationId: 123,
-        sdk: mockSdk as unknown as SdkType,
-        context: mockContext as Parameters<
-          typeof generator.generateTypes
-        >[0]["context"],
-      });
-
-      expect(result).toContain("action_without_title");
-    });
-
-    it("should generate header with timestamp and usage instructions", async () => {
-      mockSdk.listActions.mockResolvedValue({ data: [] });
-
-      const result = await generator.generateTypes({
-        app: mockApp,
-        authenticationId: 123,
-        sdk: mockSdk as unknown as SdkType,
-        context: mockContext as Parameters<
-          typeof generator.generateTypes
-        >[0]["context"],
-      });
-
-      expect(result).toContain("Auto-generated TypeScript types");
-      expect(result).toContain("Generated for test-app@1.0.0");
-      expect(result).toContain("Generated on:");
-      expect(result).toContain("Usage:");
-      expect(result).toContain("createZapierSdk");
-      expect(result).toContain(
-        "eslint-disable @typescript-eslint/naming-convention",
-      );
-    });
-
-    it("should handle Promise.allSettled with all rejections", async () => {
-      const mockActions: ActionItem[] = [
-        {
-          key: "action1",
-          title: "Action 1",
-          action_type: "write",
-          app_key: "test-app",
-          description: "Test action",
-          type: "action",
-        },
-        {
-          key: "action2",
-          title: "Action 2",
-          action_type: "write",
-          app_key: "test-app",
-          description: "Test action",
-          type: "action",
-        },
-      ];
-
-      mockSdk.listActions.mockResolvedValue({ data: mockActions });
-      mockSdk.listInputFields.mockRejectedValue(
-        new Error("All requests failed"),
-      );
-
-      const result = await generator.generateTypes({
-        app: mockApp,
-        authenticationId: 123,
-        sdk: mockSdk as unknown as SdkType,
-        context: mockContext as Parameters<
-          typeof generator.generateTypes
-        >[0]["context"],
-      });
-
-      expect(result).toContain("TestAppWriteActions");
-      expect(consoleWarnSpy).toHaveBeenCalledWith(
-        "Failed to fetch input fields for 2 action(s):",
-      );
-      expect(consoleWarnSpy).toHaveBeenCalledWith(
-        "  - action1 (write): All requests failed",
-      );
-      expect(consoleWarnSpy).toHaveBeenCalledWith(
-        "  - action2 (write): All requests failed",
-      );
-    });
-
-    it("should handle error without message property", async () => {
-      const mockActions: ActionItem[] = [
-        {
-          key: "test_action",
-          title: "Test Action",
-          action_type: "write",
-          app_key: "test-app",
-          description: "Test action",
-          type: "action",
-        },
-      ];
-
-      mockSdk.listActions.mockResolvedValue({ data: mockActions });
-      mockSdk.listInputFields.mockRejectedValue("String error");
-
-      await generator.generateTypes({
-        app: mockApp,
-        authenticationId: 123,
-        sdk: mockSdk as unknown as SdkType,
-        context: mockContext as Parameters<
-          typeof generator.generateTypes
-        >[0]["context"],
-      });
-
-      expect(consoleWarnSpy).toHaveBeenCalledWith(
-        "Failed to fetch input fields for 1 action(s):",
-      );
-      expect(consoleWarnSpy).toHaveBeenCalledWith(
-        "  - test_action (write): Unknown error",
-      );
-    });
-  });
-});