@verdaccio/local-storage/lib/local-database.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _fs = _interopRequireDefault(require("fs"));

var _path = _interopRequireDefault(require("path"));

var _lodash = _interopRequireDefault(require("lodash"));

var _async = _interopRequireDefault(require("async"));

var _mkdirp = _interopRequireDefault(require("mkdirp"));

var _level = _interopRequireDefault(require("level"));

var _lib = require("@verdaccio/commons-api/lib");

var _localFs = _interopRequireWildcard(require("./local-fs"));

var _pkgUtils = require("./pkg-utils");

function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

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

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

const DEPRECATED_DB_NAME = '.sinopia-db.json';
const DB_NAME = '.verdaccio-db.json';
const TOKEN_DB_NAME = '.token-db';

/**
 * Handle local database.
 */
class LocalDatabase {
  /**
   * Load an parse the local json database.
   * @param {*} path the database path
   */
  constructor(config, logger) {
    _defineProperty(this, "path", void 0);

    _defineProperty(this, "logger", void 0);

    _defineProperty(this, "data", void 0);

    _defineProperty(this, "config", void 0);

    _defineProperty(this, "locked", void 0);

    _defineProperty(this, "tokenDb", void 0);

    this.config = config;
    this.path = this._buildStoragePath(config);
    this.logger = logger;
    this.locked = false;
    this.data = this._fetchLocalPackages();
    this.logger.trace({
      config: this.config
    }, '[local-storage]: configuration: @{config}');

    this._sync();
  }

  getSecret() {
    return Promise.resolve(this.data.secret);
  }

  setSecret(secret) {
    return new Promise(resolve => {
      this.data.secret = secret;
      resolve(this._sync());
    });
  }
  /**
   * Add a new element.
   * @param {*} name
   * @return {Error|*}
   */


  add(name, cb) {
    if (this.data.list.indexOf(name) === -1) {
      this.data.list.push(name);
      this.logger.debug({
        name
      }, '[local-storage]: the private package @{name} has been added');
      cb(this._sync());
    } else {
      cb(null);
    }
  }

  search(onPackage, onEnd, validateName) {
    const storages = this._getCustomPackageLocalStorages();

    this.logger.trace(`local-storage: [search]: ${JSON.stringify(storages)}`);

    const base = _path.default.dirname(this.config.self_path);

    const self = this;
    const storageKeys = Object.keys(storages);
    this.logger.trace(`local-storage: [search] base: ${base} keys ${storageKeys}`);

    _async.default.eachSeries(storageKeys, function (storage, cb) {
      const position = storageKeys.indexOf(storage);

      const base2 = _path.default.join(position !== 0 ? storageKeys[0] : '');

      const storagePath = _path.default.resolve(base, base2, storage);

      self.logger.trace({
        storagePath,
        storage
      }, 'local-storage: [search] search path: @{storagePath} : @{storage}');

      _fs.default.readdir(storagePath, (err, files) => {
        if (err) {
          return cb(err);
        }

        _async.default.eachSeries(files, function (file, cb) {
          self.logger.trace({
            file
          }, 'local-storage: [search] search file path: @{file}');

          if (storageKeys.includes(file)) {
            return cb();
          }

          if (file.match(/^@/)) {
            // scoped
            const fileLocation = _path.default.resolve(base, storage, file);

            self.logger.trace({
              fileLocation
            }, 'local-storage: [search] search scoped file location: @{fileLocation}');

            _fs.default.readdir(fileLocation, function (err, files) {
              if (err) {
                return cb(err);
              }

              _async.default.eachSeries(files, (file2, cb) => {
                if (validateName(file2)) {
                  const packagePath = _path.default.resolve(base, storage, file, file2);

                  _fs.default.stat(packagePath, (err, stats) => {
                    if (_lodash.default.isNil(err) === false) {
                      return cb(err);
                    }

                    const item = {
                      name: `${file}/${file2}`,
                      path: packagePath,
                      time: stats.mtime.getTime()
                    };
                    onPackage(item, cb);
                  });
                } else {
                  cb();
                }
              }, cb);
            });
          } else if (validateName(file)) {
            const base2 = _path.default.join(position !== 0 ? storageKeys[0] : '');

            const packagePath = _path.default.resolve(base, base2, storage, file);

            self.logger.trace({
              packagePath
            }, 'local-storage: [search] search file location: @{packagePath}');

            _fs.default.stat(packagePath, (err, stats) => {
              if (_lodash.default.isNil(err) === false) {
                return cb(err);
              }

              onPackage({
                name: file,
                path: packagePath,
                time: self._getTime(stats.mtime.getTime(), stats.mtime)
              }, cb);
            });
          } else {
            cb();
          }
        }, cb);
      });
    }, onEnd);
  }
  /**
   * Remove an element from the database.
   * @param {*} name
   * @return {Error|*}
   */


  remove(name, cb) {
    this.get((err, data) => {
      if (err) {
        cb((0, _lib.getInternalError)('error remove private package'));
        this.logger.error({
          err
        }, '[local-storage/remove]: remove the private package has failed @{err}');
      }

      const pkgName = data.indexOf(name);

      if (pkgName !== -1) {
        this.data.list.splice(pkgName, 1);
        this.logger.trace({
          name
        }, 'local-storage: [remove] package @{name} has been removed');
      }

      cb(this._sync());
    });
  }
  /**
   * Return all database elements.
   * @return {Array}
   */


  get(cb) {
    const list = this.data.list;
    const totalItems = this.data.list.length;
    cb(null, list);
    this.logger.trace({
      totalItems
    }, 'local-storage: [get] full list of packages (@{totalItems}) has been fetched');
  }

  getPackageStorage(packageName) {
    const packageAccess = this.config.getMatchedPackagesSpec(packageName);

    const packagePath = this._getLocalStoragePath(packageAccess ? packageAccess.storage : undefined);

    this.logger.trace({
      packagePath
    }, '[local-storage/getPackageStorage]: storage selected: @{packagePath}');

    if (_lodash.default.isString(packagePath) === false) {
      this.logger.debug({
        name: packageName
      }, 'this package has no storage defined: @{name}');
      return;
    }

    const packageStoragePath = _path.default.join(_path.default.resolve(_path.default.dirname(this.config.self_path || ''), packagePath), packageName);

    this.logger.trace({
      packageStoragePath
    }, '[local-storage/getPackageStorage]: storage path: @{packageStoragePath}');
    return new _localFs.default(packageStoragePath, this.logger);
  }

  clean() {
    this._sync();
  }

