cozy-dataproxy-lib/dist/search/queries/index.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.queryLocalOrRemoteDocs = exports.queryFilesForSearch = exports.queryDocsByIds = exports.queryDocById = exports.queryAllDocs = void 0;

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

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

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

var _cozyClient = require("cozy-client");

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

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

var _normalizeFile = require("../helpers/normalizeFile");

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

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }

var log = (0, _cozyMinilog.default)('🗂️ [Indexing]');

var defaultFetchPolicy = _cozyClient.fetchPolicies.olderThan(5 * 60 * 1000); // 5 min


var queryFilesForSearch = /*#__PURE__*/function () {
  var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(client) {
    var resp, files, folders, filteredFiles, normalizedFiles;
    return _regenerator.default.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            _context.next = 2;
            return client.getStackClient().fetchJSON('GET', '/data/io.cozy.files/_all_docs?Fields=_id,trashed,dir_id,name,path,type,mime,class,metadata.title,metadata.version&DesignDocs=false&include_docs=true');

          case 2:
            resp = _context.sent;
            files = resp.rows.map(function (row) {
              return _objectSpread({
                id: row.id
              }, row.doc);
            });
            folders = files.filter(function (file) {
              return file.type === _consts.TYPE_DIRECTORY;
            });
            filteredFiles = files.filter(function (file) {
              return (0, _normalizeFile.shouldKeepFile)(file);
            });
            normalizedFiles = filteredFiles.map(function (file) {
              return (0, _normalizeFile.normalizeFileWithFolders)(folders, file);
            });
            return _context.abrupt("return", normalizedFiles);

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

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

exports.queryFilesForSearch = queryFilesForSearch;

var queryAllDocs = /*#__PURE__*/function () {
  var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(client, doctype) {
    var queryOpts;
    return _regenerator.default.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            queryOpts = {
              as: "".concat(doctype, "/all"),
              fetchPolicies: defaultFetchPolicy
            };
            return _context2.abrupt("return", client.queryAll((0, _cozyClient.Q)(doctype).limitBy(null), queryOpts));

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

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

exports.queryAllDocs = queryAllDocs;

var queryDocById = /*#__PURE__*/function () {
  var _ref3 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(client, doctype, id) {
    var queryOpts, resp;
    return _regenerator.default.wrap(function _callee3$(_context3) {
      while (1) {
        switch (_context3.prev = _context3.next) {
          case 0:
            queryOpts = {
              as: "".concat(doctype, "/").concat(id),
              fetchPolicy: defaultFetchPolicy,
              singleDocData: true
            };
            _context3.next = 3;
            return client.query((0, _cozyClient.Q)(doctype).getById(id), queryOpts);

          case 3:
            resp = _context3.sent;
            return _context3.abrupt("return", resp.data);

          case 5:
          case "end":
            return _context3.stop();
        }
      }
    }, _callee3);
  }));

  return function queryDocById(_x4, _x5, _x6) {
    return _ref3.apply(this, arguments);
  };
}();

exports.queryDocById = queryDocById;

var queryDocsByIds = /*#__PURE__*/function () {
  var _ref4 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(client, doctype, ids) {
    var _ref5,
        _ref5$fromStore,
        fromStore,
        allDocs,
        docs,
        resp,
        _args4 = arguments;

    return _regenerator.default.wrap(function _callee4$(_context4) {
      while (1) {
        switch (_context4.prev = _context4.next) {
          case 0:
            _ref5 = _args4.length > 3 && _args4[3] !== undefined ? _args4[3] : {}, _ref5$fromStore = _ref5.fromStore, fromStore = _ref5$fromStore === void 0 ? false : _ref5$fromStore;

            if (!fromStore) {
              _context4.next = 5;
              break;
            }

            // This used to be more efficient than querying by id, but should be fixed now
            // See https://github.com/cozy/cozy-client/issues/1591
            allDocs = client.getCollectionFromState(doctype);
            docs = allDocs.filter(function (doc) {
              return doc._id && ids.includes(doc._id);
            });
            return _context4.abrupt("return", docs);

          case 5:
            _context4.next = 7;
            return client.query((0, _cozyClient.Q)(doctype).getByIds(ids));

          case 7:
            resp = _context4.sent;
            return _context4.abrupt("return", resp.data);

          case 9:
          case "end":
            return _context4.stop();
        }
      }
    }, _callee4);
  }));

  return function queryDocsByIds(_x7, _x8, _x9) {
    return _ref4.apply(this, arguments);
  };
}();

exports.queryDocsByIds = queryDocsByIds;

var queryLocalOrRemoteDocs = /*#__PURE__*/function () {
  var _ref7 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5(client, doctype, _ref6) {
    var isLocalSearch, docs, startTimeQ, endTimeQ;
    return _regenerator.default.wrap(function _callee5$(_context5) {
      while (1) {
        switch (_context5.prev = _context5.next) {
          case 0:
            isLocalSearch = _ref6.isLocalSearch;
            docs = [];
            startTimeQ = performance.now();

            if (!(!isLocalSearch && doctype === _consts.FILES_DOCTYPE)) {
              _context5.next = 9;
              break;
            }

            _context5.next = 6;
            return queryFilesForSearch(client);

          case 6:
            docs = _context5.sent;
            _context5.next = 12;
            break;

          case 9:
            _context5.next = 11;
            return queryAllDocs(client, doctype);

          case 11:
            docs = _context5.sent;

          case 12:
            endTimeQ = performance.now();

            if ((0, _utils.isDebug)()) {
              log.debug("Query ".concat(docs.length, " ").concat(doctype, " took ").concat((endTimeQ - startTimeQ).toFixed(2), " ms"));
            }

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

          case 15:
          case "end":
            return _context5.stop();
        }
      }
    }, _callee5);
  }));

  return function queryLocalOrRemoteDocs(_x10, _x11, _x12) {
    return _ref7.apply(this, arguments);
  };
}();

exports.queryLocalOrRemoteDocs = queryLocalOrRemoteDocs;