@zapier/zapier-sdk 0.15.3 → 0.15.4

package/dist/plugins/eventEmission/index.js

@@ -6,14 +6,17 @@
  */
 import { createTransport } from "./transport";
 import { generateEventId, getCurrentTimestamp, getReleaseId } from "./utils";
+import { extractUserIdsFromJwt } from "../../api/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 +24,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 +91,24 @@ 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 {
+            // Dynamically import the CLI login package if available
+            const { getToken } = await import("@zapier/zapier-sdk-cli-login");
+            // Pass baseUrl for potential token refresh operations
+            const token = await getToken({
+                baseUrl: context.options.baseUrl,
+            });
+            if (token) {
+                return extractUserIdsFromJwt(token);
+            }
+        }
+        catch {
+            // CLI login package not available or getToken failed, fall back to null context
+        }
+        return { customuser_id: null, account_id: null };
+    })();
     const startupTime = Date.now();
     let shutdownStartTime = null;
     // If disabled, return noop implementations
@@ -86,7 +119,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 +142,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 +185,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 +198,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 +226,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 +238,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 +261,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 +299,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,168 @@ 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);
     });
 });

package/dist/schemas/Action.d.ts

@@ -8,7 +8,7 @@ export declare const ActionItemSchema: z.ZodObject<Omit<{
     is_important: z.ZodOptional<z.ZodBoolean>;
     is_hidden: z.ZodOptional<z.ZodBoolean>;
     selected_api: z.ZodOptional<z.ZodString>;
-}, "type" | "name" | "selected_api"> & {
+}, "type" | "selected_api" | "name"> & {
     app_key: z.ZodString;
     app_version: z.ZodOptional<z.ZodString>;
     action_type: z.ZodEnum<["filter", "read", "read_bulk", "run", "search", "search_and_write", "search_or_write", "write"]>;

package/dist/schemas/Auth.d.ts

@@ -20,7 +20,7 @@ export declare const AuthenticationItemSchema: z.ZodObject<Omit<{
     groups: z.ZodOptional<z.ZodString>;
     members: z.ZodOptional<z.ZodString>;
     permissions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
-}, "selected_api" | "customuser_id"> & {
+}, "customuser_id" | "selected_api"> & {
     implementation_id: z.ZodOptional<z.ZodString>;
     is_expired: z.ZodOptional<z.ZodString>;
     expired_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -28,9 +28,9 @@ export declare const AuthenticationItemSchema: z.ZodObject<Omit<{
     app_version: z.ZodOptional<z.ZodString>;
     user_id: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
+    account_id: number;
     id: number;
     date: string;
-    account_id: number;
     is_invite_only: boolean;
     is_private: boolean;
     shared_with_all: boolean;
@@ -53,9 +53,9 @@ export declare const AuthenticationItemSchema: z.ZodObject<Omit<{
     app_key?: string | undefined;
     app_version?: string | undefined;
 }, {
+    account_id: number;
     id: number;
     date: string;
-    account_id: number;
     is_invite_only: boolean;
     is_private: boolean;
     shared_with_all: boolean;
@@ -99,7 +99,7 @@ export declare const AuthItemSchema: z.ZodObject<Omit<{
     groups: z.ZodOptional<z.ZodString>;
     members: z.ZodOptional<z.ZodString>;
     permissions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
-}, "selected_api" | "customuser_id"> & {
+}, "customuser_id" | "selected_api"> & {
     implementation_id: z.ZodOptional<z.ZodString>;
     is_expired: z.ZodOptional<z.ZodString>;
     expired_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -107,9 +107,9 @@ export declare const AuthItemSchema: z.ZodObject<Omit<{
     app_version: z.ZodOptional<z.ZodString>;
     user_id: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
+    account_id: number;
     id: number;
     date: string;
-    account_id: number;
     is_invite_only: boolean;
     is_private: boolean;
     shared_with_all: boolean;
@@ -132,9 +132,9 @@ export declare const AuthItemSchema: z.ZodObject<Omit<{
     app_key?: string | undefined;
     app_version?: string | undefined;
 }, {
+    account_id: number;
     id: number;
     date: string;
-    account_id: number;
     is_invite_only: boolean;
     is_private: boolean;
     shared_with_all: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zapier/zapier-sdk",
-  "version": "0.15.3",
+  "version": "0.15.4",
   "description": "Complete Zapier SDK - combines all Zapier SDK packages",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",