@volley/vwr-loader 1.0.5 → 1.0.6

package/src/getEnvironment.test.ts

@@ -0,0 +1,457 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
+
+import { type Environment, getEnvironment } from "./getEnvironment"
+
+describe("getEnvironment", () => {
+    const mockLogger = {
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+    }
+
+    beforeEach(() => {
+        vi.clearAllMocks()
+        mockLogger.info.mockClear()
+        mockLogger.warn.mockClear()
+        mockLogger.error.mockClear()
+        // Clean up window properties
+        delete (window as any).Capacitor
+    })
+
+    afterEach(() => {
+        vi.restoreAllMocks()
+        delete (window as any).Capacitor
+    })
+
+    describe("Fire TV - Native Environment Detection", () => {
+        it("should read environment from native BuildConfig for Fire TV", async () => {
+            // Setup Capacitor plugin mock
+            Object.defineProperty(window, "Capacitor", {
+                value: {
+                    Plugins: {
+                        DeviceInfo: {
+                            getNativeShellAppEnvironment: vi
+                                .fn()
+                                .mockResolvedValue({
+                                    environment: "development",
+                                }),
+                        },
+                    },
+                },
+                writable: true,
+                configurable: true,
+            })
+
+            const result = await getEnvironment(
+                "FIRE_TV",
+                undefined,
+                mockLogger
+            )
+
+            expect(result.environment).toBe("dev")
+            expect(result.source).toBe("native")
+            expect(mockLogger.info).toHaveBeenCalledWith(
+                expect.stringContaining(
+                    'Environment: "dev" (source: native BuildConfig.ENVIRONMENT="development")'
+                )
+            )
+        })
+
+        it("should map 'production' to 'prod'", async () => {
+            Object.defineProperty(window, "Capacitor", {
+                value: {
+                    Plugins: {
+                        DeviceInfo: {
+                            getNativeShellAppEnvironment: vi
+                                .fn()
+                                .mockResolvedValue({
+                                    environment: "production",
+                                }),
+                        },
+                    },
+                },
+                writable: true,
+                configurable: true,
+            })
+
+            const result = await getEnvironment(
+                "FIRE_TV",
+                undefined,
+                mockLogger
+            )
+
+            expect(result.environment).toBe("prod")
+            expect(result.source).toBe("native")
+        })
+
+        it("should map 'staging' to 'staging'", async () => {
+            Object.defineProperty(window, "Capacitor", {
+                value: {
+                    Plugins: {
+                        DeviceInfo: {
+                            getNativeShellAppEnvironment: vi
+                                .fn()
+                                .mockResolvedValue({
+                                    environment: "staging",
+                                }),
+                        },
+                    },
+                },
+                writable: true,
+                configurable: true,
+            })
+
+            const result = await getEnvironment(
+                "FIRE_TV",
+                undefined,
+                mockLogger
+            )
+
+            expect(result.environment).toBe("staging")
+            expect(result.source).toBe("native")
+        })
+
+        it("should handle native env already in vwr format (dev)", async () => {
+            Object.defineProperty(window, "Capacitor", {
+                value: {
+                    Plugins: {
+                        DeviceInfo: {
+                            getNativeShellAppEnvironment: vi
+                                .fn()
+                                .mockResolvedValue({
+                                    environment: "dev",
+                                }),
+                        },
+                    },
+                },
+                writable: true,
+                configurable: true,
+            })
+
+            const result = await getEnvironment(
+                "FIRE_TV",
+                undefined,
+                mockLogger
+            )
+
+            expect(result.environment).toBe("dev")
+            expect(result.source).toBe("native")
+        })
+
+        it("should fallback to dev when native returns unknown value", async () => {
+            Object.defineProperty(window, "Capacitor", {
+                value: {
+                    Plugins: {
+                        DeviceInfo: {
+                            getNativeShellAppEnvironment: vi
+                                .fn()
+                                .mockResolvedValue({
+                                    environment: "unknown-env",
+                                }),
+                        },
+                    },
+                },
+                writable: true,
+                configurable: true,
+            })
+
+            const result = await getEnvironment(
+                "FIRE_TV",
+                undefined,
+                mockLogger
+            )
+
+            expect(result.environment).toBe("dev")
+            expect(result.source).toBe("native")
+        })
+
+        it("should fallback to build-time when native plugin unavailable", async () => {
+            // No Capacitor plugin available
+            const result = await getEnvironment(
+                "FIRE_TV",
+                "staging",
+                mockLogger
+            )
+
+            expect(result.environment).toBe("staging")
+            expect(result.source).toBe("build-time")
+            expect(mockLogger.warn).toHaveBeenCalledWith(
+                expect.stringContaining(
+                    "Failed to read environment from native, falling back to build-time"
+                )
+            )
+        })
+
+        it("should fallback to build-time when native plugin throws error", async () => {
+            Object.defineProperty(window, "Capacitor", {
+                value: {
+                    Plugins: {
+                        DeviceInfo: {
+                            getNativeShellAppEnvironment: vi
+                                .fn()
+                                .mockRejectedValue(
+                                    new Error("Native plugin error")
+                                ),
+                        },
+                    },
+                },
+                writable: true,
+                configurable: true,
+            })
+
+            const result = await getEnvironment("FIRE_TV", "prod", mockLogger)
+
+            expect(result.environment).toBe("prod")
+            expect(result.source).toBe("build-time")
+            expect(mockLogger.error).toHaveBeenCalled()
+            expect(mockLogger.warn).toHaveBeenCalledWith(
+                expect.stringContaining("falling back to build-time")
+            )
+        })
+
+        it("should fallback to build-time when native returns empty", async () => {
+            Object.defineProperty(window, "Capacitor", {
+                value: {
+                    Plugins: {
+                        DeviceInfo: {
+                            getNativeShellAppEnvironment: vi
+                                .fn()
+                                .mockResolvedValue({
+                                    environment: "",
+                                }),
+                        },
+                    },
+                },
+                writable: true,
+                configurable: true,
+            })
+
+            const result = await getEnvironment("FIRE_TV", "dev", mockLogger)
+
+            expect(result.environment).toBe("dev")
+            expect(result.source).toBe("build-time")
+            expect(mockLogger.error).toHaveBeenCalledWith(
+                expect.stringContaining(
+                    "DeviceInfo.getNativeShellAppEnvironment returned empty"
+                )
+            )
+        })
+
+        it("should fallback to default when both native and build-time fail", async () => {
+            // No Capacitor plugin, no build-time env
+            const result = await getEnvironment(
+                "FIRE_TV",
+                undefined,
+                mockLogger
+            )
+
+            expect(result.environment).toBe("dev")
+            expect(result.source).toBe("default")
+            expect(mockLogger.warn).toHaveBeenCalledWith(
+                expect.stringContaining(
+                    'Environment: "dev" (source: default fallback'
+                )
+            )
+        })
+
+        it("should be case-insensitive for Fire TV platform", async () => {
+            Object.defineProperty(window, "Capacitor", {
+                value: {
+                    Plugins: {
+                        DeviceInfo: {
+                            getNativeShellAppEnvironment: vi
+                                .fn()
+                                .mockResolvedValue({
+                                    environment: "production",
+                                }),
+                        },
+                    },
+                },
+                writable: true,
+                configurable: true,
+            })
+
+            const result1 = await getEnvironment(
+                "fire_tv",
+                undefined,
+                mockLogger
+            )
+            const result2 = await getEnvironment(
+                "FIRE_TV",
+                undefined,
+                mockLogger
+            )
+
+            expect(result1.environment).toBe("prod")
+            expect(result2.environment).toBe("prod")
+        })
+    })
+
+    describe("Non-Fire TV Platforms - Build-time Environment", () => {
+        const platforms = ["SAMSUNG_TV", "LG_TV", "MOBILE", "WEB"]
+
+        platforms.forEach((platform) => {
+            describe(`${platform}`, () => {
+                it("should use build-time environment when provided", async () => {
+                    const result = await getEnvironment(
+                        platform,
+                        "staging",
+                        mockLogger
+                    )
+
+                    expect(result.environment).toBe("staging")
+                    expect(result.source).toBe("build-time")
+                    expect(mockLogger.info).toHaveBeenCalledWith(
+                        expect.stringContaining(
+                            'Environment: "staging" (source: build-time CLI injection)'
+                        )
+                    )
+                })
+
+                it("should use build-time 'prod' environment", async () => {
+                    const result = await getEnvironment(
+                        platform,
+                        "prod",
+                        mockLogger
+                    )
+
+                    expect(result.environment).toBe("prod")
+                    expect(result.source).toBe("build-time")
+                })
+
+                it("should use build-time 'dev' environment", async () => {
+                    const result = await getEnvironment(
+                        platform,
+                        "dev",
+                        mockLogger
+                    )
+
+                    expect(result.environment).toBe("dev")
+                    expect(result.source).toBe("build-time")
+                })
+
+                it("should use build-time 'local' environment", async () => {
+                    const result = await getEnvironment(
+                        platform,
+                        "local",
+                        mockLogger
+                    )
+
+                    expect(result.environment).toBe("local")
+                    expect(result.source).toBe("build-time")
+                })
+
+                it("should fallback to default when build-time not provided", async () => {
+                    const result = await getEnvironment(
+                        platform,
+                        undefined,
+                        mockLogger
+                    )
+
+                    expect(result.environment).toBe("dev")
+                    expect(result.source).toBe("default")
+                    expect(mockLogger.warn).toHaveBeenCalledWith(
+                        expect.stringContaining(
+                            'Environment: "dev" (source: default fallback'
+                        )
+                    )
+                })
+
+                it("should fallback to default when build-time is invalid", async () => {
+                    const result = await getEnvironment(
+                        platform,
+                        "invalid-env",
+                        mockLogger
+                    )
+
+                    expect(result.environment).toBe("dev")
+                    expect(result.source).toBe("default")
+                })
+            })
+        })
+    })
+
+    describe("Environment Validation", () => {
+        it("should accept valid environments", async () => {
+            const validEnvs: Environment[] = [
+                "local",
+                "dev",
+                "qa",
+                "staging",
+                "prod",
+            ]
+
+            for (const env of validEnvs) {
+                const result = await getEnvironment("WEB", env, mockLogger)
+                expect(result.environment).toBe(env)
+                expect(result.source).toBe("build-time")
+            }
+        })
+
+        it("should reject invalid environments", async () => {
+            const invalidEnvs = [
+                "development",
+                "production",
+                "test",
+                "",
+                "random",
+            ]
+
+            for (const env of invalidEnvs) {
+                const result = await getEnvironment("WEB", env, mockLogger)
+                expect(result.environment).toBe("dev")
+                expect(result.source).toBe("default")
+            }
+        })
+    })
+
+    describe("Logging", () => {
+        it("should log native environment source", async () => {
+            Object.defineProperty(window, "Capacitor", {
+                value: {
+                    Plugins: {
+                        DeviceInfo: {
+                            getNativeShellAppEnvironment: vi
+                                .fn()
+                                .mockResolvedValue({
+                                    environment: "production",
+                                }),
+                        },
+                    },
+                },
+                writable: true,
+                configurable: true,
+            })
+
+            await getEnvironment("FIRE_TV", undefined, mockLogger)
+
+            expect(mockLogger.info).toHaveBeenCalledWith(
+                '[Shell] Environment: "prod" (source: native BuildConfig.ENVIRONMENT="production")'
+            )
+        })
+
+        it("should log build-time environment source", async () => {
+            await getEnvironment("SAMSUNG_TV", "staging", mockLogger)
+
+            expect(mockLogger.info).toHaveBeenCalledWith(
+                '[Shell] Environment: "staging" (source: build-time CLI injection)'
+            )
+        })
+
+        it("should warn when falling back to default", async () => {
+            await getEnvironment("LG_TV", undefined, mockLogger)
+
+            expect(mockLogger.warn).toHaveBeenCalledWith(
+                '[Shell] Environment: "dev" (source: default fallback - no native or build-time env found)'
+            )
+        })
+
+        it("should warn when native fails and falls back", async () => {
+            await getEnvironment("FIRE_TV", "prod", mockLogger)
+
+            expect(mockLogger.warn).toHaveBeenCalledWith(
+                "[Shell] Failed to read environment from native, falling back to build-time"
+            )
+        })
+    })
+})

