@zapier/zapier-sdk 0.15.4 → 0.15.9

package/dist/temporary-internal-core/handlers/getAuthentication.test.js

@@ -0,0 +1,248 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { handleGetAuthentication, } from "./getAuthentication";
+import { ZapierAuthenticationError, ZapierResourceNotFoundError, } from "../schemas/errors";
+const mockAuthenticationResponse = {
+    id: 123,
+    date: "2021-01-01",
+    account_id: 456,
+    selected_api: "SlackCLIAPI@1.21.1",
+    is_invite_only: false,
+    is_private: false,
+    shared_with_all: false,
+    is_stale: "false",
+    marked_stale_at: null,
+    label: "My Slack Workspace",
+    title: "My Slack Workspace",
+};
+describe("handleGetAuthentication", () => {
+    let mockHttpClient;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockHttpClient = {
+            get: vi.fn().mockResolvedValue(mockAuthenticationResponse),
+            post: vi.fn(),
+            delete: vi.fn(),
+        };
+    });
+    describe("request validation", () => {
+        it("should reject request with missing authenticationId", async () => {
+            const invalidRequest = {};
+            const deps = {
+                httpClient: mockHttpClient,
+            };
+            await expect(handleGetAuthentication({ request: invalidRequest, deps })).rejects.toThrow();
+        });
+        it("should reject request with invalid authenticationId type", async () => {
+            const invalidRequest = {
+                authenticationId: { invalid: true },
+            };
+            const deps = {
+                httpClient: mockHttpClient,
+            };
+            await expect(handleGetAuthentication({ request: invalidRequest, deps })).rejects.toThrow();
+        });
+        it("should accept string authenticationId and convert to number", async () => {
+            // Note: The schema accepts string or number as input and transforms to number
+            const request = {
+                authenticationId: "123",
+            };
+            const deps = {
+                httpClient: mockHttpClient,
+            };
+            const result = await handleGetAuthentication({ request, deps });
+            expect(mockHttpClient.get).toHaveBeenCalledWith("/zapier/api/v4/authentications/123/", expect.any(Object));
+            expect(result.data).toBeDefined();
+        });
+        it("should accept number authenticationId", async () => {
+            const request = {
+                authenticationId: 123,
+            };
+            const deps = {
+                httpClient: mockHttpClient,
+            };
+            const result = await handleGetAuthentication({ request, deps });
+            expect(result.data).toBeDefined();
+        });
+    });
+    describe("API integration", () => {
+        it("should call the correct API endpoint", async () => {
+            const request = {
+                authenticationId: 123,
+            };
+            const deps = {
+                httpClient: mockHttpClient,
+            };
+            await handleGetAuthentication({ request, deps });
+            expect(mockHttpClient.get).toHaveBeenCalledWith("/zapier/api/v4/authentications/123/", expect.objectContaining({
+                authRequired: true,
+                customErrorHandler: expect.any(Function),
+            }));
+        });
+        it("should return normalized authentication data", async () => {
+            const request = {
+                authenticationId: 123,
+            };
+            const deps = {
+                httpClient: mockHttpClient,
+            };
+            const result = await handleGetAuthentication({ request, deps });
+            expect(result.data).toEqual({
+                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",
+                app_key: "SlackCLIAPI",
+                app_version: "1.21.1",
+                user_id: undefined, // customuser_id wasn't in mock data
+                is_stale: "false", // Original field preserved
+                marked_stale_at: null, // Original field preserved
+            });
+        });
+    });
+    describe("error handling", () => {
+        it("should throw ZapierAuthenticationError for 401 responses", async () => {
+            mockHttpClient.get = vi.fn().mockImplementation((_path, options) => {
+                const error = options?.customErrorHandler?.({
+                    status: 401,
+                    statusText: "Unauthorized",
+                    data: {},
+                });
+                throw error;
+            });
+            const request = {
+                authenticationId: 123,
+            };
+            const deps = {
+                httpClient: mockHttpClient,
+            };
+            await expect(handleGetAuthentication({ request, deps })).rejects.toThrow(ZapierAuthenticationError);
+        });
+        it("should throw ZapierAuthenticationError for 403 responses", async () => {
+            mockHttpClient.get = vi.fn().mockImplementation((_path, options) => {
+                const error = options?.customErrorHandler?.({
+                    status: 403,
+                    statusText: "Forbidden",
+                    data: {},
+                });
+                throw error;
+            });
+            const request = {
+                authenticationId: 123,
+            };
+            const deps = {
+                httpClient: mockHttpClient,
+            };
+            await expect(handleGetAuthentication({ request, deps })).rejects.toThrow(ZapierAuthenticationError);
+        });
+        it("should throw ZapierResourceNotFoundError for 404 responses", async () => {
+            mockHttpClient.get = vi.fn().mockImplementation((_path, options) => {
+                const error = options?.customErrorHandler?.({
+                    status: 404,
+                    statusText: "Not Found",
+                    data: {},
+                });
+                throw error;
+            });
+            const request = {
+                authenticationId: 123,
+            };
+            const deps = {
+                httpClient: mockHttpClient,
+            };
+            await expect(handleGetAuthentication({ request, deps })).rejects.toThrow(ZapierResourceNotFoundError);
+        });
+        it("should handle network errors", async () => {
+            mockHttpClient.get = vi
+                .fn()
+                .mockRejectedValue(new Error("Network error"));
+            const request = {
+                authenticationId: 123,
+            };
+            const deps = {
+                httpClient: mockHttpClient,
+            };
+            await expect(handleGetAuthentication({ request, deps })).rejects.toThrow("Network error");
+        });
+    });
+    describe("data transformation", () => {
+        it("should map is_stale to is_expired and marked_stale_at to expired_at", async () => {
+            const authWithExpiration = {
+                ...mockAuthenticationResponse,
+                is_stale: "true",
+                marked_stale_at: "2021-06-01",
+            };
+            mockHttpClient.get = vi.fn().mockResolvedValue(authWithExpiration);
+            const request = {
+                authenticationId: 123,
+            };
+            const deps = {
+                httpClient: mockHttpClient,
+            };
+            const result = await handleGetAuthentication({ request, deps });
+            expect(result.data.is_expired).toBe("true");
+            expect(result.data.expired_at).toBe("2021-06-01");
+        });
+        it("should preserve all original authentication fields", async () => {
+            const authWithAllFields = {
+                id: 123,
+                date: "2021-01-01",
+                lastchanged: "2021-01-02",
+                account_id: 456,
+                customuser_id: 789,
+                selected_api: "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_shared: "false",
+                marked_stale_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 },
+            };
+            mockHttpClient.get = vi.fn().mockResolvedValue(authWithAllFields);
+            const request = {
+                authenticationId: 123,
+            };
+            const deps = {
+                httpClient: mockHttpClient,
+            };
+            const result = await handleGetAuthentication({ request, deps });
+            const auth = result.data;
+            // Verify original fields are preserved
+            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.user_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 });
+            // Verify mapped fields
+            expect(auth.is_expired).toBe("true");
+            expect(auth.expired_at).toBe("2021-06-01");
+        });
+    });
+});

