@zapier/zapier-sdk 0.15.3 → 0.15.8

package/dist/plugins/eventEmission/index.js

@@ -6,14 +6,18 @@
  */
 import { createTransport } from "./transport";
 import { generateEventId, getCurrentTimestamp, getReleaseId } from "./utils";
+import { extractUserIdsFromJwt } from "../../api/auth";
+import { resolveAuthToken } from "../../auth";
 import { buildApplicationLifecycleEvent, buildErrorEventWithContext, } from "./builders";
 import { getTrackingBaseUrl } from "../../utils/url-utils";
+// Maximum time to wait for telemetry emission before allowing process to exit
+const TELEMETRY_EMIT_TIMEOUT_MS = 300;
 const APPLICATION_LIFECYCLE_EVENT_SUBJECT = "platform.sdk.ApplicationLifecycleEvent";
 const ERROR_OCCURRED_EVENT_SUBJECT = "platform.sdk.ErrorOccurredEvent";
 // Track transport success/failure so we only log failure once.
 const transportStates = new WeakMap();
 // Silent emission wrapper with smart first-failure logging
-async function silentEmit(transport, subject, event) {
+async function silentEmit(transport, subject, event, userContextPromise) {
     try {
         // Get or initialize state for this transport
         let state = transportStates.get(transport);
@@ -21,9 +25,21 @@ async function silentEmit(transport, subject, event) {
             state = { hasWorked: false, hasLoggedFailure: false };
             transportStates.set(transport, state);
         }
+        // Resolve user context and merge into event
+        let enrichedEvent = event;
+        if (userContextPromise) {
+            try {
+                const userContext = await userContextPromise;
+                // Use Object.assign to safely merge user context into event
+                enrichedEvent = Object.assign({}, event, userContext);
+            }
+            catch {
+                // If user context promise fails, continue with original event
+            }
+        }
         // Fire and forget - don't await the transport
         transport
-            .emit(subject, event)
+            .emit(subject, enrichedEvent)
             .then(() => {
             // Mark as working if any emit succeeds
             state.hasWorked = true;
@@ -76,6 +92,27 @@ export const eventEmissionPlugin = ({ context }) => {
             : // Otherwise, use option transport or default
                 (context.options.eventEmission?.transport ?? defaultTransport),
     };
+    // Create getUserContext promise for dynamic user context injection
+    const getUserContext = (async () => {
+        try {
+            const token = await resolveAuthToken({
+                token: context.options.token,
+                getToken: context.options.getToken,
+                baseUrl: context.options.baseUrl,
+                authBaseUrl: context.options.authBaseUrl,
+                authClientId: context.options.authClientId,
+                onEvent: context.options.onEvent,
+                fetch: context.options.fetch,
+            });
+            if (token) {
+                return extractUserIdsFromJwt(token);
+            }
+        }
+        catch {
+            // Fall back to null context on any error
+        }
+        return { customuser_id: null, account_id: null };
+    })();
     const startupTime = Date.now();
     let shutdownStartTime = null;
     // If disabled, return noop implementations
@@ -86,7 +123,7 @@ export const eventEmissionPlugin = ({ context }) => {
                     transport: createTransport({ type: "noop" }),
                     config,
                     emit: () => { },
-                    createBaseEvent: () => ({
+                    createBaseEvent: async () => ({
                         event_id: generateEventId(),
                         timestamp_ms: getCurrentTimestamp(),
                         release_id: getReleaseId(),
@@ -109,23 +146,34 @@ export const eventEmissionPlugin = ({ context }) => {
         transport = createTransport({ type: "noop" });
     }
     // Helper to create base event
-    const createBaseEventHelper = () => ({
-        event_id: generateEventId(),
-        timestamp_ms: getCurrentTimestamp(),
-        release_id: getReleaseId(),
-        customuser_id: null,
-        account_id: null,
-        identity_id: null,
-        visitor_id: null,
-        correlation_id: null,
-    });
+    const createBaseEventHelper = async () => {
+        const baseEvent = {
+            event_id: generateEventId(),
+            timestamp_ms: getCurrentTimestamp(),
+            release_id: getReleaseId(),
+            customuser_id: null,
+            account_id: null,
+            identity_id: null,
+            visitor_id: null,
+            correlation_id: null,
+        };
+        // Enrich with user context if available
+        try {
+            const userContext = await getUserContext;
+            return { ...baseEvent, ...userContext };
+        }
+        catch {
+            // Return base event if user context fails
+            return baseEvent;
+        }
+    };
     // Register lifecycle event handlers if enabled
     if (config.enabled) {
         // Emit startup event
         const startupEvent = buildApplicationLifecycleEvent({
             lifecycle_event_type: "startup",
         });
-        silentEmit(transport, APPLICATION_LIFECYCLE_EVENT_SUBJECT, startupEvent);
+        silentEmit(transport, APPLICATION_LIFECYCLE_EVENT_SUBJECT, startupEvent, getUserContext);
         // Register process event handlers (Node.js only)
         if (typeof process?.on === "function") {
             // Handle normal process exit
@@ -141,11 +189,11 @@ export const eventEmissionPlugin = ({ context }) => {
                     is_graceful_shutdown: code === 0,
                     shutdown_duration_ms: shutdownDuration,
                 });
-                silentEmit(transport, APPLICATION_LIFECYCLE_EVENT_SUBJECT, exitEvent);
+                silentEmit(transport, APPLICATION_LIFECYCLE_EVENT_SUBJECT, exitEvent, getUserContext);
             });
             // Handle uncaught exceptions
             process.on("uncaughtException", async (error) => {
-                const errorEvent = buildErrorEventWithContext({
+                let errorEvent = buildErrorEventWithContext({
                     error_message: error.message || "Unknown error",
                     error_type: "UncaughtException",
                     error_stack_trace: error.stack || null,
@@ -154,11 +202,19 @@ export const eventEmissionPlugin = ({ context }) => {
                     is_recoverable: false,
                     execution_start_time: startupTime,
                 });
+                // Enrich with user context if available
+                try {
+                    const userContext = await getUserContext;
+                    errorEvent = { ...errorEvent, ...userContext };
+                }
+                catch {
+                    // Continue with original event if user context fails
+                }
                 // Wait up to 300ms for telemetry to send before allowing process to exit
                 try {
                     await Promise.race([
                         transport.emit(ERROR_OCCURRED_EVENT_SUBJECT, errorEvent),
-                        new Promise((resolve) => setTimeout(resolve, 300)),
+                        new Promise((resolve) => setTimeout(resolve, TELEMETRY_EMIT_TIMEOUT_MS)),
                     ]);
                 }
                 catch {
@@ -174,7 +230,7 @@ export const eventEmissionPlugin = ({ context }) => {
                         ? reason
                         : "Unhandled promise rejection";
                 const errorStack = reason instanceof Error ? reason.stack : null;
-                const errorEvent = buildErrorEventWithContext({
+                let errorEvent = buildErrorEventWithContext({
                     error_message: errorMessage,
                     error_type: "UnhandledRejection",
                     error_stack_trace: errorStack,
@@ -186,11 +242,19 @@ export const eventEmissionPlugin = ({ context }) => {
                         promise: String(promise),
                     },
                 });
+                // Enrich with user context if available
+                try {
+                    const userContext = await getUserContext;
+                    errorEvent = { ...errorEvent, ...userContext };
+                }
+                catch {
+                    // Continue with original event if user context fails
+                }
                 // Wait up to 300ms for telemetry to send
                 try {
                     await Promise.race([
                         transport.emit(ERROR_OCCURRED_EVENT_SUBJECT, errorEvent),
-                        new Promise((resolve) => setTimeout(resolve, 300)),
+                        new Promise((resolve) => setTimeout(resolve, TELEMETRY_EMIT_TIMEOUT_MS)),
                     ]);
                 }
                 catch {
@@ -201,17 +265,25 @@ export const eventEmissionPlugin = ({ context }) => {
             const handleSignal = async (signal) => {
                 shutdownStartTime = Date.now();
                 const uptime = Date.now() - startupTime;
-                const signalEvent = buildApplicationLifecycleEvent({
+                let signalEvent = buildApplicationLifecycleEvent({
                     lifecycle_event_type: "signal_termination",
                     signal_name: signal,
                     uptime_ms: uptime,
                     is_graceful_shutdown: true,
                 });
+                // Enrich with user context if available
+                try {
+                    const userContext = await getUserContext;
+                    signalEvent = { ...signalEvent, ...userContext };
+                }
+                catch {
+                    // Continue with original event if user context fails
+                }
                 // Wait up to 300ms for telemetry to send
                 try {
                     await Promise.race([
                         transport.emit(APPLICATION_LIFECYCLE_EVENT_SUBJECT, signalEvent),
-                        new Promise((resolve) => setTimeout(resolve, 300)),
+                        new Promise((resolve) => setTimeout(resolve, TELEMETRY_EMIT_TIMEOUT_MS)),
                     ]);
                 }
                 catch {
@@ -231,7 +303,7 @@ export const eventEmissionPlugin = ({ context }) => {
                 transport,
                 config,
                 emit: (subject, event) => {
-                    silentEmit(transport, subject, event);
+                    silentEmit(transport, subject, event, getUserContext);
                 },
                 createBaseEvent: createBaseEventHelper,
             },

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

@@ -12,9 +12,16 @@ const mockTransport = {
 vi.mock("./transport", () => ({
     createTransport: vi.fn(() => mockTransport),
 }));
+// Mock CLI login package - default to returning null context
+const mockGetToken = vi.fn().mockResolvedValue(undefined);
+vi.mock("@zapier/zapier-sdk-cli-login", () => ({
+    getToken: mockGetToken,
+}));
 describe("eventEmissionPlugin", () => {
     beforeEach(() => {
         vi.clearAllMocks();
+        // Reset to default behavior - no token available
+        mockGetToken.mockResolvedValue(undefined);
     });
     it("should create plugin with default configuration", () => {
         const plugin = eventEmissionPlugin({
@@ -64,8 +71,13 @@ describe("eventEmissionPlugin", () => {
         const testSubject = "test.event.TestEvent";
         plugin.context.eventEmission.emit(testSubject, testEvent);
         // Give async emission time to complete
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(mockTransport.emit).toHaveBeenCalledWith(testSubject, testEvent);
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        // The event will be enriched with user context (null values)
+        expect(mockTransport.emit).toHaveBeenCalledWith(testSubject, {
+            ...testEvent,
+            customuser_id: null,
+            account_id: null,
+        });
     });
     it("should handle transport creation failures silently", () => {
         // Mock createTransport to throw an error
@@ -220,6 +232,8 @@ describe("eventEmissionPlugin", () => {
         mockConsoleWarn.mockRestore();
     });
     it("should merge options with defaults", () => {
+        // Override env var to ensure proper transport is used
+        vi.stubEnv("ZAPIER_SDK_TELEMETRY_TRANSPORT", undefined);
         const plugin = eventEmissionPlugin({
             sdk: {},
             context: {
@@ -239,5 +253,329 @@ describe("eventEmissionPlugin", () => {
             type: "http",
             endpoint: "https://example.com",
         });
+        vi.unstubAllEnvs();
+    });
+    it("should extract user IDs from JWT token and include in events", async () => {
+        // Create a test JWT token with user data
+        // JWT format: header.payload.signature
+        const header = { alg: "HS256", typ: "JWT" };
+        const payload = {
+            "zap:acc": "12345",
+            sub: "67890",
+            sub_type: "customuser",
+            "zap:uname": "test@example.com",
+        };
+        const encodedHeader = Buffer.from(JSON.stringify(header)).toString("base64url");
+        const encodedPayload = Buffer.from(JSON.stringify(payload)).toString("base64url");
+        const testJwt = `${encodedHeader}.${encodedPayload}.fake-signature`;
+        // Mock getToken to return the JWT
+        mockGetToken.mockResolvedValue(testJwt);
+        const plugin = eventEmissionPlugin({
+            sdk: {},
+            context: {
+                meta: {},
+                options: {
+                    eventEmission: {
+                        enabled: true,
+                        transport: { type: "console" },
+                    },
+                },
+            },
+        });
+        // Test that createBaseEvent includes the extracted user IDs
+        const baseEvent = await plugin.context.eventEmission.createBaseEvent();
+        expect(baseEvent.customuser_id).toBe(67890);
+        expect(baseEvent.account_id).toBe(12345);
+    });
+    it("should handle service tokens with nested JWT", async () => {
+        // Create a nested JWT for service token testing
+        const nestedHeader = { alg: "HS256", typ: "JWT" };
+        const nestedPayload = {
+            "zap:acc": "99999",
+            sub: "88888",
+            sub_type: "customuser",
+        };
+        const nestedEncodedHeader = Buffer.from(JSON.stringify(nestedHeader)).toString("base64url");
+        const nestedEncodedPayload = Buffer.from(JSON.stringify(nestedPayload)).toString("base64url");
+        const nestedJwt = `${nestedEncodedHeader}.${nestedEncodedPayload}.nested-signature`;
+        // Create the service token that wraps the nested JWT
+        const serviceHeader = { alg: "HS256", typ: "JWT" };
+        const servicePayload = {
+            "zap:acc": "11111",
+            sub: "22222",
+            sub_type: "service",
+            njwt: nestedJwt,
+        };
+        const serviceEncodedHeader = Buffer.from(JSON.stringify(serviceHeader)).toString("base64url");
+        const serviceEncodedPayload = Buffer.from(JSON.stringify(servicePayload)).toString("base64url");
+        const serviceJwt = `${serviceEncodedHeader}.${serviceEncodedPayload}.service-signature`;
+        // Mock getToken to return the service JWT
+        mockGetToken.mockResolvedValue(serviceJwt);
+        const plugin = eventEmissionPlugin({
+            sdk: {},
+            context: {
+                meta: {},
+                options: {
+                    eventEmission: {
+                        enabled: true,
+                        transport: { type: "console" },
+                    },
+                },
+            },
+        });
+        const baseEvent = await plugin.context.eventEmission.createBaseEvent();
+        // Should extract from nested JWT, not the service token
+        expect(baseEvent.customuser_id).toBe(88888);
+        expect(baseEvent.account_id).toBe(99999);
+    });
+    it("should handle invalid JWT tokens gracefully", async () => {
+        // Mock getToken to return an invalid JWT
+        mockGetToken.mockResolvedValue("not-a-valid-jwt-token");
+        const plugin = eventEmissionPlugin({
+            sdk: {},
+            context: {
+                meta: {},
+                options: {
+                    eventEmission: {
+                        enabled: true,
+                        transport: { type: "console" },
+                    },
+                },
+            },
+        });
+        const baseEvent = await plugin.context.eventEmission.createBaseEvent();
+        // Should default to null when JWT is invalid
+        expect(baseEvent.customuser_id).toBe(null);
+        expect(baseEvent.account_id).toBe(null);
+    });
+    it("should handle missing token gracefully", async () => {
+        // mockGetToken defaults to returning undefined (no token)
+        const plugin = eventEmissionPlugin({
+            sdk: {},
+            context: {
+                meta: {},
+                options: {
+                    eventEmission: {
+                        enabled: true,
+                        transport: { type: "console" },
+                    },
+                },
+            },
+        });
+        const baseEvent = await plugin.context.eventEmission.createBaseEvent();
+        // Should default to null when no token is provided
+        expect(baseEvent.customuser_id).toBe(null);
+        expect(baseEvent.account_id).toBe(null);
+    });
+    it("should extract user IDs when getToken returns valid JWT", async () => {
+        // Create a test JWT token
+        const header = { alg: "HS256", typ: "JWT" };
+        const payload = {
+            "zap:acc": "98765",
+            sub: "54321",
+            sub_type: "customuser",
+        };
+        const encodedHeader = Buffer.from(JSON.stringify(header)).toString("base64url");
+        const encodedPayload = Buffer.from(JSON.stringify(payload)).toString("base64url");
+        const testJwt = `${encodedHeader}.${encodedPayload}.test-signature`;
+        // Mock getToken to return the JWT
+        mockGetToken.mockResolvedValue(testJwt);
+        const plugin = eventEmissionPlugin({
+            sdk: {},
+            context: {
+                meta: {},
+                options: {
+                    eventEmission: {
+                        enabled: true,
+                        transport: { type: "console" },
+                    },
+                },
+            },
+        });
+        // Test that createBaseEvent includes the extracted user IDs
+        const baseEvent = await plugin.context.eventEmission.createBaseEvent();
+        expect(baseEvent.customuser_id).toBe(54321);
+        expect(baseEvent.account_id).toBe(98765);
+    });
+    it("should handle getToken failures gracefully", async () => {
+        // Mock getToken to reject/throw
+        mockGetToken.mockRejectedValue(new Error("Token fetch failed"));
+        const plugin = eventEmissionPlugin({
+            sdk: {},
+            context: {
+                meta: {},
+                options: {
+                    eventEmission: {
+                        enabled: true,
+                        transport: { type: "console" },
+                    },
+                },
+            },
+        });
+        const baseEvent = await plugin.context.eventEmission.createBaseEvent();
+        // Should gracefully fall back to null context
+        expect(baseEvent.customuser_id).toBe(null);
+        expect(baseEvent.account_id).toBe(null);
+    });
+    it("should extract user IDs from static token in SDK options", async () => {
+        // Create a test JWT token
+        const header = { alg: "HS256", typ: "JWT" };
+        const payload = {
+            "zap:acc": "11111",
+            sub: "22222",
+            sub_type: "customuser",
+        };
+        const encodedHeader = Buffer.from(JSON.stringify(header)).toString("base64url");
+        const encodedPayload = Buffer.from(JSON.stringify(payload)).toString("base64url");
+        const testJwt = `${encodedHeader}.${encodedPayload}.static-signature`;
+        const plugin = eventEmissionPlugin({
+            sdk: {},
+            context: {
+                meta: {},
+                options: {
+                    token: testJwt,
+                    eventEmission: {
+                        enabled: true,
+                        transport: { type: "console" },
+                    },
+                },
+            },
+        });
+        const baseEvent = await plugin.context.eventEmission.createBaseEvent();
+        // Should extract from static token in options
+        expect(baseEvent.customuser_id).toBe(22222);
+        expect(baseEvent.account_id).toBe(11111);
+        // CLI login package should not be called when token is in options
+        expect(mockGetToken).not.toHaveBeenCalled();
+    });
+    it("should extract user IDs from getToken function in SDK options", async () => {
+        // Create a test JWT token
+        const header = { alg: "HS256", typ: "JWT" };
+        const payload = {
+            "zap:acc": "33333",
+            sub: "44444",
+            sub_type: "customuser",
+        };
+        const encodedHeader = Buffer.from(JSON.stringify(header)).toString("base64url");
+        const encodedPayload = Buffer.from(JSON.stringify(payload)).toString("base64url");
+        const testJwt = `${encodedHeader}.${encodedPayload}.custom-signature`;
+        const customGetToken = vi.fn().mockResolvedValue(testJwt);
+        const plugin = eventEmissionPlugin({
+            sdk: {},
+            context: {
+                meta: {},
+                options: {
+                    getToken: customGetToken,
+                    eventEmission: {
+                        enabled: true,
+                        transport: { type: "console" },
+                    },
+                },
+            },
+        });
+        const baseEvent = await plugin.context.eventEmission.createBaseEvent();
+        // Should extract from custom getToken function
+        expect(baseEvent.customuser_id).toBe(44444);
+        expect(baseEvent.account_id).toBe(33333);
+        expect(customGetToken).toHaveBeenCalled();
+        // CLI login package should not be called when getToken is in options
+        expect(mockGetToken).not.toHaveBeenCalled();
+    });
+    it("should prioritize static token over getToken function", async () => {
+        // Create test JWT tokens
+        const staticHeader = { alg: "HS256", typ: "JWT" };
+        const staticPayload = {
+            "zap:acc": "55555",
+            sub: "66666",
+            sub_type: "customuser",
+        };
+        const staticEncodedHeader = Buffer.from(JSON.stringify(staticHeader)).toString("base64url");
+        const staticEncodedPayload = Buffer.from(JSON.stringify(staticPayload)).toString("base64url");
+        const staticJwt = `${staticEncodedHeader}.${staticEncodedPayload}.static-sig`;
+        const customGetToken = vi.fn().mockResolvedValue("should-not-be-used");
+        const plugin = eventEmissionPlugin({
+            sdk: {},
+            context: {
+                meta: {},
+                options: {
+                    token: staticJwt,
+                    getToken: customGetToken,
+                    eventEmission: {
+                        enabled: true,
+                        transport: { type: "console" },
+                    },
+                },
+            },
+        });
+        const baseEvent = await plugin.context.eventEmission.createBaseEvent();
+        // Should use static token, not getToken
+        expect(baseEvent.customuser_id).toBe(66666);
+        expect(baseEvent.account_id).toBe(55555);
+        expect(customGetToken).not.toHaveBeenCalled();
+        expect(mockGetToken).not.toHaveBeenCalled();
+    });
+    it("should fall back to CLI login when SDK options have no token", async () => {
+        // Create a test JWT token for CLI login
+        const header = { alg: "HS256", typ: "JWT" };
+        const payload = {
+            "zap:acc": "77777",
+            sub: "88888",
+            sub_type: "customuser",
+        };
+        const encodedHeader = Buffer.from(JSON.stringify(header)).toString("base64url");
+        const encodedPayload = Buffer.from(JSON.stringify(payload)).toString("base64url");
+        const testJwt = `${encodedHeader}.${encodedPayload}.cli-signature`;
+        mockGetToken.mockResolvedValue(testJwt);
+        const plugin = eventEmissionPlugin({
+            sdk: {},
+            context: {
+                meta: {},
+                options: {
+                    // No token or getToken in options
+                    eventEmission: {
+                        enabled: true,
+                        transport: { type: "console" },
+                    },
+                },
+            },
+        });
+        const baseEvent = await plugin.context.eventEmission.createBaseEvent();
+        // Should fall back to CLI login package
+        expect(baseEvent.customuser_id).toBe(88888);
+        expect(baseEvent.account_id).toBe(77777);
+        expect(mockGetToken).toHaveBeenCalled();
+    });
+    it("should handle custom getToken returning undefined", async () => {
+        const customGetToken = vi.fn().mockResolvedValue(undefined);
+        // Also mock CLI login to return a token
+        const header = { alg: "HS256", typ: "JWT" };
+        const payload = {
+            "zap:acc": "99999",
+            sub: "10101",
+            sub_type: "customuser",
+        };
+        const encodedHeader = Buffer.from(JSON.stringify(header)).toString("base64url");
+        const encodedPayload = Buffer.from(JSON.stringify(payload)).toString("base64url");
+        const testJwt = `${encodedHeader}.${encodedPayload}.fallback-signature`;
+        mockGetToken.mockResolvedValue(testJwt);
+        const plugin = eventEmissionPlugin({
+            sdk: {},
+            context: {
+                meta: {},
+                options: {
+                    getToken: customGetToken,
+                    eventEmission: {
+                        enabled: true,
+                        transport: { type: "console" },
+                    },
+                },
+            },
+        });
+        const baseEvent = await plugin.context.eventEmission.createBaseEvent();
+        // Should fall back to CLI login when custom getToken returns undefined
+        expect(baseEvent.customuser_id).toBe(10101);
+        expect(baseEvent.account_id).toBe(99999);
+        expect(customGetToken).toHaveBeenCalled();
+        expect(mockGetToken).toHaveBeenCalled();
     });
 });

package/dist/plugins/getAuthentication/index.d.ts

@@ -1,11 +1,8 @@
 import type { Plugin } from "../../types/plugin";
 import type { ApiClient } from "../../api";
-import type { AuthenticationItem } from "../../types/domain";
-import { GetAuthenticationSchema, type GetAuthenticationOptions } from "./schemas";
+import { GetAuthenticationSchema, type GetAuthenticationOptions, type GetAuthenticationResponse } from "./schemas";
 export interface GetAuthenticationPluginProvides {
-    getAuthentication: (options: GetAuthenticationOptions) => Promise<{
-        data: AuthenticationItem;
-    }>;
+    getAuthentication: (options: GetAuthenticationOptions) => Promise<GetAuthenticationResponse>;
     context: {
         meta: {
             getAuthentication: {

package/dist/plugins/getAuthentication/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/getAuthentication/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,EACL,uBAAuB,EACvB,KAAK,wBAAwB,EAC9B,MAAM,WAAW,CAAC;AAUnB,MAAM,WAAW,+BAA+B;IAC9C,iBAAiB,EAAE,CACjB,OAAO,EAAE,wBAAwB,KAC9B,OAAO,CAAC;QAAE,IAAI,EAAE,kBAAkB,CAAA;KAAE,CAAC,CAAC;IAC3C,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,iBAAiB,EAAE;gBACjB,WAAW,EAAE,OAAO,uBAAuB,CAAC;aAC7C,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAC1C,EAAE,EAAE,sBAAsB;AAC1B;IAAE,GAAG,EAAE,SAAS,CAAA;CAAE,EAAE,0BAA0B;AAC9C,+BAA+B,CA6DhC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/getAuthentication/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EACL,uBAAuB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EAC/B,MAAM,WAAW,CAAC;AAKnB,MAAM,WAAW,+BAA+B;IAC9C,iBAAiB,EAAE,CACjB,OAAO,EAAE,wBAAwB,KAC9B,OAAO,CAAC,yBAAyB,CAAC,CAAC;IACxC,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,iBAAiB,EAAE;gBACjB,WAAW,EAAE,OAAO,uBAAuB,CAAC;aAC7C,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAC1C,EAAE,EAAE,sBAAsB;AAC1B;IAAE,GAAG,EAAE,SAAS,CAAA;CAAE,EAAE,0BAA0B;AAC9C,+BAA+B,CA+BhC,CAAC"}

package/dist/plugins/getAuthentication/index.js

@@ -1,34 +1,13 @@
 import { GetAuthenticationSchema, } from "./schemas";
-import { ZapierAuthenticationError, ZapierResourceNotFoundError, } from "../../types/errors";
 import { createFunction } from "../../utils/function-utils";
-import { normalizeAuthenticationItem } from "../../utils/domain-utils";
 import { authenticationIdGenericResolver } from "../../resolvers";
 import { AuthenticationItemSchema } from "../../schemas/Auth";
 export const getAuthenticationPlugin = ({ context }) => {
     const getAuthentication = createFunction(async function getAuthentication(options) {
         const { api } = context;
-        const { authenticationId } = options;
-        const data = await api.get(`/zapier/api/v4/authentications/${authenticationId}/`, {
-            customErrorHandler: ({ status }) => {
-                if (status === 401) {
-                    return new ZapierAuthenticationError(`Authentication failed. Your token may not have permission to access authentications or may be expired. (HTTP ${status})`, { statusCode: status });
-                }
-                if (status === 403) {
-                    return new ZapierAuthenticationError(`Access forbidden. Your token may not have the required scopes to get authentication ${authenticationId}. (HTTP ${status})`, { statusCode: status });
-                }
-                if (status === 404) {
-                    return new ZapierResourceNotFoundError(`Authentication ${authenticationId} not found. It may not exist or you may not have access to it. (HTTP ${status})`, {
-                        resourceType: "Authentication",
-                        resourceId: String(authenticationId),
-                    });
-                }
-                return undefined;
-            },
-            authRequired: true,
-        });
-        return {
-            data: normalizeAuthenticationItem(data),
-        };
+        // Call the SDK API endpoint, which will be routed to the handler via handlerOverride in pathConfig.
+        // When the handler is migrated to SDK API, this same API call will go over the network.
+        return await api.get(`/api/v0/authentications/${options.authenticationId}`);
     }, GetAuthenticationSchema);
     return {
         getAuthentication,