@volley/vwr-loader 1.0.4 → 1.0.6

package/src/vwrConfig.ts

@@ -40,240 +40,223 @@ const buildUrl = (path: string, base: string): URL => {
     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
+class VWRConfigFetcher {
+    private readonly defaults: VWRConfig
+    private readonly timeout: number
+    private readonly logger: Logger
+    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: Logger) {
+        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
     }
-    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
+
+    async fetch(): Promise<VWRConfig> {
+        this.logger.info(
+            "[VWR Config] Fetching config with priority: local → device → shellVersion → environment → defaults"
         )
-        return environmentConfig
-    }
 
-    // All fetches failed, use defaults
-    logger.warn(
-        "[VWR Config] All config fetches failed, using built-in defaults"
-    )
-    const defaultConfig = getDefaultConfig()
-    return defaultConfig
-}
+        // Fetch all configs in parallel for performance
+        const [
+            localConfig,
+            deviceConfig,
+            shellVersionConfig,
+            environmentConfig,
+        ] = await Promise.all([
+            this.tryGetLocalConfig(),
+            this.tryGetDeviceConfig(),
+            this.tryGetShellVersionConfig(),
+            this.tryGetEnvironmentConfig(),
+        ])
 
-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
-    }
-}
+        // Return first successful config in priority order
+        if (localConfig !== null) {
+            this.logger.info(
+                "[VWR Config] ✓ Using config from: local",
+                localConfig
+            )
+            return localConfig
+        }
+        if (deviceConfig !== null) {
+            this.logger.info(
+                "[VWR Config] ✓ Using config from: device",
+                deviceConfig
+            )
+            return deviceConfig
+        }
+        if (shellVersionConfig !== null) {
+            this.logger.info(
+                "[VWR Config] ✓ Using config from: shellVersion",
+                shellVersionConfig
+            )
+            return shellVersionConfig
+        }
+        if (environmentConfig !== null) {
+            this.logger.info(
+                "[VWR Config] ✓ Using config from: environment",
+                environmentConfig
+            )
+            return environmentConfig
+        }
 
-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}`
+        // All fetches failed, use defaults
+        this.logger.warn(
+            "[VWR Config] All config fetches failed, using built-in defaults"
         )
-        return null
+        return this.defaults
     }
-}
 
-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
+    private async tryGetLocalConfig(): Promise<VWRConfig | null> {
+        try {
+            const url = buildUrl(
+                this.configFile,
+                ENV_DEFAULTS["local"]?.configUrl ?? ""
+            )
+            this.logger.info(`[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
+        }
     }
-}
 
-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
+    private async tryGetDeviceConfig(): Promise<VWRConfig | null> {
+        try {
+            const url = buildUrl(
+                `device/${this.platform}/${this.deviceId}/${this.configFile}`,
+                this.configUrl
+            )
+            this.logger.info(`[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
+        }
     }
-}
 
-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)
+    private async tryGetEnvironmentConfig(): Promise<VWRConfig | null> {
+        try {
+            const url = buildUrl(
+                `environments/${this.environment}/${this.configFile}`,
+                this.configUrl
+            )
+            this.logger.info(`[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
         }
+    }
 
-        let config = await response.json()
-        config = parseConfig(config)
-
-        clearTimeout(timeoutId)
-        return config as VWRConfig
-    } catch {
-        clearTimeout(timeoutId)
-        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.info(`[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
+        }
     }
-}
 
-const parseConfig = (config: VWRConfig): VWRConfig => {
-    const defaultConfig = getDefaultConfig()
+    private async tryFetchConfig(url: URL): Promise<VWRConfig | null> {
+        const controller = new AbortController()
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout)
 
-    if (!config.platformApiUrl) {
-        config.platformApiUrl = defaultConfig.platformApiUrl
-    }
+        try {
+            const response = await fetch(
+                new Request(url, {
+                    headers: { "Content-Type": "application/json" },
+                    signal: controller.signal,
+                })
+            )
 
-    if (!config.platformAuthApiUrl) {
-        config.platformAuthApiUrl = defaultConfig.platformAuthApiUrl
-    }
+            if (!response.ok) {
+                clearTimeout(timeoutId)
+                return null
+            }
 
-    if (
-        !Array.isArray(config.trustedDomains) ||
-        config.trustedDomains.length === 0
-    ) {
-        config.trustedDomains = defaultConfig.trustedDomains
+            const config = await response.json()
+            clearTimeout(timeoutId)
+            return this.parseConfig(config)
+        } catch {
+            clearTimeout(timeoutId)
+            return null
+        }
     }
 
-    if (!config.vwrUrl) {
-        config.vwrUrl = defaultConfig.vwrUrl
-        const vwrUrlOrigin = new URL(defaultConfig.vwrUrl).origin
-        if (!config.trustedDomains.includes(vwrUrlOrigin)) {
-            config.trustedDomains.push(vwrUrlOrigin)
+    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],
         }
-    }
 
-    if (!config.hubUrl) {
-        config.hubUrl = defaultConfig.hubUrl
-        const hubUrlOrigin = new URL(defaultConfig.hubUrl).origin
-        if (!config.trustedDomains.includes(hubUrlOrigin)) {
-            config.trustedDomains.push(hubUrlOrigin)
+        // 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 (config.launchUrl) {
-        const launchUrlOrigin = new URL(config.launchUrl).origin
-        if (!config.trustedDomains.includes(launchUrlOrigin)) {
-            config.trustedDomains.push(launchUrlOrigin)
+        // 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
     }
+}
 
-    return config
+export const getVWRConfig = async (
+    request: VWRConfigRequest,
+    logger: Logger = defaultLogger
+): Promise<VWRConfig> => {
+    return new VWRConfigFetcher(request, logger).fetch()
 }
 
 export const validateConfig = (config: VWRConfig): boolean => {
@@ -289,13 +272,12 @@ export const validateConfig = (config: VWRConfig): boolean => {
     return true
 }
 
-const getDefaultConfig = (): VWRConfig => {
-    const ENVIRONMENT = import.meta.env.VITE_ENVIRONMENT || "dev"
-    const defaults = ENV_DEFAULTS[ENVIRONMENT]
+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`
+            `[VWR Config] Unknown environment: ${environment}. Valid: local, dev, staging, prod`
         )
     }