synchronization of transactions using promise so only one can be active

services/sql.js

@@ -10,7 +10,7 @@ async function createConnection() {
 
 const dbReady = createConnection();
 
-async function insert(db, table_name, rec, replace = false) {
+async function insert(table_name, rec, replace = false) {
     const keys = Object.keys(rec);
     if (keys.length === 0) {
         log.error("Can't insert empty object into table " + table_name);
@@ -22,36 +22,36 @@ async function insert(db, table_name, rec, replace = false) {
 
     const query = "INSERT " + (replace ? "OR REPLACE" : "") + " INTO " + table_name + "(" + columns + ") VALUES (" + questionMarks + ")";
 
-    const res = await execute(db, query, Object.values(rec));
+    const res = await execute(query, Object.values(rec));
 
     return res.lastID;
 }
 
-async function replace(db, table_name, rec) {
-    return await insert(db, table_name, rec, true);
+async function replace(table_name, rec) {
+    return await insert(table_name, rec, true);
 }
 
-async function beginTransaction(db) {
-    return await wrap(async () => db.run("BEGIN"));
+async function beginTransaction() {
+    return await wrap(async db => db.run("BEGIN"));
 }
 
-async function commit(db) {
-    return await wrap(async () => db.run("COMMIT"));
+async function commit() {
+    return await wrap(async db => db.run("COMMIT"));
 }
 
-async function rollback(db) {
-    return await wrap(async () => db.run("ROLLBACK"));
+async function rollback() {
+    return await wrap(async db => db.run("ROLLBACK"));
 }
 
 async function getSingleResult(query, params = []) {
     const db = await dbReady;
 
-    return await wrap(async () => db.get(query, ...params));
+    return await wrap(async db => db.get(query, ...params));
 }
 
 async function getSingleResultOrNull(query, params = []) {
     const db = await dbReady;
-    const all = await wrap(async () => db.all(query, ...params));
+    const all = await wrap(async db => db.all(query, ...params));
 
     return all.length > 0 ? all[0] : null;
 }
@@ -69,7 +69,7 @@ async function getSingleValue(query, params = []) {
 async function getResults(query, params = []) {
     const db = await dbReady;
 
-    return await wrap(async () => db.all(query, ...params));
+    return await wrap(async db => db.all(query, ...params));
 }
 
 async function getMap(query, params = []) {
@@ -96,23 +96,24 @@ async function getFlattenedResults(key, query, params = []) {
     return list;
 }
 
-async function execute(db, query, params = []) {
-    return await wrap(async () => db.run(query, ...params));
+async function execute(query, params = []) {
+    return await wrap(async db => db.run(query, ...params));
 }
 
-async function executeScript(db, query) {
-    return await wrap(async () => db.exec(query));
+async function executeScript(query) {
+    return await wrap(async db => db.exec(query));
 }
 
-async function remove(db, tableName, noteId) {
-    return await execute(db, "DELETE FROM " + tableName + " WHERE note_id = ?", [noteId]);
+async function remove(tableName, noteId) {
+    return await execute("DELETE FROM " + tableName + " WHERE note_id = ?", [noteId]);
 }
 
 async function wrap(func) {
     const thisError = new Error();
+    const db = await dbReady;
 
     try {
-        return await func();
+        return await func(db);
     }
     catch (e) {
         log.error("Error executing query. Inner exception: " + e.stack + thisError.stack);
@@ -121,25 +122,38 @@ async function wrap(func) {
     }
 }
 
+let transactionPromise = null;
+
 async function doInTransaction(func) {
+    while (transactionPromise !== null) {
+        await transactionPromise;
+    }
+
     const error = new Error(); // to capture correct stack trace in case of exception
-    const db = await createConnection();
 
-    try {
+    transactionPromise = new Promise(async (resolve, reject) => {
+        try {
 
-        await beginTransaction(db);
+            await beginTransaction();
 
-        await func(db);
+            await func();
 
-        await commit(db);
-    }
-    catch (e) {
-        log.error("Error executing transaction, executing rollback. Inner exception: " + e.stack + error.stack);
+            await commit();
 
-        await rollback(db);
+            resolve();
+            transactionPromise = null;
+        }
+        catch (e) {
+            log.error("Error executing transaction, executing rollback. Inner exception: " + e.stack + error.stack);
 
-        throw e;
-    }
+            await rollback();
+
+            resolve();
+            transactionPromise = null;
+
+            throw e;
+        }
+    });
 }
 
 dbReady