trent_larson/crowd-funder-for-time-pwa
4
1
Fork 2
Code Issues Pull Requests 21 Releases 5 Wiki Activity

fix(electron): assign sqlitePlugin globally and improve error logging

Browse Source 
- Assign CapacitorSQLite instance to the global sqlitePlugin variable so it is accessible in IPC handlers.
- Enhance error logging in the IPC handler to include JSON stringification and stack trace for better debugging.
- Reveal that the generic .handle() method is not available on the plugin, clarifying the next steps for correct IPC wiring.
This commit is contained in:
Matthew Raymer
2025-05-30 06:01:56 +00:00
parent 3997a88b44
commit a6d8f0eb8a
5 changed files with 163 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
package.json
View File

@@ -190,8 +190,8 @@
"to": "www"
},
{
"from": "dist-electron/resources/preload.mjs",
"to": "preload.mjs"
"from": "dist-electron/resources/preload.js",
"to": "preload.js"
}
],
"linux": {

4
scripts/build-electron.js
View File

@@ -49,8 +49,8 @@ indexContent = indexContent.replace(
fs.writeFileSync(finalIndexPath, indexContent);
// Copy preload script to resources
const preloadSrc = path.join(electronDistPath, "preload.mjs");
const preloadDest = path.join(electronDistPath, "resources", "preload.mjs");
const preloadSrc = path.join(electronDistPath, "preload.js");
const preloadDest = path.join(electronDistPath, "resources", "preload.js");
// Ensure resources directory exists
const resourcesDir = path.join(electronDistPath, "resources");

84
src/electron/main.ts
View File

@@ -8,6 +8,13 @@ import { fileURLToPath } from "url";
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
@@ -69,44 +76,35 @@ let sqlitePlugin: any = null;
async function initializeSQLite() {
try {
// Import the plugin directly in the main process
const plugin = await import("@capacitor-community/sqlite/electron/dist/plugin.js");
sqlitePlugin = new plugin.CapacitorSQLite();
// Test the plugin with a simple operation
const result = await sqlitePlugin.echo({ value: "test" });
if (result.value !== "test") {
throw new Error("SQLite plugin echo test failed");
}
logger.info("SQLite plugin initialized successfully");
console.log("Initializing SQLite plugin...");
sqlitePlugin = new CapacitorSQLite();
// Test the plugin
const echoResult = await sqlitePlugin.echo({ value: "test" });
console.log("SQLite plugin echo test:", echoResult);
// Initialize database connection
const db = await sqlitePlugin.createConnection({
database: "timesafari.db",
version: 1,
});
console.log("SQLite plugin initialized successfully");
return db;
} catch (error) {
logger.error("Failed to initialize SQLite plugin:", error);
console.error("Failed to initialize SQLite plugin:", error);
throw error;
}
}
// Initialize SQLite plugin
initializeSQLite().catch(error => {
logger.error("Failed to initialize SQLite plugin:", error);
});
// Set up IPC handlers for SQLite operations
ipcMain.handle("check-sqlite-availability", () => {
return sqlitePlugin !== null;
});
ipcMain.handle("capacitor-sqlite", async (event, ...args) => {
if (!sqlitePlugin) {
throw new Error("SQLite plugin not initialized");
}
return sqlitePlugin.handle(event, ...args);
});
// Initialize app when ready
app.whenReady().then(() => {
logger.info("App is ready, creating window...");
createWindow();
app.whenReady().then(async () => {
logger.info("App is ready, initializing SQLite...");
try {
await initializeSQLite();
logger.info("SQLite initialized, creating window...");
createWindow();
} catch (error) {
logger.error("Failed to initialize app:", error);
app.quit();
}
});
// Check if running in dev mode
@@ -115,8 +113,8 @@ const isDev = process.argv.includes("--inspect");
function createWindow(): void {
// Resolve preload path based on environment
const preloadPath = app.isPackaged
? path.join(process.resourcesPath, "preload.mjs")
: path.join(__dirname, "preload.mjs");
? 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));
@@ -331,3 +329,21 @@ app.on("activate", () => {
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("capacitor-sqlite", async (event, ...args) => {
if (!sqlitePlugin) {
logger.error("SQLite plugin not initialized when handling IPC request");
throw new Error("SQLite plugin not initialized");
}
try {
return await sqlitePlugin.handle(event, ...args);
} catch (error) {
logger.error("Error handling SQLite IPC request:", error, JSON.stringify(error), (error as any)?.stack);
throw error;
}
});

50
src/main.electron.ts
View File

@@ -3,11 +3,29 @@ import { logger } from "./utils/logger";
async function initializeSQLite() {
try {
const isAvailable = await window.electron.sqlite.isAvailable();
if (!isAvailable) {
throw new Error("SQLite plugin not available in main process");
// 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.electron.sqlite.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));
}
}
logger.info("[Electron] SQLite plugin bridge initialized");
throw new Error("SQLite plugin not available after maximum retries");
} catch (error) {
logger.error("[Electron] Failed to initialize SQLite plugin bridge:", error);
throw error;
@@ -27,8 +45,22 @@ if (pwa_enabled) {
// Initialize app and SQLite
const app = initializeApp();
initializeSQLite().then(() => {
app.mount("#app");
}).catch(error => {
logger.error("[Electron] Failed to initialize app:", error);
});
// Initialize SQLite first, then mount the app
initializeSQLite()
.then(() => {
logger.info("[Electron] SQLite initialized, mounting app...");
app.mount("#app");
})
.catch(error => {
logger.error("[Electron] Failed to initialize app:", 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>
`;
document.body.appendChild(errorDiv);
});

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

@@ -4,11 +4,10 @@ import {
PlatformCapabilities,
} from "../PlatformService";
import { logger } from "../../utils/logger";
import { QueryExecResult, SqlValue } from "@/interfaces/database";
import { QueryExecResult } from "@/interfaces/database";
import {
SQLiteConnection,
SQLiteDBConnection,
Changes,
} from "@capacitor-community/sqlite";
import { DEFAULT_ENDORSER_API_SERVER } from "@/constants/app";
@@ -30,6 +29,7 @@ export class ElectronPlatformService implements PlatformService {
private db: SQLiteDBConnection | null = null;
private dbName = "timesafari.db";
private initialized = false;
private initializationPromise: Promise<void> | null = null;
constructor() {
// Use the IPC bridge for SQLite operations
@@ -40,40 +40,53 @@ export class ElectronPlatformService implements PlatformService {
}
private async initializeDatabase(): Promise<void> {
// If already initialized, return
if (this.initialized) {
return;
}
try {
// Check if SQLite is available through IPC
const isAvailable = await window.electron.sqlite.isAvailable();
if (!isAvailable) {
throw new Error("SQLite is not available in the main process");
}
// Create/Open database with native implementation
this.db = await this.sqlite.createConnection(
this.dbName,
false,
"no-encryption",
1,
true, // Use native implementation
);
await this.db.open();
// Set journal mode to WAL for better performance
await this.db.execute("PRAGMA journal_mode=WAL;");
// Run migrations
await this.runMigrations();
this.initialized = true;
logger.log("SQLite database initialized successfully");
} catch (error) {
logger.error("Error initializing SQLite database:", error);
throw new Error("Failed to initialize database");
// If initialization is in progress, wait for it
if (this.initializationPromise) {
return this.initializationPromise;
}
// Start initialization
this.initializationPromise = (async () => {
try {
// Check if SQLite is available through IPC
const isAvailable = await window.electron.sqlite.isAvailable();
if (!isAvailable) {
throw new Error("SQLite is not available in the main process");
}
// Create/Open database with native implementation
this.db = await this.sqlite.createConnection(
this.dbName,
false,
"no-encryption",
1,
true, // Use native implementation
);
await this.db.open();
// Set journal mode to WAL for better performance
await this.db.execute("PRAGMA journal_mode=WAL;");
// Run migrations
await this.runMigrations();
this.initialized = true;
logger.log("[Electron] SQLite database initialized successfully");
} catch (error) {
logger.error("[Electron] Error initializing SQLite database:", error);
this.initialized = false;
this.initializationPromise = null;
throw error;
}
})();
return this.initializationPromise;
}
private async runMigrations(): Promise<void> {
@@ -300,24 +313,24 @@ export class ElectronPlatformService implements PlatformService {
/**
* @see PlatformService.dbQuery
*/
async dbQuery(sql: string, params?: unknown[]): Promise<QueryExecResult> {
await this.initializeDatabase();
if (!this.db) {
throw new Error("Database not initialized");
}
async dbQuery(
sql: string,
params?: unknown[],
): Promise<QueryExecResult | undefined> {
try {
const result = await this.db.query(sql, params || []);
const values = result.values || [];
await this.initializeDatabase();
if (!this.db) {
throw new Error("Database not initialized");
}
const result = await this.db.query(sql, params);
// Convert SQLite plugin result to QueryExecResult format
return {
columns: [], // SQLite plugin doesn't provide column names in query result
values: values as SqlValue[][],
columns: [], // SQLite plugin doesn't provide column names
values: result.values || [],
};
} catch (error) {
logger.error("Error executing query:", error);
throw new Error(
`Database query failed: ${error instanceof Error ? error.message : String(error)}`,
);
logger.error("[Electron] Database query error:", error);
throw error;
}
}
@@ -328,23 +341,20 @@ export class ElectronPlatformService implements PlatformService {
sql: string,
params?: unknown[],
): Promise<{ changes: number; lastId?: number }> {
await this.initializeDatabase();
if (!this.db) {
throw new Error("Database not initialized");
}
try {
const result = await this.db.run(sql, params || []);
const changes = result.changes as Changes;
await this.initializeDatabase();
if (!this.db) {
throw new Error("Database not initialized");
}
const result = await this.db.run(sql, params);
// Convert SQLite plugin result to expected format
return {
changes: changes?.changes || 0,
lastId: changes?.lastId,
changes: result.changes?.changes || 0,
lastId: result.changes?.lastId,
};
} catch (error) {
logger.error("Error executing statement:", error);
throw new Error(
`Database execution failed: ${error instanceof Error ? error.message : String(error)}`,
);
logger.error("[Electron] Database execution error:", error);
throw error;
}
}
}