@volley/vwr-loader 1.6.0 → 1.7.0

package/src/__mocks__/@datadog/browser-logs.ts

@@ -1,35 +0,0 @@
-import { vi } from "vitest"
-
-const mockLogger = {
-    debug: vi.fn(),
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-    log: vi.fn(),
-    setLevel: vi.fn(),
-    setHandler: vi.fn(),
-    setContext: vi.fn(),
-    addContext: vi.fn(),
-    removeContext: vi.fn(),
-    clearContext: vi.fn(),
-    getContext: vi.fn(() => ({})),
-}
-
-export const datadogLogs = {
-    init: vi.fn(),
-    logger: mockLogger,
-    createLogger: vi.fn(() => mockLogger),
-    getLogger: vi.fn(() => mockLogger),
-    setUser: vi.fn(),
-    setUserProperty: vi.fn(),
-    removeUserProperty: vi.fn(),
-    clearUser: vi.fn(),
-    getUser: vi.fn(() => ({})),
-    setGlobalContext: vi.fn(),
-    setGlobalContextProperty: vi.fn(),
-    removeGlobalContextProperty: vi.fn(),
-    clearGlobalContext: vi.fn(),
-    getGlobalContext: vi.fn(() => ({})),
-    getInitConfiguration: vi.fn(() => ({})),
-    getInternalContext: vi.fn(() => ({})),
-}

package/src/__mocks__/@datadog/browser-rum.ts

@@ -1,27 +0,0 @@
-import { vi } from "vitest"
-
-export const datadogRum = {
-    init: vi.fn(),
-    startSessionReplayRecording: vi.fn(),
-    stopSessionReplayRecording: vi.fn(),
-    addAction: vi.fn(),
-    addError: vi.fn(),
-    addTiming: vi.fn(),
-    setUser: vi.fn(),
-    setUserProperty: vi.fn(),
-    removeUserProperty: vi.fn(),
-    clearUser: vi.fn(),
-    setGlobalContext: vi.fn(),
-    setGlobalContextProperty: vi.fn(),
-    removeGlobalContextProperty: vi.fn(),
-    clearGlobalContext: vi.fn(),
-    getGlobalContext: vi.fn(() => ({})),
-    getUser: vi.fn(() => ({})),
-    getInitConfiguration: vi.fn(() => ({})),
-    getInternalContext: vi.fn(() => ({})),
-    addFeatureFlagEvaluation: vi.fn(),
-    startView: vi.fn(),
-    stopView: vi.fn(),
-}
-
-export type RumGlobal = typeof datadogRum

package/src/__mocks__/vwrModule.ts

@@ -1,3 +0,0 @@
-import { vi } from "vitest"
-
-export const init = vi.fn()

package/src/amplitudeFlagFetcher.test.ts

