@volley/vwr-loader 1.0.0-alpha.1

package/src/vwrConfig.test.ts

@@ -0,0 +1,316 @@
+import { describe, expect, it, vi } from "vitest"
+
+// Stub environment to use "production" which maps to ENV_DEFAULTS["production"]
+vi.stubEnv("VITE_ENVIRONMENT", "production")
+
+import type { VWRConfig, VWRConfigRequest } from "./vwrConfig"
+
+describe("vwrConfig", async () => {
+    const { getVWRConfig, validateConfig } = await import("./vwrConfig")
+    describe("validateConfig", () => {
+        const config = {
+            vwrUrl: "https://vwr.example.com",
+            hubUrl: "https://hub.example.com",
+            launchUrl: "https://launch.example.com",
+            trustedDomains: ["example.com"],
+        }
+
+        it("returns false for empty vwrUrl", () => {
+            const invalidConfig = { ...config, vwrUrl: "" }
+            expect(validateConfig(invalidConfig)).toBe(false)
+        })
+
+        it("returns false for undefined vwrUrl", () => {
+            const invalidConfig: VWRConfig = JSON.parse(
+                JSON.stringify({ ...config, vwrUrl: undefined })
+            )
+            expect(validateConfig(invalidConfig)).toBe(false)
+        })
+
+        it("returns false for empty hubUrl", () => {
+            const invalidConfig = { ...config, hubUrl: "" }
+            expect(validateConfig(invalidConfig)).toBe(false)
+        })
+
+        it("returns false for undefined hubUrl", () => {
+            const invalidConfig: VWRConfig = JSON.parse(
+                JSON.stringify({ ...config, hubUrl: undefined })
+            )
+            expect(validateConfig(invalidConfig)).toBe(false)
+        })
+
+        it("returns true for empty launchUrl (optional field)", () => {
+            const validConfig = { ...config, launchUrl: "" }
+            expect(validateConfig(validConfig)).toBe(true)
+        })
+
+        it("returns true for undefined launchUrl (optional field)", () => {
+            const validConfig: VWRConfig = JSON.parse(
+                JSON.stringify({ ...config, launchUrl: undefined })
+            )
+            expect(validateConfig(validConfig)).toBe(true)
+        })
+
+        it("returns false for empty trustedDomains", () => {
+            const invalidConfig = { ...config, trustedDomains: [] }
+            expect(validateConfig(invalidConfig)).toBe(false)
+        })
+
+        it("returns false for undefined trustedDomains", () => {
+            const invalidConfig: VWRConfig = JSON.parse(
+                JSON.stringify({ ...config, trustedDomains: undefined })
+            )
+            expect(validateConfig(invalidConfig)).toBe(false)
+        })
+
+        it("returns false for non array trustedDomains", () => {
+            const invalidConfig: VWRConfig = JSON.parse(
+                JSON.stringify({ ...config, trustedDomains: "" })
+            )
+            expect(validateConfig(invalidConfig)).toBe(false)
+        })
+    })
+
+    describe("getVWRConfig", () => {
+        const configRequest: VWRConfigRequest = {
+            configUrl: "https://config.example.com",
+            configFile: "vwr-config.json",
+            platform: "web",
+            deviceId: "device-123",
+            environment: "production",
+            shellVersion: "1.0.0",
+        }
+
+        const fetchSpy = vi.spyOn(global, "fetch")
+
+        it("returns default config when no configs are found", async () => {
+            const config = await getVWRConfig(configRequest)
+            // Defaults come from ENV_DEFAULTS["production"]
+            expect(config.vwrUrl).toBe("https://vwr.volley.tv/v1/latest/vwr.js")
+            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",
+            ])
+        })
+
+        it("returns local config when available", async () => {
+            fetchSpy.mockResolvedValueOnce(
+                new Response(
+                    JSON.stringify({
+                        vwrUrl: "https://local-vwr.example.com",
+                        hubUrl: "https://local-hub.example.com",
+                        launchUrl: "https://local-launch.example.com",
+                        trustedDomains: [
+                            "https://local-hub.example.com",
+                            "https://local-vwr.example.com",
+                            "https://local-launch.example.com",
+                        ],
+                    })
+                )
+            )
+            fetchSpy.mockResolvedValueOnce(
+                new Response(
+                    JSON.stringify({
+                        vwrUrl: "https://device-vwr.example.com",
+                        hubUrl: "https://device-hub.example.com",
+                        launchUrl: "https://device-launch.example.com",
+                        trustedDomains: [
+                            "https://device-hub.example.com",
+                            "https://device-vwr.example.com",
+                            "https://device-launch.example.com",
+                        ],
+                    })
+                )
+            )
+            fetchSpy.mockResolvedValueOnce(
+                new Response(
+                    JSON.stringify({
+                        vwrUrl: "https://shell-vwr.example.com",
+                        hubUrl: "https://shell-hub.example.com",
+                        launchUrl: "https://shell-launch.example.com",
+                        trustedDomains: [
+                            "https://shell-hub.example.com",
+                            "https://shell-vwr.example.com",
+                            "https://shell-launch.example.com",
+                        ],
+                    })
+                )
+            )
+            fetchSpy.mockResolvedValueOnce(
+                new Response(
+                    JSON.stringify({
+                        vwrUrl: "https://environment-vwr.example.com",
+                        hubUrl: "https://environment-hub.example.com",
+                        launchUrl: "https://environment-launch.example.com",
+                        trustedDomains: [
+                            "https://environment-hub.example.com",
+                            "https://environment-vwr.example.com",
+                            "https://environment-launch.example.com",
+                        ],
+                    })
+                )
+            )
+            const config = await getVWRConfig(configRequest)
+            expect(validateConfig(config)).toBe(true)
+            expect(config.vwrUrl).toBe("https://local-vwr.example.com")
+            expect(config.hubUrl).toBe("https://local-hub.example.com")
+            expect(config.launchUrl).toBe("https://local-launch.example.com")
+            expect(config.trustedDomains).toEqual([
+                "https://local-hub.example.com",
+                "https://local-vwr.example.com",
+                "https://local-launch.example.com",
+            ])
+        })
+
+        it("returns device config when available", async () => {
+            fetchSpy.mockResolvedValueOnce(
+                new Response(
+                    JSON.stringify({
+                        vwrUrl: "https://device-vwr.example.com",
+                        hubUrl: "https://device-hub.example.com",
+                        launchUrl: "https://device-launch.example.com",
+                        trustedDomains: [
+                            "https://device-hub.example.com",
+                            "https://device-vwr.example.com",
+                            "https://device-launch.example.com",
+                        ],
+                    })
+                )
+            )
+            fetchSpy.mockResolvedValueOnce(
+                new Response(
+                    JSON.stringify({
+                        vwrUrl: "https://shell-vwr.example.com",
+                        hubUrl: "https://shell-hub.example.com",
+                        launchUrl: "https://shell-launch.example.com",
+                        trustedDomains: [
+                            "https://shell-hub.example.com",
+                            "https://shell-vwr.example.com",
+                            "https://shell-launch.example.com",
+                        ],
+                    })
+                )
+            )
+            fetchSpy.mockResolvedValueOnce(
+                new Response(
+                    JSON.stringify({
+                        vwrUrl: "https://environment-vwr.example.com",
+                        hubUrl: "https://environment-hub.example.com",
+                        launchUrl: "https://environment-launch.example.com",
+                        trustedDomains: [
+                            "https://environment-hub.example.com",
+                            "https://environment-vwr.example.com",
+                            "https://environment-launch.example.com",
+                        ],
+                    })
+                )
+            )
+            const config = await getVWRConfig(configRequest)
+            expect(validateConfig(config)).toBe(true)
+            expect(config.vwrUrl).toBe("https://device-vwr.example.com")
+            expect(config.hubUrl).toBe("https://device-hub.example.com")
+            expect(config.launchUrl).toBe("https://device-launch.example.com")
+            expect(config.trustedDomains).toEqual([
+                "https://device-hub.example.com",
+                "https://device-vwr.example.com",
+                "https://device-launch.example.com",
+            ])
+        })
+
+        it("returns shell config when available", async () => {
+            fetchSpy.mockResolvedValueOnce(
+                new Response(
+                    JSON.stringify({
+                        vwrUrl: "https://shell-vwr.example.com",
+                        hubUrl: "https://shell-hub.example.com",
+                        launchUrl: "https://shell-launch.example.com",
+                        trustedDomains: [
+                            "https://shell-hub.example.com",
+                            "https://shell-vwr.example.com",
+                            "https://shell-launch.example.com",
+                        ],
+                    })
+                )
+            )
+            fetchSpy.mockResolvedValueOnce(
+                new Response(
+                    JSON.stringify({
+                        vwrUrl: "https://environment-vwr.example.com",
+                        hubUrl: "https://environment-hub.example.com",
+                        launchUrl: "https://environment-launch.example.com",
+                        trustedDomains: [
+                            "https://environment-hub.example.com",
+                            "https://environment-vwr.example.com",
+                            "https://environment-launch.example.com",
+                        ],
+                    })
+                )
+            )
+            const config = await getVWRConfig(configRequest)
+            expect(validateConfig(config)).toBe(true)
+            expect(config.vwrUrl).toBe("https://shell-vwr.example.com")
+            expect(config.hubUrl).toBe("https://shell-hub.example.com")
+            expect(config.launchUrl).toBe("https://shell-launch.example.com")
+            expect(config.trustedDomains).toEqual([
+                "https://shell-hub.example.com",
+                "https://shell-vwr.example.com",
+                "https://shell-launch.example.com",
+            ])
+        })
+
+        it("returns environment config when available", async () => {
+            fetchSpy.mockResolvedValueOnce(
+                new Response(
+                    JSON.stringify({
+                        vwrUrl: "https://environment-vwr.example.com",
+                        hubUrl: "https://environment-hub.example.com",
+                        launchUrl: "https://environment-launch.example.com",
+                        trustedDomains: [
+                            "https://environment-hub.example.com",
+                            "https://environment-vwr.example.com",
+                            "https://environment-launch.example.com",
+                        ],
+                    })
+                )
+            )
+            const config = await getVWRConfig(configRequest)
+            expect(validateConfig(config)).toBe(true)
+            expect(config.vwrUrl).toBe("https://environment-vwr.example.com")
+            expect(config.hubUrl).toBe("https://environment-hub.example.com")
+            expect(config.launchUrl).toBe(
+                "https://environment-launch.example.com"
+            )
+            expect(config.trustedDomains).toEqual([
+                "https://environment-hub.example.com",
+                "https://environment-vwr.example.com",
+                "https://environment-launch.example.com",
+            ])
+        })
+
+        it("returns default config for missing values", async () => {
+            fetchSpy.mockResolvedValueOnce(
+                new Response(
+                    JSON.stringify({
+                        vwrUrl: "https://environment-vwr.example.com",
+                        hubUrl: "https://environment-hub.example.com",
+                        trustedDomains: [
+                            "https://environment-hub.example.com",
+                            "https://environment-vwr.example.com",
+                        ],
+                    })
+                )
+            )
+            const config = await getVWRConfig(configRequest)
+            expect(config.vwrUrl).toBe("https://environment-vwr.example.com")
+            expect(config.hubUrl).toBe("https://environment-hub.example.com")
+            // launchUrl is optional, not filled when missing
+            expect(config.launchUrl).toBeUndefined()
+            expect(config.trustedDomains).toEqual([
+                "https://environment-hub.example.com",
+                "https://environment-vwr.example.com",
+            ])
+        })
+    })
+})

