add retry logic & a default ENV export...

Author: NiloCK

packages/common/src/ENVIRONMENT_VARS.ts

@@ -35,71 +35,132 @@ declare global {
     __SKUILDER_ENV__: Environment | undefined;
   }
 }
-let ENV: Environment = {
-  COUCHDB_SERVER_URL: '',
+
+// Default fallback values if all else fails
+const defaultEnv: Environment = {
+  COUCHDB_SERVER_URL: 'localhost:5984/',
   COUCHDB_SERVER_PROTOCOL: 'http',
-  EXPRESS_SERVER_URL: '',
+  EXPRESS_SERVER_URL: 'localhost:3000/',
   EXPRESS_SERVER_PROTOCOL: 'http',
   DEBUG: false,
   MOCK: false,
 };
 
-if (typeof window !== 'undefined' && window.__SKUILDER_ENV__) {
-  console.log('Using existing ENV from global scope');
-  ENV = window.__SKUILDER_ENV__;
-} else {
-  // Try to load from Vite environment if available
+// Function to load environment variables from Vite
+function loadFromVite(): Partial<Environment> {
+  const result: Partial<Environment> = {};
+
   try {
     // Use typeof check to avoid issues in non-Vite environments
     if (typeof import.meta !== 'undefined' && 'env' in import.meta) {
       const env = (import.meta as any).env;
 
       if (env.VITE_COUCHDB_SERVER) {
-        ENV.COUCHDB_SERVER_URL = env.VITE_COUCHDB_SERVER;
+        result.COUCHDB_SERVER_URL = env.VITE_COUCHDB_SERVER;
       }
 
       if (env.VITE_COUCHDB_PROTOCOL) {
-        ENV.COUCHDB_SERVER_PROTOCOL = env.VITE_COUCHDB_PROTOCOL as ProtocolString;
+        result.COUCHDB_SERVER_PROTOCOL = env.VITE_COUCHDB_PROTOCOL as ProtocolString;
       }
 
       if (env.VITE_EXPRESS_SERVER) {
-        ENV.EXPRESS_SERVER_URL = env.VITE_EXPRESS_SERVER;
+        result.EXPRESS_SERVER_URL = env.VITE_EXPRESS_SERVER;
       }
 
       if (env.VITE_EXPRESS_PROTOCOL) {
-        ENV.EXPRESS_SERVER_PROTOCOL = env.VITE_EXPRESS_PROTOCOL as ProtocolString;
+        result.EXPRESS_SERVER_PROTOCOL = env.VITE_EXPRESS_PROTOCOL as ProtocolString;
       }
 
       if (env.VITE_DEBUG !== undefined) {
-        ENV.DEBUG = env.VITE_DEBUG === 'true';
+        result.DEBUG = env.VITE_DEBUG === 'true';
       }
 
       if (env.VITE_MOCK !== undefined) {
-        ENV.MOCK = env.VITE_MOCK === 'true';
+        result.MOCK = env.VITE_MOCK === 'true';
       }
     }
   } catch (e) {
     console.warn('Unable to load environment variables from Vite:', e);
   }
-  // Store in global scope if in browser environment
-  if (typeof window !== 'undefined' && ENV.COUCHDB_SERVER_URL && ENV.EXPRESS_SERVER_URL) {
-    window.__SKUILDER_ENV__ = ENV;
-    console.log('ENV initialized and stored in global scope');
 
-    console.log(`ENV init:`);
+  return result;
+}
+
+// Function to validate if environment is properly loaded
+function isValidEnv(env: Environment): boolean {
+  return Boolean(env.COUCHDB_SERVER_URL && env.EXPRESS_SERVER_URL);
+}
 
-    console.log(`  COUCHDB_SERVER_URL: ${ENV.COUCHDB_SERVER_URL}`);
-    console.log(`  COUCHDB_SERVER_PROTOCOL: ${ENV.COUCHDB_SERVER_PROTOCOL}`);
-    console.log(`  EXPRESS_SERVER_URL: ${ENV.EXPRESS_SERVER_URL}`);
-    console.log(`  EXPRESS_SERVER_PROTOCOL: ${ENV.EXPRESS_SERVER_PROTOCOL}`);
-    console.log(`  DEBUG: ${ENV.DEBUG}`);
-    console.log(`  MOCK: ${ENV.MOCK}`);
+// Initialize ENV with a blocking retry mechanism if needed
+let ENV: Environment;
+
+// First check if we have a global instance already
+if (
+  typeof window !== 'undefined' &&
+  window.__SKUILDER_ENV__ &&
+  isValidEnv(window.__SKUILDER_ENV__)
+) {
+  console.log('Using existing ENV from global scope');
+  ENV = window.__SKUILDER_ENV__;
+} else {
+  // Try loading with a blocking retry if in browser environment
+  if (typeof window !== 'undefined') {
+    let viteEnv = loadFromVite();
+
+    // If initial load didn't succeed, do a blocking retry
+    if (!viteEnv.COUCHDB_SERVER_URL || !viteEnv.EXPRESS_SERVER_URL) {
+      console.warn('Initial ENV load incomplete, performing blocking retries...');
+
+      // Synchronous retries with exponential backoff
+      const maxRetries = 5;
+      let retryCount = 0;
+      let baseDelay = 20; // ms
+
+      while (
+        retryCount < maxRetries &&
+        (!viteEnv.COUCHDB_SERVER_URL || !viteEnv.EXPRESS_SERVER_URL)
+      ) {
+        // Create a delay using a synchronous approach
+        const delay = baseDelay * Math.pow(2, retryCount);
+        const startTime = Date.now();
+        while (Date.now() - startTime < delay) {
+          // Empty blocking loop
+        }
+
+        retryCount++;
+        console.log(`Retry ${retryCount}/${maxRetries} for ENV initialization...`);
+        viteEnv = loadFromVite();
+      }
+
+      if (!viteEnv.COUCHDB_SERVER_URL || !viteEnv.EXPRESS_SERVER_URL) {
+        console.error('ENV initialization failed after retries, using defaults');
+        // Use default values if all retries fail
+        ENV = { ...defaultEnv };
+      } else {
+        console.log('ENV successfully initialized after retries');
+        ENV = { ...defaultEnv, ...viteEnv };
+      }
+    } else {
+      ENV = { ...defaultEnv, ...viteEnv };
+    }
+
+    // Store in global scope
+    window.__SKUILDER_ENV__ = ENV;
+    console.log('ENV initialized and stored in global scope');
   } else {
-    console.warn('ENV initialization failed');
+    // Node.js environment (SSR or build)
+    const viteEnv = loadFromVite();
+    ENV = { ...defaultEnv, ...viteEnv };
   }
 }
 
-// if (ENV.DEBUG) {
-// }
+// Log the initialized environment
+console.log(`ENV init:`);
+console.log(`  COUCHDB_SERVER_URL: ${ENV.COUCHDB_SERVER_URL}`);
+console.log(`  COUCHDB_SERVER_PROTOCOL: ${ENV.COUCHDB_SERVER_PROTOCOL}`);
+console.log(`  EXPRESS_SERVER_URL: ${ENV.EXPRESS_SERVER_URL}`);
+console.log(`  EXPRESS_SERVER_PROTOCOL: ${ENV.EXPRESS_SERVER_PROTOCOL}`);
+console.log(`  DEBUG: ${ENV.DEBUG}`);
+console.log(`  MOCK: ${ENV.MOCK}`);
 
 export default ENV;