package/dist/temporary-internal-core/handlers/listApps.js

@@ -12,7 +12,7 @@
  * The handler receives pre-resolved implementation IDs and performs search augmentation.
  */
 import { ListAppsHandlerRequestSchema, } from "../schemas/apps";
-import { splitVersionedKey } from "../utils/app-locators";
+import { splitVersionedKey } from "../utils/string-utils";
 import { transformImplementationMetaToAppItem, extractPaginationCursor, } from "../utils/transformations";
 // ============================================================================
 // Constants

package/dist/temporary-internal-core/index.d.ts

@@ -14,5 +14,7 @@
 export type { HandlerDeps, Handler, ValidatedHandler } from "./types";
 export * from "./schemas/apps";
 export * from "./schemas/implementations";
+export * from "./schemas/authentications";
 export { handleListApps, type ListAppsHandlerDeps } from "./handlers/listApps";
+export { handleGetAuthentication, type GetAuthenticationHandlerDeps, } from "./handlers/getAuthentication";
 //# sourceMappingURL=index.d.ts.map

package/dist/temporary-internal-core/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/temporary-internal-core/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,YAAY,EAAE,WAAW,EAAE,OAAO,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAGtE,cAAc,gBAAgB,CAAC;AAC/B,cAAc,2BAA2B,CAAC;AAG1C,OAAO,EAAE,cAAc,EAAE,KAAK,mBAAmB,EAAE,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/temporary-internal-core/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,YAAY,EAAE,WAAW,EAAE,OAAO,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAGtE,cAAc,gBAAgB,CAAC;AAC/B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,2BAA2B,CAAC;AAG1C,OAAO,EAAE,cAAc,EAAE,KAAK,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC/E,OAAO,EACL,uBAAuB,EACvB,KAAK,4BAA4B,GAClC,MAAM,8BAA8B,CAAC"}

package/dist/temporary-internal-core/index.js

@@ -14,5 +14,7 @@
 // Schemas
 export * from "./schemas/apps";
 export * from "./schemas/implementations";
+export * from "./schemas/authentications";
 // Handlers
 export { handleListApps } from "./handlers/listApps";
+export { handleGetAuthentication, } from "./handlers/getAuthentication";