@volley/vwr-loader 1.5.0 → 1.7.0

package/src/vwrConfig.ts

@@ -1,374 +0,0 @@
-import type { ILogger } from "@volley/logger"
-
-import { ENV_DEFAULTS } from "./envDefaults"
-
-export type VWRConfig = {
-    hubUrl: string
-    vwrUrl: string
-    launchUrl: string | undefined
-    platformApiUrl: string
-    platformAuthApiUrl: string
-    trustedDomains: Array<string>
-}
-
-export type VWRConfigRequest = {
-    configUrl: string
-    configFile: string
-    platform: string
-    deviceId: string
-    environment: string
-    shellVersion: string
-    timeout?: number
-}
-
-export type ConfigSource =
-    | "local"
-    | "device"
-    | "shellVersion"
-    | "environment"
-    | "defaults"
-
-export type ConfigFetchAttempt = {
-    source: ConfigSource
-    success: boolean
-    duration_ms: number
-}
-
-export type VWRConfigResult = {
-    config: VWRConfig
-    source: ConfigSource
-    attempts: ConfigFetchAttempt[]
-    total_duration_ms: 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)
-}
-
-class VWRConfigFetcher {
-    private readonly defaults: VWRConfig
-    private readonly timeout: number
-    private readonly logger: ILogger
-    private readonly configUrl: string
-    private readonly configFile: string
-    private readonly platform: string
-    private readonly deviceId: string
-    private readonly environment: string
-    private readonly shellVersion: string
-
-    constructor(request: VWRConfigRequest, logger: ILogger) {
-        this.defaults = getDefaultConfig(request.environment)
-        this.timeout = request.timeout ?? DEFAULT_CONFIG_TIMEOUT
-        this.logger = logger
-        this.configUrl = request.configUrl
-        this.configFile = request.configFile
-        this.platform = request.platform
-        this.deviceId = request.deviceId
-        this.environment = request.environment
-        this.shellVersion = request.shellVersion
-    }
-
-    async fetch(): Promise<VWRConfigResult> {
-        const fetchStartTime = performance.now()
-
-        this.logger.debug(
-            "[VWR Config] Fetching config with priority: local → device → shellVersion → environment → defaults"
-        )
-
-        // Fetch all configs in parallel for performance, with timing
-        const [
-            localResult,
-            deviceResult,
-            shellVersionResult,
-            environmentResult,
-        ] = await Promise.all([
-            this.timedFetch("local", () => this.tryGetLocalConfig()),
-            this.timedFetch("device", () => this.tryGetDeviceConfig()),
-            this.timedFetch("shellVersion", () =>
-                this.tryGetShellVersionConfig()
-            ),
-            this.timedFetch("environment", () =>
-                this.tryGetEnvironmentConfig()
-            ),
-        ])
-
-        const total_duration_ms = Math.round(performance.now() - fetchStartTime)
-        const attempts: ConfigFetchAttempt[] = [
-            localResult.attempt,
-            deviceResult.attempt,
-            shellVersionResult.attempt,
-            environmentResult.attempt,
-        ]
-
-        // Return first successful config in priority order
-        if (localResult.config !== null) {
-            this.logger.debug(
-                "[VWR Config] ✓ Using config from: local",
-                localResult.config
-            )
-            return {
-                config: localResult.config,
-                source: "local",
-                attempts,
-                total_duration_ms,
-            }
-        }
-        if (deviceResult.config !== null) {
-            this.logger.debug(
-                "[VWR Config] ✓ Using config from: device",
-                deviceResult.config
-            )
-            return {
-                config: deviceResult.config,
-                source: "device",
-                attempts,
-                total_duration_ms,
-            }
-        }
-        if (shellVersionResult.config !== null) {
-            this.logger.debug(
-                "[VWR Config] ✓ Using config from: shellVersion",
-                shellVersionResult.config
-            )
-            return {
-                config: shellVersionResult.config,
-                source: "shellVersion",
-                attempts,
-                total_duration_ms,
-            }
-        }
-        if (environmentResult.config !== null) {
-            this.logger.debug(
-                "[VWR Config] ✓ Using config from: environment",
-                environmentResult.config
-            )
-            return {
-                config: environmentResult.config,
-                source: "environment",
-                attempts,
-                total_duration_ms,
-            }
-        }
-
-        // All fetches failed, use defaults
-        this.logger.warn(
-            "[VWR Config] All config fetches failed, using built-in defaults"
-        )
-        return {
-            config: this.defaults,
-            source: "defaults",
-            attempts,
-            total_duration_ms,
-        }
-    }
-
-    private async timedFetch(
-        source: Exclude<ConfigSource, "defaults">,
-        fetchFn: () => Promise<VWRConfig | null>
-    ): Promise<{ config: VWRConfig | null; attempt: ConfigFetchAttempt }> {
-        const startTime = performance.now()
-        const config = await fetchFn()
-        const duration_ms = Math.round(performance.now() - startTime)
-
-        return {
-            config,
-            attempt: {
-                source,
-                success: config !== null,
-                duration_ms,
-            },
-        }
-    }
-
-    private async tryGetLocalConfig(): Promise<VWRConfig | null> {
-        try {
-            const url = buildUrl(
-                this.configFile,
-                ENV_DEFAULTS["local"]?.configUrl ?? ""
-            )
-            this.logger.debug(`[VWR Config] Trying local: ${url}`)
-            return this.tryFetchConfig(url)
-        } catch (error) {
-            this.logger.error(
-                `[VWR Config] URL construction failed for local config: ${error}`
-            )
-            return null
-        }
-    }
-
-    private async tryGetDeviceConfig(): Promise<VWRConfig | null> {
-        try {
-            const url = buildUrl(
-                `device/${this.platform}/${this.deviceId}/${this.configFile}`,
-                this.configUrl
-            )
-            this.logger.debug(`[VWR Config] Trying device: ${url}`)
-            return this.tryFetchConfig(url)
-        } catch (error) {
-            this.logger.error(
-                `[VWR Config] URL construction failed for device config: ${error}`
-            )
-            return null
-        }
-    }
-
-    private async tryGetEnvironmentConfig(): Promise<VWRConfig | null> {
-        try {
-            const url = buildUrl(
-                `environments/${this.environment}/${this.configFile}`,
-                this.configUrl
-            )
-            this.logger.debug(`[VWR Config] Trying environment: ${url}`)
-            return this.tryFetchConfig(url)
-        } catch (error) {
-            this.logger.error(
-                `[VWR Config] URL construction failed for environment config: ${error}`
-            )
-            return null
-        }
-    }
-
-    private async tryGetShellVersionConfig(): Promise<VWRConfig | null> {
-        try {
-            const url = buildUrl(
-                `shellVersion/${this.environment}/${this.platform}/${this.shellVersion}/${this.configFile}`,
-                this.configUrl
-            )
-            this.logger.debug(`[VWR Config] Trying shellVersion: ${url}`)
-            return this.tryFetchConfig(url)
-        } catch (error) {
-            this.logger.error(
-                `[VWR Config] URL construction failed for shellVersion config: ${error}`
-            )
-            return null
-        }
-    }
-
-    private async tryFetchConfig(url: URL): Promise<VWRConfig | null> {
-        const controller = new AbortController()
-        const timeoutId = setTimeout(() => controller.abort(), this.timeout)
-
-        try {
-            const response = await fetch(
-                new Request(url, {
-                    headers: { "Content-Type": "application/json" },
-                    signal: controller.signal,
-                })
-            )
-
-            if (!response.ok) {
-                clearTimeout(timeoutId)
-                return null
-            }
-
-            const config = await response.json()
-            clearTimeout(timeoutId)
-            return this.parseConfig(config)
-        } catch {
-            clearTimeout(timeoutId)
-            return null
-        }
-    }
-
-    private parseConfig(config: Partial<VWRConfig>): VWRConfig {
-        const result: VWRConfig = {
-            hubUrl: config.hubUrl || this.defaults.hubUrl,
-            vwrUrl: config.vwrUrl || this.defaults.vwrUrl,
-            launchUrl: config.launchUrl,
-            platformApiUrl:
-                config.platformApiUrl || this.defaults.platformApiUrl,
-            platformAuthApiUrl:
-                config.platformAuthApiUrl || this.defaults.platformAuthApiUrl,
-            trustedDomains:
-                Array.isArray(config.trustedDomains) &&
-                config.trustedDomains.length > 0
-                    ? [...config.trustedDomains]
-                    : [...this.defaults.trustedDomains],
-        }
-
-        // Ensure vwrUrl origin is in trustedDomains
-        const vwrUrlOrigin = new URL(result.vwrUrl).origin
-        if (!result.trustedDomains.includes(vwrUrlOrigin)) {
-            result.trustedDomains.push(vwrUrlOrigin)
-        }
-
-        // Ensure hubUrl origin is in trustedDomains
-        const hubUrlOrigin = new URL(result.hubUrl).origin
-        if (!result.trustedDomains.includes(hubUrlOrigin)) {
-            result.trustedDomains.push(hubUrlOrigin)
-        }
-
-        // launchUrl is optional - only add to trustedDomains if explicitly set
-        if (result.launchUrl) {
-            try {
-                const launchUrlOrigin = new URL(result.launchUrl).origin
-                if (!result.trustedDomains.includes(launchUrlOrigin)) {
-                    result.trustedDomains.push(launchUrlOrigin)
-                }
-            } catch {
-                // Invalid launchUrl - skip adding to trustedDomains
-            }
-        }
-
-        return result
-    }
-}
-
-export const getVWRConfig = async (
-    request: VWRConfigRequest,
-    logger: ILogger
-): Promise<VWRConfigResult> => {
-    return new VWRConfigFetcher(request, logger).fetch()
-}
-
-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 = (environment: string): VWRConfig => {
-    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,
-        platformApiUrl: defaults.platformApiUrl,
-        platformAuthApiUrl: defaults.platformAuthApiUrl,
-        trustedDomains: [
-            new URL(defaults.hubUrl).origin,
-            new URL(defaults.vwrUrl).origin,
-            ...(defaults.trustedOrigins ?? []),
-        ],
-    }
-}