  saveToken(token) {
    const key = this._getTokenKey(token);

    const db = this.getTokenDb();
    return new Promise((resolve, reject) => {
      db.put(key, token, err => {
        if (err) {
          reject(err);
          return;
        }

        resolve();
      });
    });
  }

  deleteToken(user, tokenKey) {
    const key = this._compoundTokenKey(user, tokenKey);

    const db = this.getTokenDb();
    return new Promise((resolve, reject) => {
      db.del(key, err => {
        if (err) {
          reject(err);
          return;
        }

        resolve();
      });
    });
  }

  readTokens(filter) {
    return new Promise((resolve, reject) => {
      const tokens = [];
      const key = filter.user + ':';
      const db = this.getTokenDb();
      const stream = db.createReadStream({
        gte: key,
        lte: String.fromCharCode(key.charCodeAt(0) + 1)
      });
      stream.on('data', data => {
        tokens.push(data.value);
      });
      stream.once('end', () => resolve(tokens));
      stream.once('error', err => reject(err));
    });
  }

  _getTime(time, mtime) {
    return time ? time : mtime;
  }

  _getCustomPackageLocalStorages() {
    const storages = {}; // add custom storage if exist

    if (this.config.storage) {
      storages[this.config.storage] = true;
    }

    const {
      packages
    } = this.config;

    if (packages) {
      const listPackagesConf = Object.keys(packages || {});
      listPackagesConf.map(pkg => {
        const storage = packages[pkg].storage;

        if (storage) {
          storages[storage] = false;
        }
      });
    }

    return storages;
  }
  /**
   * Syncronize {create} database whether does not exist.
   * @return {Error|*}
   */


  _sync() {
    this.logger.debug('[local-storage/_sync]: init sync database');

    if (this.locked) {
      this.logger.error('Database is locked, please check error message printed during startup to prevent data loss.');
      return new Error('Verdaccio database is locked, please contact your administrator to checkout logs during verdaccio startup.');
    } // Uses sync to prevent ugly race condition


    try {
      // https://www.npmjs.com/package/mkdirp#mkdirpsyncdir-opts
      const folderName = _path.default.dirname(this.path);

      _mkdirp.default.sync(folderName);

      this.logger.debug({
        folderName
      }, '[local-storage/_sync]: folder @{folderName} created succeed');
    } catch (err) {
      // perhaps a logger instance?
      this.logger.debug({
        err
      }, '[local-storage/_sync/mkdirp.sync]: sync failed @{err}');
      return null;
    }

    try {
      _fs.default.writeFileSync(this.path, JSON.stringify(this.data));

      this.logger.debug('[local-storage/_sync/writeFileSync]: sync write succeed');
      return null;
    } catch (err) {
      this.logger.debug({
        err
      }, '[local-storage/_sync/writeFileSync]: sync failed @{err}');
      return err;
    }
  }
  /**
   * Verify the right local storage location.
   * @param {String} path
   * @return {String}
   * @private
   */


  _getLocalStoragePath(storage) {
    const globalConfigStorage = this.config ? this.config.storage : undefined;

    if (_lodash.default.isNil(globalConfigStorage)) {
      throw new Error('global storage is required for this plugin');
    } else {
      if (_lodash.default.isNil(storage) === false && _lodash.default.isString(storage)) {
        return _path.default.join(globalConfigStorage, storage);
      }

      return globalConfigStorage;
    }
  }
  /**
   * Build the local database path.
   * @param {Object} config
   * @return {string|String|*}
   * @private
   */


  _buildStoragePath(config) {
    const sinopiadbPath = this._dbGenPath(DEPRECATED_DB_NAME, config);

    try {
      _fs.default.accessSync(sinopiadbPath, _fs.default.constants.F_OK);

      return sinopiadbPath;
    } catch (err) {
      if (err.code === _localFs.noSuchFile) {
        return this._dbGenPath(DB_NAME, config);
      }

      throw err;
    }
  }

  _dbGenPath(dbName, config) {
    return _path.default.join(_path.default.resolve(_path.default.dirname(config.self_path || ''), config.storage, dbName));
  }
  /**
   * Fetch local packages.
   * @private
   * @return {Object}
   */


  _fetchLocalPackages() {
    const list = [];
    const emptyDatabase = {
      list,
      secret: ''
    };

    try {
      const db = (0, _pkgUtils.loadPrivatePackages)(this.path, this.logger);
      return db;
    } catch (err) {
      // readFileSync is platform specific, macOS, Linux and Windows thrown an error
      // Only recreate if file not found to prevent data loss
      if (err.code !== _localFs.noSuchFile) {
        this.locked = true;
        this.logger.error('Failed to read package database file, please check the error printed below:\n', `File Path: ${this.path}\n\n ${err.message}`);
      }

      return emptyDatabase;
    }
  }

  getTokenDb() {
    if (!this.tokenDb) {
      this.tokenDb = (0, _level.default)(this._dbGenPath(TOKEN_DB_NAME, this.config), {
        valueEncoding: 'json'
      });
    }

    return this.tokenDb;
  }

  _getTokenKey(token) {
    const {
      user,
      key
    } = token;
    return this._compoundTokenKey(user, key);
  }

  _compoundTokenKey(user, key) {
    return `${user}:${key}`;
  }

}

