@teambit/objects 0.0.0-00133c53667c619f31de3353b1a01a30e323f7bd

package/dist/objects/repository.js

@@ -0,0 +1,851 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _fsExtra() {
+  const data = _interopRequireDefault(require("fs-extra"));
+  _fsExtra = function () {
+    return data;
+  };
+  return data;
+}
+function _uidNumber() {
+  const data = _interopRequireDefault(require("uid-number"));
+  _uidNumber = function () {
+    return data;
+  };
+  return data;
+}
+function _asyncMutex() {
+  const data = require("async-mutex");
+  _asyncMutex = function () {
+    return data;
+  };
+  return data;
+}
+function _lodash() {
+  const data = require("lodash");
+  _lodash = function () {
+    return data;
+  };
+  return data;
+}
+function _bitError() {
+  const data = require("@teambit/bit-error");
+  _bitError = function () {
+    return data;
+  };
+  return data;
+}
+function _componentVersion() {
+  const data = require("@teambit/component-version");
+  _componentVersion = function () {
+    return data;
+  };
+  return data;
+}
+function path() {
+  const data = _interopRequireWildcard(require("path"));
+  path = function () {
+    return data;
+  };
+  return data;
+}
+function _toolboxPromise() {
+  const data = require("@teambit/toolbox.promise.map-pool");
+  _toolboxPromise = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy() {
+  const data = require("@teambit/legacy.constants");
+  _legacy = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy2() {
+  const data = require("@teambit/legacy.logger");
+  _legacy2 = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy3() {
+  const data = require("@teambit/legacy.utils");
+  _legacy3 = function () {
+    return data;
+  };
+  return data;
+}
+function _toolboxFs() {
+  const data = require("@teambit/toolbox.fs.remove-empty-dir");
+  _toolboxFs = function () {
+    return data;
+  };
+  return data;
+}
+function _harmonyModules() {
+  const data = require("@teambit/harmony.modules.concurrency");
+  _harmonyModules = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy4() {
+  const data = require("@teambit/legacy.scope");
+  _legacy4 = function () {
+    return data;
+  };
+  return data;
+}
+function _scopeIndex() {
+  const data = require("./scope-index");
+  _scopeIndex = function () {
+    return data;
+  };
+  return data;
+}
+function _object() {
+  const data = _interopRequireDefault(require("./object"));
+  _object = function () {
+    return data;
+  };
+  return data;
+}
+function _objectList() {
+  const data = require("./object-list");
+  _objectList = function () {
+    return data;
+  };
+  return data;
+}
+function _rawObject() {
+  const data = _interopRequireDefault(require("./raw-object"));
+  _rawObject = function () {
+    return data;
+  };
+  return data;
+}
+function _ref() {
+  const data = _interopRequireDefault(require("./ref"));
+  _ref = function () {
+    return data;
+  };
+  return data;
+}
+function _harmonyModules2() {
+  const data = require("@teambit/harmony.modules.in-memory-cache");
+  _harmonyModules2 = function () {
+    return data;
+  };
+  return data;
+}
+function _models() {
+  const data = require("../models");
+  _models = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+const OBJECTS_BACKUP_DIR = `${_legacy().OBJECTS_DIR}.bak`;
+const TRASH_DIR = 'trash';
+class Repository {
+  constructor(scopePath, scopeJson) {
+    _defineProperty(this, "objects", {});
+    _defineProperty(this, "objectsToRemove", []);
+    _defineProperty(this, "scopeJson", void 0);
+    _defineProperty(this, "onRead", void 0);
+    _defineProperty(this, "onPersist", void 0);
+    _defineProperty(this, "scopePath", void 0);
+    _defineProperty(this, "scopeIndex", void 0);
+    _defineProperty(this, "cache", void 0);
+    _defineProperty(this, "remoteLanes", void 0);
+    _defineProperty(this, "unmergedComponents", void 0);
+    _defineProperty(this, "_persistMutex", void 0);
+    this.scopePath = scopePath;
+    this.scopeJson = scopeJson;
+    this.onRead = content => Repository.onPostObjectRead?.(content) || content;
+    this.onPersist = content => Repository.onPreObjectPersist?.(content) || content;
+    this.cache = (0, _harmonyModules2().createInMemoryCache)({
+      maxSize: (0, _harmonyModules2().getMaxSizeForObjects)()
+    });
+  }
+  get persistMutex() {
+    if (!this._persistMutex) {
+      this._persistMutex = new (_asyncMutex().Mutex)();
+    }
+    return this._persistMutex;
+  }
+  static async load({
+    scopePath,
+    scopeJson
+  }) {
+    const repository = new Repository(scopePath, scopeJson);
+    await repository.init();
+    return repository;
+  }
+  async init() {
+    const scopeIndex = await this.loadOptionallyCreateScopeIndex();
+    this.scopeIndex = scopeIndex;
+    this.remoteLanes = new (_legacy4().RemoteLanes)(this.scopePath);
+    this.unmergedComponents = await _legacy4().UnmergedComponents.load(this.scopePath);
+  }
+  static async create({
+    scopePath,
+    scopeJson
+  }) {
+    const repository = new Repository(scopePath, scopeJson);
+    const scopeIndex = _scopeIndex().ScopeIndex.create(scopePath);
+    repository.scopeIndex = scopeIndex;
+    repository.unmergedComponents = await _legacy4().UnmergedComponents.load(scopePath);
+    repository.remoteLanes = new (_legacy4().RemoteLanes)(scopePath);
+    return repository;
+  }
+  static reset(scopePath) {
+    return _scopeIndex().ScopeIndex.reset(scopePath);
+  }
+  static getPathByScopePath(scopePath) {
+    return path().join(scopePath, _legacy().OBJECTS_DIR);
+  }
+  async reLoadScopeIndex() {
+    this.scopeIndex = await this.loadOptionallyCreateScopeIndex();
+  }
+
+  /**
+   * current scope index difference with <scope_folder>/index.json content, reload it
+   * @deprecated use Scope aspect `watchSystemFiles` instead, it's way more efficient.
+   */
+  async reloadScopeIndexIfNeed(force = false) {
+    const latestScopeIndex = await this.loadOptionallyCreateScopeIndex();
+    if (force) {
+      this.scopeIndex = latestScopeIndex;
+      return;
+    }
+    const currentAllScopeIndexItems = this.scopeIndex.getAll();
+    const latestAllScopeIndexItems = latestScopeIndex.getAll();
+    if (currentAllScopeIndexItems.length !== latestAllScopeIndexItems.length) {
+      this.scopeIndex = latestScopeIndex;
+      return;
+    }
+    if ((0, _lodash().differenceWith)(currentAllScopeIndexItems, latestAllScopeIndexItems, _lodash().isEqual).length) {
+      this.scopeIndex = latestScopeIndex;
+    }
+  }
+  ensureDir() {
+    return _fsExtra().default.ensureDir(this.getPath());
+  }
+  getPath() {
+    return Repository.getPathByScopePath(this.scopePath);
+  }
+  getBackupPath(dirName) {
+    const backupPath = path().join(this.scopePath, OBJECTS_BACKUP_DIR);
+    return dirName ? path().join(backupPath, dirName) : backupPath;
+  }
+  getTrashDir() {
+    return path().join(this.scopePath, TRASH_DIR);
+  }
+  getLicense() {
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    return this.scopeJson.getPopulatedLicense();
+  }
+  async getScopeMetaObject() {
+    const license = await this.getLicense();
+    const object = _models().ScopeMeta.fromObject({
+      license,
+      name: this.scopeJson.name
+    });
+    return {
+      ref: object.hash(),
+      buffer: await object.compress()
+    };
+  }
+  objectPath(ref) {
+    return path().join(this.getPath(), this.hashPath(ref));
+  }
+  async has(ref) {
+    const objectPath = this.objectPath(ref);
+    return _fsExtra().default.pathExists(objectPath);
+  }
+  async hasMultiple(refs) {
+    const concurrency = (0, _harmonyModules().concurrentIOLimit)();
+    const existingRefs = await (0, _toolboxPromise().pMapPool)(refs, async ref => {
+      const pathExists = await this.has(ref);
+      return pathExists ? ref : null;
+    }, {
+      concurrency
+    });
+    return (0, _lodash().compact)(existingRefs);
+  }
+  async load(ref, throws = false) {
+    // during tag, the updated objects are in `this.objects`.
+    // `this.cache` is less reliable, because if it reaches its max, then it loads from the filesystem, which may not
+    // be there yet (in case of "version" object), or may be out-of-date (in case of "component" object).
+    const inMemoryObjects = this.objects[ref.hash.toString()];
+    if (inMemoryObjects) return inMemoryObjects;
+    if (ref.hash.length < _componentVersion().HASH_SIZE) {
+      ref = await this.getFullRefFromShortHash(ref);
+    }
+    const cached = this.getCache(ref);
+    if (cached) {
+      return cached;
+    }
+    let fileContentsRaw;
+    const objectPath = this.objectPath(ref);
+    try {
+      fileContentsRaw = await _fsExtra().default.readFile(objectPath);
+    } catch (err) {
+      if (err.code !== 'ENOENT') {
+        _legacy2().logger.error(`Failed reading a ref file ${objectPath}. Error: ${err.message}`);
+        throw err;
+      }
+      _legacy2().logger.trace(`Failed finding a ref file ${objectPath}.`);
+      if (throws) {
+        // if we just `throw err` we loose the stack trace.
+        // see https://stackoverflow.com/questions/68022123/no-stack-in-fs-promises-readfile-enoent-error
+        const msg = `fatal: failed finding an object file ${objectPath} in the filesystem at ${err.path}`;
+        throw Object.assign(err, {
+          stack: new Error(msg).stack
+        });
+      }
+      // @ts-ignore @todo: fix! it should return BitObject | null.
+      return null;
+    }
+    const size = fileContentsRaw.byteLength;
+    const fileContents = this.onRead(fileContentsRaw);
+    // uncomment to debug the transformed objects by onRead
+    // console.log('transformedContent load', ref.toString(), BitObject.parseSync(fileContents).getType());
+    const parsedObject = await _object().default.parseObject(fileContents, objectPath);
+    const maxSizeToCache = 100 * 1024; // 100KB
+    if (size < maxSizeToCache) {
+      // don't cache big files (mainly artifacts) to prevent out-of-memory
+      this.setCache(parsedObject);
+    }
+    return parsedObject;
+  }
+
+  /**
+   * this is restricted to provide objects according to the given types. Otherwise, big scopes (>1GB) could crush.
+   * example usage: `this.list([ModelComponent, Symlink, Lane])`
+   */
+  async list(types) {
+    const refs = await this.listRefs();
+    const concurrency = (0, _harmonyModules().concurrentIOLimit)();
+    _legacy2().logger.debug(`Repository.list, ${refs.length} refs are going to be loaded, searching for types: ${types.map(t => t.name).join(', ')}`);
+    const objects = [];
+    const loadGracefully = process.argv.includes('--never-exported');
+    const isTypeIncluded = obj => types.some(type => type.name === obj.constructor.name); // avoid using "obj instanceof type" for Harmony to call this function successfully
+    await (0, _toolboxPromise().pMapPool)(refs, async ref => {
+      const object = loadGracefully ? await this.loadRefDeleteIfInvalid(ref) : await this.loadRefOnlyIfType(ref, types);
+      if (!object) return;
+      if (loadGracefully && !isTypeIncluded(object)) return;
+      objects.push(object);
+    }, {
+      concurrency,
+      onCompletedChunk: completed => {
+        if (completed % 1000 === 0) _legacy2().logger.debug(`Repository.list, completed ${completed} out of ${refs.length}`);
+      }
+    });
+    return objects;
+  }
+  async loadRefDeleteIfInvalid(ref) {
+    try {
+      return await this.load(ref, true);
+    } catch (err) {
+      // this is needed temporarily to allow `bit reset --never-exported` to fix the bit-id-comp-id error.
+      // in a few months, we can remove this condition (around min 2024)
+      if (err.constructor.name === 'BitIdCompIdError' || err.constructor.name === 'MissingScope') {
+        _legacy2().logger.debug(`bit-id-comp-id error, moving an object to trash ${ref.toString()}`);
+        await this.moveOneObjectToTrash(ref);
+        return undefined;
+      }
+      throw err;
+    }
+  }
+  async loadRefOnlyIfType(ref, types) {
+    const objectPath = this.objectPath(ref);
+    const fileContentsRaw = await _fsExtra().default.readFile(objectPath);
+    const fileContents = this.onRead(fileContentsRaw);
+    const typeNames = types.map(type => type.name);
+    const parsedObject = await _object().default.parseObjectOnlyIfType(fileContents, typeNames, objectPath);
+    return parsedObject;
+  }
+  async listRefs(cwd = this.getPath()) {
+    const matches = await (0, _legacy3().glob)(path().join('*', '*'), {
+      cwd
+    });
+    const refs = matches.map(str => {
+      const hash = str.replace(path().sep, '');
+      if (!(0, _componentVersion().isSnap)(hash)) {
+        _legacy2().logger.error(`fatal: the file "${str}" is not a valid bit object path`);
+        return null;
+      }
+      return new (_ref().default)(hash);
+    });
+    return (0, _lodash().compact)(refs);
+  }
+  async listRefsStartWith(shortHash) {
+    const pathPrefix = this.hashPath(shortHash);
+    const matches = await (0, _legacy3().glob)(`${pathPrefix}*`, {
+      cwd: this.getPath()
+    });
+    const refs = matches.map(str => {
+      const hash = str.replace(path().sep, '');
+      if (!(0, _componentVersion().isSnap)(hash)) {
+        _legacy2().logger.error(`fatal: the file "${str}" is not a valid bit object path`);
+        return null;
+      }
+      return new (_ref().default)(hash);
+    });
+    return (0, _lodash().compact)(refs);
+  }
+  async listRawObjects() {
+    const refs = await this.listRefs();
+    const concurrency = (0, _harmonyModules().concurrentIOLimit)();
+    return (0, _toolboxPromise().pMapPool)(refs, async ref => {
+      try {
+        const buffer = await this.loadRaw(ref);
+        const bitRawObject = await _rawObject().default.fromDeflatedBuffer(buffer, ref.hash);
+        return bitRawObject;
+      } catch {
+        _legacy2().logger.error(`Couldn't load the ref ${ref} this object is probably corrupted and should be delete`);
+        return null;
+      }
+    }, {
+      concurrency
+    });
+  }
+  async listObjectsFromIndex(indexType, filter) {
+    const hashes = filter ? this.scopeIndex.getHashesByQuery(indexType, filter) : this.scopeIndex.getHashes(indexType);
+    return this._getBitObjectsByHashes(hashes);
+  }
+  getHashFromIndex(indexType, filter) {
+    const hashes = this.scopeIndex.getHashesByQuery(indexType, filter);
+    if (hashes.length > 2) throw new Error('getHashFromIndex expect to get zero or one result');
+    return hashes.length ? hashes[0] : null;
+  }
+  async _getBitObjectsByHashes(hashes) {
+    const missingIndexItems = [];
+    const bitObjects = await Promise.all(hashes.map(async hash => {
+      const bitObject = await this.load(new (_ref().default)(hash));
+      if (!bitObject) {
+        const indexItem = this.scopeIndex.find(hash);
+        if (!indexItem) throw new Error(`_getBitObjectsByHashes failed finding ${hash}`);
+        missingIndexItems.push(indexItem);
+        return;
+      }
+      return bitObject;
+    }));
+    if (missingIndexItems.length) {
+      this.scopeIndex.removeMany(missingIndexItems.map(item => new (_ref().default)(item.hash)));
+      await this.scopeIndex.write();
+      const missingStringified = missingIndexItems.map(item => item.toIdentifierString());
+      throw new (_legacy4().OutdatedIndexJson)(missingStringified);
+    }
+    return (0, _lodash().compact)(bitObjects);
+  }
+  async loadOptionallyCreateScopeIndex() {
+    try {
+      const scopeIndex = await _scopeIndex().ScopeIndex.load(this.scopePath);
+      return scopeIndex;
+    } catch (err) {
+      if (err.code === 'ENOENT') {
+        const bitObjects = await this.list([_models().ModelComponent, _models().Lane]);
+        const scopeIndex = _scopeIndex().ScopeIndex.create(this.scopePath);
+        const added = scopeIndex.addMany(bitObjects);
+        if (added) await scopeIndex.write();
+        return scopeIndex;
+      }
+      throw err;
+    }
+  }
+  async loadRaw(ref) {
+    if (ref.hash.length < _componentVersion().HASH_SIZE) {
+      ref = await this.getFullRefFromShortHash(ref);
+    }
+    const raw = await _fsExtra().default.readFile(this.objectPath(ref));
+    // Run hook to transform content pre reading
+    const transformedContent = this.onRead(raw);
+    // uncomment to debug the transformed objects by onRead
+    // console.log('transformedContent loadRaw', ref.toString(), BitObject.parseSync(transformedContent).getType());
+    return transformedContent;
+  }
+  async getFullRefFromShortHash(ref) {
+    const refs = await this.listRefsStartWith(ref);
+    if (refs.length > 1) {
+      throw new Error(`found ${refs.length} objects with the same short hash ${ref.toString()}, please use longer hash`);
+    }
+    if (refs.length === 0) {
+      throw new Error(`failed finding an object with the short hash ${ref.toString()}`);
+    }
+    return refs[0];
+  }
+  async loadManyRaw(refs) {
+    const concurrency = (0, _harmonyModules().concurrentIOLimit)();
+    const uniqRefs = (0, _lodash().uniqBy)(refs, 'hash');
+    return (0, _toolboxPromise().pMapPool)(uniqRefs, async ref => ({
+      ref,
+      buffer: await this.loadRaw(ref)
+    }), {
+      concurrency
+    });
+  }
+  async loadManyRawIgnoreMissing(refs) {
+    const concurrency = (0, _harmonyModules().concurrentIOLimit)();
+    const results = await (0, _toolboxPromise().pMapPool)(refs, async ref => {
+      try {
+        const buffer = await this.loadRaw(ref);
+        return {
+          ref,
+          buffer
+        };
+      } catch (err) {
+        if (err.code === 'ENOENT') return null;
+        throw err;
+      }
+    }, {
+      concurrency
+    });
+    return (0, _lodash().compact)(results);
+  }
+  async loadRawObject(ref) {
+    const buffer = await this.loadRaw(ref);
+    const bitRawObject = await _rawObject().default.fromDeflatedBuffer(buffer, ref.hash);
+    return bitRawObject;
+  }
+
+  /**
+   * prefer using `this.load()` for an async version, which also writes to the cache
+   */
+  loadSync(ref, throws = true) {
+    try {
+      const objectFile = _fsExtra().default.readFileSync(this.objectPath(ref));
+      // Run hook to transform content pre reading
+      const transformedContent = this.onRead(objectFile);
+      return _object().default.parseSync(transformedContent);
+    } catch {
+      if (throws) {
+        throw new (_legacy4().HashNotFound)(ref.toString());
+      }
+      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+      return null;
+    }
+  }
+  setCache(object) {
+    this.cache.set(object.hash().toString(), object);
+    return this;
+  }
+  getCache(ref) {
+    return this.cache.get(ref.toString());
+  }
+  removeFromCache(ref) {
+    this.cache.delete(ref.toString());
+  }
+  async clearCache() {
+    _legacy2().logger.debug('repository.clearCache');
+    this.cache.deleteAll();
+    await this.init();
+  }
+  clearObjectsFromCache() {
+    _legacy2().logger.debug('repository.clearObjectsFromCache');
+    this.cache.deleteAll();
+  }
+  backup(dirName) {
+    const backupDir = this.getBackupPath(dirName);
+    const objectsDir = this.getPath();
+    _legacy2().logger.debug(`making a backup of all objects from ${objectsDir} to ${backupDir}`);
+    _fsExtra().default.emptyDirSync(backupDir);
+    _fsExtra().default.copySync(objectsDir, backupDir);
+  }
+  add(object) {
+    // console.trace(`repository: adding object ${object?.hash().toString()}`);
+    if (!object) return this;
+    // leave the following commented log message, it is very useful for debugging but too verbose when not needed.
+    // logger.debug(`repository: adding object ${object.hash().toString()} which consist of the following id: ${object.id()}`);
+    this.objects[object.hash().toString()] = object;
+    this.setCache(object);
+    return this;
+  }
+  addMany(objects) {
+    if (!objects || !objects.length) return this;
+    objects.forEach(obj => this.add(obj));
+    return this;
+  }
+  removeObject(ref) {
+    this.objectsToRemove.push(ref);
+  }
+  removeManyObjects(refs) {
+    if (!refs || !refs.length) return;
+    refs.forEach(ref => this.removeObject(ref));
+  }
+  findMany(refs) {
+    return Promise.all(refs.map(ref => this.load(ref)));
+  }
+
+  /**
+   * important! use this method only for commands that are non running on an http server.
+   *
+   * it's better to remove/delete objects directly and not using the `objects` member.
+   * it helps to avoid multiple processes running concurrently on an http server.
+   *
+   * persist objects changes (added and removed) into the filesystem
+   * do not call this function multiple times in parallel, otherwise, it'll damage the index.json file.
+   * call this function only once after you added and removed all applicable objects.
+   */
+  async persist(validate = true) {
+    // do not let two requests enter this critical area, otherwise, refs/index.json/objects could
+    // be corrupted
+    _legacy2().logger.debug(`Repository.persist, going to acquire a lock`);
+    await this.persistMutex.runExclusive(async () => {
+      _legacy2().logger.debug(`Repository.persist, validate = ${validate.toString()}, a lock has been acquired`);
+      await this.deleteObjectsFromFS(this.objectsToRemove);
+      this.validateObjects(validate, Object.values(this.objects));
+      await this.writeObjectsToTheFS(Object.values(this.objects));
+      await this.writeRemoteLanes();
+      await this.unmergedComponents.write();
+    });
+    _legacy2().logger.debug(`Repository.persist, completed. the lock has been released`);
+    this.clearObjects();
+    if (Repository.onPostObjectsPersist) {
+      Repository.onPostObjectsPersist().catch(err => {
+        _legacy2().logger.error('fatal: onPostObjectsPersist encountered an error (this error does not stop the process)', err);
+      });
+    }
+  }
+  async writeRemoteLanes() {
+    await this.remoteLanes.write();
+  }
+
+  /**
+   * this is especially critical for http server, where one process lives long and serves multiple
+   * exports. without this, the objects get accumulated over time and being rewritten over and over
+   * again.
+   */
+  clearObjects() {
+    this.objects = {};
+    this.objectsToRemove = [];
+  }
+
+  /**
+   * normally, the validation step takes place just before the acutal writing of the file.
+   * however, this can be an issue where a component has an invalid version. the component could
+   * be saved before validating the version (see #1727). that's why we validate here before writing
+   * anything to the filesystem.
+   * the open question here is whether should we validate again before the actual writing or it
+   * should be enough to validate here?
+   * for now, it does validate again before saving, only to be 100% sure nothing happens in a few
+   * lines of code until the actual writing. however, if the performance penalty is noticeable, we
+   * can easily revert it by changing `bitObject.validateBeforePersist = false` line run regardless
+   * the `validate` argument.
+   */
+  validateObjects(validate, objects) {
+    objects.forEach(bitObject => {
+      // @ts-ignore some BitObject classes have validate() method
+      if (validate && bitObject.validate) {
+        // @ts-ignore
+        bitObject.validate();
+      }
+      if (!validate) {
+        bitObject.validateBeforePersist = false;
+      }
+    });
+  }
+  async deleteObjectsFromFS(refs) {
+    if (!refs.length) return;
+    const uniqRefs = (0, _lodash().uniqBy)(refs, 'hash');
+    _legacy2().logger.debug(`Repository._deleteMany: deleting ${uniqRefs.length} objects`);
+    const concurrency = (0, _harmonyModules().concurrentIOLimit)();
+    await (0, _toolboxPromise().pMapPool)(uniqRefs, ref => this._deleteOne(ref), {
+      concurrency
+    });
+    const removed = this.scopeIndex.removeMany(uniqRefs);
+    if (removed) await this.scopeIndex.write();
+  }
+  async moveObjectsToDir(refs, dir) {
+    if (!refs.length) return;
+    const uniqRefs = (0, _lodash().uniqBy)(refs, 'hash');
+    _legacy2().logger.debug(`Repository.moveObjectsToDir: ${uniqRefs.length} objects`);
+    const concurrency = (0, _harmonyModules().concurrentIOLimit)();
+    await (0, _toolboxPromise().pMapPool)(uniqRefs, ref => this.moveOneObjectToDir(ref, dir), {
+      concurrency
+    });
+    const removed = this.scopeIndex.removeMany(uniqRefs);
+    if (removed) await this.scopeIndex.write();
+  }
+  async moveObjectsToTrash(refs) {
+    await this.moveObjectsToDir(refs, TRASH_DIR);
+  }
+  async listTrash() {
+    return this.listRefs(this.getTrashDir());
+  }
+  async getFromTrash(refs) {
+    const objectsFromTrash = await Promise.all(refs.map(async ref => {
+      const trashObjPath = path().join(this.getTrashDir(), this.hashPath(ref));
+      let buffer;
+      try {
+        buffer = await _fsExtra().default.readFile(trashObjPath);
+      } catch (err) {
+        if (err.code === 'ENOENT') {
+          throw new (_bitError().BitError)(`unable to find the object ${ref.toString()} in the trash`);
+        }
+        throw err;
+      }
+      return _object().default.parseObject(buffer, trashObjPath);
+    }));
+    return objectsFromTrash;
+  }
+  async restoreFromTrash(refs) {
+    _legacy2().logger.debug(`Repository.restoreFromTrash: ${refs.length} objects`);
+    const objectsFromTrash = await this.getFromTrash(refs);
+    await this.writeObjectsToTheFS(objectsFromTrash);
+  }
+  async restoreFromDir(dir, overwrite = false) {
+    await _fsExtra().default.copy(path().join(this.scopePath, dir), this.getPath(), {
+      overwrite
+    });
+  }
+  async moveOneObjectToDir(ref, dir) {
+    const currentPath = this.objectPath(ref);
+    const absDir = path().join(this.scopePath, dir);
+    const fullPath = path().join(absDir, this.hashPath(ref));
+    await _fsExtra().default.move(currentPath, fullPath, {
+      overwrite: true
+    });
+    this.removeFromCache(ref);
+  }
+  async moveOneObjectToTrash(ref) {
+    await this.moveOneObjectToDir(ref, TRASH_DIR);
+  }
+  async deleteRecordsFromUnmergedComponents(compIds) {
+    this.unmergedComponents.removeMultipleComponents(compIds);
+    await this.unmergedComponents.write();
+  }
+
+  /**
+   * write all objects to the FS and index the components/lanes/symlink objects
+   */
+  async writeObjectsToTheFS(objects) {
+    const count = objects.length;
+    if (!count) return;
+    _legacy2().logger.trace(`Repository.writeObjectsToTheFS: started writing ${count} objects`);
+    const concurrency = (0, _harmonyModules().concurrentIOLimit)();
+    await (0, _toolboxPromise().pMapPool)(objects, obj => this._writeOne(obj), {
+      concurrency
+    });
+    _legacy2().logger.trace(`Repository.writeObjectsToTheFS: completed writing ${count} objects`);
+    const added = this.scopeIndex.addMany(objects);
+    if (added) await this.scopeIndex.write();
+  }
+
+  /**
+   * do not call this method directly. always call this.removeObject() and once done with all objects,
+   * call this.persist()
+   */
+  _deleteOne(ref) {
+    this.removeFromCache(ref);
+    const pathToDelete = this.objectPath(ref);
+    _legacy2().logger.trace(`repository._deleteOne: deleting ${pathToDelete}`);
+    return removeFile(pathToDelete, true);
+  }
+
+  /**
+   * always prefer this.persist() or this.writeObjectsToTheFS()
+   * this method doesn't write to scopeIndex. so using this method for ModelComponent or
+   * Symlink makes the index outdated.
+   */
+  async _writeOne(object) {
+    const contents = await object.compress();
+    const options = {};
+    if (this.scopeJson.groupName) options.gid = await resolveGroupId(this.scopeJson.groupName);
+    const hash = object.hash();
+    if (this.cache.has(hash.toString())) this.cache.set(hash.toString(), object); // update the cache
+    const objectPath = this.objectPath(hash);
+    _legacy2().logger.trace(`repository._writeOne: ${objectPath}`);
+    // Run hook to transform content pre persisting
+    const transformedContent = this.onPersist(contents);
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    return (0, _legacy3().writeFile)(objectPath, transformedContent, options);
+  }
+  async writeObjectsToPendingDir(objectList, pendingDir) {
+    const options = {};
+    if (this.scopeJson.groupName) options.gid = await resolveGroupId(this.scopeJson.groupName);
+    await Promise.all(objectList.objects.map(async object => {
+      const objPath = path().join(pendingDir, this.hashPath(object.ref));
+      await (0, _legacy3().writeFile)(objPath, object.buffer, options);
+    }));
+  }
+  async readObjectsFromPendingDir(pendingDir) {
+    const refs = await this.listRefs(pendingDir);
+    const objects = await Promise.all(refs.map(async ref => {
+      const buffer = await _fsExtra().default.readFile(path().join(pendingDir, this.hashPath(ref)));
+      return {
+        ref,
+        buffer
+      };
+    }));
+    return new (_objectList().ObjectList)(objects);
+  }
+  hashPath(ref) {
+    const hash = ref.toString();
+    return path().join(hash.slice(0, 2), hash.slice(2));
+  }
+}
+exports.default = Repository;
+_defineProperty(Repository, "onPostObjectsPersist", void 0);
+/**
+ * Hook for transforming content before objects are persisted to the filesystem.
+ * Note: This function cannot be async because it's used by the synchronous `loadSync` method
+ * which needs to maintain sync behavior for compatibility with existing code.
+ */
+_defineProperty(Repository, "onPreObjectPersist", void 0);
+/**
+ * Hook for transforming content after objects are read from the filesystem.
+ * Note: This function cannot be async because it's used by the synchronous `loadSync` method
+ * which needs to maintain sync behavior for compatibility with existing code.
+ */
+_defineProperty(Repository, "onPostObjectRead", void 0);
+async function removeFile(filePath, propagateDirs = false) {
+  try {
+    await _fsExtra().default.unlink(filePath);
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      // the file doesn't exist, that's fine, no need to do anything
+      return false;
+    }
+    throw err;
+  }
+  if (!propagateDirs) return true;
+  const {
+    dir
+  } = path().parse(filePath);
+  await (0, _toolboxFs().removeEmptyDir)(dir);
+  return true;
+}
+function resolveGroupId(groupName) {
+  return new Promise((resolve, reject) => {
+    (0, _uidNumber().default)(null, groupName, (err, uid, gid) => {
+      if (err) {
+        _legacy2().logger.error('resolveGroupId', err);
+        if (err.message.includes('EPERM')) {
+          return reject(new (_bitError().BitError)(`unable to resolve group id of "${groupName}", current user does not have sufficient permissions`));
+        }
+        if (err.message.includes('group id does not exist')) {
+          return reject(new (_bitError().BitError)(`unable to resolve group id of "${groupName}", the group does not exist`));
+        }
+        return reject(new (_bitError().BitError)(`unable to resolve group id of "${groupName}", got an error ${err.message}`));
+      }
+      // on Windows it'll always be null
+      return resolve(gid);
+    });
+  });
+}
+
+//# sourceMappingURL=repository.js.map