@zapier/zapier-sdk 0.18.2 → 0.18.3

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

@@ -4,37 +4,35 @@ import { listAuthenticationsPlugin } from "./index";
 import { createSdk } from "../../sdk";
 import { eventEmissionPlugin } from "../eventEmission";
 const mockAuthenticationsResponse = {
-    results: [
+    data: [
         {
-            id: 123,
+            id: "123",
             date: "2021-01-01",
-            account_id: 456,
-            selected_api: "SlackCLIAPI@1.21.1",
+            account_id: "456",
+            implementation_id: "SlackCLIAPI@1.21.1",
             is_invite_only: false,
             is_private: false,
             shared_with_all: false,
-            is_stale: "false",
-            marked_stale_at: null,
+            is_expired: "false",
+            expired_at: null,
             label: "My Slack Workspace",
             title: "My Slack Workspace",
         },
         {
-            id: 789,
+            id: "789",
             date: "2021-02-01",
-            account_id: 456,
-            selected_api: "GitHubAPI@2.1.0",
+            account_id: "456",
+            implementation_id: "GitHubAPI@2.1.0",
             is_invite_only: false,
             is_private: false,
             shared_with_all: true,
-            is_stale: "true",
-            marked_stale_at: "2021-06-01",
+            is_expired: "true",
+            expired_at: "2021-06-01",
             label: "GitHub Integration",
             title: "GitHub Integration",
         },
     ],
-    count: 2,
-    next: null,
-    previous: null,
+    nextCursor: undefined,
 };
 describe("listAuthentications plugin", () => {
     let mockApiClient;
@@ -205,7 +203,7 @@ describe("listAuthentications plugin", () => {
         });
     });
     describe("data mapping", () => {
-        it("should map is_stale to is_expired and marked_stale_at to expired_at", async () => {
+        it("should pass through is_expired and expired_at fields", async () => {
             const sdk = createTestSdk();
             const result = await sdk.listAuthentications();
             expect(result.data[0].is_expired).toBe("false");
@@ -213,12 +211,12 @@ describe("listAuthentications plugin", () => {
             expect(result.data[1].is_expired).toBe("true");
             expect(result.data[1].expired_at).toBe("2021-06-01");
         });
-        it("should coerce title from label when title is missing", async () => {
+        it("should pass through label field when title is missing", async () => {
             const responseWithoutTitle = {
                 ...mockAuthenticationsResponse,
-                results: [
+                data: [
                     {
-                        ...mockAuthenticationsResponse.results[0],
+                        ...mockAuthenticationsResponse.data[0],
                         title: undefined,
                         label: "Label Only Auth",
                     },
@@ -227,14 +225,16 @@ describe("listAuthentications plugin", () => {
             mockApiClient.get = vi.fn().mockResolvedValue(responseWithoutTitle);
             const sdk = createTestSdk();
             const result = await sdk.listAuthentications({});
-            expect(result.data[0].title).toBe("Label Only Auth");
+            // 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,
-                results: [
+                data: [
                     {
-                        ...mockAuthenticationsResponse.results[0],
+                        ...mockAuthenticationsResponse.data[0],
                         title: undefined,
                         label: undefined,
                     },
@@ -249,85 +249,90 @@ describe("listAuthentications plugin", () => {
         });
     });
     describe("filtering", () => {
-        it("should filter by exact title match", async () => {
-            const sdk = createTestSdk();
-            const result = await sdk.listAuthentications({
-                title: "My Slack Workspace",
-            });
-            // Should filter to exact match
-            expect(result.data).toHaveLength(1);
-            expect(result.data[0].title).toBe("My Slack Workspace");
-        });
-        it("should use search parameter when provided", async () => {
+        it("should pass search parameter to API when provided", async () => {
             const sdk = createTestSdk();
             await sdk.listAuthentications({ search: "workspace" });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/zapier/api/v4/authentications/", expect.objectContaining({
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
                 searchParams: expect.objectContaining({
                     search: "workspace",
                 }),
             }));
         });
-        it("should use title as search when search not provided", async () => {
+        it("should pass title parameter separately to API", async () => {
             const sdk = createTestSdk();
             await sdk.listAuthentications({ title: "My Slack Workspace" });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/zapier/api/v4/authentications/", expect.objectContaining({
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
                 searchParams: expect.objectContaining({
-                    search: "My Slack Workspace",
+                    title: "My Slack Workspace",
                 }),
             }));
         });
-        it("should prefer search over title when both provided", async () => {
+        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("/zapier/api/v4/authentications/", expect.objectContaining({
+            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("/zapier/api/v4/authentications/", expect.objectContaining({
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
                 searchParams: expect.objectContaining({
-                    account_id: "acc_123",
+                    accountId: "acc_123",
                 }),
             }));
         });
         it("should pass owner filter to API", async () => {
             const sdk = createTestSdk();
             await sdk.listAuthentications({ owner: "me" });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/zapier/api/v4/authentications/", expect.objectContaining({
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
                 searchParams: expect.objectContaining({
                     owner: "me",
                 }),
             }));
         });
-        it("should pass authenticationIds as ids parameter to API", async () => {
+        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("/zapier/api/v4/authentications/", expect.objectContaining({
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
                 searchParams: expect.objectContaining({
-                    ids: "123,456,789",
+                    authenticationIds: "123,456,789",
                 }),
             }));
         });
-        it("should not include ids parameter when authenticationIds is empty", async () => {
+        it("should not include authenticationIds parameter when array is empty", async () => {
             const sdk = createTestSdk();
             await sdk.listAuthentications({
                 authenticationIds: [],
             });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/zapier/api/v4/authentications/", expect.objectContaining({
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
                 searchParams: expect.not.objectContaining({
-                    ids: expect.anything(),
+                    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 () => {
@@ -335,27 +340,25 @@ describe("listAuthentications plugin", () => {
             mockApiClient.get = vi
                 .fn()
                 .mockResolvedValueOnce({
-                results: mockAuthenticationsResponse.results,
-                count: 3,
-                next: "http://example.com/api/v4/authentications/?offset=2",
+                data: mockAuthenticationsResponse.data,
+                nextCursor: "2",
             })
                 .mockResolvedValueOnce({
-                results: [
+                data: [
                     {
-                        id: 999,
+                        id: "999",
                         date: "2021-03-01",
-                        account_id: 456,
-                        selected_api: "DropboxAPI@3.0.0",
+                        account_id: "456",
+                        implementation_id: "DropboxAPI@3.0.0",
                         is_invite_only: false,
                         is_private: false,
                         shared_with_all: false,
-                        is_stale: "false",
-                        marked_stale_at: null,
+                        is_expired: "false",
+                        expired_at: null,
                         title: "Dropbox Integration",
                     },
                 ],
-                count: 3,
-                next: null,
+                nextCursor: undefined,
             });
             const sdk = createTestSdk();
             // Collect all items using the items() iterator
@@ -370,9 +373,8 @@ describe("listAuthentications plugin", () => {
         });
         it("should return first page when awaited", async () => {
             mockApiClient.get = vi.fn().mockResolvedValue({
-                results: mockAuthenticationsResponse.results,
-                count: 2,
-                next: null, // No more pages to prevent automatic fetching
+                data: mockAuthenticationsResponse.data,
+                nextCursor: undefined,
             });
             const sdk = createTestSdk();
             const result = await sdk.listAuthentications({});
@@ -384,14 +386,12 @@ describe("listAuthentications plugin", () => {
             mockApiClient.get = vi
                 .fn()
                 .mockResolvedValueOnce({
-                results: mockAuthenticationsResponse.results.slice(0, 1),
-                count: 2,
-                next: "http://example.com/api/v4/authentications/?offset=1",
+                data: mockAuthenticationsResponse.data.slice(0, 1),
+                nextCursor: "1",
             })
                 .mockResolvedValueOnce({
-                results: mockAuthenticationsResponse.results.slice(1, 2),
-                count: 2,
-                next: null,
+                data: mockAuthenticationsResponse.data.slice(1, 2),
+                nextCursor: undefined,
             });
             const sdk = createTestSdk();
             const pages = [];
@@ -418,43 +418,79 @@ describe("listAuthentications plugin", () => {
             expect(items[0].id).toBe("123");
             expect(items[1].id).toBe("789");
         });
-        it("should set appropriate pageSize for API calls", async () => {
+        it("should set pageSize in searchParams for API calls", async () => {
             const sdk = createTestSdk();
-            await sdk.listAuthentications({ pageSize: 1 });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/zapier/api/v4/authentications/", expect.objectContaining({
+            await sdk.listAuthentications({ pageSize: 15 });
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
                 searchParams: expect.objectContaining({
-                    limit: "1",
+                    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("/zapier/api/v4/authentications/", expect.any(Object));
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.any(Object));
         });
-        it("should pass pageSize as limit parameter", async () => {
+        it("should pass pageSize as string in searchParams", async () => {
             const sdk = createTestSdk();
             await sdk.listAuthentications({ pageSize: 25 });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/zapier/api/v4/authentications/", expect.objectContaining({
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
                 searchParams: expect.objectContaining({
-                    limit: "25",
+                    pageSize: "25",
                 }),
             }));
         });
-        it("should handle cursor-based pagination internally", async () => {
+        it("should handle cursor-based pagination with nextCursor", async () => {
             mockApiClient.get = vi
                 .fn()
                 .mockResolvedValueOnce({
-                results: mockAuthenticationsResponse.results.slice(0, 1),
-                count: 2,
-                next: "http://example.com/api/v4/authentications/?offset=1",
+                data: mockAuthenticationsResponse.data.slice(0, 1),
+                nextCursor: "offset-1",
             })
                 .mockResolvedValueOnce({
-                results: mockAuthenticationsResponse.results.slice(1, 2),
-                count: 2,
-                next: null,
+                data: mockAuthenticationsResponse.data.slice(1, 2),
+                nextCursor: undefined,
             });
             const sdk = createTestSdk();
             // Test that the function can handle multiple pages
@@ -466,42 +502,68 @@ describe("listAuthentications plugin", () => {
             }
             expect(pageCount).toBe(2);
             expect(mockApiClient.get).toHaveBeenCalledTimes(2);
-            // The second call should include the offset from the cursor
-            expect(mockApiClient.get).toHaveBeenNthCalledWith(2, "/zapier/api/v4/authentications/", expect.objectContaining({
+            // The second call should include the offset from the nextCursor
+            expect(mockApiClient.get).toHaveBeenNthCalledWith(2, "/api/v0/authentications", expect.objectContaining({
                 searchParams: expect.objectContaining({
-                    offset: "1",
+                    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 () => {
-            const customErrorHandler = vi
-                .fn()
-                .mockReturnValue(new ZapierAuthenticationError("Authentication failed. Your token may not have permission to access authentications or may be expired. (HTTP 401)", { statusCode: 401 }));
-            mockApiClient.get = vi.fn().mockImplementation(() => {
-                const error = customErrorHandler({ status: 401 });
-                throw error;
+            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 () => {
-            const customErrorHandler = vi
-                .fn()
-                .mockReturnValue(new ZapierAuthenticationError("Access forbidden. Your token may not have the required scopes to list authentications. (HTTP 403)", { statusCode: 403 }));
-            mockApiClient.get = vi.fn().mockImplementation(() => {
-                const error = customErrorHandler({ status: 403 });
-                throw error;
+            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 results", async () => {
+        it("should handle empty data array", async () => {
             const emptyResponse = {
-                results: [],
-                count: 0,
-                next: null,
+                data: [],
+                nextCursor: undefined,
             };
             mockApiClient.get = vi.fn().mockResolvedValue(emptyResponse);
             const sdk = createTestSdk();
@@ -509,59 +571,74 @@ describe("listAuthentications plugin", () => {
             expect(result.data).toHaveLength(0);
             expect(Array.isArray(result.data)).toBe(true);
         });
-        it("should handle missing results field", async () => {
-            const responseWithoutResults = {
-                count: 0,
-                next: null,
-            };
-            mockApiClient.get = vi.fn().mockResolvedValue(responseWithoutResults);
+        it("should handle API errors gracefully", async () => {
+            const networkError = new Error("Network error");
+            mockApiClient.get = vi.fn().mockRejectedValue(networkError);
             const sdk = createTestSdk();
-            const result = await sdk.listAuthentications({});
-            expect(result.data).toHaveLength(0);
-            expect(Array.isArray(result.data)).toBe(true);
+            await expect(sdk.listAuthentications({})).rejects.toThrow("Network error");
         });
     });
     describe("app key integration", () => {
-        it("should handle app without current_implementation_id", async () => {
+        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 versionless_selected_api parameter
-            expect(mockApiClient.get).toHaveBeenCalledWith("/zapier/api/v4/authentications/", expect.objectContaining({
+            // Should not add appKey parameter when implementation can't be resolved
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
                 searchParams: expect.not.objectContaining({
-                    versionless_selected_api: expect.any(String),
+                    appKey: expect.any(String),
                 }),
             }));
         });
-        it("should extract versionless API from versioned implementation ID", async () => {
+        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("/zapier/api/v4/authentications/", expect.objectContaining({
+            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({
-                    versionless_selected_api: "SlackCLIAPI",
+                    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 original authentication fields", async () => {
+        it("should preserve all authentication fields from new API response", async () => {
             const authWithAllFields = {
-                results: [
+                data: [
                     {
-                        id: 123,
+                        id: "123",
                         date: "2021-01-01",
                         lastchanged: "2021-01-02",
-                        account_id: 456,
-                        customuser_id: 789,
-                        selected_api: "SlackCLIAPI@1.21.1",
+                        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_stale: "true",
+                        is_expired: "true",
                         is_shared: "false",
-                        marked_stale_at: "2021-06-01",
+                        expired_at: "2021-06-01",
                         label: "Auth Label",
                         title: "Auth Title",
                         identifier: "auth-identifier",
@@ -569,15 +646,17 @@ describe("listAuthentications plugin", () => {
                         groups: "group1,group2",
                         members: "user1,user2",
                         permissions: { read: true, write: false },
+                        app_key: "SlackCLIAPI",
+                        app_version: "1.21.1",
                     },
                 ],
-                count: 1,
+                nextCursor: undefined,
             };
             mockApiClient.get = vi.fn().mockResolvedValue(authWithAllFields);
             const sdk = createTestSdk();
             const result = await sdk.listAuthentications({});
             const auth = result.data[0];
-            // Verify original fields are preserved (IDs are converted to strings)
+            // 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");
@@ -596,9 +675,29 @@ describe("listAuthentications plugin", () => {
             expect(auth.groups).toBe("group1,group2");
             expect(auth.members).toBe("user1,user2");
             expect(auth.permissions).toEqual({ read: true, write: false });
-            // Verify mapped fields
             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", () => {
@@ -608,5 +707,126 @@ describe("listAuthentications plugin", () => {
             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);
+        });
     });
 });