Browse Source
The preload script (src/electron/preload.js) was removed as part of a refactor to separate web and electron builds. This script was previously responsible for: - Secure IPC communication between electron main and renderer processes - SQLite database access bridge for the renderer process - Context isolation and API exposure for electron-specific features Current state: - Web app builds successfully without preload script - Electron builds fail due to missing preload script - SQLite initialization works in main process but renderer can't access it - Database operations fail with "Cannot read properties of undefined" This commit is a breaking change for electron builds. The preload script will need to be recreated to restore electron database functionality. Affected files: - Deleted: src/electron/preload.js - Modified: src/main.electron.ts (removed DatabaseManager import) - Modified: src/utils/logger.ts (simplified logging implementation) - Modified: src/types/electron.d.ts (updated ElectronAPI interface) - Modified: src/types/global.d.ts (updated window.electron type definition) Next steps: - Recreate preload script with proper SQLite bridge - Update electron build configuration - Restore database access in renderer processsql-absurd-sql-further
Matthew Raymer
4 weeks ago
5 changed files with 24 additions and 1089 deletions
@ -1,174 +0,0 @@ |
|||
const { app, BrowserWindow } = require("electron"); |
|||
const path = require("path"); |
|||
const fs = require("fs"); |
|||
const logger = require("../utils/logger"); |
|||
|
|||
// Check if running in dev mode
|
|||
const isDev = process.argv.includes("--inspect"); |
|||
|
|||
function createWindow() { |
|||
// Add before createWindow function
|
|||
const preloadPath = path.join(__dirname, "preload.js"); |
|||
logger.log("Checking preload path:", preloadPath); |
|||
logger.log("Preload exists:", fs.existsSync(preloadPath)); |
|||
|
|||
// Create the browser window.
|
|||
const mainWindow = new BrowserWindow({ |
|||
width: 1200, |
|||
height: 800, |
|||
webPreferences: { |
|||
nodeIntegration: false, |
|||
contextIsolation: true, |
|||
webSecurity: true, |
|||
allowRunningInsecureContent: false, |
|||
preload: path.join(__dirname, "preload.js"), |
|||
}, |
|||
}); |
|||
|
|||
// Always open DevTools for now
|
|||
mainWindow.webContents.openDevTools(); |
|||
|
|||
// Intercept requests to fix asset paths
|
|||
mainWindow.webContents.session.webRequest.onBeforeRequest( |
|||
{ |
|||
urls: [ |
|||
"file://*/*/assets/*", |
|||
"file://*/assets/*", |
|||
"file:///assets/*", // Catch absolute paths
|
|||
"<all_urls>", // Catch all URLs as a fallback
|
|||
], |
|||
}, |
|||
(details, callback) => { |
|||
let url = details.url; |
|||
|
|||
// Handle paths that don't start with file://
|
|||
if (!url.startsWith("file://") && url.includes("/assets/")) { |
|||
url = `file://${path.join(__dirname, "www", url)}`; |
|||
} |
|||
|
|||
// Handle absolute paths starting with /assets/
|
|||
if (url.includes("/assets/") && !url.includes("/www/assets/")) { |
|||
const baseDir = url.includes("dist-electron") |
|||
? url.substring( |
|||
0, |
|||
url.indexOf("/dist-electron") + "/dist-electron".length, |
|||
) |
|||
: `file://${__dirname}`; |
|||
const assetPath = url.split("/assets/")[1]; |
|||
const newUrl = `${baseDir}/www/assets/${assetPath}`; |
|||
callback({ redirectURL: newUrl }); |
|||
return; |
|||
} |
|||
|
|||
callback({}); // No redirect for other URLs
|
|||
}, |
|||
); |
|||
|
|||
if (isDev) { |
|||
// Debug info
|
|||
logger.log("Debug Info:"); |
|||
logger.log("Running in dev mode:", isDev); |
|||
logger.log("App is packaged:", app.isPackaged); |
|||
logger.log("Process resource path:", process.resourcesPath); |
|||
logger.log("App path:", app.getAppPath()); |
|||
logger.log("__dirname:", __dirname); |
|||
logger.log("process.cwd():", process.cwd()); |
|||
} |
|||
|
|||
const indexPath = path.join(__dirname, "www", "index.html"); |
|||
|
|||
if (isDev) { |
|||
logger.log("Loading index from:", indexPath); |
|||
logger.log("www path:", path.join(__dirname, "www")); |
|||
logger.log("www assets path:", path.join(__dirname, "www", "assets")); |
|||
} |
|||
|
|||
if (!fs.existsSync(indexPath)) { |
|||
logger.error(`Index file not found at: ${indexPath}`); |
|||
throw new Error("Index file not found"); |
|||
} |
|||
|
|||
// Add CSP headers to allow API connections
|
|||
mainWindow.webContents.session.webRequest.onHeadersReceived( |
|||
(details, callback) => { |
|||
callback({ |
|||
responseHeaders: { |
|||
...details.responseHeaders, |
|||
"Content-Security-Policy": [ |
|||
"default-src 'self';" + |
|||
"connect-src 'self' https://api.endorser.ch https://*.timesafari.app;" + |
|||
"img-src 'self' data: https: blob:;" + |
|||
"script-src 'self' 'unsafe-inline' 'unsafe-eval';" + |
|||
"style-src 'self' 'unsafe-inline';" + |
|||
"font-src 'self' data:;", |
|||
], |
|||
}, |
|||
}); |
|||
}, |
|||
); |
|||
|
|||
// Load the index.html
|
|||
mainWindow |
|||
.loadFile(indexPath) |
|||
.then(() => { |
|||
logger.log("Successfully loaded index.html"); |
|||
if (isDev) { |
|||
mainWindow.webContents.openDevTools(); |
|||
logger.log("DevTools opened - running in dev mode"); |
|||
} |
|||
}) |
|||
.catch((err) => { |
|||
logger.error("Failed to load index.html:", err); |
|||
logger.error("Attempted path:", indexPath); |
|||
}); |
|||
|
|||
// Listen for console messages from the renderer
|
|||
mainWindow.webContents.on("console-message", (_event, level, message) => { |
|||
logger.log("Renderer Console:", message); |
|||
}); |
|||
|
|||
// Add right after creating the BrowserWindow
|
|||
mainWindow.webContents.on( |
|||
"did-fail-load", |
|||
(event, errorCode, errorDescription) => { |
|||
logger.error("Page failed to load:", errorCode, errorDescription); |
|||
}, |
|||
); |
|||
|
|||
mainWindow.webContents.on("preload-error", (event, preloadPath, error) => { |
|||
logger.error("Preload script error:", preloadPath, error); |
|||
}); |
|||
|
|||
mainWindow.webContents.on( |
|||
"console-message", |
|||
(event, level, message, line, sourceId) => { |
|||
logger.log("Renderer Console:", line, sourceId, message); |
|||
}, |
|||
); |
|||
|
|||
// Enable remote debugging when in dev mode
|
|||
if (isDev) { |
|||
mainWindow.webContents.openDevTools(); |
|||
} |
|||
} |
|||
|
|||
// Handle app ready
|
|||
app.whenReady().then(createWindow); |
|||
|
|||
// Handle all windows closed
|
|||
app.on("window-all-closed", () => { |
|||
if (process.platform !== "darwin") { |
|||
app.quit(); |
|||
} |
|||
}); |
|||
|
|||
app.on("activate", () => { |
|||
if (BrowserWindow.getAllWindows().length === 0) { |
|||
createWindow(); |
|||
} |
|||
}); |
|||
|
|||
// Handle any errors
|
|||
process.on("uncaughtException", (error) => { |
|||
logger.error("Uncaught Exception:", error); |
|||
}); |
|||
@ -1,712 +0,0 @@ |
|||
import { app, BrowserWindow, ipcMain } from "electron"; |
|||
import { Capacitor } from "@capacitor/core"; |
|||
import fs from "fs"; |
|||
import path from "path"; |
|||
import { fileURLToPath } from "url"; |
|||
|
|||
// Get __dirname equivalent in ES modules
|
|||
const __filename = fileURLToPath(import.meta.url); |
|||
const __dirname = path.dirname(__filename); |
|||
|
|||
// Set global variables that the plugin needs
|
|||
global.__dirname = __dirname; |
|||
global.__filename = __filename; |
|||
|
|||
// Now import the plugin after setting up globals
|
|||
import { CapacitorSQLite } from "@capacitor-community/sqlite/electron/dist/plugin.js"; |
|||
|
|||
// Simple logger implementation
|
|||
const logger = { |
|||
// eslint-disable-next-line no-console
|
|||
log: (...args: unknown[]) => console.log("[Main]", ...args), |
|||
// eslint-disable-next-line no-console
|
|||
error: (...args: unknown[]) => console.error("[Main]", ...args), |
|||
// eslint-disable-next-line no-console
|
|||
info: (...args: unknown[]) => console.info("[Main]", ...args), |
|||
// eslint-disable-next-line no-console
|
|||
warn: (...args: unknown[]) => console.warn("[Main]", ...args), |
|||
// eslint-disable-next-line no-console
|
|||
debug: (...args: unknown[]) => console.debug("[Main]", ...args), |
|||
}; |
|||
|
|||
logger.info("Starting main process initialization..."); |
|||
|
|||
// Initialize Capacitor for Electron in main process
|
|||
try { |
|||
logger.info("About to initialize Capacitor..."); |
|||
logger.info("Capacitor before init:", { |
|||
hasPlatform: "platform" in Capacitor, |
|||
hasIsNativePlatform: "isNativePlatform" in Capacitor, |
|||
platformType: typeof Capacitor.platform, |
|||
isNativePlatformType: typeof Capacitor.isNativePlatform, |
|||
}); |
|||
|
|||
// Try direct assignment first
|
|||
try { |
|||
(Capacitor as unknown as { platform: string }).platform = "electron"; |
|||
(Capacitor as unknown as { isNativePlatform: boolean }).isNativePlatform = |
|||
true; |
|||
logger.info("Direct assignment successful"); |
|||
} catch (e) { |
|||
logger.warn("Direct assignment failed, trying defineProperty:", e); |
|||
Object.defineProperty(Capacitor, "isNativePlatform", { |
|||
get: () => true, |
|||
configurable: true, |
|||
}); |
|||
|
|||
Object.defineProperty(Capacitor, "platform", { |
|||
get: () => "electron", |
|||
configurable: true, |
|||
}); |
|||
} |
|||
|
|||
logger.info("Capacitor after init:", { |
|||
platform: Capacitor.platform, |
|||
isNativePlatform: Capacitor.isNativePlatform, |
|||
platformType: typeof Capacitor.platform, |
|||
isNativePlatformType: typeof Capacitor.isNativePlatform, |
|||
}); |
|||
} catch (error) { |
|||
logger.error("Failed to initialize Capacitor:", error); |
|||
throw error; |
|||
} |
|||
|
|||
// Database path resolution utilities
|
|||
const getAppDataPath = async (): Promise<string> => { |
|||
try { |
|||
// Read config file directly
|
|||
const configPath = path.join(__dirname, "..", "capacitor.config.json"); |
|||
const configContent = await fs.promises.readFile(configPath, "utf-8"); |
|||
const config = JSON.parse(configContent); |
|||
const linuxPath = config?.plugins?.CapacitorSQLite?.electronLinuxLocation; |
|||
|
|||
if (linuxPath) { |
|||
// Expand ~ to home directory
|
|||
const expandedPath = linuxPath.replace(/^~/, process.env.HOME || ""); |
|||
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 Main] Using fallback user data path:", userDataPath); |
|||
return userDataPath; |
|||
} catch (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 Main] Using fallback user data path after error:", |
|||
userDataPath, |
|||
); |
|||
return userDataPath; |
|||
} |
|||
}; |
|||
|
|||
const validateAndNormalizePath = async (filePath: string): Promise<string> => { |
|||
// Resolve any relative paths
|
|||
const resolvedPath = path.resolve(filePath); |
|||
|
|||
// Ensure it's an absolute path
|
|||
if (!path.isAbsolute(resolvedPath)) { |
|||
throw new Error(`Database path must be absolute: ${resolvedPath}`); |
|||
} |
|||
|
|||
// Ensure it's within the app data directory
|
|||
const appDataPath = await getAppDataPath(); |
|||
if (!resolvedPath.startsWith(appDataPath)) { |
|||
throw new Error( |
|||
`Database path must be within app data directory: ${resolvedPath}`, |
|||
); |
|||
} |
|||
|
|||
// Normalize the path
|
|||
const normalizedPath = path.normalize(resolvedPath); |
|||
|
|||
logger.info("[Electron Main] Validated database path:", { |
|||
original: filePath, |
|||
resolved: resolvedPath, |
|||
normalized: normalizedPath, |
|||
appDataPath, |
|||
isAbsolute: path.isAbsolute(normalizedPath), |
|||
isWithinAppData: normalizedPath.startsWith(appDataPath), |
|||
}); |
|||
|
|||
return normalizedPath; |
|||
}; |
|||
|
|||
const ensureDirectoryExists = async (dirPath: string): Promise<void> => { |
|||
try { |
|||
// Normalize the path first
|
|||
const normalizedPath = path.normalize(dirPath); |
|||
|
|||
// Check if directory exists
|
|||
if (!fs.existsSync(normalizedPath)) { |
|||
logger.info("[Electron Main] Creating database directory:", normalizedPath); |
|||
await fs.promises.mkdir(normalizedPath, { recursive: true }); |
|||
} |
|||
|
|||
// Verify directory permissions
|
|||
try { |
|||
await fs.promises.access( |
|||
normalizedPath, |
|||
fs.constants.R_OK | fs.constants.W_OK, |
|||
); |
|||
logger.info( |
|||
"[Electron Main] Database directory permissions verified:", |
|||
normalizedPath, |
|||
); |
|||
} catch (error) { |
|||
logger.error("[Electron Main] Database directory permission error:", error); |
|||
throw new Error(`Database directory not accessible: ${normalizedPath}`); |
|||
} |
|||
|
|||
// Test write permissions
|
|||
const testFile = path.join(normalizedPath, ".write-test"); |
|||
try { |
|||
await fs.promises.writeFile(testFile, "test"); |
|||
await fs.promises.unlink(testFile); |
|||
logger.info( |
|||
"[Electron Main] Database directory write test passed:", |
|||
normalizedPath, |
|||
); |
|||
} catch (error) { |
|||
logger.error("[Electron Main] Database directory write test failed:", error); |
|||
throw new Error(`Database directory not writable: ${normalizedPath}`); |
|||
} |
|||
} catch (error) { |
|||
logger.error( |
|||
"[Electron Main] Failed to ensure database directory exists:", |
|||
error, |
|||
); |
|||
throw error; |
|||
} |
|||
}; |
|||
|
|||
// Initialize database paths
|
|||
let dbPath: string | undefined; |
|||
let dbDir: string | undefined; |
|||
let dbPathInitialized = false; |
|||
let dbPathInitializationPromise: Promise<void> | null = null; |
|||
|
|||
const initializeDatabasePaths = async (): Promise<void> => { |
|||
// Prevent multiple simultaneous initializations
|
|||
if (dbPathInitializationPromise) { |
|||
return dbPathInitializationPromise; |
|||
} |
|||
|
|||
if (dbPathInitialized) { |
|||
return; |
|||
} |
|||
|
|||
dbPathInitializationPromise = (async () => { |
|||
try { |
|||
// Get the base directory from config
|
|||
dbDir = await getAppDataPath(); |
|||
logger.info("[Electron Main] Database directory:", dbDir); |
|||
|
|||
// Ensure the directory exists and is writable
|
|||
await ensureDirectoryExists(dbDir); |
|||
|
|||
// Construct the database path
|
|||
dbPath = await validateAndNormalizePath( |
|||
path.join(dbDir, "timesafari.db"), |
|||
); |
|||
logger.info("[Electron Main] Database path initialized:", dbPath); |
|||
|
|||
// Verify the database file if it exists
|
|||
if (fs.existsSync(dbPath)) { |
|||
try { |
|||
await fs.promises.access( |
|||
dbPath, |
|||
fs.constants.R_OK | fs.constants.W_OK, |
|||
); |
|||
logger.info( |
|||
"[Electron Main] Existing database file permissions verified:", |
|||
dbPath, |
|||
); |
|||
} catch (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 Main] Failed to initialize database paths:", error); |
|||
throw error; |
|||
} finally { |
|||
dbPathInitializationPromise = null; |
|||
} |
|||
})(); |
|||
|
|||
return dbPathInitializationPromise; |
|||
}; |
|||
|
|||
// Initialize SQLite plugin
|
|||
let sqlitePlugin: any = null; |
|||
let sqliteInitialized = false; |
|||
let sqliteInitializationPromise: Promise<void> | null = null; |
|||
|
|||
async function initializeSQLite() { |
|||
// Prevent multiple simultaneous initializations
|
|||
if (sqliteInitializationPromise) { |
|||
return sqliteInitializationPromise; |
|||
} |
|||
|
|||
if (sqliteInitialized) { |
|||
return; |
|||
} |
|||
|
|||
sqliteInitializationPromise = (async () => { |
|||
try { |
|||
logger.info("[Electron Main] Initializing SQLite plugin..."); |
|||
sqlitePlugin = new CapacitorSQLite(); |
|||
|
|||
// Initialize database paths first
|
|||
await initializeDatabasePaths(); |
|||
|
|||
if (!dbPath) { |
|||
throw new Error("Database path not initialized"); |
|||
} |
|||
|
|||
// Test the plugin
|
|||
const echoResult = await sqlitePlugin.echo({ value: "test" }); |
|||
logger.info("[Electron Main] SQLite plugin echo test:", echoResult); |
|||
|
|||
// Initialize database connection using validated dbPath
|
|||
const connectionOptions = { |
|||
database: dbPath, |
|||
version: 1, |
|||
readOnly: false, |
|||
encryption: "no-encryption", |
|||
useNative: true, |
|||
mode: "rwc", // Force read-write-create mode
|
|||
}; |
|||
|
|||
logger.info( |
|||
"[Electron Main] Creating initial connection with options:", |
|||
connectionOptions, |
|||
); |
|||
|
|||
// Log the actual path being used
|
|||
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); |
|||
|
|||
if (!db || typeof db !== "object") { |
|||
throw new Error( |
|||
`Failed to create database connection - invalid response. Path used: ${dbPath}`, |
|||
); |
|||
} |
|||
|
|||
// Wait a moment for the connection to be fully established
|
|||
await new Promise((resolve) => setTimeout(resolve, 100)); |
|||
|
|||
// Verify the connection is working
|
|||
try { |
|||
const result = await db.query("PRAGMA journal_mode;"); |
|||
logger.info("[Electron Main] Database connection verified:", result); |
|||
} catch (error) { |
|||
logger.error( |
|||
"[Electron Main] Database connection verification failed:", |
|||
error, |
|||
); |
|||
throw error; |
|||
} |
|||
|
|||
sqliteInitialized = true; |
|||
logger.info("[Electron Main] SQLite plugin initialized successfully"); |
|||
} catch (error) { |
|||
logger.error("[Electron Main] Failed to initialize SQLite plugin:", error); |
|||
throw error; |
|||
} finally { |
|||
sqliteInitializationPromise = null; |
|||
} |
|||
})(); |
|||
|
|||
return sqliteInitializationPromise; |
|||
} |
|||
|
|||
// Initialize app when ready
|
|||
app.whenReady().then(async () => { |
|||
logger.info("App is ready, starting initialization..."); |
|||
|
|||
// Create window first
|
|||
const mainWindow = createWindow(); |
|||
|
|||
// 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 Main] Database initialization failed:", |
|||
error, |
|||
); |
|||
// Notify renderer about database status
|
|||
if (!mainWindow.isDestroyed()) { |
|||
mainWindow.webContents.send("database-status", { |
|||
status: "error", |
|||
error: error instanceof Error ? error.message : 'Unknown error', |
|||
}); |
|||
} |
|||
} |
|||
|
|||
// Handle window close
|
|||
mainWindow.on("closed", () => { |
|||
logger.info("[Electron Main] Main window closed"); |
|||
}); |
|||
|
|||
// Handle window close request
|
|||
mainWindow.on("close", (event) => { |
|||
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 Main] Deferring window close due to loading state"); |
|||
mainWindow.webContents.once("did-finish-load", () => { |
|||
mainWindow.close(); |
|||
}); |
|||
} |
|||
}); |
|||
}); |
|||
|
|||
// Check if running in dev mode
|
|||
// const isDev = process.argv.includes("--inspect");
|
|||
|
|||
function createWindow(): BrowserWindow { |
|||
// Resolve preload path based on environment
|
|||
const preloadPath = app.isPackaged |
|||
? path.join(process.resourcesPath, "preload.js") |
|||
: path.join(__dirname, "preload.js"); |
|||
|
|||
logger.log("[Electron Main] Preload path:", preloadPath); |
|||
logger.log("[Electron Main] Preload exists:", fs.existsSync(preloadPath)); |
|||
|
|||
// Log environment and paths
|
|||
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 { |
|||
logger.log("Files in __dirname:", fs.readdirSync(__dirname)); |
|||
const wwwDir = path.join(__dirname, "www"); |
|||
if (fs.existsSync(wwwDir)) { |
|||
logger.log("Files in www:", fs.readdirSync(wwwDir)); |
|||
} else { |
|||
logger.log("www directory does not exist in __dirname"); |
|||
} |
|||
} catch (e) { |
|||
logger.error("Error reading directories:", e); |
|||
} |
|||
|
|||
// Create the browser window with proper error handling
|
|||
const mainWindow = new BrowserWindow({ |
|||
width: 1200, |
|||
height: 800, |
|||
show: false, // Don't show until ready
|
|||
webPreferences: { |
|||
nodeIntegration: false, |
|||
contextIsolation: true, |
|||
sandbox: false, |
|||
preload: preloadPath, |
|||
webSecurity: true, |
|||
allowRunningInsecureContent: false, |
|||
}, |
|||
}); |
|||
|
|||
// Show window when ready
|
|||
mainWindow.once("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 Main] Render process gone:", details); |
|||
}); |
|||
|
|||
mainWindow.webContents.on( |
|||
"did-fail-load", |
|||
(_event, errorCode, errorDescription) => { |
|||
logger.error( |
|||
"[Electron Main] Page failed to load:", |
|||
errorCode, |
|||
errorDescription, |
|||
); |
|||
logger.error("[Electron Main] Failed URL:", mainWindow.webContents.getURL()); |
|||
}, |
|||
); |
|||
|
|||
// Load the index.html
|
|||
let indexPath: string; |
|||
let fileUrl: string; |
|||
|
|||
if (app.isPackaged) { |
|||
indexPath = path.join(process.resourcesPath, "www", "index.html"); |
|||
fileUrl = `file://${indexPath}`; |
|||
logger.info( |
|||
"[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 Main] App is not packaged. Using __dirname for index.html", |
|||
); |
|||
} |
|||
|
|||
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 Main] Window was destroyed before loading index.html", |
|||
); |
|||
return; |
|||
} |
|||
|
|||
const exists = fs.existsSync(indexPath); |
|||
logger.info(`[Electron Main] fs.existsSync for index.html: ${exists}`); |
|||
|
|||
if (!exists) { |
|||
throw new Error(`index.html not found at path: ${indexPath}`); |
|||
} |
|||
|
|||
// Try to read the file to verify it's accessible
|
|||
const stats = fs.statSync(indexPath); |
|||
logger.info("[Electron Main] index.html stats:", { |
|||
size: stats.size, |
|||
mode: stats.mode, |
|||
uid: stats.uid, |
|||
gid: stats.gid, |
|||
}); |
|||
|
|||
// Try loadURL first
|
|||
try { |
|||
logger.info("[Electron Main] Attempting to load index.html via loadURL"); |
|||
await mainWindow.loadURL(fileUrl); |
|||
logger.info("[Electron Main] Successfully loaded index.html via loadURL"); |
|||
} catch (loadUrlError) { |
|||
logger.warn( |
|||
"[Electron Main] loadURL failed, trying loadFile:", |
|||
loadUrlError, |
|||
); |
|||
// Fallback to loadFile
|
|||
await mainWindow.loadFile(indexPath); |
|||
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 Main] Error loading index.html:", errorMessage); |
|||
|
|||
// Retry logic
|
|||
if (retryCount < 3 && !mainWindow.isDestroyed()) { |
|||
logger.info( |
|||
`[Electron Main] Retrying index.html load (attempt ${retryCount + 1})`, |
|||
); |
|||
await new Promise((resolve) => setTimeout(resolve, 1000)); // Wait 1 second
|
|||
return loadIndexHtml(retryCount + 1); |
|||
} |
|||
|
|||
// If we've exhausted retries, show error in window
|
|||
if (!mainWindow.isDestroyed()) { |
|||
const errorHtml = ` |
|||
<html> |
|||
<body style="font-family: sans-serif; padding: 20px;"> |
|||
<h1>Error Loading Application</h1> |
|||
<p>Failed to load the application after multiple attempts.</p> |
|||
<pre style="background: #f0f0f0; padding: 10px; border-radius: 4px;">${errorMessage}</pre> |
|||
</body> |
|||
</html> |
|||
`;
|
|||
await mainWindow.loadURL( |
|||
`data:text/html,${encodeURIComponent(errorHtml)}`, |
|||
); |
|||
} |
|||
} |
|||
}; |
|||
|
|||
// Start loading the index.html
|
|||
loadIndexHtml().catch((error: unknown) => { |
|||
logger.error("[Electron Main] Fatal error loading index.html:", error); |
|||
}); |
|||
|
|||
// Only open DevTools if not in production
|
|||
if (!app.isPackaged) { |
|||
mainWindow.webContents.openDevTools({ mode: "detach" }); |
|||
} |
|||
|
|||
return mainWindow; |
|||
} |
|||
|
|||
// Handle app ready
|
|||
app.whenReady().then(createWindow); |
|||
|
|||
// Handle all windows closed
|
|||
app.on("window-all-closed", () => { |
|||
if (process.platform !== "darwin") { |
|||
app.quit(); |
|||
} |
|||
}); |
|||
|
|||
app.on("activate", () => { |
|||
if (BrowserWindow.getAllWindows().length === 0) { |
|||
createWindow(); |
|||
} |
|||
}); |
|||
|
|||
// Handle any errors
|
|||
process.on("uncaughtException", (error) => { |
|||
logger.error("Uncaught Exception:", error); |
|||
}); |
|||
|
|||
// Set up IPC handlers for SQLite operations
|
|||
ipcMain.handle("check-sqlite-availability", () => { |
|||
return sqlitePlugin !== null; |
|||
}); |
|||
|
|||
ipcMain.handle("sqlite-echo", async (_event, value) => { |
|||
try { |
|||
return await sqlitePlugin.echo({ value }); |
|||
} catch (error) { |
|||
logger.error( |
|||
"Error in sqlite-echo:", |
|||
error, |
|||
JSON.stringify(error), |
|||
(error as any)?.stack, |
|||
); |
|||
throw error; |
|||
} |
|||
}); |
|||
|
|||
ipcMain.handle("sqlite-create-connection", async (_event, options) => { |
|||
try { |
|||
// Ensure database is initialized
|
|||
await initializeSQLite(); |
|||
|
|||
if (!dbPath) { |
|||
throw new Error("Database path not initialized"); |
|||
} |
|||
|
|||
// Override any provided database path with our resolved path
|
|||
const connectionOptions = { |
|||
...options, |
|||
database: dbPath, |
|||
readOnly: false, |
|||
mode: "rwc", // Force read-write-create mode
|
|||
encryption: "no-encryption", |
|||
useNative: true, |
|||
}; |
|||
|
|||
logger.info( |
|||
"[Electron Main] Creating database connection with options:", |
|||
connectionOptions, |
|||
); |
|||
const result = await sqlitePlugin.createConnection(connectionOptions); |
|||
|
|||
if (!result || typeof result !== "object") { |
|||
throw new Error( |
|||
"Failed to create database connection - invalid response", |
|||
); |
|||
} |
|||
|
|||
// Wait a moment for the connection to be fully established
|
|||
await new Promise((resolve) => setTimeout(resolve, 100)); |
|||
|
|||
try { |
|||
// Verify connection is not read-only
|
|||
const testResult = await result.query({ |
|||
statement: "PRAGMA journal_mode;", |
|||
}); |
|||
if (testResult?.values?.[0]?.journal_mode === "off") { |
|||
logger.error( |
|||
"[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 Main] Error verifying connection:", queryError); |
|||
throw queryError; |
|||
} |
|||
|
|||
logger.info("[Electron Main] Database connection created successfully"); |
|||
return result; |
|||
} catch (error) { |
|||
logger.error("[Electron Main] Error in sqlite-create-connection:", error); |
|||
throw error; |
|||
} |
|||
}); |
|||
|
|||
ipcMain.handle("sqlite-execute", async (_event, options) => { |
|||
try { |
|||
return await sqlitePlugin.execute(options); |
|||
} catch (error) { |
|||
logger.error( |
|||
"Error in sqlite-execute:", |
|||
error, |
|||
JSON.stringify(error), |
|||
(error as any)?.stack, |
|||
); |
|||
throw error; |
|||
} |
|||
}); |
|||
|
|||
ipcMain.handle("sqlite-query", async (_event, options) => { |
|||
try { |
|||
return await sqlitePlugin.query(options); |
|||
} catch (error) { |
|||
logger.error( |
|||
"Error in sqlite-query:", |
|||
error, |
|||
JSON.stringify(error), |
|||
(error as any)?.stack, |
|||
); |
|||
throw error; |
|||
} |
|||
}); |
|||
|
|||
ipcMain.handle("sqlite-close-connection", async (_event, options) => { |
|||
try { |
|||
return await sqlitePlugin.closeConnection(options); |
|||
} catch (error) { |
|||
logger.error( |
|||
"Error in sqlite-close-connection:", |
|||
error, |
|||
JSON.stringify(error), |
|||
(error as any)?.stack, |
|||
); |
|||
throw error; |
|||
} |
|||
}); |
|||
|
|||
ipcMain.handle("sqlite-is-available", async () => { |
|||
return sqlitePlugin !== null; |
|||
}); |
|||
@ -1,178 +0,0 @@ |
|||
const { contextBridge, ipcRenderer } = require("electron"); |
|||
|
|||
const logger = { |
|||
log: (message, ...args) => { |
|||
// Always log in development, log with context in production
|
|||
if (process.env.NODE_ENV !== "production") { |
|||
/* eslint-disable no-console */ |
|||
console.log(`[Electron Preload] ${message}`, ...args); |
|||
/* eslint-enable no-console */ |
|||
} |
|||
}, |
|||
warn: (message, ...args) => { |
|||
// Always log warnings
|
|||
/* eslint-disable no-console */ |
|||
console.warn(`[Electron Preload] ${message}`, ...args); |
|||
/* eslint-enable no-console */ |
|||
}, |
|||
error: (message, ...args) => { |
|||
// Always log errors
|
|||
/* eslint-disable no-console */ |
|||
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(`[Electron Preload] ${message}`, ...args); |
|||
/* eslint-enable no-console */ |
|||
} |
|||
}, |
|||
}; |
|||
|
|||
// Use a more direct path resolution approach
|
|||
const getPath = (pathType) => { |
|||
switch (pathType) { |
|||
case "userData": |
|||
return ( |
|||
process.env.APPDATA || |
|||
(process.platform === "darwin" |
|||
? `${process.env.HOME}/Library/Application Support` |
|||
: `${process.env.HOME}/.local/share`) |
|||
); |
|||
case "home": |
|||
return process.env.HOME; |
|||
case "appPath": |
|||
return process.resourcesPath; |
|||
default: |
|||
return ""; |
|||
} |
|||
}; |
|||
|
|||
logger.info("Preload script starting..."); |
|||
|
|||
// Force electron platform in the renderer process
|
|||
window.process = { env: { VITE_PLATFORM: "electron" } }; |
|||
|
|||
try { |
|||
contextBridge.exposeInMainWorld("electronAPI", { |
|||
// Path utilities
|
|||
getPath, |
|||
|
|||
// IPC functions
|
|||
send: (channel, data) => { |
|||
const validChannels = ["toMain"]; |
|||
if (validChannels.includes(channel)) { |
|||
ipcRenderer.send(channel, data); |
|||
} |
|||
}, |
|||
receive: (channel, func) => { |
|||
const validChannels = ["fromMain"]; |
|||
if (validChannels.includes(channel)) { |
|||
ipcRenderer.on(channel, (event, ...args) => func(...args)); |
|||
} |
|||
}, |
|||
// Environment info
|
|||
env: { |
|||
isElectron: true, |
|||
isDev: process.env.NODE_ENV === "development", |
|||
platform: "electron", // Explicitly set platform
|
|||
}, |
|||
// Path utilities
|
|||
getBasePath: () => { |
|||
return process.env.NODE_ENV === "development" ? "/" : "./"; |
|||
}, |
|||
}); |
|||
|
|||
// Create a proxy for the CapacitorSQLite plugin
|
|||
const createSQLiteProxy = () => { |
|||
const MAX_RETRIES = 3; |
|||
const RETRY_DELAY = 1000; // 1 second
|
|||
|
|||
const withRetry = async (operation, ...args) => { |
|||
let lastError; |
|||
for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) { |
|||
try { |
|||
return await operation(...args); |
|||
} catch (error) { |
|||
lastError = error; |
|||
if (attempt < MAX_RETRIES) { |
|||
logger.warn( |
|||
`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"}`, |
|||
); |
|||
}; |
|||
|
|||
const wrapOperation = (method) => { |
|||
return async (...args) => { |
|||
try { |
|||
return await withRetry( |
|||
ipcRenderer.invoke, |
|||
"sqlite-" + method, |
|||
...args, |
|||
); |
|||
} catch (error) { |
|||
logger.error(`SQLite ${method} failed:`, error); |
|||
throw new Error( |
|||
`Database operation failed: ${error.message || "Unknown error"}`, |
|||
); |
|||
} |
|||
}; |
|||
}; |
|||
|
|||
// Create a proxy that matches the CapacitorSQLite interface
|
|||
return { |
|||
echo: wrapOperation("echo"), |
|||
createConnection: wrapOperation("create-connection"), |
|||
closeConnection: wrapOperation("close-connection"), |
|||
execute: wrapOperation("execute"), |
|||
query: wrapOperation("query"), |
|||
run: wrapOperation("run"), |
|||
isAvailable: wrapOperation("is-available"), |
|||
getPlatform: () => Promise.resolve("electron"), |
|||
// Add other methods as needed
|
|||
}; |
|||
}; |
|||
|
|||
// Expose only the CapacitorSQLite proxy
|
|||
contextBridge.exposeInMainWorld("electron", { |
|||
sqlite: createSQLiteProxy(), |
|||
getPath: (pathType) => ipcRenderer.invoke("get-path", pathType), |
|||
send: (channel, data) => { |
|||
ipcRenderer.send(channel, data); |
|||
}, |
|||
receive: (channel, func) => { |
|||
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: { |
|||
platform: "electron", |
|||
}, |
|||
getBasePath: () => ipcRenderer.invoke("get-base-path"), |
|||
}); |
|||
|
|||
logger.info("Preload script completed successfully"); |
|||
} catch (error) { |
|||
logger.error("Error in preload script:", error); |
|||
} |
|||
Loading…
Reference in new issue