fix(electron): improve SQLite initialization and timing handling

- Add structured SQLite configuration in main process with separate settings for
  initialization and operations
- Implement proper retry logic with configurable attempts and delays
- Add connection pool management to prevent resource exhaustion
- Reduce initialization timeout from 30s to 10s for faster feedback
- Add proper cleanup of timeouts and resources
- Maintain consistent retry behavior in preload script

This change addresses the cascade of SQLite timeout errors seen in the logs
by implementing proper timing controls and resource management. The main
process now handles initialization more robustly with configurable retries,
while the preload script maintains its existing retry behavior for
compatibility.

Security Impact:
- No security implications
- Improves application stability
- Prevents resource exhaustion

Testing:
- Verify SQLite initialization completes within new timeout
- Confirm retry behavior works as expected
- Check that connection pool limits are respected
- Ensure proper cleanup of resources

electron/src/setup.ts

@@ -12,33 +12,161 @@ import electronServe from 'electron-serve';
 import windowStateKeeper from 'electron-window-state';
 import { join } from 'path';
 
-// Define components for a watcher to detect when the webapp is changed so we can reload in Dev mode.
+/**
+ * Reload watcher configuration and state management
+ * Prevents infinite reload loops and implements rate limiting
+ * 
+ * @author Matthew Raymer
+ */
+const RELOAD_CONFIG = {
+  DEBOUNCE_MS: 1500,
+  COOLDOWN_MS: 5000,
+  MAX_RELOADS_PER_MINUTE: 10,
+  MAX_RELOADS_PER_SESSION: 100
+};
+
 const reloadWatcher = {
-  debouncer: null,
+  debouncer: null as NodeJS.Timeout | null,
   ready: false,
-  watcher: null,
+  watcher: null as chokidar.FSWatcher | null,
+  lastReloadTime: 0,
+  reloadCount: 0,
+  sessionReloadCount: 0,
+  resetTimeout: null as NodeJS.Timeout | null,
+  isReloading: false
 };
