trent_larson
/
crowd-funder-for-time-pwa
4
1
Fork 2
Code Pull Requests 11 Releases 5 Wiki Activity
Browse Source

refactor(electron): WIP - use window.CapacitorSQLite API for all DB ops in ElectronPlatformService 

- Remove connection object and connection pool logic
- Call all database methods directly on window.CapacitorSQLite with db name
- Refactor migrations, queries, and exec to match Capacitor SQLite Electron API
- Ensure preload script exposes both window.electron and window.CapacitorSQLite
- Fixes runtime errors related to missing query/run methods on connection
- Improves security and cross-platform compatibility

Co-authored-by: Matthew Raymer
pull/136/head
Matthew Raymer 5 days ago
parent
1e63ddcb6e
commit
66929d9b14
8 changed files with 367 additions and 350 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 79
      electron/src/index.ts
  2. 25
      electron/src/preload.ts
  3. 148
      src/electron/main.ts
  4. 41
      src/electron/preload.js
  5. 90
      src/main.electron.ts
  6. 21
      src/services/PlatformService.ts
  7. 286
      src/services/platforms/ElectronPlatformService.ts
  8. 27
      src/types/electron.d.ts

79
electron/src/index.ts
View File

@ -40,52 +40,71 @@ if (electronIsDev) {
// Run Application
(async () => {
try {
// Wait for electron app to be ready.
await app.whenReady();
// Wait for electron app to be ready.
await app.whenReady();
// Security - Set Content-Security-Policy based on whether or not we are in dev mode.
setupContentSecurityPolicy(myCapacitorApp.getCustomURLScheme());
// Security - Set Content-Security-Policy based on whether or not we are in dev mode.
setupContentSecurityPolicy(myCapacitorApp.getCustomURLScheme());
// Initialize SQLite and register handlers BEFORE app initialization
console.log('[Main] Starting SQLite initialization...');
// Initialize our app, build windows, and load content first
console.log('[Electron Main Process] Starting app initialization...');
await myCapacitorApp.init();
console.log('[Electron Main Process] App initialization complete');
// Get the main window and wait for it to be ready
const mainWindow = myCapacitorApp.getMainWindow();
if (!mainWindow) {
throw new Error('Main window not available after app initialization');
}
// Wait for window to be ready
await new Promise<void>((resolve) => {
if (mainWindow.isVisible()) {
resolve();
} else {
mainWindow.once('show', () => resolve());
}
});
// Now initialize SQLite after window is ready
console.log('[Electron Main Process] Starting SQLite initialization...');
try {
// Register handlers first to prevent "no handler" errors
setupSQLiteHandlers();
console.log('[Main] SQLite handlers registered');
console.log('[Electron Main Process] SQLite handlers registered');
// Then initialize the plugin
await initializeSQLite();
console.log('[Main] SQLite plugin initialized successfully');
console.log('[Electron Main Process] SQLite plugin initialized successfully');
// Send SQLite ready signal since window is ready
if (!mainWindow.isDestroyed()) {
mainWindow.webContents.send('sqlite-ready');
console.log('[Electron Main Process] Sent SQLite ready signal to renderer');
} else {
console.warn('[Electron Main Process] Could not send SQLite ready signal - window was destroyed');
}
} catch (error) {
console.error('[Main] Failed to initialize SQLite:', error);
console.error('[Electron Main Process] Failed to initialize SQLite:', error);
// Notify renderer about database status
if (!mainWindow.isDestroyed()) {
mainWindow.webContents.send('database-status', {
status: 'error',
error: error instanceof Error ? error.message : 'Unknown error'
});
}
// Don't proceed with app initialization if SQLite fails
throw new Error(`SQLite initialization failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
}
// Initialize our app, build windows, and load content.
console.log('[Main] Starting app initialization...');
await myCapacitorApp.init();
console.log('[Main] App initialization complete');
// Check for updates if we are in a packaged app.
// Check for updates if we are in a packaged app.
if (!electronIsDev) {
console.log('[Main] Checking for updates...');
autoUpdater.checkForUpdatesAndNotify();
console.log('[Electron Main Process] Checking for updates...');
autoUpdater.checkForUpdatesAndNotify();
}
} catch (error) {
console.error('[Main] Fatal error during app initialization:', error);
// Ensure we notify the user before quitting
const mainWindow = myCapacitorApp.getMainWindow();
if (mainWindow && !mainWindow.isDestroyed()) {
mainWindow.webContents.send('app-error', {
type: 'initialization',
error: error instanceof Error ? error.message : 'Unknown error'
});
// Give the window time to show the error
setTimeout(() => app.quit(), 5000);
} else {
app.quit();
}
console.error('[Electron Main Process] Fatal error during initialization:', error);
app.quit();
}
})();

25
electron/src/preload.ts
View File

@ -41,12 +41,12 @@ const createSQLiteProxy = () => {
} catch (error) {
lastError = error instanceof Error ? error : new Error(String(error));
if (attempt < MAX_RETRIES) {
logger.warn(`SQLite operation failed (attempt ${attempt}/${MAX_RETRIES}), retrying...`, error);
logger.warn(`[CapacitorSQLite] SQLite operation failed (attempt ${attempt}/${MAX_RETRIES}), retrying...`, error);
await new Promise(resolve => setTimeout(resolve, RETRY_DELAY));
}
}
}
throw new Error(`SQLite operation failed after ${MAX_RETRIES} attempts: ${lastError?.message || 'Unknown error'}`);
throw new Error(`[CapacitorSQLite] SQLite operation failed after ${MAX_RETRIES} attempts: ${lastError?.message || 'Unknown error'}`);
};
const wrapOperation = (method: string) => {
@ -65,8 +65,8 @@ const createSQLiteProxy = () => {
}
return await withRetry(ipcRenderer.invoke, 'sqlite-' + method, ...args);
} catch (error) {
logger.error(`SQLite ${method} failed:`, error);
throw new Error(`Database operation failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
logger.error(`[CapacitorSQLite] SQLite ${method} failed:`, error);
throw new Error(`[CapacitorSQLite] Database operation failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
}
};
};
@ -85,13 +85,24 @@ const createSQLiteProxy = () => {
};
};
// Expose only the CapacitorSQLite proxy
// Expose the Electron IPC API
contextBridge.exposeInMainWorld('electron', {
ipcRenderer: {
on: (channel: string, func: (...args: unknown[]) => void) => ipcRenderer.on(channel, (event, ...args) => func(...args)),
once: (channel: string, func: (...args: unknown[]) => void) => ipcRenderer.once(channel, (event, ...args) => func(...args)),
send: (channel: string, data: unknown) => ipcRenderer.send(channel, data),
invoke: (channel: string, ...args: unknown[]) => ipcRenderer.invoke(channel, ...args),
},
// Add other APIs as needed
});
// Expose CapacitorSQLite proxy as before
contextBridge.exposeInMainWorld('CapacitorSQLite', createSQLiteProxy());
// Log startup
logger.log('Script starting...');
logger.log('[CapacitorSQLite] Preload script starting...');
// Handle window load
window.addEventListener('load', () => {
logger.log('Script complete');
logger.log('[CapacitorSQLite] Preload script complete');
});

148
src/electron/main.ts
View File

@ -83,20 +83,20 @@ const getAppDataPath = async (): Promise<string> => {
if (linuxPath) {
// Expand ~ to home directory
const expandedPath = linuxPath.replace(/^~/, process.env.HOME || "");
logger.info("[Electron] Using configured database path:", expandedPath);
logger.info("[Electron Main] Using configured database path:", expandedPath);
return expandedPath;
}
// Fallback to app.getPath if config path is not available
const userDataPath = app.getPath("userData");
logger.info("[Electron] Using fallback user data path:", userDataPath);
logger.info("[Electron Main] Using fallback user data path:", userDataPath);
return userDataPath;
} catch (error) {
logger.error("[Electron] Error getting app data path:", error);
logger.error("[Electron Main] Error getting app data path:", error);
// Fallback to app.getPath if anything fails
const userDataPath = app.getPath("userData");
logger.info(
"[Electron] Using fallback user data path after error:",
"[Electron Main] Using fallback user data path after error:",
userDataPath,
);
return userDataPath;
@ -123,7 +123,7 @@ const validateAndNormalizePath = async (filePath: string): Promise<string> => {
// Normalize the path
const normalizedPath = path.normalize(resolvedPath);
logger.info("[Electron] Validated database path:", {
logger.info("[Electron Main] Validated database path:", {
original: filePath,
resolved: resolvedPath,
normalized: normalizedPath,
@ -142,7 +142,7 @@ const ensureDirectoryExists = async (dirPath: string): Promise<void> => {
// Check if directory exists
if (!fs.existsSync(normalizedPath)) {
logger.info("[Electron] Creating database directory:", normalizedPath);
logger.info("[Electron Main] Creating database directory:", normalizedPath);
await fs.promises.mkdir(normalizedPath, { recursive: true });
}
@ -153,11 +153,11 @@ const ensureDirectoryExists = async (dirPath: string): Promise<void> => {
fs.constants.R_OK | fs.constants.W_OK,
);
logger.info(
"[Electron] Database directory permissions verified:",
"[Electron Main] Database directory permissions verified:",
normalizedPath,
);
} catch (error) {
logger.error("[Electron] Database directory permission error:", error);
logger.error("[Electron Main] Database directory permission error:", error);
throw new Error(`Database directory not accessible: ${normalizedPath}`);
}
@ -167,16 +167,16 @@ const ensureDirectoryExists = async (dirPath: string): Promise<void> => {
await fs.promises.writeFile(testFile, "test");
await fs.promises.unlink(testFile);
logger.info(
"[Electron] Database directory write test passed:",
"[Electron Main] Database directory write test passed:",
normalizedPath,
);
} catch (error) {
logger.error("[Electron] Database directory write test failed:", error);
logger.error("[Electron Main] Database directory write test failed:", error);
throw new Error(`Database directory not writable: ${normalizedPath}`);
}
} catch (error) {
logger.error(
"[Electron] Failed to ensure database directory exists:",
"[Electron Main] Failed to ensure database directory exists:",
error,
);
throw error;
@ -203,7 +203,7 @@ const initializeDatabasePaths = async (): Promise<void> => {
try {
// Get the base directory from config
dbDir = await getAppDataPath();
logger.info("[Electron] Database directory:", dbDir);
logger.info("[Electron Main] Database directory:", dbDir);
// Ensure the directory exists and is writable
await ensureDirectoryExists(dbDir);
@ -212,7 +212,7 @@ const initializeDatabasePaths = async (): Promise<void> => {
dbPath = await validateAndNormalizePath(
path.join(dbDir, "timesafari.db"),
);
logger.info("[Electron] Database path initialized:", dbPath);
logger.info("[Electron Main] Database path initialized:", dbPath);
// Verify the database file if it exists
if (fs.existsSync(dbPath)) {
@ -222,18 +222,18 @@ const initializeDatabasePaths = async (): Promise<void> => {
fs.constants.R_OK | fs.constants.W_OK,
);
logger.info(
"[Electron] Existing database file permissions verified:",
"[Electron Main] Existing database file permissions verified:",
dbPath,
);
} catch (error) {
logger.error("[Electron] Database file permission error:", error);
logger.error("[Electron Main] Database file permission error:", error);
throw new Error(`Database file not accessible: ${dbPath}`);
}
}
dbPathInitialized = true;
} catch (error) {
logger.error("[Electron] Failed to initialize database paths:", error);
logger.error("[Electron Main] Failed to initialize database paths:", error);
throw error;
} finally {
dbPathInitializationPromise = null;
@ -260,7 +260,7 @@ async function initializeSQLite() {
sqliteInitializationPromise = (async () => {
try {
logger.info("[Electron] Initializing SQLite plugin...");
logger.info("[Electron Main] Initializing SQLite plugin...");
sqlitePlugin = new CapacitorSQLite();
// Initialize database paths first
@ -272,7 +272,7 @@ async function initializeSQLite() {
// Test the plugin
const echoResult = await sqlitePlugin.echo({ value: "test" });
logger.info("[Electron] SQLite plugin echo test:", echoResult);
logger.info("[Electron Main] SQLite plugin echo test:", echoResult);
// Initialize database connection using validated dbPath
const connectionOptions = {
@ -285,14 +285,14 @@ async function initializeSQLite() {
};
logger.info(
"[Electron] Creating initial connection with options:",
"[Electron Main] Creating initial connection with options:",
connectionOptions,
);
// Log the actual path being used
logger.info("[Electron] Using database path:", dbPath);
logger.info("[Electron] Path exists:", fs.existsSync(dbPath));
logger.info("[Electron] Path is absolute:", path.isAbsolute(dbPath));
logger.info("[Electron Main] Using database path:", dbPath);
logger.info("[Electron Main] Path exists:", fs.existsSync(dbPath));
logger.info("[Electron Main] Path is absolute:", path.isAbsolute(dbPath));
const db = await sqlitePlugin.createConnection(connectionOptions);
@ -308,19 +308,19 @@ async function initializeSQLite() {
// Verify the connection is working
try {
const result = await db.query("PRAGMA journal_mode;");
logger.info("[Electron] Database connection verified:", result);
logger.info("[Electron Main] Database connection verified:", result);
} catch (error) {
logger.error(
"[Electron] Database connection verification failed:",
"[Electron Main] Database connection verification failed:",
error,
);
throw error;
}
sqliteInitialized = true;
logger.info("[Electron] SQLite plugin initialized successfully");
logger.info("[Electron Main] SQLite plugin initialized successfully");
} catch (error) {
logger.error("[Electron] Failed to initialize SQLite plugin:", error);
logger.error("[Electron Main] Failed to initialize SQLite plugin:", error);
throw error;
} finally {
sqliteInitializationPromise = null;
@ -337,33 +337,53 @@ app.whenReady().then(async () => {
// Create window first
const mainWindow = createWindow();
// Initialize database in background
initializeSQLite().catch((error) => {
// Wait for window to be ready
await new Promise<void>((resolve) => {
mainWindow.once('ready-to-show', () => {
logger.info("[Electron Main] Window ready to show");
mainWindow.show();
resolve();
});
});
// Initialize database after window is ready
try {
await initializeSQLite();
logger.info("[Electron Main] SQLite plugin initialized successfully");
// Now send the ready signal since window is ready
if (!mainWindow.isDestroyed()) {
mainWindow.webContents.send('sqlite-ready');
logger.info("[Electron Main] Sent SQLite ready signal to renderer");
} else {
logger.error("[Electron Main] Window was destroyed before sending SQLite ready signal");
}
} catch (error) {
logger.error(
"[Electron] Database initialization failed, but continuing:",
"[Electron Main] Database initialization failed:",
error,
);
// Notify renderer about database status
if (!mainWindow.isDestroyed()) {
mainWindow.webContents.send("database-status", {
status: "error",
error: error.message,
error: error instanceof Error ? error.message : 'Unknown error',
});
}
});
}
// Handle window close
mainWindow.on("closed", () => {
logger.info("[Electron] Main window closed");
logger.info("[Electron Main] Main window closed");
});
// Handle window close request
mainWindow.on("close", (event) => {
logger.info("[Electron] Window close requested");
logger.info("[Electron Main] Window close requested");
// Prevent immediate close if we're in the middle of something
if (mainWindow.webContents.isLoading()) {
event.preventDefault();
logger.info("[Electron] Deferring window close due to loading state");
logger.info("[Electron Main] Deferring window close due to loading state");
mainWindow.webContents.once("did-finish-load", () => {
mainWindow.close();
});
@ -380,15 +400,15 @@ function createWindow(): BrowserWindow {
? path.join(process.resourcesPath, "preload.js")
: path.join(__dirname, "preload.js");
logger.log("[Electron] Preload path:", preloadPath);
logger.log("[Electron] Preload exists:", fs.existsSync(preloadPath));
logger.log("[Electron Main] Preload path:", preloadPath);
logger.log("[Electron Main] Preload exists:", fs.existsSync(preloadPath));
// Log environment and paths
logger.log("[Electron] process.cwd():", process.cwd());
logger.log("[Electron] __dirname:", __dirname);
logger.log("[Electron] app.getAppPath():", app.getAppPath());
logger.log("[Electron] app.isPackaged:", app.isPackaged);
logger.log("[Electron] process.resourcesPath:", process.resourcesPath);
logger.log("[Electron Main] process.cwd():", process.cwd());
logger.log("[Electron Main] __dirname:", __dirname);
logger.log("[Electron Main] app.getAppPath():", app.getAppPath());
logger.log("[Electron Main] app.isPackaged:", app.isPackaged);
logger.log("[Electron Main] process.resourcesPath:", process.resourcesPath);
// List files in __dirname and __dirname/www
try {
@ -420,24 +440,24 @@ function createWindow(): BrowserWindow {
// Show window when ready
mainWindow.once("ready-to-show", () => {
logger.info("[Electron] Window ready to show");
logger.info("[Electron Main] Window ready to show");
mainWindow.show();
});
// Handle window errors
mainWindow.webContents.on("render-process-gone", (_event, details) => {
logger.error("[Electron] Render process gone:", details);
logger.error("[Electron Main] Render process gone:", details);
});
mainWindow.webContents.on(
"did-fail-load",
(_event, errorCode, errorDescription) => {
logger.error(
"[Electron] Page failed to load:",
"[Electron Main] Page failed to load:",
errorCode,
errorDescription,
);
logger.error("[Electron] Failed URL:", mainWindow.webContents.getURL());
logger.error("[Electron Main] Failed URL:", mainWindow.webContents.getURL());
},
);
@ -449,31 +469,31 @@ function createWindow(): BrowserWindow {
indexPath = path.join(process.resourcesPath, "www", "index.html");
fileUrl = `file://${indexPath}`;
logger.info(
"[Electron] App is packaged. Using process.resourcesPath for index.html",
"[Electron Main] App is packaged. Using process.resourcesPath for index.html",
);
} else {
indexPath = path.resolve(__dirname, "www", "index.html");
fileUrl = `file://${indexPath}`;
logger.info(
"[Electron] App is not packaged. Using __dirname for index.html",
"[Electron Main] App is not packaged. Using __dirname for index.html",
);
}
logger.info("[Electron] Resolved index.html path:", indexPath);
logger.info("[Electron] Using file URL:", fileUrl);
logger.info("[Electron Main] Resolved index.html path:", indexPath);
logger.info("[Electron Main] Using file URL:", fileUrl);
// Load the index.html with retry logic
const loadIndexHtml = async (retryCount = 0): Promise<void> => {
try {
if (mainWindow.isDestroyed()) {
logger.error(
"[Electron] Window was destroyed before loading index.html",
"[Electron Main] Window was destroyed before loading index.html",
);
return;
}
const exists = fs.existsSync(indexPath);
logger.info(`[Electron] fs.existsSync for index.html: ${exists}`);
logger.info(`[Electron Main] fs.existsSync for index.html: ${exists}`);
if (!exists) {
throw new Error(`index.html not found at path: ${indexPath}`);
@ -481,7 +501,7 @@ function createWindow(): BrowserWindow {
// Try to read the file to verify it's accessible
const stats = fs.statSync(indexPath);
logger.info("[Electron] index.html stats:", {
logger.info("[Electron Main] index.html stats:", {
size: stats.size,
mode: stats.mode,
uid: stats.uid,
@ -490,27 +510,27 @@ function createWindow(): BrowserWindow {
// Try loadURL first
try {
logger.info("[Electron] Attempting to load index.html via loadURL");
logger.info("[Electron Main] Attempting to load index.html via loadURL");
await mainWindow.loadURL(fileUrl);
logger.info("[Electron] Successfully loaded index.html via loadURL");
logger.info("[Electron Main] Successfully loaded index.html via loadURL");
} catch (loadUrlError) {
logger.warn(
"[Electron] loadURL failed, trying loadFile:",
"[Electron Main] loadURL failed, trying loadFile:",
loadUrlError,
);
// Fallback to loadFile
await mainWindow.loadFile(indexPath);
logger.info("[Electron] Successfully loaded index.html via loadFile");
logger.info("[Electron Main] Successfully loaded index.html via loadFile");
}
} catch (error: unknown) {
const errorMessage =
error instanceof Error ? error.message : "Unknown error occurred";
logger.error("[Electron] Error loading index.html:", errorMessage);
logger.error("[Electron Main] Error loading index.html:", errorMessage);
// Retry logic
if (retryCount < 3 && !mainWindow.isDestroyed()) {
logger.info(
`[Electron] Retrying index.html load (attempt ${retryCount + 1})`,
`[Electron Main] Retrying index.html load (attempt ${retryCount + 1})`,
);
await new Promise((resolve) => setTimeout(resolve, 1000)); // Wait 1 second
return loadIndexHtml(retryCount + 1);
@ -536,7 +556,7 @@ function createWindow(): BrowserWindow {
// Start loading the index.html
loadIndexHtml().catch((error: unknown) => {
logger.error("[Electron] Fatal error loading index.html:", error);
logger.error("[Electron Main] Fatal error loading index.html:", error);
});
// Only open DevTools if not in production
@ -607,7 +627,7 @@ ipcMain.handle("sqlite-create-connection", async (_event, options) => {
};
logger.info(
"[Electron] Creating database connection with options:",
"[Electron Main] Creating database connection with options:",
connectionOptions,
);
const result = await sqlitePlugin.createConnection(connectionOptions);
@ -628,19 +648,19 @@ ipcMain.handle("sqlite-create-connection", async (_event, options) => {
});
if (testResult?.values?.[0]?.journal_mode === "off") {
logger.error(
"[Electron] Connection opened in read-only mode despite options",
"[Electron Main] Connection opened in read-only mode despite options",
);
throw new Error("Database connection opened in read-only mode");
}
} catch (queryError) {
logger.error("[Electron] Error verifying connection:", queryError);
logger.error("[Electron Main] Error verifying connection:", queryError);
throw queryError;
}
logger.info("[Electron] Database connection created successfully");
logger.info("[Electron Main] Database connection created successfully");
return result;
} catch (error) {
logger.error("[Electron] Error in sqlite-create-connection:", error);
logger.error("[Electron Main] Error in sqlite-create-connection:", error);
throw error;
}
});

41
src/electron/preload.js
View File

@ -5,27 +5,27 @@ const logger = {
// Always log in development, log with context in production
if (process.env.NODE_ENV !== "production") {
/* eslint-disable no-console */
console.log(`[Preload] ${message}`, ...args);
console.log(`[Electron Preload] ${message}`, ...args);
/* eslint-enable no-console */
}
},
warn: (message, ...args) => {
// Always log warnings
/* eslint-disable no-console */
console.warn(`[Preload] ${message}`, ...args);
console.warn(`[Electron Preload] ${message}`, ...args);
/* eslint-enable no-console */
},
error: (message, ...args) => {
// Always log errors
/* eslint-disable no-console */
console.error(`[Preload] ${message}`, ...args);
console.error(`[Electron Preload] ${message}`, ...args);
/* eslint-enable no-console */
},
info: (message, ...args) => {
// Always log info in development, log with context in production
if (process.env.NODE_ENV !== "production") {
/* eslint-disable no-console */
console.info(`[Preload] ${message}`, ...args);
console.info(`[Electron Preload] ${message}`, ...args);
/* eslint-enable no-console */
}
},
@ -143,32 +143,33 @@ try {
};
// Expose only the CapacitorSQLite proxy
contextBridge.exposeInMainWorld("CapacitorSQLite", createSQLiteProxy());
// Remove the duplicate electron.sqlite bridge
contextBridge.exposeInMainWorld("electron", {
// Keep other electron APIs but remove sqlite
getPath,
sqlite: createSQLiteProxy(),
getPath: (pathType) => ipcRenderer.invoke("get-path", pathType),
send: (channel, data) => {
const validChannels = ["toMain"];
if (validChannels.includes(channel)) {
ipcRenderer.send(channel, data);
}
ipcRenderer.send(channel, data);
},
receive: (channel, func) => {
const validChannels = ["fromMain"];
if (validChannels.includes(channel)) {
ipcRenderer.on(channel, (event, ...args) => func(...args));
},
ipcRenderer: {
on: (channel, func) => {
ipcRenderer.on(channel, (event, ...args) => func(...args));
},
once: (channel, func) => {
ipcRenderer.once(channel, (event, ...args) => func(...args));
},
send: (channel, data) => {
ipcRenderer.send(channel, data);
},
invoke: (channel, ...args) => {
return ipcRenderer.invoke(channel, ...args);
}
},
env: {
isElectron: true,
isDev: process.env.NODE_ENV === "development",
platform: "electron",
},
getBasePath: () => {
return process.env.NODE_ENV === "development" ? "/" : "./";
},
getBasePath: () => ipcRenderer.invoke("get-base-path"),
});
logger.info("Preload script completed successfully");

90
src/main.electron.ts
View File

@ -1,75 +1,65 @@
import { initializeApp } from "./main.common";
import { logger } from "./utils/logger";
async function initializeSQLite() {
try {
// Wait for SQLite to be available in the main process
let retries = 0;
const maxRetries = 5;
const retryDelay = 1000; // 1 second
while (retries < maxRetries) {
try {
const isAvailable = await window.CapacitorSQLite.isAvailable();
if (isAvailable) {
logger.info(
"[Electron] SQLite plugin bridge initialized successfully",
);
return true;
}
} catch (error) {
logger.warn(
`[Electron] SQLite not available yet (attempt ${retries + 1}/${maxRetries}):`,
error,
);
}
retries++;
if (retries < maxRetries) {
await new Promise((resolve) => setTimeout(resolve, retryDelay));
}
}
throw new Error("SQLite plugin not available after maximum retries");
} catch (error) {
logger.error(
"[Electron] Failed to initialize SQLite plugin bridge:",
error,
);
throw error;
}
}
const platform = process.env.VITE_PLATFORM;
const pwa_enabled = process.env.VITE_PWA_ENABLED === "true";
logger.info("[Electron] Initializing app");
logger.info("[Electron] Platform:", { platform });
logger.info("[Electron] PWA enabled:", { pwa_enabled });
logger.info("[Main Electron] Initializing app");
logger.info("[Main Electron] Platform:", { platform });
logger.info("[Main Electron] PWA enabled:", { pwa_enabled });
if (pwa_enabled) {
logger.warn("[Electron] PWA is enabled, but not supported in electron");
logger.warn("[Main Electron] PWA is enabled, but not supported in electron");
}
// Initialize app and SQLite
const app = initializeApp();
// Initialize SQLite first, then mount the app
initializeSQLite()
// Create a promise that resolves when SQLite is ready
const sqliteReady = new Promise<void>((resolve, reject) => {
if (!window.electron?.ipcRenderer) {
logger.error("[Main Electron] IPC renderer not available");
reject(new Error("IPC renderer not available"));
return;
}
// Set a timeout to prevent hanging
const timeout = setTimeout(() => {
reject(new Error("SQLite initialization timeout"));
}, 30000); // 30 second timeout
window.electron.ipcRenderer.once('sqlite-ready', () => {
clearTimeout(timeout);
logger.info("[Main Electron] Received SQLite ready signal");
resolve();
});
// Also listen for database errors
window.electron.ipcRenderer.once('database-status', (...args: unknown[]) => {
clearTimeout(timeout);
const status = args[0] as { status: string; error?: string };
if (status.status === 'error') {
reject(new Error(status.error || 'Database initialization failed'));
}
});
});
// Wait for SQLite to be ready before mounting
sqliteReady
.then(() => {
logger.info("[Electron] SQLite initialized, mounting app...");
logger.info("[Main Electron] SQLite ready, mounting app...");
app.mount("#app");
})
.catch((error) => {
logger.error("[Electron] Failed to initialize app:", error);
logger.error("[Main Electron] Failed to initialize SQLite:", error instanceof Error ? error.message : 'Unknown error');
// Show error to user
const errorDiv = document.createElement("div");
errorDiv.style.cssText =
"position: fixed; top: 50%; left: 50%; transform: translate(-50%, -50%); background: #ffebee; color: #c62828; padding: 20px; border-radius: 4px; text-align: center; max-width: 80%;";
errorDiv.innerHTML = `
<h2>Failed to Initialize Database</h2>
<p>There was an error initializing the database. Please try restarting the application.</p>
<p>Error details: ${error.message}</p>
<h2>Failed to Initialize Application</h2>
<p>There was an error initializing the database. Please try restarting.</p>
<p>Error details: ${error instanceof Error ? error.message : 'Unknown error'}</p>
`;
document.body.appendChild(errorDiv);
});

21
src/services/PlatformService.ts
View File

@ -1,5 +1,13 @@
import { QueryExecResult } from "@/interfaces/database";
/**
* Query execution result interface
*/
export interface QueryExecResult<T = unknown> {
columns: string[];
values: T[];
}
/**
* Represents the result of an image capture or selection operation.
* Contains both the image data as a Blob and the associated filename.
@ -102,15 +110,12 @@ export interface PlatformService {
handleDeepLink(url: string): Promise<void>;
/**
* Executes a SQL query on the database.
* @param sql - The SQL query to execute
* @param params - The parameters to pass to the query
* @returns Promise resolving to the query result
* Execute a database query and return the results
* @param sql SQL query to execute
* @param params Query parameters
* @returns Query results with columns and values
*/
dbQuery(
sql: string,
params?: unknown[],
): Promise<QueryExecResult | undefined>;
dbQuery<T = unknown>(sql: string, params?: unknown[]): Promise<QueryExecResult<T>>;
/**
* Executes a create/update/delete on the database.

286
src/services/platforms/ElectronPlatformService.ts
View File

@ -2,13 +2,37 @@ import {
ImageResult,
PlatformService,
PlatformCapabilities,
QueryExecResult,
} from "../PlatformService";
import { logger } from "../../utils/logger";
import { QueryExecResult } from "@/interfaces/database";
import { SQLiteDBConnection } from "@capacitor-community/sqlite";
import { DEFAULT_ENDORSER_API_SERVER } from "@/constants/app";
import { DatabaseConnectionPool } from "../database/ConnectionPool";
// Type for the electron window object
declare global {
interface Window {
electron: {
ipcRenderer?: {
on: (channel: string, func: (...args: unknown[]) => void) => void;
once: (channel: string, func: (...args: unknown[]) => void) => void;
send: (channel: string, data: unknown) => void;
invoke: (channel: string, ...args: unknown[]) => Promise<unknown>;
};
sqlite: {
isAvailable: () => Promise<boolean>;
execute: (method: string, ...args: unknown[]) => Promise<unknown>;
};
getPath: (pathType: string) => Promise<string>;
send: (channel: string, data: unknown) => void;
receive: (channel: string, func: (...args: unknown[]) => void) => void;
env: {
platform: string;
};
getBasePath: () => Promise<string>;
};
}
}
interface Migration {
name: string;
sql: string;
@ -24,121 +48,78 @@ interface Migration {
*/
export class ElectronPlatformService implements PlatformService {
private sqlite: any;
private connection: SQLiteDBConnection | null = null;
private connectionPool: DatabaseConnectionPool;
private initializationPromise: Promise<void> | null = null;
private dbName = "timesafari";
private isInitialized = false;
private dbFatalError = false;
private sqliteReadyPromise: Promise<void> | null = null;
constructor() {
this.connectionPool = DatabaseConnectionPool.getInstance();
if (!window.CapacitorSQLite) {
throw new Error("CapacitorSQLite not initialized in Electron");
}
this.sqlite = window.CapacitorSQLite;
this.sqliteReadyPromise = new Promise<void>((resolve, reject) => {
if (!window.electron?.ipcRenderer) {
logger.warn('[ElectronPlatformService] IPC renderer not available');
reject(new Error('IPC renderer not available'));
return;
}
const timeout = setTimeout(() => {
reject(new Error('SQLite initialization timeout'));
}, 30000);
window.electron.ipcRenderer.once('sqlite-ready', () => {
clearTimeout(timeout);
logger.info('[ElectronPlatformService] Received SQLite ready signal');
this.isInitialized = true;
resolve();
});
window.electron.ipcRenderer.once('database-status', (...args: unknown[]) => {
clearTimeout(timeout);
const status = args[0] as { status: string; error?: string };
if (status.status === 'error') {
this.dbFatalError = true;
reject(new Error(status.error || 'Database initialization failed'));
}
});
});
}
private async initializeDatabase(): Promise<void> {
// If we already have a connection, return immediately
if (this.connection) {
return;
}
// If initialization is in progress, wait for it
if (this.initializationPromise) {
return this.initializationPromise;
}
// Start initialization
this.initializationPromise = (async () => {
try {
if (!this.sqlite) {
logger.debug("[ElectronPlatformService] SQLite plugin not available, checking...");
this.sqlite = await import("@capacitor-community/sqlite");
}
if (!this.sqlite) {
throw new Error("SQLite plugin not available");
}
// Get connection from pool
this.connection = await this.connectionPool.getConnection("timesafari", async () => {
// Create the connection
const connection = await this.sqlite.createConnection({
database: "timesafari",
encrypted: false,
mode: "no-encryption",
readonly: false,
});
// Wait for the connection to be fully initialized
await new Promise<void>((resolve, reject) => {
const checkConnection = async () => {
try {
// Try a simple query to verify the connection is ready
const result = await connection.query("SELECT 1");
if (result && result.values) {
resolve();
} else {
reject(new Error("Connection query returned invalid result"));
}
} catch (error) {
// If the error is that query is not a function, the connection isn't ready yet
if (error instanceof Error && error.message.includes("query is not a function")) {
setTimeout(checkConnection, 100);
} else {
reject(error);
}
}
};
checkConnection();
});
// Verify write access
const result = await connection.query("PRAGMA journal_mode");
const journalMode = result.values?.[0]?.journal_mode;
if (journalMode !== "wal") {
throw new Error(`Database is not writable. Journal mode: ${journalMode}`);
}
return connection;
});
// Run migrations if needed
await this.runMigrations();
logger.info("[ElectronPlatformService] Database initialized successfully");
} catch (error) {
logger.error("[ElectronPlatformService] Database initialization failed:", error);
this.connection = null;
throw error;
} finally {
this.initializationPromise = null;
}
})();
return this.initializationPromise;
if (this.isInitialized) return;
if (this.sqliteReadyPromise) await this.sqliteReadyPromise;
this.sqlite = window.CapacitorSQLite;
if (!this.sqlite) throw new Error("CapacitorSQLite not available");
// Create the connection (idempotent)
await this.sqlite.createConnection({
database: this.dbName,
encrypted: false,
mode: "no-encryption",
readOnly: false,
});
// Optionally, test the connection
await this.sqlite.query({
database: this.dbName,
statement: "SELECT 1"
});
// Run migrations if needed
await this.runMigrations();
logger.info("[ElectronPlatformService] Database initialized successfully");
}
private async runMigrations(): Promise<void> {
if (!this.connection) {
throw new Error("Database not initialized");
}
// Create migrations table if it doesn't exist
await this.connection.execute(`
CREATE TABLE IF NOT EXISTS migrations (
await this.sqlite.execute({
database: this.dbName,
statements: `CREATE TABLE IF NOT EXISTS migrations (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL UNIQUE,
executed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
`);
);`
});
// Get list of executed migrations
const result = await this.connection.query("SELECT name FROM migrations;");
const result = await this.sqlite.query({
database: this.dbName,
statement: "SELECT name FROM migrations;"
});
const executedMigrations = new Set(
result.values?.map((row) => row[0]) || [],
(result.values as unknown[][])?.map((row: unknown[]) => row[0] as string) || []
);
// Run pending migrations in order
const migrations: Migration[] = [
{
@ -226,13 +207,17 @@ export class ElectronPlatformService implements PlatformService {
`,
},
];
for (const migration of migrations) {
if (!executedMigrations.has(migration.name)) {
await this.connection.execute(migration.sql);
await this.connection.run("INSERT INTO migrations (name) VALUES (?)", [
migration.name,
]);
await this.sqlite.execute({
database: this.dbName,
statements: migration.sql
});
await this.sqlite.run({
database: this.dbName,
statement: "INSERT INTO migrations (name) VALUES (?)",
values: [migration.name]
});
logger.log(`Migration ${migration.name} executed successfully`);
}
}
@ -343,43 +328,32 @@ export class ElectronPlatformService implements PlatformService {
/**
* @see PlatformService.dbQuery
*/
async dbQuery(
sql: string,
params?: unknown[],
): Promise<QueryExecResult | undefined> {
if (this.dbFatalError) {
throw new Error("Database is in a fatal error state. Please restart the app.");
}
async dbQuery<T = unknown>(sql: string, params: unknown[] = []): Promise<QueryExecResult<T>> {
await this.initializeDatabase();
if (!this.connection) {
throw new Error("Database not initialized");
}
const result = await this.connection.query(sql, params);
if (this.dbFatalError) throw new Error("Database is in a fatal error state. Please restart the app.");
const result = await this.sqlite.query({
database: this.dbName,
statement: sql,
values: params
});
const columns = result.values?.[0] ? Object.keys(result.values[0]) : [];
return {
columns: [], // SQLite plugin doesn't provide column names
values: result.values || [],
columns,
values: (result.values || []).map((row: Record<string, unknown>) => row as T)
};
}
/**
* @see PlatformService.dbExec
*/
async dbExec(
sql: string,
params?: unknown[],
): Promise<{ changes: number; lastId?: number }> {
if (this.dbFatalError) {
throw new Error("Database is in a fatal error state. Please restart the app.");
}
async dbExec(sql: string, params?: unknown[]): Promise<{ changes: number; lastId?: number }> {
await this.initializeDatabase();
if (!this.connection) {
throw new Error("Database not initialized");
}
const result = await this.connection.run(sql, params);
if (this.dbFatalError) throw new Error("Database is in a fatal error state. Please restart the app.");
const result = await this.sqlite.run({
database: this.dbName,
statement: sql,
values: params
});
return {
changes: result.changes?.changes || 0,
lastId: result.changes?.lastId,
@ -387,50 +361,20 @@ export class ElectronPlatformService implements PlatformService {
}
async initialize(): Promise<void> {
if (this.dbFatalError) {
throw new Error("Database is in a fatal error state. Please restart the app.");
}
await this.initializeDatabase();
}
async query<T>(sql: string, params: any[] = []): Promise<T[]> {
if (this.dbFatalError) {
throw new Error("Database is in a fatal error state. Please restart the app.");
}
await this.initializeDatabase();
if (!this.connection) {
throw new Error("Database not initialized");
}
const result = await this.connection.query(sql, params);
return (result.values || []) as T[];
}
async execute(sql: string, params: any[] = []): Promise<void> {
if (this.dbFatalError) {
throw new Error("Database is in a fatal error state. Please restart the app.");
}
await this.initializeDatabase();
if (!this.connection) {
throw new Error("Database not initialized");
}
await this.connection.run(sql, params);
if (this.dbFatalError) throw new Error("Database is in a fatal error state. Please restart the app.");
await this.sqlite.run({
database: this.dbName,
statement: sql,
values: params
});
}
async close(): Promise<void> {
if (!this.connection) {
return;
}
try {
await this.connectionPool.releaseConnection("timesafari");
this.connection = null;
} catch (error) {
logger.error("Failed to close database:", error);
throw error;
}
// Optionally implement close logic if needed
}
}

27
src/types/electron.d.ts
View File

@ -0,0 +1,27 @@
interface ElectronAPI {
sqlite: {
isAvailable: () => Promise<boolean>;
execute: (method: string, ...args: unknown[]) => Promise<unknown>;
};
getPath: (pathType: string) => Promise<string>;
send: (channel: string, data: unknown) => void;
receive: (channel: string, func: (...args: unknown[]) => void) => void;
ipcRenderer: {
on: (channel: string, func: (...args: unknown[]) => void) => void;
once: (channel: string, func: (...args: unknown[]) => void) => void;
send: (channel: string, data: unknown) => void;
invoke: (channel: string, ...args: unknown[]) => Promise<unknown>;
};
env: {
platform: string;
};
getBasePath: () => Promise<string>;
}
declare global {
interface Window {
electron: ElectronAPI;
}
}
export {};
Write Preview
Loading…
Cancel
Save