title: IndexedDB main thread & WebWorker eventlisteners
body: <p>Hello I'm building an application in which I use indexeDB. Based on app config I' m able to choose if I should use indexeDB from WebWorker or from the main UI thread. A connection from the main UI thread is always being made regardless of the config. However based on the config the heavy lifting is being done from the worker if selected.</p>
  
  <p>Example of import prototype:</p>
  
  <pre><code>Database.prototype.importItem = function(item, callback) {
  
      if (this.settings.useWorker) {
  
          this.postMessage({
              cmd: "importItem",
              data: item
          }, callback);
  
      } else {
  
          var that = this;
          var transaction = this.db.transaction(this.settings.collection, "readwrite");
          var objectStore = transaction.objectStore(this.settings.collection);
          var request = objectStore.add(item);
  
          request.onerror = function(evt) {
              if (callback &amp;&amp; callback instanceof Function) {
                  callback(new ApplicationError("importItem error", evt.target.error), null);
              }
          };
  
          request.onsuccess = function(evt) {
              if (callback &amp;&amp; callback instanceof Function) {
                  callback(null, evt.target.result);
              }
          };
  
          transaction.oncomplete = function(evt) {};
  
      }
  };
  </code></pre>
  
  <p>What I'm curious about thought is the event listeners that are required from indexedDB, example:</p>
  
  <pre><code>Database.prototype.connect = function() {
  
      if (!this.supported()) {
          return this.emit("error", new ApplicationError("IndexedDB not supported!"));
      }
  
      var that = this;
      var openRequest = window.indexedDB.open(this.settings.dbName, this.settings.dbVersion);
  
      /**
       * [onerror description]
       * @param  {[type]} evt [description]
       * @return {[type]}     [description]
       */
      openRequest.onerror = function(evt) {
          that.emit("error", new ApplicationError("openRequest.onerror error", evt.target.error));
      };
  
      /**
       * [onblocked description]
       * @param  {[type]} evt [description]
       * @return {[type]}     [description]
       */
      openRequest.onblocked = function(evt) {
          // If some other tab is loaded with the database, then it needs to be closed
          // before we can proceed.
          alert("Please close all other tabs with this site open!");
      };
  
      /**
       * [onsuccess description]
       * @param  {[type]} evt [description]
       * @return {[type]}     [description]
       */
      openRequest.onsuccess = function(evt) {
  
          that.db = evt.target.result;
  
          that.db.onerror = function(evt) {
              logger.warn("openRequest.onsuccess error", evt.target);
          };
  
          that.db.onabort = function(evt) {
              logger.warn("openRequest.onsuccess abort", evt.target);
          };
  
          that.db.onversionchange = function(evt) {
              that.db.close();
              that.emit("versionchange", new ApplicationError("openRequest.onsuccess version change", evt.target));
          };
  
          if (that.settings.useWorker) {
              that.requestWorker();
          } else {
              that.emit("connect");
          }
  
      };
  
      /**
       * [onupgradeneeded description]
       * @param  {[type]} evt [description]
       * @return {[type]}     [description]
       */
      openRequest.onupgradeneeded = function(evt) {
  
          var stores = {};
  
          that.db = evt.target.result;
  
          that.db.onerror = function(evt) {
              logger.warn("openRequest.onupgradeneeded error", evt.target);
          };
  
          that.db.onabort = function(evt) {
              logger.warn("openRequest.onupgradeneeded abort", evt.target);
          };
  
          that.db.onversionchange = function(evt) {
              that.db.close();
              that.emit("versionchange", new ApplicationError("openRequest.onupgradeneeded version change", evt.target));
          };
  
          // Check for the objectStore - collection and delete it if exists
          if (that.db.objectStoreNames.contains(that.settings.collection)) {
              that.db.deleteObjectStore(that.settings.collection);
          }
  
          // Create new objectStore
          stores[that.settings.collection] = that.db.createObjectStore(that.settings.collection, {
              keyPath: that.settings.indexes[0]
          });
  
          // Create database indexes
          that.settings.indexes.forEach(function(index) {
              stores[that.settings.collection].createIndex(index, index, {
                  unique: false
              });
          });
  
          that.upgraded = true;
          that.emit("upgrade");
  
      };
  
      /**
       * [onbeforeunload description]
       * @param  {[type]} evt [description]
       * @return {[type]}     [description]
       */
      window.onbeforeunload = function(evt) {
          that.db.close();
      };
  
  };
  </code></pre>
  
  <p>Since I'm connecting always first from the main ui and then from the worker, should I just listen for events like "onblocked, versionchange" only in the main UI thread and not in the worker? I Suppose it wont be needed to listen from both threads?</p>
  
  <p><strong>UPDATE</strong></p>
  
  <p>I know that this is a weird implementation but the reason I was thinking about it is because I'm building an app on a very machine that has 3GB of ram and 2 cores... Also I have a method that iterates all records in a collection from my db. What I was thinking is pass each record retrieved to another method for image loading &amp; manipulation and then perhaps call the callback... That would limit the memory usage since it would be done in a serie if I'm not mistaken. However I'm not sure if the transaction will still be alive.</p>
  
  <p>Bottom line that's the main reason I was thinking for 2 connections (because of 1 method) and I was wondering if I could avoid double event listeners. Maybe have some of them on 1 thread.</p>