var _default = LocalDatabase;
exports.default = _default;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/local-database.ts"],"names":["DEPRECATED_DB_NAME","DB_NAME","TOKEN_DB_NAME","LocalDatabase","constructor","config","logger","path","_buildStoragePath","locked","data","_fetchLocalPackages","trace","_sync","getSecret","Promise","resolve","secret","setSecret","add","name","cb","list","indexOf","push","debug","search","onPackage","onEnd","validateName","storages","_getCustomPackageLocalStorages","JSON","stringify","base","Path","dirname","self_path","self","storageKeys","Object","keys","async","eachSeries","storage","position","base2","join","storagePath","fs","readdir","err","files","file","includes","match","fileLocation","file2","packagePath","stat","stats","_","isNil","item","time","mtime","getTime","_getTime","remove","get","error","pkgName","splice","totalItems","length","getPackageStorage","packageName","packageAccess","getMatchedPackagesSpec","_getLocalStoragePath","undefined","isString","packageStoragePath","LocalDriver","clean","saveToken","token","key","_getTokenKey","db","getTokenDb","reject","put","deleteToken","user","tokenKey","_compoundTokenKey","del","readTokens","filter","tokens","stream","createReadStream","gte","lte","String","fromCharCode","charCodeAt","on","value","once","packages","listPackagesConf","map","pkg","Error","folderName","mkdirp","sync","writeFileSync","globalConfigStorage","sinopiadbPath","_dbGenPath","accessSync","constants","F_OK","code","noSuchFile","dbName","emptyDatabase","message","tokenDb","valueEncoding"],"mappings":";;;;;;;AAAA;;AACA;;AAGA;;AACA;;AACA;;AAYA;;AACA;;AAEA;;AACA;;;;;;;;;;AAEA,MAAMA,kBAAkB,GAAG,kBAA3B;AACA,MAAMC,OAAO,GAAG,oBAAhB;AACA,MAAMC,aAAa,GAAG,WAAtB;;AAYA;;;AAGA,MAAMC,aAAN,CAAkD;AAQhD;;;;AAIOC,EAAAA,WAAP,CAAmBC,MAAnB,EAAmCC,MAAnC,EAAmD;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AAAA;;AACjD,SAAKD,MAAL,GAAcA,MAAd;AACA,SAAKE,IAAL,GAAY,KAAKC,iBAAL,CAAuBH,MAAvB,CAAZ;AACA,SAAKC,MAAL,GAAcA,MAAd;AACA,SAAKG,MAAL,GAAc,KAAd;AACA,SAAKC,IAAL,GAAY,KAAKC,mBAAL,EAAZ;AAEA,SAAKL,MAAL,CAAYM,KAAZ,CAAkB;AAAEP,MAAAA,MAAM,EAAE,KAAKA;AAAf,KAAlB,EAA2C,2CAA3C;;AAEA,SAAKQ,KAAL;AACD;;AAEMC,EAAAA,SAAP,GAAoC;AAClC,WAAOC,OAAO,CAACC,OAAR,CAAgB,KAAKN,IAAL,CAAUO,MAA1B,CAAP;AACD;;AAEMC,EAAAA,SAAP,CAAiBD,MAAjB,EAAwD;AACtD,WAAO,IAAIF,OAAJ,CAAaC,OAAD,IAAmB;AACpC,WAAKN,IAAL,CAAUO,MAAV,GAAmBA,MAAnB;AAEAD,MAAAA,OAAO,CAAC,KAAKH,KAAL,EAAD,CAAP;AACD,KAJM,CAAP;AAKD;AAED;;;;;;;AAKOM,EAAAA,GAAP,CAAWC,IAAX,EAAyBC,EAAzB,EAA6C;AAC3C,QAAI,KAAKX,IAAL,CAAUY,IAAV,CAAeC,OAAf,CAAuBH,IAAvB,MAAiC,CAAC,CAAtC,EAAyC;AACvC,WAAKV,IAAL,CAAUY,IAAV,CAAeE,IAAf,CAAoBJ,IAApB;AAEA,WAAKd,MAAL,CAAYmB,KAAZ,CAAkB;AAAEL,QAAAA;AAAF,OAAlB,EAA4B,6DAA5B;AACAC,MAAAA,EAAE,CAAC,KAAKR,KAAL,EAAD,CAAF;AACD,KALD,MAKO;AACLQ,MAAAA,EAAE,CAAC,IAAD,CAAF;AACD;AACF;;AAEMK,EAAAA,MAAP,CAAcC,SAAd,EAAmCC,KAAnC,EAAoDC,YAApD,EAAmG;AACjG,UAAMC,QAAQ,GAAG,KAAKC,8BAAL,EAAjB;;AACA,SAAKzB,MAAL,CAAYM,KAAZ,CAAmB,4BAA2BoB,IAAI,CAACC,SAAL,CAAeH,QAAf,CAAyB,EAAvE;;AACA,UAAMI,IAAI,GAAGC,cAAKC,OAAL,CAAa,KAAK/B,MAAL,CAAYgC,SAAzB,CAAb;;AACA,UAAMC,IAAI,GAAG,IAAb;AACA,UAAMC,WAAW,GAAGC,MAAM,CAACC,IAAP,CAAYX,QAAZ,CAApB;AACA,SAAKxB,MAAL,CAAYM,KAAZ,CAAmB,iCAAgCsB,IAAK,SAAQK,WAAY,EAA5E;;AAEAG,mBAAMC,UAAN,CACEJ,WADF,EAEE,UAASK,OAAT,EAAkBvB,EAAlB,EAAsB;AACpB,YAAMwB,QAAQ,GAAGN,WAAW,CAAChB,OAAZ,CAAoBqB,OAApB,CAAjB;;AACA,YAAME,KAAK,GAAGX,cAAKY,IAAL,CAAUF,QAAQ,KAAK,CAAb,GAAiBN,WAAW,CAAC,CAAD,CAA5B,GAAkC,EAA5C,CAAd;;AACA,YAAMS,WAAmB,GAAGb,cAAKnB,OAAL,CAAakB,IAAb,EAAmBY,KAAnB,EAA0BF,OAA1B,CAA5B;;AACAN,MAAAA,IAAI,CAAChC,MAAL,CAAYM,KAAZ,CAAkB;AAAEoC,QAAAA,WAAF;AAAeJ,QAAAA;AAAf,OAAlB,EAA4C,kEAA5C;;AACAK,kBAAGC,OAAH,CAAWF,WAAX,EAAwB,CAACG,GAAD,EAAMC,KAAN,KAAgB;AACtC,YAAID,GAAJ,EAAS;AACP,iBAAO9B,EAAE,CAAC8B,GAAD,CAAT;AACD;;AAEDT,uBAAMC,UAAN,CACES,KADF,EAEE,UAASC,IAAT,EAAehC,EAAf,EAAmB;AACjBiB,UAAAA,IAAI,CAAChC,MAAL,CAAYM,KAAZ,CAAkB;AAAEyC,YAAAA;AAAF,WAAlB,EAA4B,mDAA5B;;AACA,cAAId,WAAW,CAACe,QAAZ,CAAqBD,IAArB,CAAJ,EAAgC;AAC9B,mBAAOhC,EAAE,EAAT;AACD;;AAED,cAAIgC,IAAI,CAACE,KAAL,CAAW,IAAX,CAAJ,EAAsB;AACpB;AACA,kBAAMC,YAAY,GAAGrB,cAAKnB,OAAL,CAAakB,IAAb,EAAmBU,OAAnB,EAA4BS,IAA5B,CAArB;;AACAf,YAAAA,IAAI,CAAChC,MAAL,CAAYM,KAAZ,CACE;AAAE4C,cAAAA;AAAF,aADF,EAEE,sEAFF;;AAIAP,wBAAGC,OAAH,CAAWM,YAAX,EAAyB,UAASL,GAAT,EAAcC,KAAd,EAAqB;AAC5C,kBAAID,GAAJ,EAAS;AACP,uBAAO9B,EAAE,CAAC8B,GAAD,CAAT;AACD;;AAEDT,6BAAMC,UAAN,CACES,KADF,EAEE,CAACK,KAAD,EAAQpC,EAAR,KAAe;AACb,oBAAIQ,YAAY,CAAC4B,KAAD,CAAhB,EAAyB;AACvB,wBAAMC,WAAW,GAAGvB,cAAKnB,OAAL,CAAakB,IAAb,EAAmBU,OAAnB,EAA4BS,IAA5B,EAAkCI,KAAlC,CAApB;;AAEAR,8BAAGU,IAAH,CAAQD,WAAR,EAAqB,CAACP,GAAD,EAAMS,KAAN,KAAgB;AACnC,wBAAIC,gBAAEC,KAAF,CAAQX,GAAR,MAAiB,KAArB,EAA4B;AAC1B,6BAAO9B,EAAE,CAAC8B,GAAD,CAAT;AACD;;AACD,0BAAMY,IAAI,GAAG;AACX3C,sBAAAA,IAAI,EAAG,GAAEiC,IAAK,IAAGI,KAAM,EADZ;AAEXlD,sBAAAA,IAAI,EAAEmD,WAFK;AAGXM,sBAAAA,IAAI,EAAEJ,KAAK,CAACK,KAAN,CAAYC,OAAZ;AAHK,qBAAb;AAKAvC,oBAAAA,SAAS,CAACoC,IAAD,EAAO1C,EAAP,CAAT;AACD,mBAVD;AAWD,iBAdD,MAcO;AACLA,kBAAAA,EAAE;AACH;AACF,eApBH,EAqBEA,EArBF;AAuBD,aA5BD;AA6BD,WApCD,MAoCO,IAAIQ,YAAY,CAACwB,IAAD,CAAhB,EAAwB;AAC7B,kBAAMP,KAAK,GAAGX,cAAKY,IAAL,CAAUF,QAAQ,KAAK,CAAb,GAAiBN,WAAW,CAAC,CAAD,CAA5B,GAAkC,EAA5C,CAAd;;AACA,kBAAMmB,WAAW,GAAGvB,cAAKnB,OAAL,CAAakB,IAAb,EAAmBY,KAAnB,EAA0BF,OAA1B,EAAmCS,IAAnC,CAApB;;AACAf,YAAAA,IAAI,CAAChC,MAAL,CAAYM,KAAZ,CAAkB;AAAE8C,cAAAA;AAAF,aAAlB,EAAmC,8DAAnC;;AACAT,wBAAGU,IAAH,CAAQD,WAAR,EAAqB,CAACP,GAAD,EAAMS,KAAN,KAAgB;AACnC,kBAAIC,gBAAEC,KAAF,CAAQX,GAAR,MAAiB,KAArB,EAA4B;AAC1B,uBAAO9B,EAAE,CAAC8B,GAAD,CAAT;AACD;;AACDxB,cAAAA,SAAS,CACP;AACEP,gBAAAA,IAAI,EAAEiC,IADR;AAEE9C,gBAAAA,IAAI,EAAEmD,WAFR;AAGEM,gBAAAA,IAAI,EAAE1B,IAAI,CAAC6B,QAAL,CAAcP,KAAK,CAACK,KAAN,CAAYC,OAAZ,EAAd,EAAqCN,KAAK,CAACK,KAA3C;AAHR,eADO,EAMP5C,EANO,CAAT;AAQD,aAZD;AAaD,WAjBM,MAiBA;AACLA,YAAAA,EAAE;AACH;AACF,SAhEH,EAiEEA,EAjEF;AAmED,OAxED;AAyED,KAhFH,EAiFEO,KAjFF;AAmFD;AAED;;;;;;;AAKOwC,EAAAA,MAAP,CAAchD,IAAd,EAA4BC,EAA5B,EAAgD;AAC9C,SAAKgD,GAAL,CAAS,CAAClB,GAAD,EAAMzC,IAAN,KAAe;AACtB,UAAIyC,GAAJ,EAAS;AACP9B,QAAAA,EAAE,CAAC,2BAAiB,8BAAjB,CAAD,CAAF;AACA,aAAKf,MAAL,CAAYgE,KAAZ,CAAkB;AAAEnB,UAAAA;AAAF,SAAlB,EAA2B,sEAA3B;AACD;;AAED,YAAMoB,OAAO,GAAG7D,IAAI,CAACa,OAAL,CAAaH,IAAb,CAAhB;;AACA,UAAImD,OAAO,KAAK,CAAC,CAAjB,EAAoB;AAClB,aAAK7D,IAAL,CAAUY,IAAV,CAAekD,MAAf,CAAsBD,OAAtB,EAA+B,CAA/B;AAEA,aAAKjE,MAAL,CAAYM,KAAZ,CAAkB;AAAEQ,UAAAA;AAAF,SAAlB,EAA4B,0DAA5B;AACD;;AAEDC,MAAAA,EAAE,CAAC,KAAKR,KAAL,EAAD,CAAF;AACD,KAdD;AAeD;AAED;;;;;;AAIOwD,EAAAA,GAAP,CAAWhD,EAAX,EAA+B;AAC7B,UAAMC,IAAI,GAAG,KAAKZ,IAAL,CAAUY,IAAvB;AACA,UAAMmD,UAAU,GAAG,KAAK/D,IAAL,CAAUY,IAAV,CAAeoD,MAAlC;AAEArD,IAAAA,EAAE,CAAC,IAAD,EAAOC,IAAP,CAAF;AAEA,SAAKhB,MAAL,CAAYM,KAAZ,CAAkB;AAAE6D,MAAAA;AAAF,KAAlB,EAAkC,6EAAlC;AACD;;AAEME,EAAAA,iBAAP,CAAyBC,WAAzB,EAA+D;AAC7D,UAAMC,aAAa,GAAG,KAAKxE,MAAL,CAAYyE,sBAAZ,CAAmCF,WAAnC,CAAtB;;AAEA,UAAMlB,WAAmB,GAAG,KAAKqB,oBAAL,CAA0BF,aAAa,GAAGA,aAAa,CAACjC,OAAjB,GAA2BoC,SAAlE,CAA5B;;AACA,SAAK1E,MAAL,CAAYM,KAAZ,CAAkB;AAAE8C,MAAAA;AAAF,KAAlB,EAAmC,qEAAnC;;AAEA,QAAIG,gBAAEoB,QAAF,CAAWvB,WAAX,MAA4B,KAAhC,EAAuC;AACrC,WAAKpD,MAAL,CAAYmB,KAAZ,CAAkB;AAAEL,QAAAA,IAAI,EAAEwD;AAAR,OAAlB,EAAyC,8CAAzC;AACA;AACD;;AAED,UAAMM,kBAA0B,GAAG/C,cAAKY,IAAL,CACjCZ,cAAKnB,OAAL,CAAamB,cAAKC,OAAL,CAAa,KAAK/B,MAAL,CAAYgC,SAAZ,IAAyB,EAAtC,CAAb,EAAwDqB,WAAxD,CADiC,EAEjCkB,WAFiC,CAAnC;;AAKA,SAAKtE,MAAL,CAAYM,KAAZ,CAAkB;AAAEsE,MAAAA;AAAF,KAAlB,EAA0C,wEAA1C;AAEA,WAAO,IAAIC,gBAAJ,CAAgBD,kBAAhB,EAAoC,KAAK5E,MAAzC,CAAP;AACD;;AAEM8E,EAAAA,KAAP,GAAqB;AACnB,SAAKvE,KAAL;AACD;;AAEMwE,EAAAA,SAAP,CAAiBC,KAAjB,EAA8C;AAC5C,UAAMC,GAAG,GAAG,KAAKC,YAAL,CAAkBF,KAAlB,CAAZ;;AACA,UAAMG,EAAE,GAAG,KAAKC,UAAL,EAAX;AAEA,WAAO,IAAI3E,OAAJ,CAAY,CAACC,OAAD,EAAU2E,MAAV,KAA2B;AAC5CF,MAAAA,EAAE,CAACG,GAAH,CAAOL,GAAP,EAAYD,KAAZ,EAAmBnC,GAAG,IAAI;AACxB,YAAIA,GAAJ,EAAS;AACPwC,UAAAA,MAAM,CAACxC,GAAD,CAAN;AACA;AACD;;AACDnC,QAAAA,OAAO;AACR,OAND;AAOD,KARM,CAAP;AASD;;AAEM6E,EAAAA,WAAP,CAAmBC,IAAnB,EAAiCC,QAAjC,EAAkE;AAChE,UAAMR,GAAG,GAAG,KAAKS,iBAAL,CAAuBF,IAAvB,EAA6BC,QAA7B,CAAZ;;AACA,UAAMN,EAAE,GAAG,KAAKC,UAAL,EAAX;AACA,WAAO,IAAI3E,OAAJ,CAAY,CAACC,OAAD,EAAU2E,MAAV,KAA2B;AAC5CF,MAAAA,EAAE,CAACQ,GAAH,CAAOV,GAAP,EAAYpC,GAAG,IAAI;AACjB,YAAIA,GAAJ,EAAS;AACPwC,UAAAA,MAAM,CAACxC,GAAD,CAAN;AACA;AACD;;AACDnC,QAAAA,OAAO;AACR,OAND;AAOD,KARM,CAAP;AASD;;AAEMkF,EAAAA,UAAP,CAAkBC,MAAlB,EAAyD;AACvD,WAAO,IAAIpF,OAAJ,CAAY,CAACC,OAAD,EAAU2E,MAAV,KAA2B;AAC5C,YAAMS,MAAe,GAAG,EAAxB;AACA,YAAMb,GAAG,GAAGY,MAAM,CAACL,IAAP,GAAc,GAA1B;AACA,YAAML,EAAE,GAAG,KAAKC,UAAL,EAAX;AACA,YAAMW,MAAM,GAAGZ,EAAE,CAACa,gBAAH,CAAoB;AACjCC,QAAAA,GAAG,EAAEhB,GAD4B;AAEjCiB,QAAAA,GAAG,EAAEC,MAAM,CAACC,YAAP,CAAoBnB,GAAG,CAACoB,UAAJ,CAAe,CAAf,IAAoB,CAAxC;AAF4B,OAApB,CAAf;AAKAN,MAAAA,MAAM,CAACO,EAAP,CAAU,MAAV,EAAkBlG,IAAI,IAAI;AACxB0F,QAAAA,MAAM,CAAC5E,IAAP,CAAYd,IAAI,CAACmG,KAAjB;AACD,OAFD;AAIAR,MAAAA,MAAM,CAACS,IAAP,CAAY,KAAZ,EAAmB,MAAM9F,OAAO,CAACoF,MAAD,CAAhC;AAEAC,MAAAA,MAAM,CAACS,IAAP,CAAY,OAAZ,EAAqB3D,GAAG,IAAIwC,MAAM,CAACxC,GAAD,CAAlC;AACD,KAhBM,CAAP;AAiBD;;AAEOgB,EAAAA,QAAR,CAAiBH,IAAjB,EAA+BC,KAA/B,EAA2D;AACzD,WAAOD,IAAI,GAAGA,IAAH,GAAUC,KAArB;AACD;;AAEOlC,EAAAA,8BAAR,GAAiD;AAC/C,UAAMD,QAAQ,GAAG,EAAjB,CAD+C,CAG/C;;AACA,QAAI,KAAKzB,MAAL,CAAYuC,OAAhB,EAAyB;AACvBd,MAAAA,QAAQ,CAAC,KAAKzB,MAAL,CAAYuC,OAAb,CAAR,GAAgC,IAAhC;AACD;;AAED,UAAM;AAAEmE,MAAAA;AAAF,QAAe,KAAK1G,MAA1B;;AAEA,QAAI0G,QAAJ,EAAc;AACZ,YAAMC,gBAAgB,GAAGxE,MAAM,CAACC,IAAP,CAAYsE,QAAQ,IAAI,EAAxB,CAAzB;AAEAC,MAAAA,gBAAgB,CAACC,GAAjB,CAAqBC,GAAG,IAAI;AAC1B,cAAMtE,OAAO,GAAGmE,QAAQ,CAACG,GAAD,CAAR,CAActE,OAA9B;;AACA,YAAIA,OAAJ,EAAa;AACXd,UAAAA,QAAQ,CAACc,OAAD,CAAR,GAAoB,KAApB;AACD;AACF,OALD;AAMD;;AAED,WAAOd,QAAP;AACD;AAED;;;;;;AAIQjB,EAAAA,KAAR,GAA8B;AAC5B,SAAKP,MAAL,CAAYmB,KAAZ,CAAkB,2CAAlB;;AAEA,QAAI,KAAKhB,MAAT,EAAiB;AACf,WAAKH,MAAL,CAAYgE,KAAZ,CAAkB,6FAAlB;AACA,aAAO,IAAI6C,KAAJ,CACL,4GADK,CAAP;AAGD,KAR2B,CAS5B;;;AACA,QAAI;AACF;AACA,YAAMC,UAAU,GAAGjF,cAAKC,OAAL,CAAa,KAAK7B,IAAlB,CAAnB;;AACA8G,sBAAOC,IAAP,CAAYF,UAAZ;;AACA,WAAK9G,MAAL,CAAYmB,KAAZ,CAAkB;AAAE2F,QAAAA;AAAF,OAAlB,EAAkC,6DAAlC;AACD,KALD,CAKE,OAAOjE,GAAP,EAAY;AACZ;AACA,WAAK7C,MAAL,CAAYmB,KAAZ,CAAkB;AAAE0B,QAAAA;AAAF,OAAlB,EAA2B,uDAA3B;AAEA,aAAO,IAAP;AACD;;AAED,QAAI;AACFF,kBAAGsE,aAAH,CAAiB,KAAKhH,IAAtB,EAA4ByB,IAAI,CAACC,SAAL,CAAe,KAAKvB,IAApB,CAA5B;;AACA,WAAKJ,MAAL,CAAYmB,KAAZ,CAAkB,yDAAlB;AAEA,aAAO,IAAP;AACD,KALD,CAKE,OAAO0B,GAAP,EAAY;AACZ,WAAK7C,MAAL,CAAYmB,KAAZ,CAAkB;AAAE0B,QAAAA;AAAF,OAAlB,EAA2B,yDAA3B;AAEA,aAAOA,GAAP;AACD;AACF;AAED;;;;;;;;AAMQ4B,EAAAA,oBAAR,CAA6BnC,OAA7B,EAA6D;AAC3D,UAAM4E,mBAAmB,GAAG,KAAKnH,MAAL,GAAc,KAAKA,MAAL,CAAYuC,OAA1B,GAAoCoC,SAAhE;;AACA,QAAInB,gBAAEC,KAAF,CAAQ0D,mBAAR,CAAJ,EAAkC;AAChC,YAAM,IAAIL,KAAJ,CAAU,4CAAV,CAAN;AACD,KAFD,MAEO;AACL,UAAItD,gBAAEC,KAAF,CAAQlB,OAAR,MAAqB,KAArB,IAA8BiB,gBAAEoB,QAAF,CAAWrC,OAAX,CAAlC,EAAuD;AACrD,eAAOT,cAAKY,IAAL,CAAUyE,mBAAV,EAAyC5E,OAAzC,CAAP;AACD;;AAED,aAAO4E,mBAAP;AACD;AACF;AAED;;;;;;;;AAMQhH,EAAAA,iBAAR,CAA0BH,MAA1B,EAAkD;AAChD,UAAMoH,aAAqB,GAAG,KAAKC,UAAL,CAAgB1H,kBAAhB,EAAoCK,MAApC,CAA9B;;AACA,QAAI;AACF4C,kBAAG0E,UAAH,CAAcF,aAAd,EAA6BxE,YAAG2E,SAAH,CAAaC,IAA1C;;AACA,aAAOJ,aAAP;AACD,KAHD,CAGE,OAAOtE,GAAP,EAAY;AACZ,UAAIA,GAAG,CAAC2E,IAAJ,KAAaC,mBAAjB,EAA6B;AAC3B,eAAO,KAAKL,UAAL,CAAgBzH,OAAhB,EAAyBI,MAAzB,CAAP;AACD;;AAED,YAAM8C,GAAN;AACD;AACF;;AAEOuE,EAAAA,UAAR,CAAmBM,MAAnB,EAAmC3H,MAAnC,EAA2D;AACzD,WAAO8B,cAAKY,IAAL,CAAUZ,cAAKnB,OAAL,CAAamB,cAAKC,OAAL,CAAa/B,MAAM,CAACgC,SAAP,IAAoB,EAAjC,CAAb,EAAmDhC,MAAM,CAACuC,OAA1D,EAA6EoF,MAA7E,CAAV,CAAP;AACD;AAED;;;;;;;AAKQrH,EAAAA,mBAAR,GAA4C;AAC1C,UAAMW,IAAiB,GAAG,EAA1B;AACA,UAAM2G,aAAa,GAAG;AAAE3G,MAAAA,IAAF;AAAQL,MAAAA,MAAM,EAAE;AAAhB,KAAtB;;AAEA,QAAI;AACF,YAAMwE,EAAE,GAAG,mCAAoB,KAAKlF,IAAzB,EAA+B,KAAKD,MAApC,CAAX;AAEA,aAAOmF,EAAP;AACD,KAJD,CAIE,OAAOtC,GAAP,EAAY;AACZ;AACA;AACA,UAAIA,GAAG,CAAC2E,IAAJ,KAAaC,mBAAjB,EAA6B;AAC3B,aAAKtH,MAAL,GAAc,IAAd;AACA,aAAKH,MAAL,CAAYgE,KAAZ,CACE,+EADF,EAEG,cAAa,KAAK/D,IAAK,QAAO4C,GAAG,CAAC+E,OAAQ,EAF7C;AAID;;AAED,aAAOD,aAAP;AACD;AACF;;AAEOvC,EAAAA,UAAR,GAA4B;AAC1B,QAAI,CAAC,KAAKyC,OAAV,EAAmB;AACjB,WAAKA,OAAL,GAAe,oBAAM,KAAKT,UAAL,CAAgBxH,aAAhB,EAA+B,KAAKG,MAApC,CAAN,EAAmD;AAChE+H,QAAAA,aAAa,EAAE;AADiD,OAAnD,CAAf;AAGD;;AAED,WAAO,KAAKD,OAAZ;AACD;;AAEO3C,EAAAA,YAAR,CAAqBF,KAArB,EAA2C;AACzC,UAAM;AAAEQ,MAAAA,IAAF;AAAQP,MAAAA;AAAR,QAAgBD,KAAtB;AACA,WAAO,KAAKU,iBAAL,CAAuBF,IAAvB,EAA6BP,GAA7B,CAAP;AACD;;AAEOS,EAAAA,iBAAR,CAA0BF,IAA1B,EAAwCP,GAAxC,EAA6D;AAC3D,WAAQ,GAAEO,IAAK,IAAGP,GAAI,EAAtB;AACD;;AAzZ+C;;eA4ZnCpF,a","sourcesContent":["import fs from 'fs';\nimport Path from 'path';\nimport stream from 'stream';\n\nimport _ from 'lodash';\nimport async from 'async';\nimport mkdirp from 'mkdirp';\nimport {\n  Callback,\n  Config,\n  IPackageStorage,\n  IPluginStorage,\n  LocalStorage,\n  Logger,\n  StorageList,\n  Token,\n  TokenFilter,\n} from '@verdaccio/types';\nimport level from 'level';\nimport { getInternalError } from '@verdaccio/commons-api/lib';\n\nimport LocalDriver, { noSuchFile } from './local-fs';\nimport { loadPrivatePackages } from './pkg-utils';\n\nconst DEPRECATED_DB_NAME = '.sinopia-db.json';\nconst DB_NAME = '.verdaccio-db.json';\nconst TOKEN_DB_NAME = '.token-db';\n\ninterface Level {\n  put(key: string, token, fn?: Function): void;\n\n  get(key: string, fn?: Function): void;\n\n  del(key: string, fn?: Function): void;\n\n  createReadStream(options?: object): stream.Readable;\n}\n\n/**\n * Handle local database.\n */\nclass LocalDatabase implements IPluginStorage<{}> {\n  public path: string;\n  public logger: Logger;\n  public data: LocalStorage;\n  public config: Config;\n  public locked: boolean;\n  public tokenDb;\n\n  /**\n   * Load an parse the local json database.\n   * @param {*} path the database path\n   */\n  public constructor(config: Config, logger: Logger) {\n    this.config = config;\n    this.path = this._buildStoragePath(config);\n    this.logger = logger;\n    this.locked = false;\n    this.data = this._fetchLocalPackages();\n\n    this.logger.trace({ config: this.config }, '[local-storage]: configuration: @{config}');\n\n    this._sync();\n  }\n\n  public getSecret(): Promise<string> {\n    return Promise.resolve(this.data.secret);\n  }\n\n  public setSecret(secret: string): Promise<Error | null> {\n    return new Promise((resolve): void => {\n      this.data.secret = secret;\n\n      resolve(this._sync());\n    });\n  }\n\n  /**\n   * Add a new element.\n   * @param {*} name\n   * @return {Error|*}\n   */\n  public add(name: string, cb: Callback): void {\n    if (this.data.list.indexOf(name) === -1) {\n      this.data.list.push(name);\n\n      this.logger.debug({ name }, '[local-storage]: the private package @{name} has been added');\n      cb(this._sync());\n    } else {\n      cb(null);\n    }\n  }\n\n  public search(onPackage: Callback, onEnd: Callback, validateName: (name: string) => boolean): void {\n    const storages = this._getCustomPackageLocalStorages();\n    this.logger.trace(`local-storage: [search]: ${JSON.stringify(storages)}`);\n    const base = Path.dirname(this.config.self_path);\n    const self = this;\n    const storageKeys = Object.keys(storages);\n    this.logger.trace(`local-storage: [search] base: ${base} keys ${storageKeys}`);\n\n    async.eachSeries(\n      storageKeys,\n      function(storage, cb) {\n        const position = storageKeys.indexOf(storage);\n        const base2 = Path.join(position !== 0 ? storageKeys[0] : '');\n        const storagePath: string = Path.resolve(base, base2, storage);\n        self.logger.trace({ storagePath, storage }, 'local-storage: [search] search path: @{storagePath} : @{storage}');\n        fs.readdir(storagePath, (err, files) => {\n          if (err) {\n            return cb(err);\n          }\n\n          async.eachSeries(\n            files,\n            function(file, cb) {\n              self.logger.trace({ file }, 'local-storage: [search] search file path: @{file}');\n              if (storageKeys.includes(file)) {\n                return cb();\n              }\n\n              if (file.match(/^@/)) {\n                // scoped\n                const fileLocation = Path.resolve(base, storage, file);\n                self.logger.trace(\n                  { fileLocation },\n                  'local-storage: [search] search scoped file location: @{fileLocation}'\n                );\n                fs.readdir(fileLocation, function(err, files) {\n                  if (err) {\n                    return cb(err);\n                  }\n\n                  async.eachSeries(\n                    files,\n                    (file2, cb) => {\n                      if (validateName(file2)) {\n                        const packagePath = Path.resolve(base, storage, file, file2);\n\n                        fs.stat(packagePath, (err, stats) => {\n                          if (_.isNil(err) === false) {\n                            return cb(err);\n                          }\n                          const item = {\n                            name: `${file}/${file2}`,\n                            path: packagePath,\n                            time: stats.mtime.getTime(),\n                          };\n                          onPackage(item, cb);\n                        });\n                      } else {\n                        cb();\n                      }\n                    },\n                    cb\n                  );\n                });\n              } else if (validateName(file)) {\n                const base2 = Path.join(position !== 0 ? storageKeys[0] : '');\n                const packagePath = Path.resolve(base, base2, storage, file);\n                self.logger.trace({ packagePath }, 'local-storage: [search] search file location: @{packagePath}');\n                fs.stat(packagePath, (err, stats) => {\n                  if (_.isNil(err) === false) {\n                    return cb(err);\n                  }\n                  onPackage(\n                    {\n                      name: file,\n                      path: packagePath,\n                      time: self._getTime(stats.mtime.getTime(), stats.mtime),\n                    },\n                    cb\n                  );\n                });\n              } else {\n                cb();\n              }\n            },\n            cb\n          );\n        });\n      },\n      onEnd\n    );\n  }\n\n  /**\n   * Remove an element from the database.\n   * @param {*} name\n   * @return {Error|*}\n   */\n  public remove(name: string, cb: Callback): void {\n    this.get((err, data) => {\n      if (err) {\n        cb(getInternalError('error remove private package'));\n        this.logger.error({ err }, '[local-storage/remove]: remove the private package has failed @{err}');\n      }\n\n      const pkgName = data.indexOf(name);\n      if (pkgName !== -1) {\n        this.data.list.splice(pkgName, 1);\n\n        this.logger.trace({ name }, 'local-storage: [remove] package @{name} has been removed');\n      }\n\n      cb(this._sync());\n    });\n  }\n\n  /**\n   * Return all database elements.\n   * @return {Array}\n   */\n  public get(cb: Callback): void {\n    const list = this.data.list;\n    const totalItems = this.data.list.length;\n\n    cb(null, list);\n\n    this.logger.trace({ totalItems }, 'local-storage: [get] full list of packages (@{totalItems}) has been fetched');\n  }\n\n  public getPackageStorage(packageName: string): IPackageStorage {\n    const packageAccess = this.config.getMatchedPackagesSpec(packageName);\n\n    const packagePath: string = this._getLocalStoragePath(packageAccess ? packageAccess.storage : undefined);\n    this.logger.trace({ packagePath }, '[local-storage/getPackageStorage]: storage selected: @{packagePath}');\n\n    if (_.isString(packagePath) === false) {\n      this.logger.debug({ name: packageName }, 'this package has no storage defined: @{name}');\n      return;\n    }\n\n    const packageStoragePath: string = Path.join(\n      Path.resolve(Path.dirname(this.config.self_path || ''), packagePath),\n      packageName\n    );\n\n    this.logger.trace({ packageStoragePath }, '[local-storage/getPackageStorage]: storage path: @{packageStoragePath}');\n\n    return new LocalDriver(packageStoragePath, this.logger);\n  }\n\n  public clean(): void {\n    this._sync();\n  }\n\n  public saveToken(token: Token): Promise<void> {\n    const key = this._getTokenKey(token);\n    const db = this.getTokenDb();\n\n    return new Promise((resolve, reject): void => {\n      db.put(key, token, err => {\n        if (err) {\n          reject(err);\n          return;\n        }\n        resolve();\n      });\n    });\n  }\n\n  public deleteToken(user: string, tokenKey: string): Promise<void> {\n    const key = this._compoundTokenKey(user, tokenKey);\n    const db = this.getTokenDb();\n    return new Promise((resolve, reject): void => {\n      db.del(key, err => {\n        if (err) {\n          reject(err);\n          return;\n        }\n        resolve();\n      });\n    });\n  }\n\n  public readTokens(filter: TokenFilter): Promise<Token[]> {\n    return new Promise((resolve, reject): void => {\n      const tokens: Token[] = [];\n      const key = filter.user + ':';\n      const db = this.getTokenDb();\n      const stream = db.createReadStream({\n        gte: key,\n        lte: String.fromCharCode(key.charCodeAt(0) + 1),\n      });\n\n      stream.on('data', data => {\n        tokens.push(data.value);\n      });\n\n      stream.once('end', () => resolve(tokens));\n\n      stream.once('error', err => reject(err));\n    });\n  }\n\n  private _getTime(time: number, mtime: Date): number | Date {\n    return time ? time : mtime;\n  }\n\n  private _getCustomPackageLocalStorages(): object {\n    const storages = {};\n\n    // add custom storage if exist\n    if (this.config.storage) {\n      storages[this.config.storage] = true;\n    }\n\n    const { packages } = this.config;\n\n    if (packages) {\n      const listPackagesConf = Object.keys(packages || {});\n\n      listPackagesConf.map(pkg => {\n        const storage = packages[pkg].storage;\n        if (storage) {\n          storages[storage] = false;\n        }\n      });\n    }\n\n    return storages;\n  }\n\n  /**\n   * Syncronize {create} database whether does not exist.\n   * @return {Error|*}\n   */\n  private _sync(): Error | null {\n    this.logger.debug('[local-storage/_sync]: init sync database');\n\n    if (this.locked) {\n      this.logger.error('Database is locked, please check error message printed during startup to prevent data loss.');\n      return new Error(\n        'Verdaccio database is locked, please contact your administrator to checkout logs during verdaccio startup.'\n      );\n    }\n    // Uses sync to prevent ugly race condition\n    try {\n      // https://www.npmjs.com/package/mkdirp#mkdirpsyncdir-opts\n      const folderName = Path.dirname(this.path);\n      mkdirp.sync(folderName);\n      this.logger.debug({ folderName }, '[local-storage/_sync]: folder @{folderName} created succeed');\n    } catch (err) {\n      // perhaps a logger instance?\n      this.logger.debug({ err }, '[local-storage/_sync/mkdirp.sync]: sync failed @{err}');\n\n      return null;\n    }\n\n    try {\n      fs.writeFileSync(this.path, JSON.stringify(this.data));\n      this.logger.debug('[local-storage/_sync/writeFileSync]: sync write succeed');\n\n      return null;\n    } catch (err) {\n      this.logger.debug({ err }, '[local-storage/_sync/writeFileSync]: sync failed @{err}');\n\n      return err;\n    }\n  }\n\n  /**\n   * Verify the right local storage location.\n   * @param {String} path\n   * @return {String}\n   * @private\n   */\n  private _getLocalStoragePath(storage: string | void): string {\n    const globalConfigStorage = this.config ? this.config.storage : undefined;\n    if (_.isNil(globalConfigStorage)) {\n      throw new Error('global storage is required for this plugin');\n    } else {\n      if (_.isNil(storage) === false && _.isString(storage)) {\n        return Path.join(globalConfigStorage as string, storage as string);\n      }\n\n      return globalConfigStorage as string;\n    }\n  }\n\n  /**\n   * Build the local database path.\n   * @param {Object} config\n   * @return {string|String|*}\n   * @private\n   */\n  private _buildStoragePath(config: Config): string {\n    const sinopiadbPath: string = this._dbGenPath(DEPRECATED_DB_NAME, config);\n    try {\n      fs.accessSync(sinopiadbPath, fs.constants.F_OK);\n      return sinopiadbPath;\n    } catch (err) {\n      if (err.code === noSuchFile) {\n        return this._dbGenPath(DB_NAME, config);\n      }\n\n      throw err;\n    }\n  }\n\n  private _dbGenPath(dbName: string, config: Config): string {\n    return Path.join(Path.resolve(Path.dirname(config.self_path || ''), config.storage as string, dbName));\n  }\n\n  /**\n   * Fetch local packages.\n   * @private\n   * @return {Object}\n   */\n  private _fetchLocalPackages(): LocalStorage {\n    const list: StorageList = [];\n    const emptyDatabase = { list, secret: '' };\n\n    try {\n      const db = loadPrivatePackages(this.path, this.logger);\n\n      return db;\n    } catch (err) {\n      // readFileSync is platform specific, macOS, Linux and Windows thrown an error\n      // Only recreate if file not found to prevent data loss\n      if (err.code !== noSuchFile) {\n        this.locked = true;\n        this.logger.error(\n          'Failed to read package database file, please check the error printed below:\\n',\n          `File Path: ${this.path}\\n\\n ${err.message}`\n        );\n      }\n\n      return emptyDatabase;\n    }\n  }\n\n  private getTokenDb(): Level {\n    if (!this.tokenDb) {\n      this.tokenDb = level(this._dbGenPath(TOKEN_DB_NAME, this.config), {\n        valueEncoding: 'json',\n      });\n    }\n\n    return this.tokenDb;\n  }\n\n  private _getTokenKey(token: Token): string {\n    const { user, key } = token;\n    return this._compoundTokenKey(user, key);\n  }\n\n  private _compoundTokenKey(user: string, key: string): string {\n    return `${user}:${key}`;\n  }\n}\n\nexport default LocalDatabase;\n"]}