package/src/getEnvironment.ts

@@ -1,6 +1,6 @@
 import { defaultLogger, type Logger } from "./logger"
 
-export type Environment = "local" | "dev" | "staging" | "prod"
+export type Environment = "local" | "dev" | "qa" | "staging" | "prod"
 export type EnvironmentSource = "native" | "build-time" | "default"
 
 export interface EnvironmentResult {
@@ -48,13 +48,16 @@ export async function getEnvironment(
     }
 
     // Build-time injection (CLI --env flag)
-    if (buildTimeEnv && isValidEnvironment(buildTimeEnv)) {
-        logger.info(
-            `[Shell] Environment: "${buildTimeEnv}" (source: build-time CLI injection)`
-        )
-        return {
-            environment: buildTimeEnv as Environment,
-            source: "build-time",
+    if (buildTimeEnv) {
+        const normalizedBuildTimeEnv = buildTimeEnv.toLowerCase()
+        if (isValidEnvironment(normalizedBuildTimeEnv)) {
+            logger.info(
+                `[Shell] Environment: "${normalizedBuildTimeEnv}" (source: build-time CLI injection)`
+            )
+            return {
+                environment: normalizedBuildTimeEnv as Environment,
+                source: "build-time",
+            }
         }
     }
 
@@ -130,7 +133,7 @@ function mapNativeEnvironment(nativeEnv: string): Environment {
 }
 
 function isValidEnvironment(env: string): boolean {
-    return ["local", "dev", "staging", "prod"].includes(env)
+    return ["local", "dev", "qa", "staging", "prod"].includes(env)
 }
 
 // Note: Window.Capacitor type is declared in getDeviceId.ts

package/src/getShellVersion.test.ts

@@ -268,7 +268,7 @@ describe("getShellVersion", () => {
             expect(version).toBe("unknown")
             expect(consoleWarnSpy).toHaveBeenCalledWith(
                 "[Shell] Failed to get shell version:",
-                expect.any(Error)
+                { error: expect.any(Error) }
             )
 
             consoleWarnSpy.mockRestore()

package/src/getShellVersion.ts

@@ -7,10 +7,10 @@ import { defaultLogger, type Logger } from "./logger"
  * - SAMSUNG_TV: Tizen Application API `tizen.application.getAppInfo().version`
  * - LG_TV: webOS Application API `webOS.fetchAppInfo()`
  * - FIRE_TV: Native bridge via Capacitor DeviceInfo plugin
- * - MOBILE: Native bridge (future implementation)
+ * - ANDROID_MOBILE/IOS_MOBILE: Native bridge (future implementation)
  * - WEB/Unknown: Returns 'unknown'
  *
- * @param platform - Platform identifier (SAMSUNG_TV, LG_TV, FIRE_TV, MOBILE, WEB)
+ * @param platform - Platform identifier (SAMSUNG_TV, LG_TV, FIRE_TV, ANDROID_MOBILE, IOS_MOBILE, WEB)
  * @param logger - Optional logger for warning reporting. Defaults to defaultLogger.
  * @returns Shell version string or 'unknown' if not available
  */
@@ -66,7 +66,11 @@ export async function getShellVersion(
         }
 
         // Mobile: Future implementation via native bridge
-        if (normalizedPlatform === "MOBILE") {
+        if (
+            normalizedPlatform === "ANDROID_MOBILE" ||
+            normalizedPlatform === "IOS_MOBILE" ||
+            normalizedPlatform === "MOBILE"
+        ) {
             // TODO: Implement native bridge version retrieval when available
             return "unknown"
         }

package/src/loadVwr.ts

@@ -1,3 +1,5 @@
+import type * as VWR from "@volley/vwr"
+
 import { fetchAmplitudeFlags } from "./amplitudeFlagFetcher"
 import { ENV_DEFAULTS } from "./envDefaults"
 import { getDeviceId } from "./getDeviceId"
@@ -83,7 +85,8 @@ export const loadVwr = async (logger: Logger = defaultLogger) => {
             apiKey: amplitudeKey,
             timeout: 2000,
         },
-        shellVersion
+        shellVersion,
+        logger
     )
 
     logger.info("[Shell] Flags fetched", { flags })
@@ -115,7 +118,10 @@ export const loadVwr = async (logger: Logger = defaultLogger) => {
         vwrUrl: vwrConfig.vwrUrl,
     })
     try {
-        const vwr = await import(/* @vite-ignore */ vwrConfig.vwrUrl)
+        const vwr = (await import(
+            /* @vite-ignore */ vwrConfig.vwrUrl
+        )) as typeof VWR
+
         logger.info("[Shell] VWR module loaded successfully")
 
         if (typeof vwr.init !== "function") {
@@ -124,11 +130,12 @@ export const loadVwr = async (logger: Logger = defaultLogger) => {
 
         await vwr.init({
             hubUrl: vwrConfig.hubUrl,
-            launchUrl: vwrConfig.launchUrl,
             platform: PLATFORM,
-            deviceId,
-            environment: ENVIRONMENT,
-            trustedDomains: vwrConfig.trustedDomains,
+            stage: ENVIRONMENT,
+            appVersion: shellVersion,
+            platformApiUrl: vwrConfig.platformApiUrl,
+            platformAuthApiUrl: vwrConfig.platformAuthApiUrl,
+            trustedOrigins: new Set(vwrConfig.trustedDomains),
             nativeShellVersion: shellVersion,
         })
         logger.info("[Shell] VWR initialized successfully")

package/src/main.ts

@@ -18,7 +18,9 @@ async function init() {
             }
         } finally {
             //Fallback, can't trust config exists
-            window.location.href = HUB_URL
+            const fallbackUrl = new URL(HUB_URL)
+            fallbackUrl.searchParams.set("volley_platform", PLATFORM)
+            window.location.href = fallbackUrl.toString()
         }
     }
 }

package/src/vite-env.d.ts

@@ -8,6 +8,9 @@ interface ImportMetaEnv {
     readonly VITE_SHELL_VERSION: string
     readonly VITE_CONFIG_URL: string
     readonly VITE_CONFIG_FILE: string
+    readonly VITE_PLATFORM_API_URL: string
+    readonly VITE_PLATFORM_AUTH_API_URL: string
+    readonly VITE_TRUSTED_ORIGINS: string
 }
 
 interface ImportMeta {

package/src/vwrConfig.test.ts

@@ -90,8 +90,8 @@ describe("vwrConfig", async () => {
             expect(config.hubUrl).toBe("https://game-clients.volley.tv/hub")
             expect(config.launchUrl).toBeUndefined() // Optional, not set by default
             expect(config.trustedDomains).toEqual([
-                "https://game-clients.volley.tv/hub",
-                "https://vwr.volley.tv/v1/latest/vwr.js",
+                "https://game-clients.volley.tv",
+                "https://vwr.volley.tv",
             ])
         })