kinto/lib/adapters/LocalStorage.js

An Offline-First JavaScript client for Kinto.

"use strict";

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

var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();

var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var _baseJs = require("./base.js");

var _baseJs2 = _interopRequireDefault(_baseJs);

var root = typeof window === "object" ? window : global;

// Only load localStorage in a nodejs environment
if (!root.hasOwnProperty("localStorage")) {
  root.localStorage = require("localStorage");
}

/**
 * LocalStorage adapter.
 */

var LocalStorage = (function (_BaseAdapter) {
  _inherits(LocalStorage, _BaseAdapter);

  /**
   * Constructor.
   *
   * @param  {String} dbname The database nale.
   */

  function LocalStorage(dbname) {
    _classCallCheck(this, LocalStorage);

    _get(Object.getPrototypeOf(LocalStorage.prototype), "constructor", this).call(this);
    this._db = null;
    this._keyStoreName = this.dbname + "/__keys";
    this._keyLastModified = this.dbname + "/__lastModified";
    // public properties
    /**
     * The database name.
     * @type {String}
     */
    this.dbname = dbname;
  }

  _createClass(LocalStorage, [{
    key: "_handleError",
    value: function _handleError(method, err) {
      var error = new Error(method + "() " + err.message);
      error.stack = err.stack;
      return Promise.reject(error);
    }

    /**
     * Retrieve all existing keys.
     *
     * @return {Array}
     */
  }, {
    key: "open",

    /**
     * Opens a connection to the database. Doesn't do anything as LocalStorage
     * database doesn't have to be opened.
     *
     * @override
     * @return {Promise}
     */
    value: function open() {
      return _get(Object.getPrototypeOf(LocalStorage.prototype), "open", this).call(this);
    }

    /**
     * Closes current connection to the database. Doesn't do anything as LocalStorage
     * database can't be closed.
     *
     * @override
     * @return {Promise}
     */
  }, {
    key: "close",
    value: function close() {
      return _get(Object.getPrototypeOf(LocalStorage.prototype), "close", this).call(this);
    }

    /**
     * Deletes every records in the current collection.
     *
     * @override
     * @return {Promise}
     */
  }, {
    key: "clear",
    value: function clear() {
      try {
        localStorage.clear();
        return Promise.resolve();
      } catch (err) {
        return this._handleError("clear", err);
      }
    }

    /**
     * Adds a record to the localStorage datastore.
     *
     * Note: An id value is required.
     *
     * @override
     * @param  {Object} record The record object, including an id.
     * @return {Promise}
     */
  }, {
    key: "create",
    value: function create(record) {
      if (this.keys.indexOf(record.id) !== -1) {
        return Promise.reject(new Error("Exists."));
      }
      try {
        localStorage.setItem(this.dbname + "/" + record.id, JSON.stringify(record));
        this.keys = this.keys.concat(record.id);
        return Promise.resolve(record);
      } catch (err) {
        return this._handleError("create", err);
      }
    }

    /**
     * Updates a record from the localStorage datastore.
     *
     * @override
     * @param  {Object} record
     * @return {Promise}
     */
  }, {
    key: "update",
    value: function update(record) {
      if (this.keys.indexOf(record.id) === -1) {
        return Promise.reject(new Error("Doesn't exist."));
      }
      try {
        localStorage.setItem(this.dbname + "/" + record.id, JSON.stringify(record));
        return Promise.resolve(record);
      } catch (err) {
        return this._handleError("update", err);
      }
    }

    /**
     * Retrieve a record by its primary key from the localStorage datastore.
     *
     * @override
     * @param  {String} id The record id.
     * @return {Promise}
     */
  }, {
    key: "get",
    value: function get(id) {
      try {
        return Promise.resolve(JSON.parse(localStorage.getItem(this.dbname + "/" + id)) || undefined);
      } catch (err) {
        return this._handleError("get", err);
      }
    }

    /**
     * Deletes a record from the localStorage datastore.
     *
     * @override
     * @param  {String} id The record id.
     * @return {Promise}
     */
  }, {
    key: "delete",
    value: function _delete(id) {
      try {
        localStorage.removeItem(this.dbname + "/" + id);
        this.keys = this.keys.filter(function (key) {
          return key !== id;
        });
        return Promise.resolve(id);
      } catch (err) {
        return this._handleError("delete", err);
      }
    }

    /**
     * Lists all records from the localStorage datastore.
     *
     * @override
     * @return {Promise}
     */
  }, {
    key: "list",
    value: function list() {
      var _this = this;

      try {
        return Promise.resolve(this.keys.map(function (id) {
          return JSON.parse(localStorage.getItem(_this.dbname + "/" + id));
        }));
      } catch (err) {
        return this._handleError("list", err);
      }
    }

    /**
     * Store the lastModified value into metadata store.
     *
     * @override
     * @param  {Number}  lastModified
     * @return {Promise}
     */
  }, {
    key: "saveLastModified",
    value: function saveLastModified(lastModified) {
      var value = parseInt(lastModified, 10);
      try {
        localStorage.setItem(this._keyLastModified, JSON.stringify(value));
        return Promise.resolve(value);
      } catch (err) {
        return this._handleError("saveLastModified", err);
      }
    }

    /**
     * Retrieve saved lastModified value.
     *
     * @override
     * @return {Promise}
     */
  }, {
    key: "getLastModified",
    value: function getLastModified() {
      try {
        var lastModified = JSON.parse(localStorage.getItem(this._keyLastModified));
        return Promise.resolve(parseInt(lastModified, 10) || null);
      } catch (err) {
        return this._handleError("getLastModified", err);
      }
    }

    /**
     * Load a dump of records exported from a server.
     *
     * @abstract
     * @return {Promise}
     */
  }, {
    key: "loadDump",
    value: function loadDump(records) {
      var _this2 = this;

      try {
        var _ret = (function () {
          records.forEach(function (record) {
            localStorage.setItem(_this2.dbname + "/" + record.id, JSON.stringify(record));
            if (_this2.keys.indexOf(record.id) === -1) {
              _this2.keys = _this2.keys.concat(record.id);
            }
          });
          var lastModified = Math.max.apply(Math, _toConsumableArray(records.map(function (record) {
            return record.last_modified;
          })));
          return {
            v: _this2.getLastModified().then(function (previousLastModified) {
              if (lastModified > previousLastModified) {
                return _this2.saveLastModified(lastModified);
              }
            }).then(function () {
              return records;
            })
          };
        })();

        if (typeof _ret === "object") return _ret.v;
      } catch (err) {
        return this._handleError("loadDump", err);
      }
    }
  }, {
    key: "keys",
    get: function get() {
      return JSON.parse(localStorage.getItem(this._keyStoreName)) || [];
    },

    /**
     * Set keys.
     *
     * @param  {Array} keys
     */
    set: function set(keys) {
      localStorage.setItem(this._keyStoreName, JSON.stringify(keys));
    }
  }]);

  return LocalStorage;
})(_baseJs2["default"]);

exports["default"] = LocalStorage;
module.exports = exports["default"];