@browser-storage/websql-driver/dist-node/index.js

Web SQL driver for BrowserStorage

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var core = require('@browser-storage/core');

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
  try {
    var info = gen[key](arg);
    var value = info.value;
  } catch (error) {
    reject(error);
    return;
  }

  if (info.done) {
    resolve(value);
  } else {
    Promise.resolve(value).then(_next, _throw);
  }
}

function _asyncToGenerator(fn) {
  return function () {
    var self = this,
        args = arguments;
    return new Promise(function (resolve, reject) {
      var gen = fn.apply(self, args);

      function _next(value) {
        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
      }

      function _throw(err) {
        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
      }

      _next(undefined);
    });
  };
}

class WebsqlSerializer {
  deserialize(value) {
    return _asyncToGenerator(function* () {
      return JSON.parse(value);
    })();
  }

  serialize(value) {
    return _asyncToGenerator(function* () {
      return JSON.stringify(value);
    })();
  }

}

class WebsqlDriver {
  constructor({
    description,
    size
  }) {
    this._serializer = new WebsqlSerializer();
    this._ready = new core.Defer();
    this.description = description;
    this.size = size;
  }

  get isSupported() {
    return typeof window.openDatabase === 'function';
  }

  clear() {
    var _this = this;

    return _asyncToGenerator(function* () {
      yield _this._executeSql(`DELETE FROM ${_this.options.storeName}`);
    })();
  } // tslint:disable-next-line


  destroy() {
    return _asyncToGenerator(function* () {})();
  }

  getItem(key) {
    var _this2 = this;

    return _asyncToGenerator(function* () {
      const result = yield _this2._executeSql(`SELECT * FROM ${_this2.options.storeName} WHERE key = ? LIMIT 1`, [key]);
      return _this2._serializer.deserialize(result.rows.item(0).value);
    })();
  }

  hasItem(key) {
    var _this3 = this;

    return _asyncToGenerator(function* () {
      return (yield _this3.keys()).indexOf(key) > -1;
    })();
  }

  init(dbOptions) {
    var _this4 = this;

    return _asyncToGenerator(function* () {
      _this4.options = dbOptions;
      _this4.db = _this4._createDB();
      yield _this4._executeSql(`CREATE TABLE IF NOT EXISTS ${_this4.options.storeName} (id INTEGER PRIMARY KEY, key unique, value)`);

      _this4._ready.resolve(true);
    })();
  }

  iterate(iterator) {
    var _this5 = this;

    return _asyncToGenerator(function* () {
      const keys = yield _this5.keys();
      return keys.reduceRight(
      /*#__PURE__*/
      function () {
        var _ref = _asyncToGenerator(function* (prev, key, index) {
          yield prev;
          const value = yield _this5.getItem(key);
          yield iterator(key, value, index);
        });

        return function (_x, _x2, _x3) {
          return _ref.apply(this, arguments);
        };
      }(), Promise.resolve());
    })();
  }

  key(index) {
    var _this6 = this;

    return _asyncToGenerator(function* () {
      return (yield _this6.keys())[index];
    })();
  }

  keys() {
    var _this7 = this;

    return _asyncToGenerator(function* () {
      const result = yield _this7._executeSql(`SELECT key FROM ${_this7.options.storeName} as a order by id`);
      const keys = [];

      for (let i = 0; i < result.rows.length; i++) {
        keys.push(result.rows.item(i).key);
      }

      return keys;
    })();
  }

  length() {
    var _this8 = this;

    return _asyncToGenerator(function* () {
      const result = yield _this8._executeSql(`SELECT COUNT(key) as count FROM ${_this8.options.storeName}`);
      return result.rows.item(0).count;
    })();
  }

  ready() {
    return this._ready.promise;
  }

  removeItem(key) {
    var _this9 = this;

    return _asyncToGenerator(function* () {
      yield _this9._executeSql(`DELETE FROM ${_this9.options.storeName} WHERE key = ?`, [key]);
    })();
  }

  setItem(key, item) {
    var _this10 = this;

    return _asyncToGenerator(function* () {
      yield _this10._executeSql(`INSERT OR REPLACE INTO ${_this10.options.storeName} (key, value) VALUES (?, ?)`, [key, yield _this10._serializer.serialize(item)]);
      return item;
    })();
  }

  _transaction() {
    var _this11 = this;

    return _asyncToGenerator(function* () {
      return new Promise((resolve, reject) => {
        _this11.db.transaction(tx => {
          resolve(tx);
        }, reject);
      });
    })();
  }

  _executeSql(sql, args = []) {
    var _this12 = this;

    return _asyncToGenerator(function* () {
      const tx = yield _this12._transaction();
      return new Promise((resolve, reject) => {
        tx.executeSql(sql, args, (t, result) => resolve(result), (t, error) => {
          reject(error);
          return true;
        });
      });
    })();
  }

  _createDB() {
    return window.openDatabase(this.options.name, this.options.version.toString(), this.description || '', this.size);
  }

}

exports.WebsqlDriver = WebsqlDriver;
exports.WebsqlSerializer = WebsqlSerializer;