@zapier/zapier-sdk 0.18.4 → 0.19.0

package/dist/plugins/listAuthentications/index.test.js

@@ -1,848 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { ZapierValidationError, ZapierAuthenticationError, } from "../../types/errors";
-import { listAuthenticationsPlugin } from "./index";
-import { createSdk } from "../../sdk";
-import { eventEmissionPlugin } from "../eventEmission";
-// Mock transport for testing - prevents real HTTP telemetry requests
-const mockTransport = {
-    emit: vi.fn().mockResolvedValue(undefined),
-    close: vi.fn().mockResolvedValue(undefined),
-};
-vi.mock("../eventEmission/transport", () => ({
-    createTransport: vi.fn(() => mockTransport),
-}));
-// Mock CLI login package - prevents real token resolution requests
-vi.mock("@zapier/zapier-sdk-cli-login", () => ({
-    getToken: vi.fn().mockResolvedValue(undefined),
-}));
-// Mock response in the new API format (data array, not results)
-const mockAuthenticationsResponse = {
-    data: [
-        {
-            id: "123",
-            date: "2021-01-01",
-            account_id: "456",
-            implementation_id: "SlackCLIAPI@1.21.1",
-            is_invite_only: false,
-            is_private: false,
-            shared_with_all: false,
-            is_expired: "false",
-            expired_at: null,
-            label: "My Slack Workspace",
-            title: "My Slack Workspace",
-        },
-        {
-            id: "789",
-            date: "2021-02-01",
-            account_id: "456",
-            implementation_id: "GitHubAPI@2.1.0",
-            is_invite_only: false,
-            is_private: false,
-            shared_with_all: true,
-            is_expired: "true",
-            expired_at: "2021-06-01",
-            label: "GitHub Integration",
-            title: "GitHub Integration",
-        },
-    ],
-    nextCursor: undefined,
-};
-describe("listAuthentications plugin", () => {
-    let mockApiClient;
-    let mockGetVersionedImplementationId;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockApiClient = {
-            get: vi.fn().mockResolvedValue(mockAuthenticationsResponse),
-        };
-        mockGetVersionedImplementationId = vi
-            .fn()
-            .mockResolvedValue("SlackCLIAPI@1.21.1");
-    });
-    const apiPlugin = () => ({
-        context: {
-            api: mockApiClient,
-        },
-    });
-    const mockResolveAppKeys = vi.fn().mockResolvedValue([]);
-    const manifestPlugin = () => ({
-        context: {
-            manifest: null,
-            getVersionedImplementationId: mockGetVersionedImplementationId,
-            resolveAppKeys: mockResolveAppKeys,
-            updateManifestEntry: vi
-                .fn()
-                .mockResolvedValue(["test-key", {}, { apps: {} }]),
-            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: {} }),
-        },
-    });
-    function createTestSdk() {
-        return createSdk()
-            .addPlugin(() => ({
-            context: {
-                options: {},
-            },
-        }))
-            .addPlugin(apiPlugin)
-            .addPlugin(eventEmissionPlugin)
-            .addPlugin(manifestPlugin)
-            .addPlugin(listAuthenticationsPlugin);
-    }
-    describe("schema validation", () => {
-        it("should pass validation with empty options", async () => {
-            const sdk = createTestSdk();
-            const result = await sdk.listAuthentications({});
-            expect(result.data).toHaveLength(2);
-        });
-        it("should handle undefined options", async () => {
-            const sdk = createTestSdk();
-            const result = await sdk.listAuthentications();
-            expect(result.data).toHaveLength(2);
-            expect(result.data[0]).toMatchObject({
-                id: "123",
-            });
-        });
-        it("should throw validation error for invalid appKey type", () => {
-            const sdk = createTestSdk();
-            expect(() => {
-                sdk.listAuthentications({
-                    appKey: 123,
-                });
-            }).toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for invalid search type", () => {
-            const sdk = createTestSdk();
-            expect(() => {
-                sdk.listAuthentications({
-                    search: 123,
-                });
-            }).toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for invalid title type", () => {
-            const sdk = createTestSdk();
-            expect(() => {
-                sdk.listAuthentications({
-                    title: 123,
-                });
-            }).toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for invalid accountId type", () => {
-            const sdk = createTestSdk();
-            expect(() => {
-                sdk.listAuthentications({
-                    accountId: 123,
-                });
-            }).toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for invalid owner type", () => {
-            const sdk = createTestSdk();
-            expect(() => {
-                sdk.listAuthentications({
-                    owner: 123,
-                });
-            }).toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for invalid authenticationIds type", () => {
-            const sdk = createTestSdk();
-            expect(() => {
-                sdk.listAuthentications({
-                    authenticationIds: "123", // Should be array of strings
-                });
-            }).toThrow(ZapierValidationError);
-            expect(() => {
-                sdk.listAuthentications({
-                    authenticationIds: [123], // Should be array of strings, not numbers
-                });
-            }).toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for invalid pageSize", () => {
-            const sdk = createTestSdk();
-            expect(() => {
-                sdk.listAuthentications({
-                    pageSize: 0, // Should be >= 1
-                });
-            }).toThrow(ZapierValidationError);
-            expect(() => {
-                sdk.listAuthentications({
-                    pageSize: -5, // Should be >= 1
-                });
-            }).toThrow(ZapierValidationError);
-        });
-        it("should throw validation error for invalid maxItems", () => {
-            const sdk = createTestSdk();
-            expect(() => {
-                sdk.listAuthentications({
-                    maxItems: 0, // Should be >= 1
-                });
-            }).toThrow(ZapierValidationError);
-            expect(() => {
-                sdk.listAuthentications({
-                    maxItems: -10, // Should be >= 1
-                });
-            }).toThrow(ZapierValidationError);
-        });
-        it("should pass validation with all valid fields", async () => {
-            const sdk = createTestSdk();
-            const result = await sdk.listAuthentications({
-                appKey: "slack",
-                authenticationIds: ["123", "456"],
-                search: "workspace",
-                title: "My Slack Workspace",
-                accountId: "acc_123",
-                owner: "me",
-                pageSize: 10,
-                maxItems: 50,
-            });
-            expect(result.data).toBeDefined();
-        });
-    });
-    describe("data mapping", () => {
-        it("should pass through is_expired and expired_at fields", async () => {
-            const sdk = createTestSdk();
-            const result = await sdk.listAuthentications();
-            // API returns these fields directly (no client-side transformation)
-            expect(result.data[0].is_expired).toBe("false");
-            expect(result.data[0].expired_at).toBe(null);
-            expect(result.data[1].is_expired).toBe("true");
-            expect(result.data[1].expired_at).toBe("2021-06-01");
-        });
-        it("should pass through label field when title is missing", async () => {
-            const responseWithoutTitle = {
-                ...mockAuthenticationsResponse,
-                data: [
-                    {
-                        ...mockAuthenticationsResponse.data[0],
-                        title: undefined,
-                        label: "Label Only Auth",
-                    },
-                ],
-                nextCursor: undefined,
-            };
-            mockApiClient.get = vi.fn().mockResolvedValue(responseWithoutTitle);
-            const sdk = createTestSdk();
-            const result = await sdk.listAuthentications({});
-            // New API passes through fields directly - title coercion happens server-side
-            expect(result.data[0].title).toBeUndefined();
-            expect(result.data[0].label).toBe("Label Only Auth");
-        });
-        it("should handle authentications with neither title nor label", async () => {
-            const responseWithoutTitleOrLabel = {
-                ...mockAuthenticationsResponse,
-                data: [
-                    {
-                        ...mockAuthenticationsResponse.data[0],
-                        title: undefined,
-                        label: undefined,
-                    },
-                ],
-                nextCursor: undefined,
-            };
-            mockApiClient.get = vi
-                .fn()
-                .mockResolvedValue(responseWithoutTitleOrLabel);
-            const sdk = createTestSdk();
-            const result = await sdk.listAuthentications({});
-            expect(result.data[0].title).toBeUndefined();
-        });
-    });
-    describe("filtering", () => {
-        it("should pass search parameter to API when provided", async () => {
-            const sdk = createTestSdk();
-            await sdk.listAuthentications({ search: "workspace" });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
-                searchParams: expect.objectContaining({
-                    search: "workspace",
-                }),
-            }));
-        });
-        it("should pass title parameter separately to API", async () => {
-            const sdk = createTestSdk();
-            await sdk.listAuthentications({ title: "My Slack Workspace" });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
-                searchParams: expect.objectContaining({
-                    title: "My Slack Workspace",
-                }),
-            }));
-        });
-        it("should pass both search and title when both provided", async () => {
-            const sdk = createTestSdk();
-            await sdk.listAuthentications({
-                search: "explicit search",
-                title: "My Title",
-            });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
-                searchParams: expect.objectContaining({
-                    search: "explicit search",
-                    title: "My Title",
-                }),
-            }));
-        });
-        it("should pass accountId filter to API", async () => {
-            const sdk = createTestSdk();
-            await sdk.listAuthentications({ accountId: "acc_123" });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
-                searchParams: expect.objectContaining({
-                    accountId: "acc_123",
-                }),
-            }));
-        });
-        it("should pass owner filter to API", async () => {
-            const sdk = createTestSdk();
-            await sdk.listAuthentications({ owner: "me" });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
-                searchParams: expect.objectContaining({
-                    owner: "me",
-                }),
-            }));
-        });
-        it("should pass authenticationIds as comma-separated string to API", async () => {
-            const sdk = createTestSdk();
-            await sdk.listAuthentications({
-                authenticationIds: ["123", "456", "789"],
-            });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
-                searchParams: expect.objectContaining({
-                    authenticationIds: "123,456,789",
-                }),
-            }));
-        });
-        it("should not include authenticationIds parameter when array is empty", async () => {
-            const sdk = createTestSdk();
-            await sdk.listAuthentications({
-                authenticationIds: [],
-            });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
-                searchParams: expect.not.objectContaining({
-                    authenticationIds: expect.anything(),
-                }),
-            }));
-        });
-        it("should not include undefined optional parameters in searchParams", async () => {
-            const sdk = createTestSdk();
-            await sdk.listAuthentications({});
-            const callArgs = mockApiClient.get.mock.calls[0];
-            const searchParams = callArgs[1].searchParams;
-            // Should only have pageSize (default), not undefined params
-            expect(searchParams).not.toHaveProperty("search");
-            expect(searchParams).not.toHaveProperty("title");
-            expect(searchParams).not.toHaveProperty("accountId");
-            expect(searchParams).not.toHaveProperty("owner");
-            expect(searchParams).not.toHaveProperty("authenticationIds");
-            expect(searchParams).not.toHaveProperty("appKey");
-        });
-    });
-    describe("pagination", () => {
-        it("should handle pagination with maxItems by collecting all items", async () => {
-            // Mock multiple pages - first page has 2 items, second page has 1 item
-            mockApiClient.get = vi
-                .fn()
-                .mockResolvedValueOnce({
-                data: mockAuthenticationsResponse.data,
-                nextCursor: "2",
-            })
-                .mockResolvedValueOnce({
-                data: [
-                    {
-                        id: "999",
-                        date: "2021-03-01",
-                        account_id: "456",
-                        implementation_id: "DropboxAPI@3.0.0",
-                        is_invite_only: false,
-                        is_private: false,
-                        shared_with_all: false,
-                        is_expired: "false",
-                        expired_at: null,
-                        title: "Dropbox Integration",
-                    },
-                ],
-                nextCursor: undefined,
-            });
-            const sdk = createTestSdk();
-            // Collect all items using the items() iterator
-            const items = [];
-            for await (const item of sdk
-                .listAuthentications({ maxItems: 3 })
-                .items()) {
-                items.push(item);
-            }
-            expect(items).toHaveLength(3); // Should stop at maxItems
-            expect(mockApiClient.get).toHaveBeenCalledTimes(2); // Should fetch both pages
-        });
-        it("should return first page when awaited", async () => {
-            mockApiClient.get = vi.fn().mockResolvedValue({
-                data: mockAuthenticationsResponse.data,
-                nextCursor: undefined,
-            });
-            const sdk = createTestSdk();
-            const result = await sdk.listAuthentications({});
-            // Await returns first page only
-            expect(result.data).toHaveLength(2);
-            expect(mockApiClient.get).toHaveBeenCalledTimes(1);
-        });
-        it("should support async iteration over pages", async () => {
-            mockApiClient.get = vi
-                .fn()
-                .mockResolvedValueOnce({
-                data: mockAuthenticationsResponse.data.slice(0, 1),
-                nextCursor: "1",
-            })
-                .mockResolvedValueOnce({
-                data: mockAuthenticationsResponse.data.slice(1, 2),
-                nextCursor: undefined,
-            });
-            const sdk = createTestSdk();
-            const pages = [];
-            for await (const page of sdk.listAuthentications({ pageSize: 1 })) {
-                pages.push(page);
-                if (pages.length >= 2)
-                    break;
-            }
-            expect(pages).toHaveLength(2);
-            expect(pages[0].data).toHaveLength(1);
-            expect(pages[1].data).toHaveLength(1);
-            expect(pages[0].data[0].id).toBe("123");
-            expect(pages[1].data[0].id).toBe("789");
-        });
-        it("should support async iteration over individual items", async () => {
-            const sdk = createTestSdk();
-            const items = [];
-            for await (const item of sdk
-                .listAuthentications({ maxItems: 2 })
-                .items()) {
-                items.push(item);
-            }
-            expect(items).toHaveLength(2);
-            expect(items[0].id).toBe("123");
-            expect(items[1].id).toBe("789");
-        });
-        it("should set pageSize in searchParams for API calls", async () => {
-            const sdk = createTestSdk();
-            await sdk.listAuthentications({ pageSize: 15 });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
-                searchParams: expect.objectContaining({
-                    pageSize: "15",
-                }),
-            }));
-        });
-        it("should pass cursor as offset parameter", async () => {
-            mockApiClient.get = vi
-                .fn()
-                .mockResolvedValueOnce({
-                data: mockAuthenticationsResponse.data.slice(0, 1),
-                nextCursor: "cursor-abc-123",
-            })
-                .mockResolvedValueOnce({
-                data: mockAuthenticationsResponse.data.slice(1, 2),
-                nextCursor: undefined,
-            });
-            const sdk = createTestSdk();
-            const pages = [];
-            for await (const page of sdk.listAuthentications({ pageSize: 1 })) {
-                pages.push(page);
-                if (pages.length >= 2)
-                    break;
-            }
-            // Second call should include the cursor as offset
-            expect(mockApiClient.get).toHaveBeenNthCalledWith(2, "/api/v0/authentications", expect.objectContaining({
-                searchParams: expect.objectContaining({
-                    offset: "cursor-abc-123",
-                }),
-            }));
-        });
-        it("should stop pagination when nextCursor is undefined", async () => {
-            mockApiClient.get = vi.fn().mockResolvedValue({
-                data: mockAuthenticationsResponse.data,
-                nextCursor: undefined,
-            });
-            const sdk = createTestSdk();
-            const pages = [];
-            for await (const page of sdk.listAuthentications({})) {
-                pages.push(page);
-            }
-            expect(pages).toHaveLength(1);
-            expect(mockApiClient.get).toHaveBeenCalledTimes(1);
-        });
-    });
-    describe("API integration", () => {
-        it("should call the correct API endpoint", async () => {
-            const sdk = createTestSdk();
-            await sdk.listAuthentications({});
-            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.any(Object));
-        });
-        it("should pass pageSize as string in searchParams", async () => {
-            const sdk = createTestSdk();
-            await sdk.listAuthentications({ pageSize: 25 });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
-                searchParams: expect.objectContaining({
-                    pageSize: "25",
-                }),
-            }));
-        });
-        it("should handle cursor-based pagination with nextCursor", async () => {
-            mockApiClient.get = vi
-                .fn()
-                .mockResolvedValueOnce({
-                data: mockAuthenticationsResponse.data.slice(0, 1),
-                nextCursor: "offset-1",
-            })
-                .mockResolvedValueOnce({
-                data: mockAuthenticationsResponse.data.slice(1, 2),
-                nextCursor: undefined,
-            });
-            const sdk = createTestSdk();
-            // Test that the function can handle multiple pages
-            let pageCount = 0;
-            for await (const _page of sdk.listAuthentications({ pageSize: 1 })) {
-                pageCount++;
-                if (pageCount >= 2)
-                    break;
-            }
-            expect(pageCount).toBe(2);
-            expect(mockApiClient.get).toHaveBeenCalledTimes(2);
-            // The second call should include the offset from the nextCursor
-            expect(mockApiClient.get).toHaveBeenNthCalledWith(2, "/api/v0/authentications", expect.objectContaining({
-                searchParams: expect.objectContaining({
-                    offset: "offset-1",
-                }),
-            }));
-        });
-        it("should set authRequired to true in API call options", async () => {
-            const sdk = createTestSdk();
-            await sdk.listAuthentications({});
-            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
-                authRequired: true,
-            }));
-        });
-        it("should include customErrorHandler in API call options", async () => {
-            const sdk = createTestSdk();
-            await sdk.listAuthentications({});
-            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
-                customErrorHandler: expect.any(Function),
-            }));
-        });
-    });
-    describe("error handling", () => {
-        it("should throw ZapierAuthenticationError for 401 responses", async () => {
-            mockApiClient.get = vi.fn().mockImplementation((_url, options) => {
-                // Simulate the API client calling the customErrorHandler
-                const error = options.customErrorHandler({ status: 401 });
-                if (error)
-                    throw error;
-            });
-            const sdk = createTestSdk();
-            await expect(sdk.listAuthentications({})).rejects.toThrow(ZapierAuthenticationError);
-            await expect(sdk.listAuthentications({})).rejects.toThrow(/Authentication failed.*HTTP 401/);
-        });
-        it("should throw ZapierAuthenticationError for 403 responses", async () => {
-            mockApiClient.get = vi.fn().mockImplementation((_url, options) => {
-                // Simulate the API client calling the customErrorHandler
-                const error = options.customErrorHandler({ status: 403 });
-                if (error)
-                    throw error;
-            });
-            const sdk = createTestSdk();
-            await expect(sdk.listAuthentications({})).rejects.toThrow(ZapierAuthenticationError);
-            await expect(sdk.listAuthentications({})).rejects.toThrow(/Access forbidden.*HTTP 403/);
-        });
-        it("should return undefined from customErrorHandler for non-401/403 errors", async () => {
-            let customErrorHandlerResult;
-            mockApiClient.get = vi.fn().mockImplementation((_url, options) => {
-                // Capture the customErrorHandler result for 500
-                customErrorHandlerResult = options.customErrorHandler({ status: 500 });
-                // Return valid data since we're just testing the handler
-                return mockAuthenticationsResponse;
-            });
-            const sdk = createTestSdk();
-            await sdk.listAuthentications({});
-            // The customErrorHandler should return undefined for other status codes
-            expect(customErrorHandlerResult).toBeUndefined();
-        });
-        it("should handle empty data array", async () => {
-            const emptyResponse = {
-                data: [],
-                nextCursor: undefined,
-            };
-            mockApiClient.get = vi.fn().mockResolvedValue(emptyResponse);
-            const sdk = createTestSdk();
-            const result = await sdk.listAuthentications({});
-            expect(result.data).toHaveLength(0);
-            expect(Array.isArray(result.data)).toBe(true);
-        });
-        it("should handle API errors gracefully", async () => {
-            const networkError = new Error("Network error");
-            mockApiClient.get = vi.fn().mockRejectedValue(networkError);
-            const sdk = createTestSdk();
-            await expect(sdk.listAuthentications({})).rejects.toThrow("Network error");
-        });
-    });
-    describe("app key integration", () => {
-        it("should not add appKey parameter when getVersionedImplementationId returns null", async () => {
-            mockGetVersionedImplementationId.mockResolvedValue(null);
-            const sdk = createTestSdk();
-            await sdk.listAuthentications({ appKey: "slack" });
-            // Should not add appKey parameter when implementation can't be resolved
-            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
-                searchParams: expect.not.objectContaining({
-                    appKey: expect.any(String),
-                }),
-            }));
-        });
-        it("should extract versionless app key from versioned implementation ID", async () => {
-            mockGetVersionedImplementationId.mockResolvedValue("SlackCLIAPI@2.1.3");
-            const sdk = createTestSdk();
-            await sdk.listAuthentications({ appKey: "slack" });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
-                searchParams: expect.objectContaining({
-                    appKey: "SlackCLIAPI",
-                }),
-            }));
-        });
-        it("should handle implementation ID without version", async () => {
-            mockGetVersionedImplementationId.mockResolvedValue("SlackCLIAPI");
-            const sdk = createTestSdk();
-            await sdk.listAuthentications({ appKey: "slack" });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
-                searchParams: expect.objectContaining({
-                    appKey: "SlackCLIAPI",
-                }),
-            }));
-        });
-        it("should call getVersionedImplementationId with the provided appKey", async () => {
-            const sdk = createTestSdk();
-            await sdk.listAuthentications({ appKey: "my-custom-app" });
-            expect(mockGetVersionedImplementationId).toHaveBeenCalledWith("my-custom-app");
-        });
-        it("should not call getVersionedImplementationId when appKey is not provided", async () => {
-            const sdk = createTestSdk();
-            await sdk.listAuthentications({});
-            expect(mockGetVersionedImplementationId).not.toHaveBeenCalled();
-        });
-    });
-    describe("response transformation", () => {
-        it("should preserve all authentication fields from new API response", async () => {
-            const authWithAllFields = {
-                data: [
-                    {
-                        id: "123",
-                        date: "2021-01-01",
-                        lastchanged: "2021-01-02",
-                        account_id: "456",
-                        profile_id: "789",
-                        implementation_id: "SlackCLIAPI@1.21.1",
-                        destination_selected_api: "SlackDestAPI@1.0.0",
-                        is_invite_only: true,
-                        is_private: true,
-                        shared_with_all: false,
-                        is_expired: "true",
-                        is_shared: "false",
-                        expired_at: "2021-06-01",
-                        label: "Auth Label",
-                        title: "Auth Title",
-                        identifier: "auth-identifier",
-                        url: "https://example.com",
-                        groups: "group1,group2",
-                        members: "user1,user2",
-                        permissions: { read: true, write: false },
-                        app_key: "SlackCLIAPI",
-                        app_version: "1.21.1",
-                    },
-                ],
-                nextCursor: undefined,
-            };
-            mockApiClient.get = vi.fn().mockResolvedValue(authWithAllFields);
-            const sdk = createTestSdk();
-            const result = await sdk.listAuthentications({});
-            const auth = result.data[0];
-            // Verify all fields are passed through from the new API
-            expect(auth.id).toBe("123");
-            expect(auth.date).toBe("2021-01-01");
-            expect(auth.lastchanged).toBe("2021-01-02");
-            expect(auth.account_id).toBe("456");
-            expect(auth.profile_id).toBe("789");
-            expect(auth.implementation_id).toBe("SlackCLIAPI@1.21.1");
-            expect(auth.destination_selected_api).toBe("SlackDestAPI@1.0.0");
-            expect(auth.is_invite_only).toBe(true);
-            expect(auth.is_private).toBe(true);
-            expect(auth.shared_with_all).toBe(false);
-            expect(auth.is_shared).toBe("false");
-            expect(auth.label).toBe("Auth Label");
-            expect(auth.title).toBe("Auth Title");
-            expect(auth.identifier).toBe("auth-identifier");
-            expect(auth.url).toBe("https://example.com");
-            expect(auth.groups).toBe("group1,group2");
-            expect(auth.members).toBe("user1,user2");
-            expect(auth.permissions).toEqual({ read: true, write: false });
-            expect(auth.is_expired).toBe("true");
-            expect(auth.expired_at).toBe("2021-06-01");
-            expect(auth.app_key).toBe("SlackCLIAPI");
-            expect(auth.app_version).toBe("1.21.1");
-        });
-        it("should handle authentications with minimal fields", async () => {
-            const minimalAuth = {
-                data: [
-                    {
-                        id: "100",
-                        account_id: "200",
-                        implementation_id: "TestAPI@1.0.0",
-                    },
-                ],
-                nextCursor: undefined,
-            };
-            mockApiClient.get = vi.fn().mockResolvedValue(minimalAuth);
-            const sdk = createTestSdk();
-            const result = await sdk.listAuthentications({});
-            const auth = result.data[0];
-            expect(auth.id).toBe("100");
-            expect(auth.account_id).toBe("200");
-            expect(auth.implementation_id).toBe("TestAPI@1.0.0");
-        });
-    });
-    describe("context and metadata", () => {
-        it("should provide context with meta information", () => {
-            const sdk = createTestSdk();
-            const context = sdk.getContext();
-            expect(context.meta.listAuthentications).toBeDefined();
-            expect(context.meta.listAuthentications.inputSchema).toBeDefined();
-        });
-        it("should include all required metadata properties", () => {
-            const sdk = createTestSdk();
-            const context = sdk.getContext();
-            const meta = context.meta.listAuthentications;
-            expect(meta.categories).toContain("authentication");
-            expect(meta.type).toBe("list");
-            expect(meta.itemType).toBe("Authentication");
-            expect(meta.inputSchema).toBeDefined();
-            expect(meta.outputSchema).toBeDefined();
-            expect(meta.resolvers).toBeDefined();
-            expect(meta.resolvers.appKey).toBeDefined();
-        });
-    });
-    describe("edge cases", () => {
-        it("should handle special characters in search parameter", async () => {
-            const sdk = createTestSdk();
-            await sdk.listAuthentications({ search: "test@email.com" });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
-                searchParams: expect.objectContaining({
-                    search: "test@email.com",
-                }),
-            }));
-        });
-        it("should handle special characters in title parameter", async () => {
-            const sdk = createTestSdk();
-            await sdk.listAuthentications({ title: "My Auth (Test) #1" });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
-                searchParams: expect.objectContaining({
-                    title: "My Auth (Test) #1",
-                }),
-            }));
-        });
-        it("should handle single authenticationId in array", async () => {
-            const sdk = createTestSdk();
-            await sdk.listAuthentications({ authenticationIds: ["single-id"] });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
-                searchParams: expect.objectContaining({
-                    authenticationIds: "single-id",
-                }),
-            }));
-        });
-        it("should handle multiple filters combined", async () => {
-            const sdk = createTestSdk();
-            await sdk.listAuthentications({
-                appKey: "slack",
-                search: "workspace",
-                title: "My Workspace",
-                accountId: "acc_123",
-                owner: "me",
-                authenticationIds: ["id1", "id2"],
-                pageSize: 10,
-            });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
-                searchParams: expect.objectContaining({
-                    appKey: "SlackCLIAPI",
-                    search: "workspace",
-                    title: "My Workspace",
-                    accountId: "acc_123",
-                    owner: "me",
-                    authenticationIds: "id1,id2",
-                    pageSize: "10",
-                }),
-            }));
-        });
-        it("should handle maxItems less than pageSize", async () => {
-            mockApiClient.get = vi.fn().mockResolvedValue({
-                data: mockAuthenticationsResponse.data,
-                nextCursor: "next-page",
-            });
-            const sdk = createTestSdk();
-            const items = [];
-            for await (const item of sdk
-                .listAuthentications({ pageSize: 10, maxItems: 1 })
-                .items()) {
-                items.push(item);
-            }
-            expect(items).toHaveLength(1);
-            // Should only make one API call even though there's a next page
-            expect(mockApiClient.get).toHaveBeenCalledTimes(1);
-        });
-        it("should handle owner filter with user ID instead of 'me'", async () => {
-            const sdk = createTestSdk();
-            await sdk.listAuthentications({ owner: "user_12345" });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
-                searchParams: expect.objectContaining({
-                    owner: "user_12345",
-                }),
-            }));
-        });
-        it("should pass through nextCursor in response", async () => {
-            mockApiClient.get = vi.fn().mockResolvedValue({
-                data: mockAuthenticationsResponse.data,
-                nextCursor: "cursor-for-next-page",
-            });
-            const sdk = createTestSdk();
-            const result = await sdk.listAuthentications({});
-            expect(result.nextCursor).toBe("cursor-for-next-page");
-        });
-        it("should handle undefined nextCursor in response", async () => {
-            mockApiClient.get = vi.fn().mockResolvedValue({
-                data: mockAuthenticationsResponse.data,
-                nextCursor: undefined,
-            });
-            const sdk = createTestSdk();
-            const result = await sdk.listAuthentications({});
-            expect(result.nextCursor).toBeUndefined();
-        });
-    });
-    describe("concurrent requests", () => {
-        it("should handle multiple concurrent listAuthentications calls", async () => {
-            const sdk = createTestSdk();
-            const [result1, result2, result3] = await Promise.all([
-                sdk.listAuthentications({ search: "first" }),
-                sdk.listAuthentications({ search: "second" }),
-                sdk.listAuthentications({ search: "third" }),
-            ]);
-            expect(result1.data).toHaveLength(2);
-            expect(result2.data).toHaveLength(2);
-            expect(result3.data).toHaveLength(2);
-            expect(mockApiClient.get).toHaveBeenCalledTimes(3);
-        });
-    });
-});