+
+/**
+ * Resets the reload counter after one minute
+ */
+const resetReloadCounter = () => {
+  reloadWatcher.reloadCount = 0;
+  reloadWatcher.resetTimeout = null;
+};
+
+/**
+ * Checks if a reload is allowed based on rate limits and cooldown
+ * @returns {boolean} Whether a reload is allowed
+ */
+const canReload = (): boolean => {
+  const now = Date.now();
+  
+  // Check cooldown period
+  if (now - reloadWatcher.lastReloadTime < RELOAD_CONFIG.COOLDOWN_MS) {
+    console.warn('[Reload Watcher] Skipping reload - cooldown period active');
+    return false;
+  }
+  
+  // Check per-minute limit
+  if (reloadWatcher.reloadCount >= RELOAD_CONFIG.MAX_RELOADS_PER_MINUTE) {
+    console.warn('[Reload Watcher] Skipping reload - maximum reloads per minute reached');
+    return false;
+  }
+  
+  // Check session limit
+  if (reloadWatcher.sessionReloadCount >= RELOAD_CONFIG.MAX_RELOADS_PER_SESSION) {
+    console.error('[Reload Watcher] Maximum reloads per session reached. Please restart the application.');
+    return false;
+  }
+  
+  return true;
+};
+
+/**
+ * Cleans up the current watcher instance
+ */
+const cleanupWatcher = () => {
+  if (reloadWatcher.watcher) {
+    reloadWatcher.watcher.close();
+    reloadWatcher.watcher = null;
+  }
+  if (reloadWatcher.debouncer) {
+    clearTimeout(reloadWatcher.debouncer);
+    reloadWatcher.debouncer = null;
+  }
+  if (reloadWatcher.resetTimeout) {
+    clearTimeout(reloadWatcher.resetTimeout);
+    reloadWatcher.resetTimeout = null;
+  }
+};
+
+/**
+ * Sets up the file watcher for development mode reloading
+ * Implements rate limiting and prevents infinite reload loops
+ * 
+ * @param electronCapacitorApp - The Electron Capacitor app instance
+ */
 export function setupReloadWatcher(electronCapacitorApp: ElectronCapacitorApp): void {
+  // Cleanup any existing watcher
+  cleanupWatcher();
+  
+  // Reset state
+  reloadWatcher.ready = false;
+  reloadWatcher.isReloading = false;
+  
   reloadWatcher.watcher = chokidar
     .watch(join(app.getAppPath(), 'app'), {
       ignored: /[/\\]\./,
       persistent: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 1000,
+        pollInterval: 100
+      }
     })
     .on('ready', () => {
       reloadWatcher.ready = true;
+      console.log('[Reload Watcher] Ready to watch for changes');
     })
     .on('all', (_event, _path) => {
-      if (reloadWatcher.ready) {
+      if (!reloadWatcher.ready || reloadWatcher.isReloading) {
+        return;
+      }
+      
+      // Clear existing debouncer
+      if (reloadWatcher.debouncer) {
         clearTimeout(reloadWatcher.debouncer);
-        reloadWatcher.debouncer = setTimeout(async () => {
+      }
-          electronCapacitorApp.getMainWindow().webContents.reload();
+      
+      // Set up new debouncer
+      reloadWatcher.debouncer = setTimeout(async () => {
+        if (!canReload()) {
+          return;
+        }
+        
+        try {
+          reloadWatcher.isReloading = true;
+          
+          // Update reload counters
+          reloadWatcher.lastReloadTime = Date.now();
+          reloadWatcher.reloadCount++;
+          reloadWatcher.sessionReloadCount++;
+          
+          // Set up reset timeout for per-minute counter
+          if (!reloadWatcher.resetTimeout) {
+            reloadWatcher.resetTimeout = setTimeout(resetReloadCounter, 60000);
+          }
+          
+          // Perform reload
+          console.log('[Reload Watcher] Reloading window...');
+          await electronCapacitorApp.getMainWindow().webContents.reload();
+          
+          // Reset state after reload
           reloadWatcher.ready = false;
-          clearTimeout(reloadWatcher.debouncer);
+          reloadWatcher.isReloading = false;
-          reloadWatcher.debouncer = null;
+          
-          reloadWatcher.watcher = null;
+          // Re-setup watcher after successful reload
           setupReloadWatcher(electronCapacitorApp);
-        }, 1500);
+          
-      }
+        } catch (error) {
+          console.error('[Reload Watcher] Error during reload:', error);
+          reloadWatcher.isReloading = false;
+          reloadWatcher.ready = true;
+        }
+      }, RELOAD_CONFIG.DEBOUNCE_MS);
+    })
+    .on('error', (error) => {
+      console.error('[Reload Watcher] Error:', error);
+      cleanupWatcher();
     });
 }
 

src/main.electron.ts

