cozy-dataproxy-lib/dist/search/storage.js

Library meant to be by Cozy Cloud's DataProxy apps for data manipulation

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.persistExportDate = exports.importSearchIndexes = exports.getExportDate = exports.exportSearchIndexes = void 0;

var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));

var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));

var _cozyMinilog = _interopRequireDefault(require("cozy-minilog"));

var _consts = require("./consts");

var _utils = require("./helpers/utils");

var _indexDocs = require("./indexDocs");

function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var log = (0, _cozyMinilog.default)('🗂️ [Index storage]');
var EXPORT_DATE_KEY = 'searchExportDate';
var INDEX_KEYS = 'searchIndexKeys';
var LAST_SEQ_KEY = 'searchIndexLastSeq';
var LAST_UPDATED_KEY = 'searchIndexLastUpdated';

var buildStorageKey = function buildStorageKey(doctype, key) {
  return "".concat(_consts.DATAPROXY_STORAGE_PREFIX, ":").concat(doctype, ":").concat(key);
};

var persistExportDate = /*#__PURE__*/function () {
  var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(storage) {
    var date;
    return _regenerator.default.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            date = new Date().toISOString();
            _context.next = 3;
            return storage === null || storage === void 0 ? void 0 : storage.storeData("".concat(_consts.DATAPROXY_STORAGE_PREFIX, ":").concat(EXPORT_DATE_KEY), date);

          case 3:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));

  return function persistExportDate(_x) {
    return _ref.apply(this, arguments);
  };
}();

exports.persistExportDate = persistExportDate;

var getExportDate = /*#__PURE__*/function () {
  var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(storage) {
    return _regenerator.default.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            return _context2.abrupt("return", storage === null || storage === void 0 ? void 0 : storage.getData("".concat(_consts.DATAPROXY_STORAGE_PREFIX, ":").concat(EXPORT_DATE_KEY)));

          case 1:
          case "end":
            return _context2.stop();
        }
      }
    }, _callee2);
  }));

  return function getExportDate(_x2) {
    return _ref2.apply(this, arguments);
  };
}();

exports.getExportDate = getExportDate;

var exportSearchIndexes = /*#__PURE__*/function () {
  var _ref3 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(storage, searchIndexes) {
    var lastExportDate, _loop, _i, _Object$keys;

    return _regenerator.default.wrap(function _callee3$(_context4) {
      while (1) {
        switch (_context4.prev = _context4.next) {
          case 0:
            if (storage) {
              _context4.next = 2;
              break;
            }

            return _context4.abrupt("return");

          case 2:
            _context4.next = 4;
            return getExportDate(storage);

          case 4:
            lastExportDate = _context4.sent;

            if (!lastExportDate) {
              _context4.next = 9;
              break;
            }

            if (!(new Date(lastExportDate).getTime() + _consts.MIN_DELAY_BEFORE_EXPORT > new Date().getTime())) {
              _context4.next = 9;
              break;
            }

            log.info('Export already happened earlier, skip it.');
            return _context4.abrupt("return");

          case 9:
            log.info('Start indexes export');
            _loop = /*#__PURE__*/_regenerator.default.mark(function _loop() {
              var key, doctype, searchIndex, keys;
              return _regenerator.default.wrap(function _loop$(_context3) {
                while (1) {
                  switch (_context3.prev = _context3.next) {
                    case 0:
                      key = _Object$keys[_i];
                      doctype = key;
                      searchIndex = searchIndexes[doctype];
                      keys = [];
                      _context3.next = 6;
                      return searchIndex.index.export(function (key, data) {
                        // do the saving as async
                        keys.push(key);
                        var value = JSON.stringify(data);

                        if (value) {
                          void storage.storeData(buildStorageKey(doctype, key), data);
                        }

                        return;
                      });

                    case 6:
                      _context3.next = 8;
                      return storage.storeData(buildStorageKey(doctype, INDEX_KEYS), keys);

                    case 8:
                      _context3.next = 10;
                      return storage.storeData(buildStorageKey(doctype, LAST_SEQ_KEY), searchIndex.lastSeq);

                    case 10:
                      _context3.next = 12;
                      return storage.storeData(buildStorageKey(doctype, LAST_UPDATED_KEY), searchIndex.lastUpdated);

                    case 12:
                    case "end":
                      return _context3.stop();
                  }
                }
              }, _loop);
            });
            _i = 0, _Object$keys = Object.keys(searchIndexes);

          case 12:
            if (!(_i < _Object$keys.length)) {
              _context4.next = 17;
              break;
            }

            return _context4.delegateYield(_loop(), "t0", 14);

          case 14:
            _i++;
            _context4.next = 12;
            break;

          case 17:
            _context4.next = 19;
            return persistExportDate(storage);

          case 19:
            log.info('Indexes export done');

          case 20:
          case "end":
            return _context4.stop();
        }
      }
    }, _callee3);
  }));

  return function exportSearchIndexes(_x3, _x4) {
    return _ref3.apply(this, arguments);
  };
}();

