cozy-dataproxy-lib/dist/search/helpers/filePaths.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.setFilePaths = exports.resetAllPaths = exports.getFilePath = exports.computeFileFullpath = void 0;

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

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

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

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

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

var _queries = require("../queries");

var _types = require("../types");

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; }

/**
 * The paths are not stored in CouchDB for files, thus there are not in PouchDB neither.
 * Thus, we keep all the file paths in memory to be able to quickly retrieve them
 * at search time.
 */
var allPaths = new Map();

var getFilePath = function getFilePath(id) {
  return id ? allPaths.get(id) : undefined;
};

exports.getFilePath = getFilePath;

var setFilePath = function setFilePath(id, path) {
  allPaths.set(id, path);
};

var resetAllPaths = function resetAllPaths() {
  allPaths.clear();
};
/**
 * Compute and set paths for given files.
 *
 * The paths are kept in memory to be quickly retrieved later.
 * From a list of io.cozy.files, we first extract the directories paths.
 * Then, for each file, we compute the path from its parent.
 *
 * @param {CozyDoc[]} docs - The list of docs to compute paths
 * @returns {CozyDoc[]} the list of docs with paths
 */


exports.resetAllPaths = resetAllPaths;

var setFilePaths = function setFilePaths(docs) {
  var completedDocs = (0, _toConsumableArray2.default)(docs);
  var filesAndDirs = completedDocs.filter(function (doc) {
    return (0, _types.isIOCozyFile)(doc);
  });

  if (filesAndDirs.length > 0) {
    filesAndDirs.forEach(function (file) {
      if (file.type === _consts.TYPE_DIRECTORY) {
        // Get all directory paths
        setFilePath(file._id, file.path || '');
      }
    });
    return filesAndDirs.map(function (file) {
      if (file.type === _consts.TYPE_FILE) {
        var parentPath = getFilePath(file.dir_id); // Add path to all files based on their parent path

        var path = parentPath ? "".concat(parentPath, "/").concat(file.name) : '';
        setFilePath(file._id, path);
        return _objectSpread(_objectSpread({}, file), {}, {
          path: path
        });
      }

      return file;
    });
  }

  return completedDocs;
};
/**
 * Compute paths for files
 *
 * There are several ways to get a path:
 *   - It is already defined in the file
 *   - The file path exists in memory
 *   - The directory path exists in memory
 *   - The directory path is retrieved from db
 *
 * @param { CozyClient} client - The cozy client instance
 * @param { IOCozyFile} file - The file to compute path
 * @returns {Promise<IOCozyFile>} the completed file with path
 */


exports.setFilePaths = setFilePaths;

var computeFileFullpath = /*#__PURE__*/function () {
  var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(client, file) {
    var _file$path, newPath, filePath, parentPath, path, fileWithPath, parentDir, _path;

    return _regenerator.default.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            if (!(file.type === _consts.TYPE_DIRECTORY)) {
              _context.next = 2;
              break;
            }

            return _context.abrupt("return", file);

          case 2:
            if (!file.path) {
              _context.next = 9;
              break;
            }

            if (!((_file$path = file.path) !== null && _file$path !== void 0 && _file$path.includes(file.name))) {
              _context.next = 6;
              break;
            }

            setFilePath(file._id, file.path);
            return _context.abrupt("return", file);

          case 6:
            newPath = "".concat(file.path, "/").concat(file.name);
            setFilePath(file._id, newPath);
            return _context.abrupt("return", _objectSpread(_objectSpread({}, file), {}, {
              path: newPath
            }));

          case 9:
            filePath = getFilePath(file._id);

            if (!filePath) {
              _context.next = 12;
              break;
            }

            return _context.abrupt("return", _objectSpread(_objectSpread({}, file), {}, {
              path: filePath
            }));

          case 12:
            parentPath = getFilePath(file.dir_id);

            if (!parentPath) {
              _context.next = 17;
              break;
            }

            // Parent path exists in memory
            path = "".concat(parentPath, "/").concat(file.name);
            setFilePath(file._id, path); // Add the path in memory

            return _context.abrupt("return", _objectSpread(_objectSpread({}, file), {}, {
              path: path
            }));

          case 17:
            // If there is no path found at all, let's compute it from the parent path in database
            fileWithPath = _objectSpread({}, file);
            _context.next = 20;
            return (0, _queries.queryDocById)(client, _consts.FILES_DOCTYPE, file.dir_id);

          case 20:
            parentDir = _context.sent;

            if (parentDir !== null && parentDir !== void 0 && parentDir.path) {
              _path = "".concat(parentDir.path, "/").concat(file.name);
              fileWithPath.path = _path; // Add the paths in memory

              setFilePath(file.dir_id, parentDir.path);
              setFilePath(file._id, _path);
            }

            return _context.abrupt("return", fileWithPath);

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

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

exports.computeFileFullpath = computeFileFullpath;