- await async sqlite close on Electron quit to prevent node_sqlite3 abort

- JIRA: ZAPP-1714

Author: brdandu

src-electron/main-process/startup.js

@@ -1198,21 +1198,31 @@ function clearDatabaseFile(dbPath) {
 }
 
 /**
- * Shuts down any servers that might be running.
+ * Shuts down any servers that might be running, and closes the database.
+ *
+ * NOTE: node-sqlite3's Database.close() is always asynchronous, even when the
+ * wrapper is called "sync". If the close work completes after Electron has
+ * begun tearing down the Node environment, node-sqlite3 will try to invoke its
+ * JS completion callback into a dying isolate and trigger napi_fatal_error
+ * (SIGABRT). To avoid that, this function returns a promise that resolves
+ * only after the database close callback has actually fired. Callers in
+ * Electron's 'will-quit' must preventDefault(), await this, and then app.exit().
+ *
+ * @returns Promise that resolves when shutdown is complete.
  */
-function shutdown() {
+async function shutdown() {
   env.logInfo('Shutting down HTTP and IPC servers...')
   ipcServer.shutdownServerSync()
   httpServer.shutdownHttpServerSync()
 
   if (mainDatabase != null) {
-    // Use a sync call, because you can't have promises in the 'quit' event.
+    let dbToClose = mainDatabase
+    mainDatabase = null
     try {
-      dbApi.closeDatabaseSync(mainDatabase)
-      mainDatabase = null
+      await dbApi.closeDatabase(dbToClose)
       env.logInfo('Database closed, shutting down.')
     } catch (err) {
-      env.logError('Failed to close database.')
+      env.logError(`Failed to close database: ${err}`)
     }
   }
 }

src-electron/server/ipc-server.js

@@ -111,14 +111,16 @@ function handlerConvert(context, data) {
  * @param {*} data
  */
 function handlerStop(context, data) {
-  console.log('Shutting down because of remote client request.')
+  env.logInfo('Shutting down because of remote client request.')
   server.ipc.server.emit(
     context.socket,
     eventType.overAndOut,
     'Shutting down server.'
   )
-  startup.shutdown()
-  util.waitFor(1000).then(() => startup.quit())
+  startup
+    .shutdown()
+    .catch((err) => env.logError(`Error during shutdown: ${err}`))
+    .finally(() => util.waitFor(1000).then(() => startup.quit()))
 }
 
 /**

src-electron/ui/main-ui.js

@@ -77,8 +77,23 @@ function hookMainInstanceEvents(argv) {
     })
   }
 
-  app.on('will-quit', () => {
-    startup.shutdown()
+  let isCleanShutdownDone = false
+  app.on('will-quit', (event) => {
+    // node-sqlite3 closes asynchronously. If we let Electron tear down the
+    // Node environment before the close callback fires, node-sqlite3 will
+    // try to invoke a JS callback in a destroyed isolate and abort() (see
+    // https://github.com/TryGhost/node-sqlite3 Database::Work_AfterClose).
+    // Defer the actual quit until the async shutdown finishes, then use
+    // app.exit() which does NOT re-fire 'will-quit'.
+    if (isCleanShutdownDone) return
+    event.preventDefault()
+    startup
+      .shutdown()
+      .catch((err) => env.logError(`Error during shutdown: ${err}`))
+      .finally(() => {
+        isCleanShutdownDone = true
+        app.exit(0)
+      })
   })
 
   app.on('second-instance', (event, commandLine, workingDirectory) => {