@zapier/zapier-sdk 0.18.3 → 0.19.0

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

@@ -1,581 +0,0 @@
-/**
- * Tests for Event Emission Plugin
- */
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { eventEmissionPlugin } from "./index";
-import { createTransport } from "./transport";
-// Mock transport for testing
-const mockTransport = {
-    emit: vi.fn().mockResolvedValue(undefined),
-    close: vi.fn().mockResolvedValue(undefined),
-};
-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({
-            sdk: {},
-            context: {
-                meta: {},
-                options: {},
-            },
-        });
-        expect(plugin.context.eventEmission).toBeDefined();
-        expect(plugin.context.eventEmission.emit).toBeDefined();
-        expect(plugin.context.eventEmission.transport).toBeDefined();
-        expect(plugin.context.eventEmission.config).toBeDefined();
-    });
-    it("should create noop implementations when disabled", () => {
-        const config = { enabled: false };
-        const plugin = eventEmissionPlugin({
-            sdk: {},
-            context: {
-                meta: {},
-                options: { eventEmission: config },
-            },
-        });
-        // Should not emit any events when disabled
-        plugin.context.eventEmission.emit("platform.sdk.TestEvent", {
-            test_event: "data",
-        });
-        expect(mockTransport.emit).not.toHaveBeenCalled();
-    });
-    it("should emit events using generic emit method", async () => {
-        const plugin = eventEmissionPlugin({
-            sdk: {},
-            context: {
-                meta: {},
-                options: {
-                    eventEmission: {
-                        enabled: true,
-                        transport: { type: "console" },
-                    },
-                },
-            },
-        });
-        const testEvent = {
-            test_data: "example",
-            value: 123,
-        };
-        const testSubject = "test.event.TestEvent";
-        plugin.context.eventEmission.emit(testSubject, testEvent);
-        // Give async emission time to complete
-        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
-        vi.mocked(createTransport).mockImplementationOnce(() => {
-            throw new Error("Transport creation failed");
-        });
-        expect(() => {
-            eventEmissionPlugin({
-                sdk: {},
-                context: {
-                    meta: {},
-                    options: {
-                        eventEmission: {
-                            enabled: true,
-                            transport: { type: "http", endpoint: "invalid-url" },
-                        },
-                    },
-                },
-            });
-        }).not.toThrow();
-    });
-    it("should handle event emission failures silently", async () => {
-        // Mock transport to throw error
-        const failingTransport = {
-            emit: vi.fn().mockRejectedValue(new Error("Network error")),
-            close: vi.fn().mockResolvedValue(undefined),
-        };
-        vi.mocked(createTransport).mockReturnValueOnce(failingTransport);
-        const plugin = eventEmissionPlugin({
-            sdk: {},
-            context: {
-                meta: {},
-                options: {
-                    eventEmission: {
-                        enabled: true,
-                        transport: {
-                            type: "http",
-                            endpoint: "https://example.com",
-                        },
-                    },
-                },
-            },
-        });
-        // Should not throw even if transport fails
-        expect(() => {
-            plugin.context.eventEmission.emit("test.event.TestEvent", {
-                test_event: "data",
-            });
-        }).not.toThrow();
-        // Give async emission time to complete
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(failingTransport.emit).toHaveBeenCalled();
-    });
-    it("should log tracking failure only on first occurrence", async () => {
-        // Mock console.warn to track logging calls
-        const mockConsoleWarn = vi
-            .spyOn(console, "warn")
-            .mockImplementation(() => { });
-        // Mock transport to throw error
-        const failingTransport = {
-            emit: vi.fn().mockRejectedValue(new Error("Network error")),
-            close: vi.fn().mockResolvedValue(undefined),
-        };
-        vi.mocked(createTransport).mockReturnValueOnce(failingTransport);
-        const plugin = eventEmissionPlugin({
-            sdk: {},
-            context: {
-                meta: {},
-                options: {
-                    eventEmission: {
-                        enabled: true,
-                        transport: {
-                            type: "http",
-                            endpoint: "https://example.com",
-                        },
-                    },
-                },
-            },
-        });
-        // First event should trigger logging
-        plugin.context.eventEmission.emit("test.event.FirstEvent", {
-            data: "first",
-        });
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        // Verify logging occurred
-        const initialLogCount = mockConsoleWarn.mock.calls.length;
-        expect(initialLogCount).toBeGreaterThan(0);
-        // Second and third events should not trigger additional logging
-        plugin.context.eventEmission.emit("test.event.SecondEvent", {
-            data: "second",
-        });
-        plugin.context.eventEmission.emit("test.event.ThirdEvent", {
-            data: "third",
-        });
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        // Verify no additional logging occurred
-        expect(mockConsoleWarn).toHaveBeenCalledTimes(initialLogCount);
-        mockConsoleWarn.mockRestore();
-    });
-    it("should not log failures after a successful emit", async () => {
-        // Mock console.warn to track logging calls
-        const mockConsoleWarn = vi
-            .spyOn(console, "warn")
-            .mockImplementation(() => { });
-        // Mock transport that succeeds first, then fails
-        let callCount = 0;
-        const mixedTransport = {
-            emit: vi.fn().mockImplementation(() => {
-                callCount++;
-                if (callCount === 1) {
-                    return Promise.resolve(); // First call succeeds
-                }
-                else {
-                    return Promise.reject(new Error("Network error")); // Subsequent calls fail
-                }
-            }),
-            close: vi.fn().mockResolvedValue(undefined),
-        };
-        vi.mocked(createTransport).mockReturnValueOnce(mixedTransport);
-        const plugin = eventEmissionPlugin({
-            sdk: {},
-            context: {
-                meta: {},
-                options: {
-                    eventEmission: {
-                        enabled: true,
-                        transport: {
-                            type: "http",
-                            endpoint: "https://example.com",
-                        },
-                    },
-                },
-            },
-        });
-        // First emit should succeed
-        plugin.context.eventEmission.emit("test.event.SuccessfulEvent", {
-            data: "success",
-        });
-        // Give time for success to be recorded
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        // Subsequent emits should fail but not log
-        plugin.context.eventEmission.emit("test.event.FailingEvent1", {
-            data: "fail1",
-        });
-        plugin.context.eventEmission.emit("test.event.FailingEvent2", {
-            data: "fail2",
-        });
-        // Give async emissions time to complete
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        // Should not have logged any warnings because tracking worked initially
-        expect(mockConsoleWarn).toHaveBeenCalledTimes(0);
-        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: {
-                meta: {},
-                options: {
-                    eventEmission: {
-                        transport: {
-                            type: "http",
-                            endpoint: "https://example.com",
-                        },
-                    },
-                },
-            },
-        });
-        expect(plugin.context.eventEmission.config.enabled).toBe(true);
-        expect(plugin.context.eventEmission.config.transport).toEqual({
-            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/eventEmission/transport.d.ts

@@ -1,27 +0,0 @@
-/**
- * Transport abstraction layer for event emission
- *
- * Provides configurable transport mechanisms for emitting telemetry events.
- * All transports implement silent failure to prevent SDK disruption.
- */
-export interface EventTransport {
-    emit<T extends any>(subject: string, event: T): Promise<void>;
-    close?(): Promise<void>;
-}
-export interface TransportConfig {
-    type: "http" | "console" | "noop";
-    endpoint?: string;
-    headers?: Record<string, string>;
-    retryAttempts?: number;
-    retryDelayMs?: number;
-}
-export declare function createHttpTransport(config: {
-    endpoint: string;
-    headers?: Record<string, string>;
-    retryAttempts?: number;
-    retryDelayMs?: number;
-}): EventTransport;
-export declare function createConsoleTransport(): EventTransport;
-export declare function createNoopTransport(): EventTransport;
-export declare function createTransport(config: TransportConfig): EventTransport;
-//# sourceMappingURL=transport.d.ts.map

package/dist/plugins/eventEmission/transport.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../../src/plugins/eventEmission/transport.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9D,KAAK,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB;AAGD,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAGD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAC1C,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,GAAG,cAAc,CAwDjB;AAGD,wBAAgB,sBAAsB,IAAI,cAAc,CAavD;AAGD,wBAAgB,mBAAmB,IAAI,cAAc,CAMpD;AAGD,wBAAgB,eAAe,CAAC,MAAM,EAAE,eAAe,GAAG,cAAc,CAyBvE"}