@@ -1,175 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
-
-import { fetchAmplitudeFlags, FlagFetchError } from "./amplitudeFlagFetcher"
-
-describe("fetchAmplitudeFlags", () => {
-    const mockFetch = vi.fn()
-
-    beforeEach(() => {
-        global.fetch = mockFetch
-        vi.clearAllMocks()
-    })
-
-    afterEach(() => {
-        vi.restoreAllMocks()
-    })
-
-    it("fetches flags successfully from Amplitude with context", async () => {
-        mockFetch.mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({
-                "vwr-enabled": {
-                    payload: {
-                        "vwr-enabled": true,
-                    },
-                },
-            }),
-        })
-
-        const result = await fetchAmplitudeFlags(
-            "device-123",
-            "SAMSUNG_TV",
-            { apiKey: "test-key" },
-            "1.0.0"
-        )
-
-        expect(result).toEqual({
-            "vwr-enabled": true,
-        })
-
-        // Verify context is included in the request
-        const callArgs = mockFetch.mock.calls[0]
-        const url = new URL(callArgs[0])
-        const context = JSON.parse(url.searchParams.get("context") || "{}")
-
-        expect(context).toEqual({
-            user_properties: {
-                platformEnum: "SAMSUNG_TV",
-                nativeShellAppVersion: "1.0.0",
-            },
-        })
-
-        expect(mockFetch).toHaveBeenCalledWith(
-            expect.stringContaining("user_id=device-123"),
-            expect.objectContaining({
-                method: "GET",
-                headers: { Authorization: "Api-Key test-key" },
-            })
-        )
-    })
-
-    it("includes provided shell version in context", async () => {
-        mockFetch.mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({
-                "vwr-enabled": {
-                    payload: {
-                        "vwr-enabled": true,
-                    },
-                },
-            }),
-        })
-
-        await fetchAmplitudeFlags(
-            "device-123",
-            "SAMSUNG_TV",
-            {
-                apiKey: "test-key",
-            },
-            "2.5.0"
-        )
-
-        const callArgs = mockFetch.mock.calls[0]
-        const url = new URL(callArgs[0])
-        const context = JSON.parse(url.searchParams.get("context") || "{}")
-
-        expect(context).toEqual({
-            user_properties: {
-                platformEnum: "SAMSUNG_TV",
-                nativeShellAppVersion: "2.5.0",
-            },
-        })
-    })
-
-    it("throws FlagFetchError on timeout", async () => {
-        mockFetch.mockImplementationOnce(
-            () => new Promise((resolve) => setTimeout(resolve, 3000))
-        )
-
-        await expect(
-            fetchAmplitudeFlags(
-                "device-123",
-                "FIRE_TV",
-                { apiKey: "test-key", timeout: 100 },
-                "1.0.0"
-            )
-        ).rejects.toThrow(FlagFetchError)
-    })
-
-    it("throws FlagFetchError on API error", async () => {
-        mockFetch.mockResolvedValueOnce({
-            ok: false,
-            status: 500,
-        })
-
-        await expect(
-            fetchAmplitudeFlags(
-                "device-123",
-                "MOBILE",
-                { apiKey: "test-key" },
-                "1.0.0"
-            )
-        ).rejects.toThrow(FlagFetchError)
-    })
-
-    it("throws FlagFetchError on network error", async () => {
-        mockFetch.mockRejectedValueOnce(new Error("Network error"))
-
-        await expect(
-            fetchAmplitudeFlags(
-                "device-123",
-                "MOBILE",
-                { apiKey: "test-key" },
-                "1.0.0"
-            )
-        ).rejects.toThrow(FlagFetchError)
-    })
-
-    it("handles missing flag values in response", async () => {
-        mockFetch.mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({}),
-        })
-
-        const result = await fetchAmplitudeFlags(
-            "device-123",
-            "LG_TV",
-            { apiKey: "test-key" },
-            "1.0.0"
-        )
-
-        expect(result).toEqual({
-            "vwr-enabled": false,
-        })
-    })
-
-    it("handles partial response with missing payload", async () => {
-        mockFetch.mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({
-                "vwr-enabled": {},
-            }),
-        })
-
-        const result = await fetchAmplitudeFlags(
-            "device-123",
-            "LG_TV",
-            { apiKey: "test-key" },
-            "1.0.0"
-        )
-
-        expect(result).toEqual({
-            "vwr-enabled": false,
-        })
-    })
-})

package/src/amplitudeFlagFetcher.ts

@@ -1,105 +0,0 @@
-export interface AmplitudeConfig {
-    apiKey: string
-    apiUrl?: string
-    timeout?: number
-}
-
-export interface FlagResult {
-    "vwr-enabled": boolean
-}
-
-export class FlagFetchError extends Error {
-    public readonly name = "FlagFetchError"
-
-    constructor(
-        message: string,
-        public readonly cause?: Error
-    ) {
-        super(message)
-        Object.setPrototypeOf(this, FlagFetchError.prototype)
-    }
-}
-
-/**
- * Fetch feature flags from Amplitude Experiment REST API.
- *
- * Uses GET method with query parameters and Authorization header.
- * Includes platform and shell version in context for better flag targeting.
- * Compatible with Chrome 66+ (Fetch API, async/await, AbortController).
- *
- * @param deviceId - Unique device identifier
- * @param platform - Platform name (samsung, lg, firetv, ios, android)
- * @param config - Amplitude configuration
- * @param shellVersion - Shell version for flag targeting
- * @param logger - Optional logger, defaults to console
- * @returns Flag values on success
- * @throws FlagFetchError on timeout or network error
- */
-export async function fetchAmplitudeFlags(
-    deviceId: string,
-    platform: string,
-    config: AmplitudeConfig,
-    shellVersion: string
-): Promise<FlagResult> {
-    const {
-        apiKey,
-        apiUrl = "https://api.lab.amplitude.com/v1/vardata",
-        timeout = 2000,
-    } = config
-
-    // Build context with user_properties
-    const context = {
-        user_properties: {
-            platformEnum: platform,
-            nativeShellAppVersion: shellVersion,
-        },
-    }
-
-    // Build query parameters
-    const params = new URLSearchParams({
-        user_id: deviceId,
-        flag_keys: "vwr-enabled",
-        context: JSON.stringify(context),
-    })
-
-    // Start timeout immediately before the fetch call for accurate timing
-    const controller = new AbortController()
-    const timeoutId = setTimeout(() => controller.abort(), timeout)
-
-    try {
-        const response = await fetch(`${apiUrl}?${params}`, {
-            method: "GET",
-            headers: {
-                Authorization: `Api-Key ${apiKey}`,
-            },
-            signal: controller.signal,
-        })
-
-        clearTimeout(timeoutId)
-
-        if (!response.ok) {
-            throw new Error(`Amplitude API returned ${response.status}`)
-        }
-
-        const data = await response.json()
-
-        return {
-            "vwr-enabled":
-                data["vwr-enabled"]?.payload?.["vwr-enabled"] ?? false,
-        }
-    } catch (error) {
-        clearTimeout(timeoutId)
-
-        // Provide clear error message for abort vs other errors
-        if (error instanceof Error && error.name === "AbortError") {
-            throw new FlagFetchError(
-                `Amplitude flag fetch timed out after ${timeout}ms`
-            )
-        }
-
-        throw new FlagFetchError(
-            "Amplitude flag fetch failed",
-            error instanceof Error ? error : undefined
-        )
-    }
-}

