@zapier/zapier-sdk 0.13.3 → 0.13.4

package/dist/plugins/eventEmission/index.js

@@ -0,0 +1,216 @@
+/**
+ * Event Emission Plugin for Zapier SDK
+ *
+ * Provides silent telemetry event emission capability to the SDK.
+ * All events are emitted asynchronously and failures are silently handled.
+ */
+import { createTransport } from "./transport";
+import { generateEventId, getCurrentTimestamp, getReleaseId } from "./utils";
+import { buildApplicationLifecycleEvent, buildErrorEventWithContext, } from "./builders";
+import { TRACKING_API_ENDPOINT } from "../../constants";
+const APPLICATION_LIFECYCLE_EVENT_SUBJECT = "platform.sdk.ApplicationLifecycleEvent";
+const ERROR_OCCURRED_EVENT_SUBJECT = "platform.sdk.ErrorOccurredEvent";
+// Silent emission wrapper - ensures events never disrupt SDK operation
+async function silentEmit(transport, subject, event) {
+    try {
+        // Fire and forget - don't await the transport
+        transport.emit(subject, event).catch(() => {
+            // Silently ignore transport failures
+        });
+    }
+    catch {
+        // Silently ignore all errors
+    }
+}
+// Helper to get transport config from environment or defaults
+function getTransportConfig() {
+    const envTransport = process?.env?.ZAPIER_SDK_TELEMETRY_TRANSPORT;
+    if (envTransport === "noop" || envTransport === "disabled") {
+        return { type: "noop" };
+    }
+    if (envTransport === "console") {
+        return { type: "console" };
+    }
+    // Default to HTTP transport
+    const endpoint = process?.env?.ZAPIER_SDK_TELEMETRY_ENDPOINT || TRACKING_API_ENDPOINT;
+    return {
+        type: "http",
+        endpoint,
+    };
+}
+export const eventEmissionPlugin = ({ context }) => {
+    const defaultTransport = getTransportConfig();
+    // Merge config: env var takes precedence over options, options take precedence over defaults
+    const config = {
+        enabled: context.options.eventEmission?.enabled ?? true,
+        transport: 
+        // If env var is set, use it (defaultTransport will be from env)
+        process?.env?.ZAPIER_SDK_TELEMETRY_TRANSPORT
+            ? defaultTransport
+            : // Otherwise, use option transport or default
+                (context.options.eventEmission?.transport ?? defaultTransport),
+    };
+    const startupTime = Date.now();
+    let shutdownStartTime = null;
+    // If disabled, return noop implementations
+    if (!config.enabled) {
+        return {
+            context: {
+                eventEmission: {
+                    transport: createTransport({ type: "noop" }),
+                    config,
+                    emit: () => { },
+                    createBaseEvent: () => ({
+                        event_id: generateEventId(),
+                        timestamp_ms: getCurrentTimestamp(),
+                        release_id: getReleaseId(),
+                        customuser_id: null,
+                        account_id: null,
+                        identity_id: null,
+                        visitor_id: null,
+                        correlation_id: null,
+                    }),
+                },
+            },
+        };
+    }
+    let transport;
+    try {
+        transport = createTransport(config.transport || { type: "noop" });
+    }
+    catch {
+        // If transport creation fails, fallback to noop to maintain silent operation
+        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,
+    });
+    // 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);
+        // Register process event handlers (Node.js only)
+        if (typeof process?.on === "function") {
+            // Handle normal process exit
+            process.on("exit", (code) => {
+                const uptime = Date.now() - startupTime;
+                const shutdownDuration = shutdownStartTime
+                    ? Date.now() - shutdownStartTime
+                    : null;
+                const exitEvent = buildApplicationLifecycleEvent({
+                    lifecycle_event_type: "exit",
+                    exit_code: code,
+                    uptime_ms: uptime,
+                    is_graceful_shutdown: code === 0,
+                    shutdown_duration_ms: shutdownDuration,
+                });
+                silentEmit(transport, APPLICATION_LIFECYCLE_EVENT_SUBJECT, exitEvent);
+            });
+            // Handle uncaught exceptions
+            process.on("uncaughtException", async (error) => {
+                const errorEvent = buildErrorEventWithContext({
+                    error_message: error.message || "Unknown error",
+                    error_type: "UncaughtException",
+                    error_stack_trace: error.stack || null,
+                    error_severity: "critical",
+                    is_user_facing: false,
+                    is_recoverable: false,
+                    execution_start_time: startupTime,
+                });
+                // 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)),
+                    ]);
+                }
+                catch {
+                    // Silently ignore telemetry failures
+                }
+                // Let Node.js exit naturally after all handlers complete
+            });
+            // Handle unhandled promise rejections
+            process.on("unhandledRejection", async (reason, promise) => {
+                const errorMessage = reason instanceof Error
+                    ? reason.message
+                    : typeof reason === "string"
+                        ? reason
+                        : "Unhandled promise rejection";
+                const errorStack = reason instanceof Error ? reason.stack : null;
+                const errorEvent = buildErrorEventWithContext({
+                    error_message: errorMessage,
+                    error_type: "UnhandledRejection",
+                    error_stack_trace: errorStack,
+                    error_severity: "critical",
+                    is_user_facing: false,
+                    is_recoverable: false,
+                    execution_start_time: startupTime,
+                    error_metadata: {
+                        promise: String(promise),
+                    },
+                });
+                // 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)),
+                    ]);
+                }
+                catch {
+                    // Silently ignore telemetry failures
+                }
+            });
+            // Handle termination signals
+            const handleSignal = async (signal) => {
+                shutdownStartTime = Date.now();
+                const uptime = Date.now() - startupTime;
+                const signalEvent = buildApplicationLifecycleEvent({
+                    lifecycle_event_type: "signal_termination",
+                    signal_name: signal,
+                    uptime_ms: uptime,
+                    is_graceful_shutdown: true,
+                });
+                // 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)),
+                    ]);
+                }
+                catch {
+                    // Silently ignore telemetry failures
+                }
+                // Let other signal handlers run and decide when to exit
+            };
+            // Register signal handlers
+            ["SIGINT", "SIGTERM"].forEach((signal) => {
+                process.on(signal, () => handleSignal(signal));
+            });
+        }
+    }
+    return {
+        context: {
+            eventEmission: {
+                transport,
+                config,
+                emit: (subject, event) => {
+                    silentEmit(transport, subject, event);
+                },
+                createBaseEvent: createBaseEventHelper,
+            },
+        },
+    };
+};
+export { buildApplicationLifecycleEvent, buildErrorEventWithContext, buildErrorEvent, createBaseEvent, } from "./builders";
+export * from "./utils";