@@ -15,58 +15,100 @@ if (pwa_enabled) {
 // Initialize app and SQLite
 const app = initializeApp();
 
+/**
+ * SQLite initialization configuration
+ * Defines timeouts and retry settings for database operations
+ * 
+ * @author Matthew Raymer
+ */
+const SQLITE_CONFIG = {
+  INITIALIZATION: {
+    TIMEOUT_MS: 10000,  // 10 seconds for initial setup
+    RETRY_ATTEMPTS: 3,
+    RETRY_DELAY_MS: 1000
+  },
+  OPERATIONS: {
+    TIMEOUT_MS: 5000,   // 5 seconds for regular operations
+    RETRY_ATTEMPTS: 2,
+    RETRY_DELAY_MS: 500
+  },
+  CONNECTION: {
+    MAX_CONNECTIONS: 5,
+    IDLE_TIMEOUT_MS: 30000
+  }
+};
+
 // Create a promise that resolves when SQLite is ready
 const sqliteReady = new Promise<void>((resolve, reject) => {
-  // Set a timeout to prevent hanging
+  let retryCount = 0;
-  const timeout = setTimeout(() => {
+  let initializationTimeout: NodeJS.Timeout;
-    logger.error("[Main Electron] SQLite initialization timeout");
+  
-    reject(new Error("SQLite initialization timeout"));
+  const attemptInitialization = () => {
-  }, 30000); // 30 second timeout
+    // Clear any existing timeout
+    if (initializationTimeout) {
+      clearTimeout(initializationTimeout);
+    }
     
-  // Wait for electron bridge to be available
+    // Set timeout for this attempt
-  const checkElectronBridge = () => {
+    initializationTimeout = setTimeout(() => {
-    if (window.electron?.ipcRenderer) {
+      if (retryCount < SQLITE_CONFIG.INITIALIZATION.RETRY_ATTEMPTS) {
-      logger.info("[Main Electron] IPC renderer bridge available");
+        retryCount++;
+        logger.warn(`[Main Electron] SQLite initialization attempt ${retryCount} timed out, retrying...`);
+        setTimeout(attemptInitialization, SQLITE_CONFIG.INITIALIZATION.RETRY_DELAY_MS);
+      } else {
+        logger.error("[Main Electron] SQLite initialization failed after all retries");
+        reject(new Error("SQLite initialization timeout after all retries"));
+      }
+    }, SQLITE_CONFIG.INITIALIZATION.TIMEOUT_MS);
 
-      // Listen for SQLite ready signal
+    // Wait for electron bridge to be available
-      window.electron.ipcRenderer.once('sqlite-ready', () => {
+    const checkElectronBridge = () => {
-        clearTimeout(timeout);
+      if (window.electron?.ipcRenderer) {
-        logger.info("[Main Electron] Received SQLite ready signal");
+        logger.info("[Main Electron] IPC renderer bridge available");
-        resolve();
-      });
         
-      // Also listen for database errors
+        // Listen for SQLite ready signal
-      window.electron.ipcRenderer.once('database-status', (...args: unknown[]) => {
+        window.electron.ipcRenderer.once('sqlite-ready', () => {
-        clearTimeout(timeout);
+          clearTimeout(initializationTimeout);
-        const status = args[0] as { status: string; error?: string };
+          logger.info("[Main Electron] Received SQLite ready signal");
-        if (status.status === 'error') {
+          resolve();
-          logger.error("[Main Electron] Database error:", status.error);
+        });
-          reject(new Error(status.error || 'Database initialization failed'));
-        }
-      });
 
-      // Check if SQLite is already available
+        // Also listen for database errors
-      window.electron.ipcRenderer.invoke('sqlite-is-available')
+        window.electron.ipcRenderer.once('database-status', (...args: unknown[]) => {
-        .then((result: unknown) => {
+          clearTimeout(initializationTimeout);
-          const isAvailable = Boolean(result);
+          const status = args[0] as { status: string; error?: string };
-          if (isAvailable) {
+          if (status.status === 'error') {
-            logger.info("[Main Electron] SQLite is already available");
+            logger.error("[Main Electron] Database error:", status.error);
-            // Don't resolve here - wait for the ready signal
+            reject(new Error(status.error || 'Database initialization failed'));
-            // This prevents race conditions where the ready signal arrives after this check
           }
-        })
-        .catch((error: Error) => {
-          logger.error("[Main Electron] Failed to check SQLite availability:", error);
-          // Don't reject here - wait for either ready signal or timeout
         });
-    } else {
+
-      // Check again in 100ms if bridge isn't ready
+        // Check if SQLite is already available
-      setTimeout(checkElectronBridge, 100);
+        window.electron.ipcRenderer.invoke('sqlite-is-available')
-    }
+          .then((result: unknown) => {
+            const isAvailable = Boolean(result);
+            if (isAvailable) {
+              logger.info("[Main Electron] SQLite is already available");
+              // Don't resolve here - wait for the ready signal
+              // This prevents race conditions where the ready signal arrives after this check
+            }
+          })
+          .catch((error: Error) => {
+            logger.error("[Main Electron] Failed to check SQLite availability:", error);
+            // Don't reject here - wait for either ready signal or timeout
+          });
+      } else {
+        // Check again in 100ms if bridge isn't ready
+        setTimeout(checkElectronBridge, 100);
+      }
+    };
+
+    // Start checking for bridge
+    checkElectronBridge();
   };
 
-  // Start checking for bridge
+  // Start first initialization attempt
-  checkElectronBridge();
+  attemptInitialization();
 });
 
 // Wait for SQLite to be ready before mounting