package/src/errors/InitializationError.ts

@@ -1,105 +0,0 @@
-/**
- * Reason codes for VWR loader initialization failures.
- * Each code maps to a specific failure point in the init flow.
- */
-export const InitializationErrorReason = {
-    // Environment variable errors
-    ENV_VARS_MISSING: "ENV_VARS_MISSING",
-    ENV_UNKNOWN: "ENV_UNKNOWN",
-
-    // Device/platform errors
-    DEVICE_ID_FAILED: "DEVICE_ID_FAILED",
-    SHELL_VERSION_FAILED: "SHELL_VERSION_FAILED",
-
-    // Feature flag errors
-    FLAG_DISABLED: "FLAG_DISABLED",
-    FLAG_FETCH_FAILED: "FLAG_FETCH_FAILED",
-
-    // Runtime config errors
-    CONFIG_FETCH_FAILED: "CONFIG_FETCH_FAILED",
-    CONFIG_INVALID: "CONFIG_INVALID",
-
-    // Module loading errors
-    MODULE_FETCH_FAILED: "MODULE_FETCH_FAILED",
-    MODULE_INVALID: "MODULE_INVALID",
-
-    // VWR init errors
-    INIT_FAILED: "INIT_FAILED",
-} as const
-
-export type InitializationErrorReason =
-    (typeof InitializationErrorReason)[keyof typeof InitializationErrorReason]
-
-/**
- * Context for initialization errors - used for structured logging
- * and Datadog dashboard creation.
- */
-export interface InitializationErrorContext {
-    cause?: Error
-    [key: string]: unknown
-}
-
-/**
- * Custom error for VWR loader initialization failures.
- *
- * Provides structured information for:
- * - Error categorization (reason code)
- * - RUM phase tracking
- * - Datadog dashboard filtering
- * - Original error chain preservation
- *
- * @example
- * ```typescript
- * throw new InitializationError(
- *     InitializationErrorReason.DEVICE_ID_FAILED,
- *     `Failed to retrieve device ID for platform: ${platform}`,
- *     {
- *         phase: "vwr-loader:device_id",
- *         platform,
- *     }
- * );
- * ```
- */
-export class InitializationError extends Error {
-    public readonly name = "InitializationError"
-
-    constructor(
-        /** Structured reason code for categorization */
-        public readonly reason: InitializationErrorReason,
-        /** Human-readable error message */
-        public readonly message: string,
-        /** Context for logging and RUM tracking */
-        public readonly context: InitializationErrorContext = {}
-    ) {
-        super(message)
-
-        // Ensure proper prototype chain for instanceof checks
-        Object.setPrototypeOf(this, InitializationError.prototype)
-    }
-
-    /**
-     * Convert to a plain object for structured logging.
-     * Useful for Datadog Logs and JSON serialization.
-     */
-    toJSON(): Record<string, unknown> {
-        return {
-            name: this.name,
-            reason: this.reason,
-            message: this.message,
-            ...this.context,
-            cause: this.context.cause?.message,
-            stack: this.stack,
-        }
-    }
-
-    /**
-     * Get error context.
-     * Returns the context object.
-     */
-    getContext(): Record<string, unknown> {
-        return {
-            ...this.context,
-            reason: this.reason,
-        }
-    }
-}

package/src/errors/ensureError.ts

@@ -1,6 +0,0 @@
-export function ensureError(error: unknown): Error {
-    if (error instanceof Error) {
-        return error
-    }
-    return new Error(String(error ?? "Unknown error"))
-}

package/src/errors/index.ts

@@ -1,16 +0,0 @@
-export { ensureError } from "./ensureError"
-export type { InitializationErrorContext } from "./InitializationError"
-export {
-    InitializationError,
-    InitializationErrorReason,
-} from "./InitializationError"
-
-/**
- * Type guard for VWR initialization errors.
- * Checks error.name instead of instanceof to avoid runtime dependency on @volley/vwr.
- */
-export function isVWRInitializationError(
-    error: unknown
-): error is Error & { name: "VWRInitializationError"; reason: string } {
-    return error instanceof Error && error.name === "VWRInitializationError"
-}