Chore+Refactor: Replace `nedb` package with `nedb-promises`

The 'nedb' package is unmaintained (last update was 5 years ago) and
has a couple of high severity vulnerabilities.

In addition, the use of callbacks is somewhat cumbersome for
the project's current workflow.

Therefore, I've decided to replace it with the 'nedb-promises' package,
which, internally, makes use of a maintained fork of 'nedb' and
wraps its API with Promises.

package-lock.json

@@ -3577,6 +3577,21 @@
         "fastq": "^1.6.0"
       }
     },
+    "@seald-io/binary-search-tree": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/@seald-io/binary-search-tree/-/binary-search-tree-1.0.2.tgz",
+      "integrity": "sha512-+pYGvPFAk7wUR+ONMOlc6A+LUN4kOCFwyPLjyaeS7wVibADPHWYJNYsNtyIAwjF1AXQkuaXElnIc4XjKt55QZA=="
+    },
+    "@seald-io/nedb": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/@seald-io/nedb/-/nedb-2.0.3.tgz",
+      "integrity": "sha512-NLnaDav050gnAMM8mnKQE9oH3F9RzGdKornukxLJ7BCf2YXEWndTf3Bmd+1mOqFs5DZnTY0SRigIwVXd8L39Xg==",
+      "requires": {
+        "@seald-io/binary-search-tree": "^1.0.2",
+        "async": "0.2.10",
+        "localforage": "^1.9.0"
+      }
+    },
     "@silvermine/videojs-quality-selector": {
       "version": "1.2.5",
       "resolved": "https://registry.npmjs.org/@silvermine/videojs-quality-selector/-/videojs-quality-selector-1.2.5.tgz",
@@ -5449,21 +5464,6 @@
       "integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==",
       "dev": true
     },
