Refactor code structure and remove redundant changes

src-old/lib/authStorage.ts

@@ -0,0 +1,194 @@
+import { authLog, authWarn, authError } from './authLogger';
+
+/**
+ * Custom storage adapter for Supabase authentication that handles iframe localStorage restrictions.
+ * Falls back to sessionStorage or in-memory storage if localStorage is blocked.
+ */
+class AuthStorage {
+  private storage: Storage | null = null;
+  private memoryStorage: Map<string, string> = new Map();
+  private storageType: 'localStorage' | 'sessionStorage' | 'memory' = 'memory';
+  private sessionRecoveryAttempted = false;
+
+  constructor() {
+    // Try localStorage first
+    try {
+      localStorage.setItem('__supabase_test__', 'test');
+      localStorage.removeItem('__supabase_test__');
+      this.storage = localStorage;
+      this.storageType = 'localStorage';
+      authLog('[AuthStorage] Using localStorage ✓');
+    } catch {
+      // Try sessionStorage as fallback
+      try {
+        sessionStorage.setItem('__supabase_test__', 'test');
+        sessionStorage.removeItem('__supabase_test__');
+        this.storage = sessionStorage;
+        this.storageType = 'sessionStorage';
+        authWarn('[AuthStorage] localStorage blocked, using sessionStorage ⚠️');
+      } catch {
+        // Use in-memory storage as last resort
+        this.storageType = 'memory';
+        authError('[AuthStorage] Both localStorage and sessionStorage blocked, using in-memory storage ⛔');
+        authError('[AuthStorage] Sessions will NOT persist across page reloads!');
+        
+        // Attempt to recover session from URL
+        this.attemptSessionRecoveryFromURL();
+      }
+    }
+
+    // Listen for storage events to sync across tabs (when possible)
+    if (this.storage) {
+      window.addEventListener('storage', this.handleStorageChange.bind(this));
+    }
+  }
+
+  private attemptSessionRecoveryFromURL() {
+    if (this.sessionRecoveryAttempted) return;
+    this.sessionRecoveryAttempted = true;
+
+    try {
+      const urlParams = new URLSearchParams(window.location.hash.substring(1));
+      const accessToken = urlParams.get('access_token');
+      const refreshToken = urlParams.get('refresh_token');
+      
+      if (accessToken && refreshToken) {
+        authLog('[AuthStorage] Recovering session from URL parameters');
+        // Store in memory
+        this.memoryStorage.set('sb-auth-token', JSON.stringify({
+          access_token: accessToken,
+          refresh_token: refreshToken,
+          expires_at: Date.now() + 3600000, // 1 hour
+        }));
+        
+        // Clean URL
+        window.history.replaceState({}, document.title, window.location.pathname);
+      }
+    } catch (error: unknown) {
+      authError('[AuthStorage] Failed to recover session from URL:', error);
+    }
+  }
+
+  private handleStorageChange(event: StorageEvent) {
+    // Sync auth state across tabs
+    if (event.key?.startsWith('sb-') && event.newValue) {
+      authLog('[AuthStorage] Syncing auth state across tabs');
+    }
+  }
+
+  getItem(key: string): string | null {
+    authLog('[AuthStorage] Getting key:', key);
+    try {
+      if (this.storage) {
+        const value = this.storage.getItem(key);
+        authLog('[AuthStorage] Retrieved from storage:', !!value);
+        
+        if (value) {
+          // Verify it's not expired
+          if (key.includes('auth-token')) {
+            try {
+              const parsed = JSON.parse(value);
+              
+              // Supabase stores expires_at in seconds, Date.now() is in milliseconds
+              // Check if expires_at is in seconds (< year 3000 in milliseconds)
+              const expiryTime = parsed.expires_at > 10000000000 
+                ? parsed.expires_at  // Already in milliseconds
+                : parsed.expires_at * 1000; // Convert from seconds to milliseconds
+              
+              if (parsed.expires_at && expiryTime < Date.now()) {
+                authWarn('[AuthStorage] Token expired, removing', {
+                  expires_at: parsed.expires_at,
+                  expiryTime: new Date(expiryTime),
+                  now: new Date()
+                });
+                this.removeItem(key);
+                return null;
+              }
+              
+              authLog('[AuthStorage] Token valid, expires:', new Date(expiryTime));
+            } catch (e) {
+              authWarn('[AuthStorage] Could not parse token for expiry check:', e);
+            }
+          }
+        }
+        return value;
+      }
+      authLog('[AuthStorage] Using memory storage');
+      return this.memoryStorage.get(key) || null;
+    } catch (error: unknown) {
+      authError('[AuthStorage] Error reading from storage:', error);
+      return this.memoryStorage.get(key) || null;
+    }
+  }
+
+  setItem(key: string, value: string): void {
+    authLog('[AuthStorage] Setting key:', key);
+    try {
+      if (this.storage) {
+        this.storage.setItem(key, value);
+      }
+      // Always keep in memory as backup
+      this.memoryStorage.set(key, value);
+    } catch (error: unknown) {
+      authError('[AuthStorage] Error writing to storage:', error);
+      // Fallback to memory only
+      this.memoryStorage.set(key, value);
+    }
+  }
+
+  removeItem(key: string): void {
+    try {
+      if (this.storage) {
+        this.storage.removeItem(key);
+      }
+      this.memoryStorage.delete(key);
+    } catch (error: unknown) {
+      authError('[AuthStorage] Error removing from storage:', error);
+      this.memoryStorage.delete(key);
+    }
+  }
+
+  // Get storage status for diagnostics
+  getStorageStatus(): { type: string; persistent: boolean; warning: string | null } {
+    return {
+      type: this.storageType,
+      persistent: this.storageType !== 'memory',
+      warning: this.storageType === 'memory' 
+        ? 'Sessions will not persist across page reloads. Please enable cookies/storage for this site.'
+        : null
+    };
+  }
+
+  // Clear all auth-related storage (for force logout)
+  clearAll(): void {
+    authLog('[AuthStorage] Clearing all auth storage');
+    try {
+      if (this.storage) {
+        // Get all keys from storage
+        const keys: string[] = [];
+        for (let i = 0; i < this.storage.length; i++) {
+          const key = this.storage.key(i);
+          if (key?.startsWith('sb-')) {
+            keys.push(key);
+          }
+        }
+        
+        // Remove all Supabase auth keys
+        keys.forEach(key => {
+          authLog('[AuthStorage] Removing key:', key);
+          this.storage!.removeItem(key);
+        });
+      }
+      
+      // Clear memory storage
+      this.memoryStorage.clear();
+      authLog('[AuthStorage] ✓ All auth storage cleared');
+    } catch (error: unknown) {
+      authError('[AuthStorage] Error clearing storage:', error);
+      // Still clear memory storage as fallback
+      this.memoryStorage.clear();
+    }
+  }
+}
+
+export const authStorage = new AuthStorage();