package/dist/plugins/eventEmission/index.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for Event Emission Plugin
+ */
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/plugins/eventEmission/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../../src/plugins/eventEmission/index.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

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

@@ -0,0 +1,143 @@
+/**
+ * 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),
+}));
+describe("eventEmissionPlugin", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    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, 0));
+        expect(mockTransport.emit).toHaveBeenCalledWith(testSubject, testEvent);
+    });
+    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 merge options with defaults", () => {
+        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",
+        });
+    });
+});

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

@@ -0,0 +1,37 @@
+/**
+ * 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 class HttpTransport implements EventTransport {
+    private config;
+    constructor(config: {
+        endpoint: string;
+        headers?: Record<string, string>;
+        retryAttempts?: number;
+        retryDelayMs?: number;
+    });
+    emit<T extends any>(subject: string, event: T): Promise<void>;
+    private emitWithRetry;
+    private delay;
+}
+export declare class ConsoleTransport implements EventTransport {
+    emit<T extends any>(subject: string, event: T): Promise<void>;
+}
+export declare class NoopTransport implements EventTransport {
+    emit<T extends any>(_subject: string, _event: T): Promise<void>;
+}
+export declare function createTransport(config: TransportConfig): EventTransport;
+//# sourceMappingURL=transport.d.ts.map

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

@@ -0,0 +1 @@
+{"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,qBAAa,aAAc,YAAW,cAAc;IAEhD,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE;QACd,QAAQ,EAAE,MAAM,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACjC,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB;IAGG,IAAI,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;YAYrD,aAAa;YAiCb,KAAK;CAGpB;AAGD,qBAAa,gBAAiB,YAAW,cAAc;IAC/C,IAAI,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;CAUpE;AAGD,qBAAa,aAAc,YAAW,cAAc;IAC5C,IAAI,CAAC,CAAC,SAAS,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;CAGtE;AAGD,wBAAgB,eAAe,CAAC,MAAM,EAAE,eAAe,GAAG,cAAc,CAyBvE"}

package/dist/plugins/eventEmission/transport.js

@@ -0,0 +1,96 @@
+/**
+ * Transport abstraction layer for event emission
+ *
+ * Provides configurable transport mechanisms for emitting telemetry events.
+ * All transports implement silent failure to prevent SDK disruption.
+ */
+// Constants for transport configuration
+const DEFAULT_RETRY_ATTEMPTS = 2;
+const DEFAULT_RETRY_DELAY_MS = 300;
+// HTTP Transport - sends events to remote endpoint
+export class HttpTransport {
+    constructor(config) {
+        this.config = config;
+    }
+    async emit(subject, event) {
+        try {
+            await this.emitWithRetry(subject, event, this.config.retryAttempts || DEFAULT_RETRY_ATTEMPTS);
+        }
+        catch {
+            // Silent failure - never throw
+        }
+    }
+    async emitWithRetry(subject, event, attemptsLeft) {
+        try {
+            const payload = {
+                subject,
+                properties: event,
+            };
+            const response = await fetch(this.config.endpoint, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    ...this.config.headers,
+                },
+                body: JSON.stringify(payload),
+            });
+            if (!response.ok && attemptsLeft > 1) {
+                await this.delay(this.config.retryDelayMs || DEFAULT_RETRY_DELAY_MS);
+                return this.emitWithRetry(subject, event, attemptsLeft - 1);
+            }
+        }
+        catch (error) {
+            if (attemptsLeft > 1) {
+                await this.delay(this.config.retryDelayMs || DEFAULT_RETRY_DELAY_MS);
+                return this.emitWithRetry(subject, event, attemptsLeft - 1);
+            }
+            throw error;
+        }
+    }
+    async delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+// Console Transport - logs events to console (for development)
+export class ConsoleTransport {
+    async emit(subject, event) {
+        try {
+            console.log("[SDK Telemetry]", JSON.stringify({ subject, properties: event }, null, 2));
+        }
+        catch {
+            // Silent failure - never throw
+        }
+    }
+}
+// No-op Transport - discards all events (for testing/disabled state)
+export class NoopTransport {
+    async emit(_subject, _event) {
+        // Intentionally do nothing
+    }
+}
+// Transport factory
+export function createTransport(config) {
+    try {
+        switch (config.type) {
+            case "http":
+                if (!config.endpoint) {
+                    throw new Error("HTTP transport requires endpoint");
+                }
+                return new HttpTransport({
+                    endpoint: config.endpoint,
+                    headers: config.headers,
+                    retryAttempts: config.retryAttempts,
+                    retryDelayMs: config.retryDelayMs,
+                });
+            case "console":
+                return new ConsoleTransport();
+            case "noop":
+            default:
+                return new NoopTransport();
+        }
+    }
+    catch {
+        // If transport creation fails, return noop to maintain silent operation
+        return new NoopTransport();
+    }
+}

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