package/src/vwrConfig.ts

@@ -0,0 +1,293 @@
+import { ENV_DEFAULTS } from "./envDefaults"
+import { defaultLogger, type Logger } from "./logger"
+
+export type VWRConfig = {
+    hubUrl: string
+    vwrUrl: string
+    launchUrl: string | undefined
+    trustedDomains: Array<string>
+}
+
+export type VWRConfigRequest = {
+    configUrl: string
+    configFile: string
+    platform: string
+    deviceId: string
+    environment: string
+    shellVersion: string
+    timeout?: number
+}
+
+const DEFAULT_CONFIG_TIMEOUT = 2000
+
+/**
+ * Build a URL from a base and relative path, handling missing trailing slashes.
+ *
+ * The URL constructor resolves relative paths against the "directory" of the base URL,
+ * which is defined as everything up to (but not including) the last path segment.
+ * Without a trailing slash, the last segment is treated as a "file" and gets replaced.
+ *
+ * Example:
+ *   new URL("a/b.json", "https://x.com/config")  → "https://x.com/a/b.json" (wrong)
+ *   new URL("a/b.json", "https://x.com/config/") → "https://x.com/config/a/b.json" (correct)
+ *
+ * This helper normalizes the base URL to ensure correct resolution.
+ */
+const buildUrl = (path: string, base: string): URL => {
+    const normalizedBase = base.endsWith("/") ? base : `${base}/`
+    return new URL(path, normalizedBase)
+}
+
+export const getVWRConfig = async (
+    request: VWRConfigRequest,
+    logger: Logger = defaultLogger
+): Promise<VWRConfig> => {
+    const timeout = request.timeout ?? DEFAULT_CONFIG_TIMEOUT
+
+    logger.info(
+        "[VWR Config] Fetching config with priority: local → device → shellVersion → environment → defaults"
+    )
+
+    // Fetch all configs in parallel for performance
+    const [localConfig, deviceConfig, shellVersionConfig, environmentConfig] =
+        await Promise.all([
+            tryGetLocalConfig(request.configFile, timeout, logger),
+            tryGetDeviceConfig(
+                request.configUrl,
+                request.configFile,
+                request.platform,
+                request.deviceId,
+                timeout,
+                logger
+            ),
+            tryGetShellVersionConfig(
+                request.configUrl,
+                request.configFile,
+                request.environment,
+                request.platform,
+                request.shellVersion,
+                timeout,
+                logger
+            ),
+            tryGetEnvironmentConfig(
+                request.configUrl,
+                request.configFile,
+                request.environment,
+                timeout,
+                logger
+            ),
+        ])
+
+    // Return first successful config in priority order
+    if (localConfig !== null) {
+        logger.info("[VWR Config] ✓ Using config from: local", localConfig)
+        return localConfig
+    }
+    if (deviceConfig !== null) {
+        logger.info("[VWR Config] ✓ Using config from: device", deviceConfig)
+        return deviceConfig
+    }
+    if (shellVersionConfig !== null) {
+        logger.info(
+            "[VWR Config] ✓ Using config from: shellVersion",
+            shellVersionConfig
+        )
+        return shellVersionConfig
+    }
+    if (environmentConfig !== null) {
+        logger.info(
+            "[VWR Config] ✓ Using config from: environment",
+            environmentConfig
+        )
+        return environmentConfig
+    }
+
+    // All fetches failed, use defaults
+    logger.warn(
+        "[VWR Config] All config fetches failed, using built-in defaults"
+    )
+    const defaultConfig = getDefaultConfig()
+    return defaultConfig
+}
+
+const tryGetLocalConfig = async (
+    configFile: string,
+    timeout: number,
+    logger: Logger
+): Promise<VWRConfig | null> => {
+    try {
+        const url = buildUrl(configFile, ENV_DEFAULTS["local"]?.configUrl ?? "")
+        logger.info(`[VWR Config] Trying local: ${url}`)
+        return tryGetVWRConfig(url, timeout)
+    } catch (error) {
+        logger.error(
+            `[VWR Config] URL construction failed for local config: ${error}`
+        )
+        return null
+    }
+}
+
+const tryGetDeviceConfig = async (
+    configUrl: string,
+    configFile: string,
+    platform: string,
+    deviceId: string,
+    timeout: number,
+    logger: Logger
+): Promise<VWRConfig | null> => {
+    try {
+        const url = buildUrl(
+            `device/${platform}/${deviceId}/${configFile}`,
+            configUrl
+        )
+        logger.info(`[VWR Config] Trying device: ${url}`)
+        return tryGetVWRConfig(url, timeout)
+    } catch (error) {
+        logger.error(
+            `[VWR Config] URL construction failed for device config: ${error}`
+        )
+        return null
+    }
+}
+
+const tryGetEnvironmentConfig = async (
+    configUrl: string,
+    configFile: string,
+    environment: string,
+    timeout: number,
+    logger: Logger
+): Promise<VWRConfig | null> => {
+    try {
+        const url = buildUrl(
+            `environments/${environment}/${configFile}`,
+            configUrl
+        )
+        logger.info(`[VWR Config] Trying environment: ${url}`)
+        return tryGetVWRConfig(url, timeout)
+    } catch (error) {
+        logger.error(
+            `[VWR Config] URL construction failed for environment config: ${error}`
+        )
+        return null
+    }
+}
+
+const tryGetShellVersionConfig = async (
+    configUrl: string,
+    configFile: string,
+    environment: string,
+    platform: string,
+    shellVersion: string,
+    timeout: number,
+    logger: Logger
+): Promise<VWRConfig | null> => {
+    try {
+        const url = buildUrl(
+            `shellVersion/${environment}/${platform}/${shellVersion}/${configFile}`,
+            configUrl
+        )
+        logger.info(`[VWR Config] Trying shellVersion: ${url}`)
+        return tryGetVWRConfig(url, timeout)
+    } catch (error) {
+        logger.error(
+            `[VWR Config] URL construction failed for shellVersion config: ${error}`
+        )
+        return null
+    }
+}
+
+const tryGetVWRConfig = async (
+    url: URL,
+    timeout: number
+): Promise<VWRConfig | null> => {
+    const controller = new AbortController()
+    const timeoutId = setTimeout(() => controller.abort(), timeout)
+
+    try {
+        const response = await fetch(
+            new Request(url, {
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                signal: controller.signal,
+            })
+        )
+
+        if (!response.ok) {
+            clearTimeout(timeoutId)
+            return null
+        }
+
+        let config = await response.json()
+        config = parseConfig(config)
+
+        clearTimeout(timeoutId)
+        return config as VWRConfig
+    } catch {
+        clearTimeout(timeoutId)
+        return null
+    }
+}
+
+const parseConfig = (config: VWRConfig): VWRConfig => {
+    const defaultConfig = getDefaultConfig()
+
+    if (
+        !Array.isArray(config.trustedDomains) ||
+        config.trustedDomains.length === 0
+    ) {
+        config.trustedDomains = defaultConfig.trustedDomains
+    }
+
+    if (!config.vwrUrl) {
+        config.vwrUrl = defaultConfig.vwrUrl
+        if (!config.trustedDomains.includes(defaultConfig.vwrUrl)) {
+            config.trustedDomains.push(defaultConfig.vwrUrl)
+        }
+    }
+
+    if (!config.hubUrl) {
+        config.hubUrl = defaultConfig.hubUrl
+        if (!config.trustedDomains.includes(defaultConfig.hubUrl)) {
+            config.trustedDomains.push(defaultConfig.hubUrl)
+        }
+    }
+
+    // launchUrl is optional - only add to trustedDomains if explicitly set
+    if (config.launchUrl && !config.trustedDomains.includes(config.launchUrl)) {
+        config.trustedDomains.push(config.launchUrl)
+    }
+
+    return config
+}
+
+export const validateConfig = (config: VWRConfig): boolean => {
+    if (!config.vwrUrl) return false
+
+    if (!config.hubUrl) return false
+
+    // launchUrl is optional, allow undefined
+
+    if (!Array.isArray(config.trustedDomains)) return false
+    else if (config.trustedDomains.length === 0) return false
+
+    return true
+}
+
+const getDefaultConfig = (): VWRConfig => {
+    const ENVIRONMENT = import.meta.env.VITE_ENVIRONMENT || "dev"
+    const defaults = ENV_DEFAULTS[ENVIRONMENT]
+
+    if (!defaults) {
+        throw new Error(
+            `[VWR Config] Unknown environment: ${ENVIRONMENT}. Valid: local, dev, staging, prod`
+        )
+    }
+
+    return {
+        hubUrl: defaults.hubUrl,
+        vwrUrl: defaults.vwrUrl,
+        launchUrl: undefined,
+        trustedDomains: [defaults.hubUrl, defaults.vwrUrl],
+    }
+}