-    "binary-search-tree": {
-      "version": "0.2.5",
-      "resolved": "https://registry.npmjs.org/binary-search-tree/-/binary-search-tree-0.2.5.tgz",
-      "integrity": "sha1-fbs7IQ/coIJFDa0jNMMErzm9x4Q=",
-      "requires": {
-        "underscore": "~1.4.4"
-      },
-      "dependencies": {
-        "underscore": {
-          "version": "1.4.4",
-          "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.4.4.tgz",
-          "integrity": "sha1-YaajIBBiKvoHljvzJSA88SI51gQ="
-        }
-      }
-    },
     "bindings": {
       "version": "1.5.0",
       "resolved": "https://registry.npmjs.org/bindings/-/bindings-1.5.0.tgz",
@@ -12841,7 +12841,8 @@
     "minimist": {
       "version": "1.2.5",
       "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.5.tgz",
-      "integrity": "sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw=="
+      "integrity": "sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==",
+      "dev": true
     },
     "minipass": {
       "version": "3.1.3",
@@ -12887,6 +12888,7 @@
       "version": "0.5.5",
       "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.5.tgz",
       "integrity": "sha512-NKmAlESf6jMGym1++R0Ra7wvhV+wFW63FaSOFPwRahvea0gMUcGUhVeAg/0BC0wiv9ih5NYPB1Wn1UEI1/L+xQ==",
+      "dev": true,
       "requires": {
         "minimist": "^1.2.5"
       }
@@ -12988,23 +12990,12 @@
       "integrity": "sha1-Sr6/7tdUHywnrPspvbvRXI1bpPc=",
       "dev": true
     },
-    "nedb": {
+    "nedb-promises": {
-      "version": "1.8.0",
+      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/nedb/-/nedb-1.8.0.tgz",
+      "resolved": "https://registry.npmjs.org/nedb-promises/-/nedb-promises-5.0.0.tgz",
-      "integrity": "sha1-DjUCzYLABNU1WkPJ5VV3vXvZHYg=",
+      "integrity": "sha512-PZ+V+1RScHr3mZHflAMMkx35naGHKVVGtqLwdK2aado7uN2HcIcubiaVlE/X8BTa34RnIHmusVM+VeTj/pnfew==",
       "requires": {
-        "async": "0.2.10",
+        "@seald-io/nedb": "^2.0.3"
-        "binary-search-tree": "0.2.5",
-        "localforage": "^1.3.0",
-        "mkdirp": "~0.5.1",
-        "underscore": "~1.4.4"
-      },
-      "dependencies": {
-        "underscore": {
-          "version": "1.4.4",
-          "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.4.4.tgz",
-          "integrity": "sha1-YaajIBBiKvoHljvzJSA88SI51gQ="
-        }
       }
     },
     "needle": {

package.json

@@ -26,7 +26,7 @@
     "lodash.uniqwith": "^4.5.0",
     "marked": "^2.1.1",
     "material-design-icons": "^3.0.1",
-    "nedb": "^1.8.0",
+    "nedb-promises": "^5.0.0",
     "node-forge": "^0.10.0",
     "opml-to-json": "^1.0.1",
     "rss-parser": "^3.12.0",

src/main/index.js

@@ -2,7 +2,7 @@ import {
   app, BrowserWindow, dialog, Menu, ipcMain,
   powerSaveBlocker, screen, session, shell
 } from 'electron'
-import Datastore from 'nedb'
+import Datastore from 'nedb-promises'
 import path from 'path'
 import cp from 'child_process'
 
@@ -23,7 +23,7 @@ function runApp() {
 
   const localDataStorage = app.getPath('userData') // Grabs the userdata directory based on the user's OS
 
-  const settingsDb = new Datastore({
+  const settingsDb = Datastore.create({
     filename: localDataStorage + '/settings.db',
     autoload: true
   })
@@ -83,8 +83,10 @@ function runApp() {
     })
   }
 
-  app.on('ready', (_, __) => {
+  app.on('ready', async (_, __) => {
-    settingsDb.find({
+    let docArray
+    try {
+      docArray = await settingsDb.find({
         $or: [
           { _id: 'disableSmoothScrolling' },
           { _id: 'useProxy' },
@@ -92,8 +94,9 @@ function runApp() {
           { _id: 'proxyHostname' },
           { _id: 'proxyPort' }
         ]
-    }, function (err, doc) {
+      })
-      if (err) {
+    } catch (err) {
+      console.error(err)
       app.exit()
       return
     }
@@ -104,23 +107,23 @@ function runApp() {
     let proxyHostname = '127.0.0.1'
     let proxyPort = '9050'
 
-      if (typeof doc === 'object' && doc.length > 0) {
+    if (docArray?.length > 0) {
-        doc.forEach((dbItem) => {
+      docArray.forEach((doc) => {
-          switch (dbItem._id) {
+        switch (doc._id) {
           case 'disableSmoothScrolling':
-              disableSmoothScrolling = dbItem.value
+            disableSmoothScrolling = doc.value
             break
           case 'useProxy':
-              useProxy = dbItem.value
+            useProxy = doc.value
             break
           case 'proxyProtocol':
-              proxyProtocol = dbItem.value
+            proxyProtocol = doc.value
             break
           case 'proxyHostname':
-              proxyHostname = dbItem.value
+            proxyHostname = doc.value
             break
           case 'proxyPort':
-              proxyPort = dbItem.value
+            proxyPort = doc.value
             break
         }
       })
@@ -153,7 +156,7 @@ function runApp() {
       })
     })
 
-      createWindow()
+    await createWindow()
 
     if (isDev) {
       installDevTools()
@@ -163,7 +166,6 @@ function runApp() {
       mainWindow.webContents.openDevTools()
     }
   })
-  })
 
   async function installDevTools() {
     try {
@@ -175,7 +177,7 @@ function runApp() {
     }
   }
 
-  function createWindow(replaceMainWindow = true) {
+  async function createWindow(replaceMainWindow = true) {
     /**
      * Initial window options
      */
@@ -206,18 +208,9 @@ function runApp() {
       height: 800
     })
 
-    settingsDb.findOne({
+    const boundsDoc = await settingsDb.findOne({ _id: 'bounds' })
-      _id: 'bounds'
+    if (typeof boundsDoc?.value === 'object') {
-    }, function (err, doc) {
+      const { maximized, ...bounds } = boundsDoc.value
-      if (doc === null || err) {
-        return
-      }
-
-      if (typeof doc !== 'object' || typeof doc.value !== 'object') {
-        return
-      }
-
-      const { maximized, ...bounds } = doc.value
       const allDisplaysSummaryWidth = screen
         .getAllDisplays()
         .reduce((accumulator, { size: { width } }) => accumulator + width, 0)
@@ -233,7 +226,7 @@ function runApp() {
       if (maximized) {
         newWindow.maximize()
       }
-    })
+    }
 
     // If called multiple times
     // Duplicate menu items will be added
@@ -274,18 +267,19 @@ function runApp() {
   }
 
   // Save closing window bounds & maximized status
-  ipcMain.on('setBounds', (event) => {
+  ipcMain.on('setBounds', async (event) => {
     const value = {
       ...mainWindow.getNormalBounds(),
       maximized: mainWindow.isMaximized()
     }
 
-    settingsDb.update(
+    await settingsDb.update(
       { _id: 'bounds' },
       { _id: 'bounds', value },
-      { upsert: true },
+      { upsert: true }
-      () => { event.returnValue = 0 }
     )
+
+    event.returnValue = 0
   })
 
   ipcMain.on('appReady', () => {

src/renderer/store/datastores.js

@@ -1,4 +1,4 @@
-import Datastore from 'nedb'
+import Datastore from 'nedb-promises'
 
 // Initialize all datastores and export their references
 // Current dbs:
@@ -7,36 +7,34 @@ import Datastore from 'nedb'
 // `playlists.db`
 // `history.db`
 
+let buildFileName = null
+
 // Check if using Electron
-let userDataPath
 const usingElectron = window?.process?.type === 'renderer'
 if (usingElectron) {
   const { ipcRenderer } = require('electron')
-  userDataPath = ipcRenderer.sendSync('getUserDataPathSync')
+  const userDataPath = ipcRenderer.sendSync('getUserDataPathSync')
+  buildFileName = (dbName) => userDataPath + '/' + dbName + '.db'
+} else {
+  buildFileName = (dbName) => dbName + '.db'
 }
 
-const buildFileName = (dbName) => {
+const settingsDb = Datastore.create({
-  return usingElectron
-    ? userDataPath + '/' + dbName + '.db'
-    : dbName + '.db'
-}
-
-const settingsDb = new Datastore({
   filename: buildFileName('settings'),
   autoload: true
 })
 
-const playlistsDb = new Datastore({
+const playlistsDb = Datastore.create({
   filename: buildFileName('playlists'),
   autoload: true
 })
 
-const profilesDb = new Datastore({
+const profilesDb = Datastore.create({
   filename: buildFileName('profiles'),
   autoload: true
 })
 
-const historyDb = new Datastore({
+const historyDb = Datastore.create({
   filename: buildFileName('history'),
   autoload: true
 })

src/renderer/store/modules/history.js

@@ -11,57 +11,46 @@ const getters = {
 }
 
 const actions = {
-  grabHistory ({ commit }) {
+  async grabHistory({ commit }) {
-    historyDb.find({}).sort({
+    const results = await historyDb.find({}).sort({ timeWatched: -1 })
-      timeWatched: -1
-    }).exec((err, results) => {
-      if (err) {
-        console.log(err)
-        return
-      }
     commit('setHistoryCache', results)
-    })
   },
 
-  updateHistory ({ dispatch }, videoData) {
+  async updateHistory({ dispatch }, videoData) {
-    historyDb.update({ videoId: videoData.videoId }, videoData, { upsert: true }, (err, numReplaced) => {
+    await historyDb.update(
-      if (!err) {
+      { videoId: videoData.videoId },
+      videoData,
+      { upsert: true }
+    )
     dispatch('grabHistory')
-      }
-    })
   },
 
-  removeFromHistory ({ dispatch }, videoId) {
+  async removeFromHistory({ dispatch }, videoId) {
-    historyDb.remove({ videoId: videoId }, (err, numReplaced) => {
+    await historyDb.remove({ videoId: videoId })
-      if (!err) {
     dispatch('grabHistory')
-      }
-    })
   },
 
-  removeAllHistory ({ dispatch }) {
+  async removeAllHistory({ dispatch }) {
-    historyDb.remove({}, { multi: true }, (err, numReplaced) => {
+    await historyDb.remove({}, { multi: true })
-      if (!err) {
     dispatch('grabHistory')
-      }
-    })
   },
 
-  updateWatchProgress ({ dispatch }, videoData) {
+  async updateWatchProgress({ dispatch }, videoData) {
-    historyDb.update({ videoId: videoData.videoId }, { $set: { watchProgress: videoData.watchProgress } }, { upsert: true }, (err, numReplaced) => {
+    await historyDb.update(
-      if (!err) {
+      { videoId: videoData.videoId },
+      { $set: { watchProgress: videoData.watchProgress } },
+      { upsert: true }
+    )
     dispatch('grabHistory')
-      }
-    })
   },
 
-  compactHistory (_) {
+  compactHistory(_) {
     historyDb.persistence.compactDatafile()
   }
 }
 
 const mutations = {
-  setHistoryCache (state, historyCache) {
+  setHistoryCache(state, historyCache) {
     state.historyCache = historyCache
   }
 }

src/renderer/store/modules/playlists.js

@@ -24,156 +24,146 @@ const getters = {
 }
 
 const actions = {
-  addPlaylist ({ commit }, payload) {
+  async addPlaylist({ commit }, payload) {
-    playlistsDb.insert(payload, (err, payload) => {
+    await playlistsDb.insert(payload)
-      if (err) {
-        console.error(err)
-      } else {
     commit('addPlaylist', payload)
-      }
-    })
   },
-  addPlaylists ({ commit }, payload) {
+
-    playlistsDb.insert(payload, (err, payload) => {
+  async addPlaylists({ commit }, payload) {
-      if (err) {
+    await playlistsDb.insert(payload)
-        console.error(err)
-      } else {
     commit('addPlaylists', payload)
-      }
-    })
   },
-  addVideo ({ commit }, payload) {
+
-    playlistsDb.update({ playlistName: payload.playlistName }, { $push: { videos: payload.videoData } }, { upsert: true }, err => {
+  async addVideo({ commit }, payload) {
-      if (err) {
+    await playlistsDb.update(
-        console.error(err)
+      { playlistName: payload.playlistName },
-      } else {
+      { $push: { videos: payload.videoData } },
+      { upsert: true }
+    )
     commit('addVideo', payload)
-      }
-    })
   },
-  addVideos ({ commit }, payload) {
+
-    playlistsDb.update({ _id: payload.playlistId }, { $push: { videos: { $each: payload.videosIds } } }, { upsert: true }, err => {
+  async addVideos({ commit }, payload) {
-      if (err) {
+    await playlistsDb.update(
-        console.error(err)
+      { _id: payload.playlistId },
-      } else {
+      { $push: { videos: { $each: payload.videosIds } } },
+      { upsert: true }
+    )
     commit('addVideos', payload)
-      }
-    })
   },
-  grabAllPlaylists({ commit, dispatch }) {
+
-    playlistsDb.find({}, (err, payload) => {
+  async grabAllPlaylists({ commit, dispatch }) {
-      if (err) {
+    const payload = await playlistsDb.find({})
-        console.error(err)
-      } else {
     if (payload.length === 0) {
       commit('setAllPlaylists', state.playlists)
       dispatch('addPlaylists', payload)
     } else {
       commit('setAllPlaylists', payload)
     }
-      }
-    })
   },
-  removeAllPlaylists ({ commit }) {
+
-    playlistsDb.remove({ protected: { $ne: true } }, err => {
+  async removeAllPlaylists({ commit }) {
-      if (err) {
+    await playlistsDb.remove({ protected: { $ne: true } })
-        console.error(err)
-      } else {
     commit('removeAllPlaylists')
-      }
-    })
   },
-  removeAllVideos ({ commit }, playlistName) {
+
-    playlistsDb.update({ playlistName: playlistName }, { $set: { videos: [] } }, { upsert: true }, err => {
+  async removeAllVideos({ commit }, playlistName) {
-      if (err) {
+    await playlistsDb.update(
-        console.error(err)
+      { playlistName: playlistName },
-      } else {
+      { $set: { videos: [] } },
+      { upsert: true }
+    )
     commit('removeAllVideos', playlistName)
-      }
-    })
   },
-  removePlaylist ({ commit }, playlistId) {
+
-    playlistsDb.remove({ _id: playlistId, protected: { $ne: true } }, (err, playlistId) => {
+  async removePlaylist({ commit }, playlistId) {
-      if (err) {
+    await playlistsDb.remove({
-        console.error(err)
+      _id: playlistId,
-      } else {
+      protected: { $ne: true }
+    })
     commit('removePlaylist', playlistId)
-      }
-    })
   },
-  removePlaylists ({ commit }, playlistIds) {
+
-    playlistsDb.remove({ _id: { $in: playlistIds }, protected: { $ne: true } }, (err, playlistIds) => {
+  async removePlaylists({ commit }, playlistIds) {
-      if (err) {
+    await playlistsDb.remove({
-        console.error(err)
+      _id: { $in: playlistIds },
-      } else {
+      protected: { $ne: true }
+    })
     commit('removePlaylists', playlistIds)
-      }
-    })
   },
-  removeVideo ({ commit }, payload) {
+
-    playlistsDb.update({ playlistName: payload.playlistName }, { $pull: { videos: { videoId: payload.videoId } } }, { upsert: true }, (err, numRemoved) => {
+  async removeVideo({ commit }, payload) {
-      if (err) {
+    await playlistsDb.update(
-        console.error(err)
+      { playlistName: payload.playlistName },
-      } else {
+      { $pull: { videos: { videoId: payload.videoId } } },
+      { upsert: true }
+    )
     commit('removeVideo', payload)
-      }
-    })
   },
-  removeVideos ({ commit }, payload) {
+
-    playlistsDb.update({ _id: payload.playlistName }, { $pull: { videos: { $in: payload.videoId } } }, { upsert: true }, err => {
+  async removeVideos({ commit }, payload) {
-      if (err) {
+    await playlistsDb.update(
-        console.error(err)
+      { _id: payload.playlistName },
-      } else {
+      { $pull: { videos: { $in: payload.videoId } } },
+      { upsert: true }
+    )
     commit('removeVideos', payload)
   }
-    })
-  }
 }
 
 const mutations = {
-  addPlaylist (state, payload) {
+  addPlaylist(state, payload) {
     state.playlists.push(payload)
   },
-  addPlaylists (state, payload) {
+
+  addPlaylists(state, payload) {
     state.playlists = state.playlists.concat(payload)
   },
-  addVideo (state, payload) {
+
+  addVideo(state, payload) {
     const playlist = state.playlists.find(playlist => playlist.playlistName === payload.playlistName)
     if (playlist) {
       playlist.videos.push(payload.videoData)
     }
   },
-  addVideos (state, payload) {
+
+  addVideos(state, payload) {
     const playlist = state.playlists.find(playlist => playlist._id === payload.playlistId)
     if (playlist) {
       playlist.videos = playlist.videos.concat(payload.playlistIds)
     }
   },
-  removeAllPlaylists (state) {
+
+  removeAllPlaylists(state) {
     state.playlists = state.playlists.filter(playlist => playlist.protected !== true)
   },
-  removeAllVideos (state, playlistName) {
+
+  removeAllVideos(state, playlistName) {
     const playlist = state.playlists.find(playlist => playlist.playlistName === playlistName)
     if (playlist) {
       playlist.videos = []
     }
   },
-  removeVideo (state, payload) {
+
+  removeVideo(state, payload) {
     const playlist = state.playlists.findIndex(playlist => playlist.playlistName === payload.playlistName)
     if (playlist !== -1) {
       state.playlists[playlist].videos = state.playlists[playlist].videos.filter(video => video.videoId !== payload.videoId)
     }
   },
-  removeVideos (state, payload) {
+
+  removeVideos(state, payload) {
     const playlist = state.playlists.findIndex(playlist => playlist._id === payload.playlistId)
     if (playlist !== -1) {
       playlist.videos = playlist.videos.filter(video => payload.videoId.indexOf(video) === -1)
     }
   },
-  removePlaylist (state, playlistId) {
+
+  removePlaylist(state, playlistId) {
     state.playlists = state.playlists.filter(playlist => playlist._id !== playlistId || playlist.protected)
   },
-  setAllPlaylists (state, payload) {
+
+  setAllPlaylists(state, payload) {
     state.playlists = payload
   }
 }

src/renderer/store/modules/profiles.js

@@ -22,16 +22,15 @@ const getters = {
 }
 
 const actions = {
-  grabAllProfiles ({ rootState, dispatch, commit }, defaultName = null) {
+  async grabAllProfiles({ rootState, dispatch, commit }, defaultName = null) {
-    return new Promise((resolve, reject) => {
+    let profiles = await profilesDb.find({})
-      profilesDb.find({}, (err, results) => {
+    if (profiles.length === 0) {
-        if (!err) {
-          if (results.length === 0) {
       dispatch('createDefaultProfile', defaultName)
-          } else {
+      return
+    }
     // We want the primary profile to always be first
     // So sort with that then sort alphabetically by profile name
-            const profiles = results.sort((a, b) => {
+    profiles = profiles.sort((a, b) => {
       if (a._id === 'allChannels') {
         return -1
       }
@@ -54,28 +53,14 @@ const actions = {
     }
 
     commit('setProfileList', profiles)
-          }
-
-          resolve()
-        } else {
-          reject(err)
-        }
-      })
-    })
   },
 
-  grabProfileInfo (_, profileId) {
+  async grabProfileInfo(_, profileId) {
-    return new Promise((resolve, reject) => {
     console.log(profileId)
-      profilesDb.findOne({ _id: profileId }, (err, results) => {
+    return await profilesDb.findOne({ _id: profileId })
-        if (!err) {
-          resolve(results)
-        }
-      })
-    })
   },
 
-  async createDefaultProfile ({ dispatch }, defaultName) {
+  async createDefaultProfile({ dispatch }, defaultName) {
     const randomColor = await dispatch('getRandomColor')
     const textColor = await dispatch('calculateColorLuminance', randomColor)
     const defaultProfile = {
@@ -86,51 +71,47 @@ const actions = {
       subscriptions: []
     }
 
-    profilesDb.update({ _id: 'allChannels' }, defaultProfile, { upsert: true }, (err, numReplaced) => {
+    await profilesDb.update(
-      if (!err) {
+      { _id: 'allChannels' },
+      defaultProfile,
+      { upsert: true }
+    )
     dispatch('grabAllProfiles')
-      }
-    })
   },
 
-  updateProfile ({ dispatch }, profile) {
+  async updateProfile({ dispatch }, profile) {
-    profilesDb.update({ _id: profile._id }, profile, { upsert: true }, (err, numReplaced) => {
+    await profilesDb.update(
-      if (!err) {
+      { _id: profile._id },
+      profile,
+      { upsert: true }
+    )
     dispatch('grabAllProfiles')
-      }
-    })
   },
 
-  insertProfile ({ dispatch }, profile) {
+  async insertProfile({ dispatch }, profile) {
-    profilesDb.insert(profile, (err, newDocs) => {
+    await profilesDb.insert(profile)
-      if (!err) {
     dispatch('grabAllProfiles')
-      }
-    })
   },
 
-  removeProfile ({ dispatch }, profileId) {
+  async removeProfile({ dispatch }, profileId) {
-    profilesDb.remove({ _id: profileId }, (err, numReplaced) => {
+    await profilesDb.remove({ _id: profileId })
-      if (!err) {
     dispatch('grabAllProfiles')
-      }
-    })
   },
 
-  compactProfiles (_) {
+  compactProfiles(_) {
     profilesDb.persistence.compactDatafile()
   },
 
-  updateActiveProfile ({ commit }, index) {
+  updateActiveProfile({ commit }, index) {
     commit('setActiveProfile', index)
   }
 }
 
 const mutations = {
-  setProfileList (state, profileList) {
+  setProfileList(state, profileList) {
     state.profileList = profileList
   },
-  setActiveProfile (state, activeProfile) {
+  setActiveProfile(state, activeProfile) {
     state.activeProfile = activeProfile
   }
 }

src/renderer/store/modules/settings.js

@@ -264,15 +264,10 @@ Object.assign(customGetters, {
 /**********/
 
 const customActions = {
-  grabUserSettings: ({ commit, dispatch, getters }) => {
+  grabUserSettings: async ({ commit, dispatch, getters }) => {
-    return new Promise((resolve, reject) => {
+    const userSettings = await settingsDb.find({
-      settingsDb.find(
+      _id: { $ne: 'bounds' }
-        { _id: { $ne: 'bounds' } },
+    })
-        (err, userSettings) => {
-          if (err) {
-            reject(err)
-            return
-          }
 
     for (const setting of userSettings) {
       const { _id, value } = setting
@@ -282,11 +277,6 @@ const customActions = {
 
       commit(defaultMutationId(_id), value)
     }
-
-          resolve()
-        }
-      )
-    })
   },
 
   setUpListenerToSyncSettings: ({ commit, dispatch, getters }) => {
@@ -347,13 +337,12 @@ for (const settingId of Object.keys(state)) {
     actions[triggerId] = stateWithSideEffects[settingId].sideEffectsHandler
   }
 
-  actions[updaterId] = ({ commit, dispatch, getters }, value) => {
+  actions[updaterId] = async ({ commit, dispatch, getters }, value) => {
-    settingsDb.update(
+    await settingsDb.update(
       { _id: settingId },
       { _id: settingId, value: value },
-      { upsert: true },
+      { upsert: true }
-      (err, _) => {
+    )
-        if (err) return
 
     const {
       getUsingElectron: usingElectron,
@@ -374,8 +363,6 @@ for (const settingId of Object.keys(state)) {
       })
     }
   }
-    )
-  }
 }
 
 // Add all custom data/logic to their respective objects