@@ -0,0 +1,5 @@
+/**
+ * Tests for Event Transport Layer
+ */
+export {};
+//# sourceMappingURL=transport.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transport.test.d.ts","sourceRoot":"","sources":["../../../src/plugins/eventEmission/transport.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

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

@@ -0,0 +1,153 @@
+/**
+ * Tests for Event Transport Layer
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { HttpTransport, ConsoleTransport, NoopTransport, createTransport, } from "./transport";
+// Mock fetch globally
+const mockFetch = vi.fn();
+global.fetch = mockFetch;
+// Mock console.log
+const mockConsoleLog = vi.spyOn(console, "log").mockImplementation(() => { });
+describe("Transport Layer", () => {
+    const sampleEvent = {
+        event_id: "test-123",
+        timestamp_ms: Date.now(),
+        release_id: "test-release",
+        error_message: "Test error",
+        is_user_facing: false,
+    };
+    const sampleSubject = "platform.sdk.ErrorOccurredEvent";
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe("HttpTransport", () => {
+        it("should emit events via HTTP successfully", async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+            });
+            const transport = new HttpTransport({
+                endpoint: "https://telemetry.example.com/events",
+                headers: { "x-api-key": "test-key" },
+            });
+            await transport.emit(sampleSubject, sampleEvent);
+            expect(mockFetch).toHaveBeenCalledWith("https://telemetry.example.com/events", {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-api-key": "test-key",
+                },
+                body: JSON.stringify({
+                    subject: sampleSubject,
+                    properties: sampleEvent,
+                }),
+            });
+        });
+        it("should retry on HTTP failures", async () => {
+            // Fail twice, then succeed
+            mockFetch
+                .mockResolvedValueOnce({ ok: false, status: 500 })
+                .mockResolvedValueOnce({ ok: false, status: 500 })
+                .mockResolvedValueOnce({ ok: true, status: 200 });
+            const transport = new HttpTransport({
+                endpoint: "https://telemetry.example.com/events",
+                retryAttempts: 3,
+                retryDelayMs: 10, // Short delay for testing
+            });
+            await transport.emit(sampleSubject, sampleEvent);
+            expect(mockFetch).toHaveBeenCalledTimes(3);
+        });
+        it("should handle network errors silently", async () => {
+            mockFetch.mockRejectedValue(new Error("Network error"));
+            const transport = new HttpTransport({
+                endpoint: "https://telemetry.example.com/events",
+                retryAttempts: 1,
+                retryDelayMs: 1,
+            });
+            // Should not throw despite network error
+            await expect(transport.emit(sampleSubject, sampleEvent)).resolves.toBeUndefined();
+        });
+        it("should stop retrying after max attempts", async () => {
+            mockFetch.mockResolvedValue({ ok: false, status: 500 });
+            const transport = new HttpTransport({
+                endpoint: "https://telemetry.example.com/events",
+                retryAttempts: 2,
+                retryDelayMs: 1,
+            });
+            await transport.emit(sampleSubject, sampleEvent);
+            expect(mockFetch).toHaveBeenCalledTimes(2);
+        });
+    });
+    describe("ConsoleTransport", () => {
+        it("should log events to console", async () => {
+            const transport = new ConsoleTransport();
+            await transport.emit(sampleSubject, sampleEvent);
+            expect(mockConsoleLog).toHaveBeenCalledWith("[SDK Telemetry]", JSON.stringify({ subject: sampleSubject, properties: sampleEvent }, null, 2));
+        });
+        it("should handle console errors silently", async () => {
+            mockConsoleLog.mockImplementation(() => {
+                throw new Error("Console error");
+            });
+            const transport = new ConsoleTransport();
+            // Should not throw despite console error
+            await expect(transport.emit(sampleSubject, sampleEvent)).resolves.toBeUndefined();
+        });
+    });
+    describe("NoopTransport", () => {
+        it("should do nothing when emitting events", async () => {
+            const transport = new NoopTransport();
+            await transport.emit(sampleSubject, sampleEvent);
+            // Verify no side effects
+            expect(mockFetch).not.toHaveBeenCalled();
+            expect(mockConsoleLog).not.toHaveBeenCalled();
+        });
+    });
+    describe("createTransport", () => {
+        it("should create HTTP transport with valid config", () => {
+            const transport = createTransport({
+                type: "http",
+                endpoint: "https://example.com",
+                headers: { "x-key": "value" },
+                retryAttempts: 5,
+                retryDelayMs: 2000,
+            });
+            expect(transport).toBeInstanceOf(HttpTransport);
+        });
+        it("should create console transport", () => {
+            const transport = createTransport({
+                type: "console",
+            });
+            expect(transport).toBeInstanceOf(ConsoleTransport);
+        });
+        it("should create noop transport by default", () => {
+            const transport = createTransport({
+                type: "noop",
+            });
+            expect(transport).toBeInstanceOf(NoopTransport);
+        });
+        it("should fallback to noop transport on invalid HTTP config", () => {
+            const transport = createTransport({
+                type: "http",
+                // Missing endpoint
+            });
+            expect(transport).toBeInstanceOf(NoopTransport);
+        });
+        it("should fallback to noop transport on unknown type", () => {
+            const transport = createTransport({
+                type: "unknown",
+            });
+            expect(transport).toBeInstanceOf(NoopTransport);
+        });
+        it("should handle transport creation errors gracefully", () => {
+            // Since createTransport already handles errors internally,
+            // this test verifies that invalid configs don't throw
+            expect(() => {
+                const transport = createTransport({
+                    type: "http",
+                    // Missing required endpoint - should fallback to noop
+                });
+                expect(transport).toBeInstanceOf(NoopTransport);
+            }).not.toThrow();
+        });
+    });
+});