exports.exportSearchIndexes = exportSearchIndexes;

var importSearchIndexes = /*#__PURE__*/function () {
  var _ref4 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(storage) {
    var searchIndexes, _iterator, _step, doctype, index, startImportDoctype, keys, _iterator2, _step2, key, data, lastSeq, lastUpdated, searchIndex, endImportDoctype;

    return _regenerator.default.wrap(function _callee4$(_context5) {
      while (1) {
        switch (_context5.prev = _context5.next) {
          case 0:
            log.info('Start indexes import');
            searchIndexes = {};

            if (storage) {
              _context5.next = 4;
              break;
            }

            return _context5.abrupt("return", searchIndexes);

          case 4:
            _iterator = _createForOfIteratorHelper(_consts.SEARCHABLE_DOCTYPES);
            _context5.prev = 5;

            _iterator.s();

          case 7:
            if ((_step = _iterator.n()).done) {
              _context5.next = 50;
              break;
            }

            doctype = _step.value;
            index = (0, _indexDocs.initSearchIndex)(doctype);
            startImportDoctype = performance.now();
            _context5.next = 13;
            return storage.getData(buildStorageKey(doctype, INDEX_KEYS));

          case 13:
            keys = _context5.sent;

            if (keys) {
              _context5.next = 17;
              break;
            }

            log.warn("No keys available to import index ".concat(doctype));
            return _context5.abrupt("continue", 48);

          case 17:
            _iterator2 = _createForOfIteratorHelper(keys);
            _context5.prev = 18;

            _iterator2.s();

          case 20:
            if ((_step2 = _iterator2.n()).done) {
              _context5.next = 30;
              break;
            }

            key = _step2.value;
            _context5.next = 24;
            return storage.getData(buildStorageKey(doctype, key));

          case 24:
            data = _context5.sent;

            if (!data) {
              _context5.next = 28;
              break;
            }

            _context5.next = 28;
            return index.import(key, data);

          case 28:
            _context5.next = 20;
            break;

          case 30:
            _context5.next = 35;
            break;

          case 32:
            _context5.prev = 32;
            _context5.t0 = _context5["catch"](18);

            _iterator2.e(_context5.t0);

          case 35:
            _context5.prev = 35;

            _iterator2.f();

            return _context5.finish(35);

          case 38:
            _context5.next = 40;
            return storage.getData(buildStorageKey(doctype, LAST_SEQ_KEY));

          case 40:
            lastSeq = _context5.sent;
            _context5.next = 43;
            return storage.getData(buildStorageKey(doctype, LAST_UPDATED_KEY));

          case 43:
            lastUpdated = _context5.sent;
            searchIndex = {
              index: index,
              lastSeq: lastSeq,
              lastUpdated: lastUpdated
            };
            searchIndexes[doctype] = searchIndex;
            endImportDoctype = performance.now();

            if ((0, _utils.isDebug)()) {
              log.debug("".concat(doctype, " import took ").concat((endImportDoctype - startImportDoctype).toFixed(2), " ms"));
            }

          case 48:
            _context5.next = 7;
            break;

          case 50:
            _context5.next = 55;
            break;

          case 52:
            _context5.prev = 52;
            _context5.t1 = _context5["catch"](5);

            _iterator.e(_context5.t1);

          case 55:
            _context5.prev = 55;

            _iterator.f();

            return _context5.finish(55);

          case 58:
            return _context5.abrupt("return", searchIndexes);

          case 59:
          case "end":
            return _context5.stop();
        }
      }
    }, _callee4, null, [[5, 52, 55, 58], [18, 32, 35, 38]]);
  }));

  return function importSearchIndexes(_x5) {
    return _ref4.apply(this, arguments);
  };
}();

exports.importSearchIndexes = importSearchIndexes;