3.0.24

- dbManager async API
- snjs@1.0.5
- fixes issue with blank alert on deleting locked note

app/assets/javascripts/app/controllers/editor.js

@@ -426,7 +426,7 @@ export class EditorPanel {
       let run = () => {
         $timeout(() => {
           if(this.note.locked) {
-            alertManager.alert("This note is locked. If you'd like to delete it, unlock it, and try again.");
+            alertManager.alert({text: "This note is locked. If you'd like to delete it, unlock it, and try again."});
             return;
           }
 

app/assets/javascripts/app/controllers/home.js

@@ -164,10 +164,12 @@ export class Home {
 
     function openDatabase() {
       dbManager.setLocked(false);
-      dbManager.openDatabase(null, function() {
+      dbManager.openDatabase({
-        // new database, delete syncToken so that items can be refetched entirely from server
+        onUpgradeNeeded: () => {
-        syncManager.clearSyncToken();
+          // new database, delete syncToken so that items can be refetched entirely from server
-        syncManager.sync();
+          syncManager.clearSyncToken();
+          syncManager.sync();
+        }
       })
     }
 

app/assets/javascripts/app/services/dbManager.js

@@ -16,166 +16,165 @@ export class DBManager {
     this.locked = locked;
   }
 
-  openDatabase(callback, onUgradeNeeded) {
+  async openDatabase({onUpgradeNeeded} = {}) {
     if(this.locked) {
       return;
     }
 
-    var request = window.indexedDB.open("standardnotes", 1);
+    const request = window.indexedDB.open("standardnotes", 1);
 
-    request.onerror = function(event) {
+    return new Promise((resolve, reject) => {
-      if(event.target.errorCode) {
+      request.onerror = (event) => {
-        this.alertManager.alert({text: "Offline database issue: " + event.target.errorCode});
+        if(event.target.errorCode) {
-      } else {
+          this.alertManager.alert({text: "Offline database issue: " + event.target.errorCode});
-        this.displayOfflineAlert();
+        } else {
-      }
+          this.displayOfflineAlert();
-      console.error("Offline database issue:", event);
-      if(callback) {
-        callback(null);
-      }
-    }.bind(this);
-
-    request.onsuccess = (event) => {
-      var db = event.target.result;
-      db.onversionchange = function(event) {
-        db.close();
-      };
-      db.onerror = function(errorEvent) {
-        console.log("Database error: " + errorEvent.target.errorCode);
-      }
-      if(callback) {
-        callback(db);
-      }
-    };
-
-    request.onblocked = (event) => {
-      console.error("Request blocked error:", event.target.errorCode);
-    }
-
-    request.onupgradeneeded = (event) => {
-      var db = event.target.result;
-
-      db.onversionchange = function(event) {
-        db.close();
-      };
-
-      // Create an objectStore for this database
-      var objectStore = db.createObjectStore("items", { keyPath: "uuid" });
-      objectStore.createIndex("title", "title", { unique: false });
-      objectStore.createIndex("uuid", "uuid", { unique: true });
-      objectStore.transaction.oncomplete = function(event) {
-        // Ready to store values in the newly created objectStore.
-        if(db.version === 1) {
-          if(onUgradeNeeded) {
-            onUgradeNeeded();
-          }
         }
+        console.error("Offline database issue:", event);
+        resolve(null);
       };
-    };
+
+      request.onsuccess = (event) => {
+        const db = event.target.result;
+        db.onversionchange = function(event) {
+          db.close();
+        };
+        db.onerror = function(errorEvent) {
+          console.log("Database error: " + errorEvent.target.errorCode);
+        }
+        resolve(db);
+      };
+
+      request.onblocked = (event) => {
+        console.error("Request blocked error:", event.target.errorCode);
+      }
+
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        db.onversionchange = function(event) {
+          db.close();
+        };
+
+        // Create an objectStore for this database
+        const objectStore = db.createObjectStore("items", { keyPath: "uuid" });
+        objectStore.createIndex("uuid", "uuid", { unique: true });
+        objectStore.transaction.oncomplete = function(event) {
+          // Ready to store values in the newly created objectStore.
+          if(db.version === 1 && onUpgradeNeeded) {
+            onUpgradeNeeded();
+          }
+        };
+      };
+    })
   }
 
-  getAllModels(callback) {
+  async getAllModels() {
-    this.openDatabase((db) => {
+    const db = await this.openDatabase();
-      var objectStore = db.transaction("items").objectStore("items");
+    const objectStore = db.transaction("items").objectStore("items");
-      var items = [];
+    const items = [];
-      objectStore.openCursor().onsuccess = function(event) {
+    return new Promise(async (resolve, reject) => {
-        var cursor = event.target.result;
+      objectStore.openCursor().onsuccess = (event) => {
+        const cursor = event.target.result;
         if (cursor) {
           items.push(cursor.value);
           cursor.continue();
-        }
+        } else {
-        else {
+          resolve(items);
-          callback(items);
         }
       };
-    }, null)
+    })
   }
 
-  saveModel(item) {
+  async saveModel(item) {
     this.saveModels([item]);
   }
 
-  saveModels(items, onsuccess, onerror) {
+  async saveModels(items) {
-
+    const showGenericError = (error) => {
-    if(items.length == 0) {
+      this.alertManager.alert({text: `Unable to save changes locally due to an unknown system issue. Issue Code: ${error.code} Issue Name: ${error.name}.`});
-      if(onsuccess) {
-        onsuccess();
-      }
-      return;
     }
 
-    this.openDatabase((db) => {
+    return new Promise(async (resolve, reject) => {
-      var transaction = db.transaction("items", "readwrite");
+      if(items.length === 0) {
-      transaction.oncomplete = function(event) {
+        resolve();
-
+        return;
-      };
+      }
 
+      const db = await this.openDatabase();
+      const transaction = db.transaction("items", "readwrite");
+      transaction.oncomplete = (event) => {};
       transaction.onerror = function(event) {
         console.error("Transaction error:", event.target.errorCode);
+        showGenericError(event.target.error);
       };
-
       transaction.onblocked = function(event) {
         console.error("Transaction blocked error:", event.target.errorCode);
+        showGenericError(event.target.error);
       };
-
       transaction.onabort = function(event) {
-        console.log("Offline saving aborted:", event);
+        console.error("Offline saving aborted:", event);
-        var error = event.target.error;
+        const error = event.target.error;
         if(error.name == "QuotaExceededError") {
           this.alertManager.alert({text: "Unable to save changes locally because your device is out of space. Please free up some disk space and try again, otherwise, your data may end up in an inconsistent state."});
         } else {
-          this.alertManager.alert({text: `Unable to save changes locally due to an unknown system issue. Issue Code: ${error.code} Issue Name: ${error.name}.`});
+          showGenericError(error);
         }
-        onerror && onerror(error);
+        reject(error);
       };
 
-      var itemObjectStore = transaction.objectStore("items");
+      const itemObjectStore = transaction.objectStore("items");
-      var i = 0;
-      putNext();
 
-      function putNext() {
+      const putItem = async (item) => {
-        if (i < items.length) {
+        return new Promise((resolve, reject) => {
-          var item = items[i];
+          const request = itemObjectStore.put(item);
-          var request = itemObjectStore.put(item);
           request.onerror = (event) => {
             console.error("DB put error:", event.target.error);
+            resolve();
           }
-          request.onsuccess = putNext;
+          request.onsuccess = resolve;
-          ++i;
+        })
-        } else {
-          onsuccess && onsuccess();
-        }
       }
-    }, null)
+
+      for(const item of items) {
+        await putItem(item);
+      }
+
+      resolve();
+    })
   }
 
-  deleteModel(item, callback) {
+  async deleteModel(item) {
-    this.openDatabase((db) => {
+    return new Promise(async (resolve, reject) => {
-      var request = db.transaction("items", "readwrite").objectStore("items").delete(item.uuid);
+      const db = await this.openDatabase();
-      request.onsuccess = function(event) {
+      const request = db.transaction("items", "readwrite").objectStore("items").delete(item.uuid);
-        if(callback) {
+      request.onsuccess = (event) => {
-          callback(true);
+        resolve();
-        }
+      }
+      request.onerror = (event) => {
+        reject();
+      }
+    })
+  }
+
+  async clearAllModels() {
+    const deleteRequest = window.indexedDB.deleteDatabase("standardnotes");
+
+    return new Promise((resolve, reject) => {
+      deleteRequest.onerror = function(event) {
+        console.log("Error deleting database.");
+        resolve();
       };
-    }, null)
-  }
 
-  clearAllModels(callback) {
+      deleteRequest.onsuccess = function(event) {
-    var deleteRequest = window.indexedDB.deleteDatabase("standardnotes");
+        console.log("Database deleted successfully");
+        resolve();
+      };
 
-    deleteRequest.onerror = function(event) {
+      deleteRequest.onblocked = function(event) {
-      console.log("Error deleting database.");
+        console.error("Delete request blocked");
-      callback && callback();
+        this.alertManager.alert({text: "Your browser is blocking Standard Notes from deleting the local database. Make sure there are no other open windows of this app and try again. If the issue persists, please manually delete app data to sign out."})
-    };
+        resolve();
-
+      };
-    deleteRequest.onsuccess = function(event) {
+    })
-      console.log("Database deleted successfully");
-      callback && callback();
-    };
-
-    deleteRequest.onblocked = function(event) {
-      console.error("Delete request blocked");
-      this.alertManager.alert({text: "Your browser is blocking Standard Notes from deleting the local database. Make sure there are no other open windows of this app and try again. If the issue persists, please manually delete app data to sign out."})
-    };
   }
 }

app/assets/javascripts/app/services/storageManager.js

@@ -210,13 +210,9 @@ export class StorageManager extends SFStorageManager {
   }
 
   async getAllModels() {
-    return new Promise((resolve, reject) => {
+    if(this.modelStorageMode == StorageManager.Fixed) {
-      if(this.modelStorageMode == StorageManager.Fixed) {
+      return this.dbManager.getAllModels();
-        this.dbManager.getAllModels(resolve);
+    }
-      } else {
-        resolve();
-      }
-    })
   }
 
   async saveModel(item) {
@@ -224,29 +220,19 @@ export class StorageManager extends SFStorageManager {
   }
 
   async saveModels(items, onsuccess, onerror) {
-    return new Promise((resolve, reject) => {
+    if(this.modelStorageMode == StorageManager.Fixed) {
-      if(this.modelStorageMode == StorageManager.Fixed) {
+      return this.dbManager.saveModels(items);
-        this.dbManager.saveModels(items, resolve, reject);
+    }
-      } else {
-        resolve();
-      }
-    });
   }
 
   async deleteModel(item) {
-    return new Promise((resolve, reject) => {
+    if(this.modelStorageMode == StorageManager.Fixed) {
-      if(this.modelStorageMode == StorageManager.Fixed) {
+      return this.dbManager.deleteModel(item);
-        this.dbManager.deleteModel(item, resolve);
+    }
-      } else {
-        resolve();
-      }
-    });
   }
 
   async clearAllModels() {
-    return new Promise((resolve, reject) => {
+    return this.dbManager.clearAllModels();
-      this.dbManager.clearAllModels(resolve);
-    });
   }
 }
 

app/assets/javascripts/app/services/syncManager.js

@@ -17,11 +17,6 @@ export class SyncManager extends SFSyncManager {
     this.$compile = $compile;
 
     // this.loggingEnabled = true;
-
-    // Content types appearing first are always mapped first
-    this.contentTypeLoadPriority = [
-      "SN|UserPreferences", "SN|Privileges",
-      "SN|Component", "SN|Theme"];
   }
 
   presentConflictResolutionModal(items, callback) {

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "standard-notes-web",
-  "version": "3.0.22",
+  "version": "3.0.24",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {
@@ -8687,9 +8687,9 @@
       }
     },
     "snjs": {
-      "version": "1.0.3",
+      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/snjs/-/snjs-1.0.3.tgz",
+      "resolved": "https://registry.npmjs.org/snjs/-/snjs-1.0.5.tgz",
-      "integrity": "sha512-XKw0PYfZjTB4bQOdF7nxkSHdCgAsHv6CyfXLK927vQzo5PBi5pZWobx+C9l0uajt/VmSk9YdO8+fQhCK3GcFNw==",
+      "integrity": "sha512-wKasLkMCcd9KYjgZxUNX2TkWVUO/G8YGI2P7hA189BlFjeDv/U9epm6oPo+C4jHkFPV6ttEz/iWTs2CoK4u5Fg==",
       "dev": true,
       "requires": {
         "lodash": "^4.17.15"

package.json

@@ -1,6 +1,6 @@
 {
   "name": "standard-notes-web",
-  "version": "3.0.22",
+  "version": "3.0.24",
   "license": "AGPL-3.0-or-later",
   "repository": {
     "type": "git",
@@ -44,7 +44,7 @@
     "mocha": "^6.2.2",
     "serve-static": "^1.14.1",
     "sn-stylekit": "2.0.20",
-    "snjs": "1.0.3",
+    "snjs": "1.0.5",
     "webpack": "^4.41.3",
     "webpack-cli": "^3.3.10"
   },