@zapier/zapier-sdk 0.26.0 → 0.27.0

package/dist/plugins/{listAuthentications → listConnections}/index.test.js

@@ -1,6 +1,6 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import { ZapierValidationError, ZapierAuthenticationError, } from "../../types/errors";
-import { listAuthenticationsPlugin } from "./index";
+import { listConnectionsPlugin } from "./index";
 import { createSdk } from "../../sdk";
 import { eventEmissionPlugin } from "../eventEmission";
 // Mock transport for testing - prevents real HTTP telemetry requests
@@ -16,7 +16,7 @@ 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 = {
+const mockConnectionsResponse = {
     data: [
         {
             id: "123",
@@ -47,13 +47,13 @@ const mockAuthenticationsResponse = {
     ],
     nextCursor: undefined,
 };
-describe("listAuthentications plugin", () => {
+describe("listConnections plugin", () => {
     let mockApiClient;
     let mockGetVersionedImplementationId;
     beforeEach(() => {
         vi.clearAllMocks();
         mockApiClient = {
-            get: vi.fn().mockResolvedValue(mockAuthenticationsResponse),
+            get: vi.fn().mockResolvedValue(mockConnectionsResponse),
         };
         mockGetVersionedImplementationId = vi
             .fn()
@@ -105,17 +105,17 @@ describe("listAuthentications plugin", () => {
             .addPlugin(apiPlugin)
             .addPlugin(eventEmissionPlugin)
             .addPlugin(manifestPlugin)
-            .addPlugin(listAuthenticationsPlugin);
+            .addPlugin(listConnectionsPlugin);
     }
     describe("schema validation", () => {
         it("should pass validation with empty options", async () => {
             const sdk = createTestSdk();
-            const result = await sdk.listAuthentications({});
+            const result = await sdk.listConnections({});
             expect(result.data).toHaveLength(2);
         });
         it("should handle undefined options", async () => {
             const sdk = createTestSdk();
-            const result = await sdk.listAuthentications();
+            const result = await sdk.listConnections();
             expect(result.data).toHaveLength(2);
             expect(result.data[0]).toMatchObject({
                 id: "123",
@@ -124,7 +124,7 @@ describe("listAuthentications plugin", () => {
         it("should throw validation error for invalid appKey type", () => {
             const sdk = createTestSdk();
             expect(() => {
-                sdk.listAuthentications({
+                sdk.listConnections({
                     appKey: 123,
                 });
             }).toThrow(ZapierValidationError);
@@ -132,7 +132,7 @@ describe("listAuthentications plugin", () => {
         it("should throw validation error for invalid search type", () => {
             const sdk = createTestSdk();
             expect(() => {
-                sdk.listAuthentications({
+                sdk.listConnections({
                     search: 123,
                 });
             }).toThrow(ZapierValidationError);
@@ -140,7 +140,7 @@ describe("listAuthentications plugin", () => {
         it("should throw validation error for invalid title type", () => {
             const sdk = createTestSdk();
             expect(() => {
-                sdk.listAuthentications({
+                sdk.listConnections({
                     title: 123,
                 });
             }).toThrow(ZapierValidationError);
@@ -148,7 +148,7 @@ describe("listAuthentications plugin", () => {
         it("should throw validation error for invalid accountId type", () => {
             const sdk = createTestSdk();
             expect(() => {
-                sdk.listAuthentications({
+                sdk.listConnections({
                     accountId: 123,
                 });
             }).toThrow(ZapierValidationError);
@@ -156,7 +156,7 @@ describe("listAuthentications plugin", () => {
         it("should throw validation error for invalid owner type", () => {
             const sdk = createTestSdk();
             expect(() => {
-                sdk.listAuthentications({
+                sdk.listConnections({
                     owner: 123,
                 });
             }).toThrow(ZapierValidationError);
@@ -164,12 +164,12 @@ describe("listAuthentications plugin", () => {
         it("should throw validation error for invalid isExpired type", () => {
             const sdk = createTestSdk();
             expect(() => {
-                sdk.listAuthentications({
+                sdk.listConnections({
                     isExpired: "true", // Should be boolean, not string
                 });
             }).toThrow(ZapierValidationError);
             expect(() => {
-                sdk.listAuthentications({
+                sdk.listConnections({
                     isExpired: 1, // Should be boolean, not number
                 });
             }).toThrow(ZapierValidationError);
@@ -177,34 +177,34 @@ describe("listAuthentications plugin", () => {
         it("should pass validation with isExpired boolean values", async () => {
             const sdk = createTestSdk();
             // Test with true
-            const resultTrue = await sdk.listAuthentications({ isExpired: true });
+            const resultTrue = await sdk.listConnections({ isExpired: true });
             expect(resultTrue.data).toBeDefined();
             // Test with false
-            const resultFalse = await sdk.listAuthentications({ isExpired: false });
+            const resultFalse = await sdk.listConnections({ isExpired: false });
             expect(resultFalse.data).toBeDefined();
         });
-        it("should throw validation error for invalid authenticationIds type", () => {
+        it("should throw validation error for invalid connectionIds type", () => {
             const sdk = createTestSdk();
             expect(() => {
-                sdk.listAuthentications({
-                    authenticationIds: "123", // Should be array of strings
+                sdk.listConnections({
+                    connectionIds: "123", // Should be array of strings
                 });
             }).toThrow(ZapierValidationError);
             expect(() => {
-                sdk.listAuthentications({
-                    authenticationIds: [123], // Should be array of strings, not numbers
+                sdk.listConnections({
+                    connectionIds: [123], // Should be array of strings, not numbers
                 });
             }).toThrow(ZapierValidationError);
         });
         it("should throw validation error for invalid pageSize", () => {
             const sdk = createTestSdk();
             expect(() => {
-                sdk.listAuthentications({
+                sdk.listConnections({
                     pageSize: 0, // Should be >= 1
                 });
             }).toThrow(ZapierValidationError);
             expect(() => {
-                sdk.listAuthentications({
+                sdk.listConnections({
                     pageSize: -5, // Should be >= 1
                 });
             }).toThrow(ZapierValidationError);
@@ -212,21 +212,21 @@ describe("listAuthentications plugin", () => {
         it("should throw validation error for invalid maxItems", () => {
             const sdk = createTestSdk();
             expect(() => {
-                sdk.listAuthentications({
+                sdk.listConnections({
                     maxItems: 0, // Should be >= 1
                 });
             }).toThrow(ZapierValidationError);
             expect(() => {
-                sdk.listAuthentications({
+                sdk.listConnections({
                     maxItems: -10, // Should be >= 1
                 });
             }).toThrow(ZapierValidationError);
         });
         it("should pass validation with all valid fields", async () => {
             const sdk = createTestSdk();
-            const result = await sdk.listAuthentications({
+            const result = await sdk.listConnections({
                 appKey: "slack",
-                authenticationIds: ["123", "456"],
+                connectionIds: ["123", "456"],
                 search: "workspace",
                 title: "My Slack Workspace",
                 accountId: "acc_123",
@@ -238,10 +238,35 @@ describe("listAuthentications plugin", () => {
             expect(result.data).toBeDefined();
         });
     });
+    describe("deprecated authenticationIds support", () => {
+        it("should accept deprecated authenticationIds parameter", async () => {
+            const sdk = createTestSdk();
+            await sdk.listConnections({
+                authenticationIds: ["123", "456"],
+            });
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/connections", expect.objectContaining({
+                searchParams: expect.objectContaining({
+                    connection_ids: "123,456",
+                }),
+            }));
+        });
+        it("should prefer connectionIds over authenticationIds when both provided", async () => {
+            const sdk = createTestSdk();
+            await sdk.listConnections({
+                connectionIds: ["new-1", "new-2"],
+                authenticationIds: ["old-1", "old-2"],
+            });
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/connections", expect.objectContaining({
+                searchParams: expect.objectContaining({
+                    connection_ids: "new-1,new-2",
+                }),
+            }));
+        });
+    });
     describe("data mapping", () => {
         it("should pass through is_expired and expired_at fields", async () => {
             const sdk = createTestSdk();
-            const result = await sdk.listAuthentications();
+            const result = await sdk.listConnections();
             // 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);
@@ -250,29 +275,29 @@ describe("listAuthentications plugin", () => {
         });
         it("should pass through label field when title is missing", async () => {
             const responseWithoutTitle = {
-                ...mockAuthenticationsResponse,
+                ...mockConnectionsResponse,
                 data: [
                     {
-                        ...mockAuthenticationsResponse.data[0],
+                        ...mockConnectionsResponse.data[0],
                         title: undefined,
-                        label: "Label Only Auth",
+                        label: "Label Only Connection",
                     },
                 ],
                 nextCursor: undefined,
             };
             mockApiClient.get = vi.fn().mockResolvedValue(responseWithoutTitle);
             const sdk = createTestSdk();
-            const result = await sdk.listAuthentications({});
+            const result = await sdk.listConnections({});
             // 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");
+            expect(result.data[0].label).toBe("Label Only Connection");
         });
-        it("should handle authentications with neither title nor label", async () => {
+        it("should handle connections with neither title nor label", async () => {
             const responseWithoutTitleOrLabel = {
-                ...mockAuthenticationsResponse,
+                ...mockConnectionsResponse,
                 data: [
                     {
-                        ...mockAuthenticationsResponse.data[0],
+                        ...mockConnectionsResponse.data[0],
                         title: undefined,
                         label: undefined,
                     },
@@ -283,15 +308,15 @@ describe("listAuthentications plugin", () => {
                 .fn()
                 .mockResolvedValue(responseWithoutTitleOrLabel);
             const sdk = createTestSdk();
-            const result = await sdk.listAuthentications({});
+            const result = await sdk.listConnections({});
             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({
+            await sdk.listConnections({ search: "workspace" });
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/connections", expect.objectContaining({
                 searchParams: expect.objectContaining({
                     search: "workspace",
                 }),
@@ -299,8 +324,8 @@ describe("listAuthentications plugin", () => {
         });
         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({
+            await sdk.listConnections({ title: "My Slack Workspace" });
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/connections", expect.objectContaining({
                 searchParams: expect.objectContaining({
                     title: "My Slack Workspace",
                 }),
@@ -308,11 +333,11 @@ describe("listAuthentications plugin", () => {
         });
         it("should pass both search and title when both provided", async () => {
             const sdk = createTestSdk();
-            await sdk.listAuthentications({
+            await sdk.listConnections({
                 search: "explicit search",
                 title: "My Title",
             });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/connections", expect.objectContaining({
                 searchParams: expect.objectContaining({
                     search: "explicit search",
                     title: "My Title",
@@ -321,17 +346,17 @@ describe("listAuthentications plugin", () => {
         });
         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({
+            await sdk.listConnections({ accountId: "acc_123" });
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/connections", expect.objectContaining({
                 searchParams: expect.objectContaining({
-                    accountId: "acc_123",
+                    account_id: "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({
+            await sdk.listConnections({ owner: "me" });
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/connections", expect.objectContaining({
                 searchParams: expect.objectContaining({
                     owner: "me",
                 }),
@@ -339,63 +364,63 @@ describe("listAuthentications plugin", () => {
         });
         it("should pass isExpired=true filter to API", async () => {
             const sdk = createTestSdk();
-            await sdk.listAuthentications({ isExpired: true });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
+            await sdk.listConnections({ isExpired: true });
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/connections", expect.objectContaining({
                 searchParams: expect.objectContaining({
-                    isExpired: "true",
+                    is_expired: "true",
                 }),
             }));
         });
         it("should pass isExpired=false filter to API", async () => {
             const sdk = createTestSdk();
-            await sdk.listAuthentications({ isExpired: false });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
+            await sdk.listConnections({ isExpired: false });
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/connections", expect.objectContaining({
                 searchParams: expect.objectContaining({
-                    isExpired: "false",
+                    is_expired: "false",
                 }),
             }));
         });
         it("should not include isExpired parameter when not provided", async () => {
             const sdk = createTestSdk();
-            await sdk.listAuthentications({});
+            await sdk.listConnections({});
             const callArgs = mockApiClient.get.mock.calls[0];
             const searchParams = callArgs[1].searchParams;
-            expect(searchParams).not.toHaveProperty("isExpired");
+            expect(searchParams).not.toHaveProperty("is_expired");
         });
-        it("should pass authenticationIds as comma-separated string to API", async () => {
+        it("should pass connectionIds as comma-separated string to API", async () => {
             const sdk = createTestSdk();
-            await sdk.listAuthentications({
-                authenticationIds: ["123", "456", "789"],
+            await sdk.listConnections({
+                connectionIds: ["123", "456", "789"],
             });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/connections", expect.objectContaining({
                 searchParams: expect.objectContaining({
-                    authenticationIds: "123,456,789",
+                    connection_ids: "123,456,789",
                 }),
             }));
         });
-        it("should not include authenticationIds parameter when array is empty", async () => {
+        it("should not include connectionIds parameter when array is empty", async () => {
             const sdk = createTestSdk();
-            await sdk.listAuthentications({
-                authenticationIds: [],
+            await sdk.listConnections({
+                connectionIds: [],
             });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/connections", expect.objectContaining({
                 searchParams: expect.not.objectContaining({
-                    authenticationIds: expect.anything(),
+                    connection_ids: expect.anything(),
                 }),
             }));
         });
         it("should not include undefined optional parameters in searchParams", async () => {
             const sdk = createTestSdk();
-            await sdk.listAuthentications({});
+            await sdk.listConnections({});
             const callArgs = mockApiClient.get.mock.calls[0];
             const searchParams = callArgs[1].searchParams;
-            // Should only have pageSize (default), not undefined params
+            // Should only have page_size (default), not undefined params
             expect(searchParams).not.toHaveProperty("search");
             expect(searchParams).not.toHaveProperty("title");
-            expect(searchParams).not.toHaveProperty("accountId");
+            expect(searchParams).not.toHaveProperty("account_id");
             expect(searchParams).not.toHaveProperty("owner");
-            expect(searchParams).not.toHaveProperty("authenticationIds");
-            expect(searchParams).not.toHaveProperty("appKey");
+            expect(searchParams).not.toHaveProperty("connection_ids");
+            expect(searchParams).not.toHaveProperty("app_key");
         });
     });
     describe("pagination", () => {
@@ -404,7 +429,7 @@ describe("listAuthentications plugin", () => {
             mockApiClient.get = vi
                 .fn()
                 .mockResolvedValueOnce({
-                data: mockAuthenticationsResponse.data,
+                data: mockConnectionsResponse.data,
                 nextCursor: "2",
             })
                 .mockResolvedValueOnce({
@@ -427,9 +452,7 @@ describe("listAuthentications plugin", () => {
             const sdk = createTestSdk();
             // Collect all items using the items() iterator
             const items = [];
-            for await (const item of sdk
-                .listAuthentications({ maxItems: 3 })
-                .items()) {
+            for await (const item of sdk.listConnections({ maxItems: 3 }).items()) {
                 items.push(item);
             }
             expect(items).toHaveLength(3); // Should stop at maxItems
@@ -437,11 +460,11 @@ describe("listAuthentications plugin", () => {
         });
         it("should return first page when awaited", async () => {
             mockApiClient.get = vi.fn().mockResolvedValue({
-                data: mockAuthenticationsResponse.data,
+                data: mockConnectionsResponse.data,
                 nextCursor: undefined,
             });
             const sdk = createTestSdk();
-            const result = await sdk.listAuthentications({});
+            const result = await sdk.listConnections({});
             // Await returns first page only
             expect(result.data).toHaveLength(2);
             expect(mockApiClient.get).toHaveBeenCalledTimes(1);
@@ -450,16 +473,16 @@ describe("listAuthentications plugin", () => {
             mockApiClient.get = vi
                 .fn()
                 .mockResolvedValueOnce({
-                data: mockAuthenticationsResponse.data.slice(0, 1),
+                data: mockConnectionsResponse.data.slice(0, 1),
                 nextCursor: "1",
             })
                 .mockResolvedValueOnce({
-                data: mockAuthenticationsResponse.data.slice(1, 2),
+                data: mockConnectionsResponse.data.slice(1, 2),
                 nextCursor: undefined,
             });
             const sdk = createTestSdk();
             const pages = [];
-            for await (const page of sdk.listAuthentications({ pageSize: 1 })) {
+            for await (const page of sdk.listConnections({ pageSize: 1 })) {
                 pages.push(page);
                 if (pages.length >= 2)
                     break;
@@ -473,9 +496,7 @@ describe("listAuthentications plugin", () => {
         it("should support async iteration over individual items", async () => {
             const sdk = createTestSdk();
             const items = [];
-            for await (const item of sdk
-                .listAuthentications({ maxItems: 2 })
-                .items()) {
+            for await (const item of sdk.listConnections({ maxItems: 2 }).items()) {
                 items.push(item);
             }
             expect(items).toHaveLength(2);
@@ -484,10 +505,10 @@ describe("listAuthentications plugin", () => {
         });
         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({
+            await sdk.listConnections({ pageSize: 15 });
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/connections", expect.objectContaining({
                 searchParams: expect.objectContaining({
-                    pageSize: "15",
+                    page_size: "15",
                 }),
             }));
         });
@@ -495,22 +516,22 @@ describe("listAuthentications plugin", () => {
             mockApiClient.get = vi
                 .fn()
                 .mockResolvedValueOnce({
-                data: mockAuthenticationsResponse.data.slice(0, 1),
+                data: mockConnectionsResponse.data.slice(0, 1),
                 nextCursor: "cursor-abc-123",
             })
                 .mockResolvedValueOnce({
-                data: mockAuthenticationsResponse.data.slice(1, 2),
+                data: mockConnectionsResponse.data.slice(1, 2),
                 nextCursor: undefined,
             });
             const sdk = createTestSdk();
             const pages = [];
-            for await (const page of sdk.listAuthentications({ pageSize: 1 })) {
+            for await (const page of sdk.listConnections({ 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({
+            expect(mockApiClient.get).toHaveBeenNthCalledWith(2, "/api/v0/connections", expect.objectContaining({
                 searchParams: expect.objectContaining({
                     offset: "cursor-abc-123",
                 }),
@@ -518,12 +539,12 @@ describe("listAuthentications plugin", () => {
         });
         it("should stop pagination when nextCursor is undefined", async () => {
             mockApiClient.get = vi.fn().mockResolvedValue({
-                data: mockAuthenticationsResponse.data,
+                data: mockConnectionsResponse.data,
                 nextCursor: undefined,
             });
             const sdk = createTestSdk();
             const pages = [];
-            for await (const page of sdk.listAuthentications({})) {
+            for await (const page of sdk.listConnections({})) {
                 pages.push(page);
             }
             expect(pages).toHaveLength(1);
@@ -533,15 +554,15 @@ describe("listAuthentications plugin", () => {
     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));
+            await sdk.listConnections({});
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/connections", 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({
+            await sdk.listConnections({ pageSize: 25 });
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/connections", expect.objectContaining({
                 searchParams: expect.objectContaining({
-                    pageSize: "25",
+                    page_size: "25",
                 }),
             }));
         });
@@ -549,17 +570,17 @@ describe("listAuthentications plugin", () => {
             mockApiClient.get = vi
                 .fn()
                 .mockResolvedValueOnce({
-                data: mockAuthenticationsResponse.data.slice(0, 1),
+                data: mockConnectionsResponse.data.slice(0, 1),
                 nextCursor: "offset-1",
             })
                 .mockResolvedValueOnce({
-                data: mockAuthenticationsResponse.data.slice(1, 2),
+                data: mockConnectionsResponse.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 })) {
+            for await (const _page of sdk.listConnections({ pageSize: 1 })) {
                 pageCount++;
                 if (pageCount >= 2)
                     break;
@@ -567,7 +588,7 @@ describe("listAuthentications plugin", () => {
             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({
+            expect(mockApiClient.get).toHaveBeenNthCalledWith(2, "/api/v0/connections", expect.objectContaining({
                 searchParams: expect.objectContaining({
                     offset: "offset-1",
                 }),
@@ -575,15 +596,15 @@ describe("listAuthentications plugin", () => {
         });
         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({
+            await sdk.listConnections({});
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/connections", 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({
+            await sdk.listConnections({});
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/connections", expect.objectContaining({
                 customErrorHandler: expect.any(Function),
             }));
         });
@@ -597,8 +618,8 @@ describe("listAuthentications plugin", () => {
                     throw error;
             });
             const sdk = createTestSdk();
-            await expect(sdk.listAuthentications({})).rejects.toThrow(ZapierAuthenticationError);
-            await expect(sdk.listAuthentications({})).rejects.toThrow(/Authentication failed.*HTTP 401/);
+            await expect(sdk.listConnections({})).rejects.toThrow(ZapierAuthenticationError);
+            await expect(sdk.listConnections({})).rejects.toThrow(/Authentication failed.*HTTP 401/);
         });
         it("should throw ZapierAuthenticationError for 403 responses", async () => {
             mockApiClient.get = vi.fn().mockImplementation((_url, options) => {
@@ -608,8 +629,8 @@ describe("listAuthentications plugin", () => {
                     throw error;
             });
             const sdk = createTestSdk();
-            await expect(sdk.listAuthentications({})).rejects.toThrow(ZapierAuthenticationError);
-            await expect(sdk.listAuthentications({})).rejects.toThrow(/Access forbidden.*HTTP 403/);
+            await expect(sdk.listConnections({})).rejects.toThrow(ZapierAuthenticationError);
+            await expect(sdk.listConnections({})).rejects.toThrow(/Access forbidden.*HTTP 403/);
         });
         it("should return undefined from customErrorHandler for non-401/403 errors", async () => {
             let customErrorHandlerResult;
@@ -617,10 +638,10 @@ describe("listAuthentications plugin", () => {
                 // Capture the customErrorHandler result for 500
                 customErrorHandlerResult = options.customErrorHandler({ status: 500 });
                 // Return valid data since we're just testing the handler
-                return mockAuthenticationsResponse;
+                return mockConnectionsResponse;
             });
             const sdk = createTestSdk();
-            await sdk.listAuthentications({});
+            await sdk.listConnections({});
             // The customErrorHandler should return undefined for other status codes
             expect(customErrorHandlerResult).toBeUndefined();
         });
@@ -631,7 +652,7 @@ describe("listAuthentications plugin", () => {
             };
             mockApiClient.get = vi.fn().mockResolvedValue(emptyResponse);
             const sdk = createTestSdk();
-            const result = await sdk.listAuthentications({});
+            const result = await sdk.listConnections({});
             expect(result.data).toHaveLength(0);
             expect(Array.isArray(result.data)).toBe(true);
         });
@@ -639,55 +660,55 @@ describe("listAuthentications plugin", () => {
             const networkError = new Error("Network error");
             mockApiClient.get = vi.fn().mockRejectedValue(networkError);
             const sdk = createTestSdk();
-            await expect(sdk.listAuthentications({})).rejects.toThrow("Network error");
+            await expect(sdk.listConnections({})).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),
+            await sdk.listConnections({ appKey: "slack" });
+            // Should pass raw appKey when implementation can't be resolved via manifest
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/connections", expect.objectContaining({
+                searchParams: expect.objectContaining({
+                    app_key: "slack",
                 }),
             }));
         });
         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({
+            await sdk.listConnections({ appKey: "slack" });
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/connections", expect.objectContaining({
                 searchParams: expect.objectContaining({
-                    appKey: "SlackCLIAPI",
+                    app_key: "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({
+            await sdk.listConnections({ appKey: "slack" });
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/connections", expect.objectContaining({
                 searchParams: expect.objectContaining({
-                    appKey: "SlackCLIAPI",
+                    app_key: "SlackCLIAPI",
                 }),
             }));
         });
         it("should call getVersionedImplementationId with the provided appKey", async () => {
             const sdk = createTestSdk();
-            await sdk.listAuthentications({ appKey: "my-custom-app" });
+            await sdk.listConnections({ 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({});
+            await sdk.listConnections({});
             expect(mockGetVersionedImplementationId).not.toHaveBeenCalled();
         });
     });
     describe("response transformation", () => {
-        it("should preserve all authentication fields from new API response", async () => {
-            const authWithAllFields = {
+        it("should preserve all connection fields from new API response", async () => {
+            const connectionWithAllFields = {
                 data: [
                     {
                         id: "123",
@@ -703,9 +724,9 @@ describe("listAuthentications plugin", () => {
                         is_expired: "true",
                         is_shared: "false",
                         expired_at: "2021-06-01",
-                        label: "Auth Label",
-                        title: "Auth Title",
-                        identifier: "auth-identifier",
+                        label: "Connection Label",
+                        title: "Connection Title",
+                        identifier: "test-identifier",
                         url: "https://example.com",
                         groups: "group1,group2",
                         members: "user1,user2",
@@ -716,36 +737,36 @@ describe("listAuthentications plugin", () => {
                 ],
                 nextCursor: undefined,
             };
-            mockApiClient.get = vi.fn().mockResolvedValue(authWithAllFields);
+            mockApiClient.get = vi.fn().mockResolvedValue(connectionWithAllFields);
             const sdk = createTestSdk();
-            const result = await sdk.listAuthentications({});
-            const auth = result.data[0];
+            const result = await sdk.listConnections({});
+            const connection = 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 = {
+            expect(connection.id).toBe("123");
+            expect(connection.date).toBe("2021-01-01");
+            expect(connection.lastchanged).toBe("2021-01-02");
+            expect(connection.account_id).toBe("456");
+            expect(connection.profile_id).toBe("789");
+            expect(connection.implementation_id).toBe("SlackCLIAPI@1.21.1");
+            expect(connection.destination_selected_api).toBe("SlackDestAPI@1.0.0");
+            expect(connection.is_invite_only).toBe(true);
+            expect(connection.is_private).toBe(true);
+            expect(connection.shared_with_all).toBe(false);
+            expect(connection.is_shared).toBe("false");
+            expect(connection.label).toBe("Connection Label");
+            expect(connection.title).toBe("Connection Title");
+            expect(connection.identifier).toBe("test-identifier");
+            expect(connection.url).toBe("https://example.com");
+            expect(connection.groups).toBe("group1,group2");
+            expect(connection.members).toBe("user1,user2");
+            expect(connection.permissions).toEqual({ read: true, write: false });
+            expect(connection.is_expired).toBe("true");
+            expect(connection.expired_at).toBe("2021-06-01");
+            expect(connection.app_key).toBe("SlackCLIAPI");
+            expect(connection.app_version).toBe("1.21.1");
+        });
+        it("should handle connections with minimal fields", async () => {
+            const minimalConnection = {
                 data: [
                     {
                         id: "100",
@@ -755,29 +776,29 @@ describe("listAuthentications plugin", () => {
                 ],
                 nextCursor: undefined,
             };
-            mockApiClient.get = vi.fn().mockResolvedValue(minimalAuth);
+            mockApiClient.get = vi.fn().mockResolvedValue(minimalConnection);
             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");
+            const result = await sdk.listConnections({});
+            const connection = result.data[0];
+            expect(connection.id).toBe("100");
+            expect(connection.account_id).toBe("200");
+            expect(connection.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();
+            expect(context.meta.listConnections).toBeDefined();
+            expect(context.meta.listConnections.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");
+            const meta = context.meta.listConnections;
+            expect(meta.categories).toContain("connection");
             expect(meta.type).toBe("list");
-            expect(meta.itemType).toBe("Authentication");
+            expect(meta.itemType).toBe("Connection");
             expect(meta.inputSchema).toBeDefined();
             expect(meta.outputSchema).toBeDefined();
             expect(meta.resolvers).toBeDefined();
@@ -787,8 +808,8 @@ describe("listAuthentications plugin", () => {
     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({
+            await sdk.listConnections({ search: "test@email.com" });
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/connections", expect.objectContaining({
                 searchParams: expect.objectContaining({
                     search: "test@email.com",
                 }),
@@ -796,54 +817,54 @@ describe("listAuthentications plugin", () => {
         });
         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({
+            await sdk.listConnections({ title: "My Connection (Test) #1" });
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/connections", expect.objectContaining({
                 searchParams: expect.objectContaining({
-                    title: "My Auth (Test) #1",
+                    title: "My Connection (Test) #1",
                 }),
             }));
         });
-        it("should handle single authenticationId in array", async () => {
+        it("should handle single connectionId in array", async () => {
             const sdk = createTestSdk();
-            await sdk.listAuthentications({ authenticationIds: ["single-id"] });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
+            await sdk.listConnections({ connectionIds: ["single-id"] });
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/connections", expect.objectContaining({
                 searchParams: expect.objectContaining({
-                    authenticationIds: "single-id",
+                    connection_ids: "single-id",
                 }),
             }));
         });
         it("should handle multiple filters combined", async () => {
             const sdk = createTestSdk();
-            await sdk.listAuthentications({
+            await sdk.listConnections({
                 appKey: "slack",
                 search: "workspace",
                 title: "My Workspace",
                 accountId: "acc_123",
                 owner: "me",
-                authenticationIds: ["id1", "id2"],
+                connectionIds: ["id1", "id2"],
                 pageSize: 10,
             });
-            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/authentications", expect.objectContaining({
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/connections", expect.objectContaining({
                 searchParams: expect.objectContaining({
-                    appKey: "SlackCLIAPI",
+                    app_key: "SlackCLIAPI",
                     search: "workspace",
                     title: "My Workspace",
-                    accountId: "acc_123",
+                    account_id: "acc_123",
                     owner: "me",
-                    authenticationIds: "id1,id2",
-                    pageSize: "10",
+                    connection_ids: "id1,id2",
+                    page_size: "10",
                 }),
             }));
         });
         it("should handle maxItems less than pageSize", async () => {
             mockApiClient.get = vi.fn().mockResolvedValue({
-                data: mockAuthenticationsResponse.data,
+                data: mockConnectionsResponse.data,
                 nextCursor: "next-page",
             });
             const sdk = createTestSdk();
             const items = [];
             for await (const item of sdk
-                .listAuthentications({ pageSize: 10, maxItems: 1 })
+                .listConnections({ pageSize: 10, maxItems: 1 })
                 .items()) {
                 items.push(item);
             }
@@ -853,8 +874,8 @@ describe("listAuthentications plugin", () => {
         });
         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({
+            await sdk.listConnections({ owner: "user_12345" });
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v0/connections", expect.objectContaining({
                 searchParams: expect.objectContaining({
                     owner: "user_12345",
                 }),
@@ -862,30 +883,30 @@ describe("listAuthentications plugin", () => {
         });
         it("should pass through nextCursor in response", async () => {
             mockApiClient.get = vi.fn().mockResolvedValue({
-                data: mockAuthenticationsResponse.data,
+                data: mockConnectionsResponse.data,
                 nextCursor: "cursor-for-next-page",
             });
             const sdk = createTestSdk();
-            const result = await sdk.listAuthentications({});
+            const result = await sdk.listConnections({});
             expect(result.nextCursor).toBe("cursor-for-next-page");
         });
         it("should handle undefined nextCursor in response", async () => {
             mockApiClient.get = vi.fn().mockResolvedValue({
-                data: mockAuthenticationsResponse.data,
+                data: mockConnectionsResponse.data,
                 nextCursor: undefined,
             });
             const sdk = createTestSdk();
-            const result = await sdk.listAuthentications({});
+            const result = await sdk.listConnections({});
             expect(result.nextCursor).toBeUndefined();
         });
     });
     describe("concurrent requests", () => {
-        it("should handle multiple concurrent listAuthentications calls", async () => {
+        it("should handle multiple concurrent listConnections calls", async () => {
             const sdk = createTestSdk();
             const [result1, result2, result3] = await Promise.all([
-                sdk.listAuthentications({ search: "first" }),
-                sdk.listAuthentications({ search: "second" }),
-                sdk.listAuthentications({ search: "third" }),
+                sdk.listConnections({ search: "first" }),
+                sdk.listConnections({ search: "second" }),
+                sdk.listConnections({ search: "third" }),
             ]);
             expect(result1.data).toHaveLength(2);
             expect(result2.data).toHaveLength(2);