fix: history saving race conditions

src/main/services/storage.ts

@@ -17,6 +17,7 @@ import {
 import { countVisitedTimes } from '~/utils/history';
 import { windowsManager } from '..';
 import { promises } from 'fs';
+import { Queue } from '~/utils/queue';
 
 interface Databases {
   [key: string]: Datastore;

src/main/view.ts

@@ -13,6 +13,7 @@ import {
   ZOOM_FACTOR_INCREMENT,
 } from '~/constants/web-contents';
 import { TabEvent } from '~/interfaces/tabs';
+import { Queue } from '~/utils/queue';
 
 export class View extends BrowserView {
   public title = '';
@@ -32,6 +33,8 @@ export class View extends BrowserView {
 
   public bookmark: IBookmark;
 
+  private historyQueue = new Queue();
+
   public constructor(window: AppWindow, url: string, incognito: boolean) {
     super({
       webPreferences: {
@@ -273,18 +276,22 @@ export class View extends BrowserView {
         date: new Date().getTime(),
       };
 
-      this.lastHistoryId = (
-        await storage.insert<IHistoryItem>({
-          scope: 'history',
-          item: historyItem,
-        })
-      )._id;
+      await this.historyQueue.enqueue(async () => {
+        this.lastHistoryId = (
+          await storage.insert<IHistoryItem>({
+            scope: 'history',
+            item: historyItem,
+          })
+        )._id;
 
-      historyItem._id = this.lastHistoryId;
+        historyItem._id = this.lastHistoryId;
 
-      storage.history.push(historyItem);
+        storage.history.push(historyItem);
+      });
     } else if (!inPage) {
-      this.lastHistoryId = '';
+      await this.historyQueue.enqueue(async () => {
+        this.lastHistoryId = '';
+      });
     }
   }
 
@@ -311,29 +318,32 @@ export class View extends BrowserView {
 
   public async updateData() {
     if (!this.incognito) {
-      if (this.lastHistoryId) {
+      const id = this.lastHistoryId;
+      if (id) {
         const { title, url, favicon } = this;
 
-        storage.update({
-          scope: 'history',
-          query: {
-            _id: this.lastHistoryId,
-          },
-          value: {
-            title,
-            url,
-            favicon,
-          },
-          multi: false,
+        this.historyQueue.enqueue(async () => {
+          await storage.update({
+            scope: 'history',
+            query: {
+              _id: id,
+            },
+            value: {
+              title,
+              url,
+              favicon,
+            },
+            multi: false,
+          });
+
+          const item = storage.history.find(x => x._id === id);
+
+          if (item) {
+            item.title = title;
+            item.url = url;
+            item.favicon = favicon;
+          }
         });
-
-        const item = storage.history.find(x => x._id === this.lastHistoryId);
-
-        if (item) {
-          item.title = title;
-          item.url = url;
-          item.favicon = favicon;
-        }
       }
     }
   }

src/utils/queue.ts

@@ -0,0 +1,50 @@
+export class Queue {
+  private queue: {
+    promise: () => Promise<any>;
+    reject: any;
+    resolve: any;
+  }[] = [];
+  private pendingPromise = false;
+
+  public enqueue<T>(promise: () => Promise<T>): Promise<T> {
+    return new Promise((resolve, reject) => {
+      this.queue.push({
+        promise,
+        resolve,
+        reject,
+      });
+
+      this.dequeue();
+    });
+  }
+
+  public dequeue() {
+    if (this.pendingPromise) {
+      return false;
+    }
+    const item = this.queue.shift();
+    if (!item) {
+      return false;
+    }
+    try {
+      this.pendingPromise = true;
+      item
+        .promise()
+        .then(value => {
+          this.pendingPromise = false;
+          item.resolve(value);
+          this.dequeue();
+        })
+        .catch(err => {
+          this.pendingPromise = false;
+          item.reject(err);
+          this.dequeue();
+        });
+    } catch (err) {
+      this.pendingPromise = false;
+      item.reject(err);
+      this.dequeue();
+    }
+    return true;
+  }
+}