atom/src/state-store.js

'use strict';

module.exports = class StateStore {
  constructor(databaseName, version) {
    this.connected = false;
    this.databaseName = databaseName;
    this.version = version;
  }

  get dbPromise() {
    if (!this._dbPromise) {
      this._dbPromise = new Promise(resolve => {
        const dbOpenRequest = indexedDB.open(this.databaseName, this.version);
        dbOpenRequest.onupgradeneeded = event => {
          let db = event.target.result;
          db.createObjectStore('states');
        };
        dbOpenRequest.onsuccess = () => {
          this.connected = true;
          resolve(dbOpenRequest.result);
        };
        dbOpenRequest.onerror = error => {
          console.error('Could not connect to indexedDB', error);
          this.connected = false;
          resolve(null);
        };
      });
    }

    return this._dbPromise;
  }

  isConnected() {
    return this.connected;
  }

  connect() {
    return this.dbPromise.then(db => !!db);
  }

  save(key, value) {
    return new Promise((resolve, reject) => {
      this.dbPromise.then(db => {
        if (db == null) return resolve();

        var request = db
          .transaction(['states'], 'readwrite')
          .objectStore('states')
          .put({ value: value, storedAt: new Date().toString() }, key);

        request.onsuccess = resolve;
        request.onerror = reject;
      });
    });
  }

  load(key) {
    return this.dbPromise.then(db => {
      if (!db) return;

      return new Promise((resolve, reject) => {
        var request = db
          .transaction(['states'])
          .objectStore('states')
          .get(key);

        request.onsuccess = event => {
          let result = event.target.result;
          if (result && !result.isJSON) {
            resolve(result.value);
          } else {
            resolve(null);
          }
        };

        request.onerror = event => reject(event);
      });
    });
  }

  delete(key) {
    return new Promise((resolve, reject) => {
      this.dbPromise.then(db => {
        if (db == null) return resolve();

        var request = db
          .transaction(['states'], 'readwrite')
          .objectStore('states')
          .delete(key);

        request.onsuccess = resolve;
        request.onerror = reject;
      });
    });
  }

  clear() {
    return this.dbPromise.then(db => {
      if (!db) return;

      return new Promise((resolve, reject) => {
        var request = db
          .transaction(['states'], 'readwrite')
          .objectStore('states')
          .clear();

        request.onsuccess = resolve;
        request.onerror = reject;
      });
    });
  }

  count() {
    return this.dbPromise.then(db => {
      if (!db) return;

      return new Promise((resolve, reject) => {
        var request = db
          .transaction(['states'])
          .objectStore('states')
          .count();

        request.onsuccess = () => {
          resolve(request.result);
        };
        request.onerror = reject;
      });
    });
  }
};