deep-package-manager/lib.compiled/Property/ExtractStrategy/PessimisticStrategy.js

DEEP Package Manager

/**
 * Created by CCristi on 6/30/16.
 */

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.PessimisticStrategy = undefined;

var _AbstractStrategy = require('./AbstractStrategy');

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _Config = require('../Config');

var _fs = require('fs');

var _fs2 = _interopRequireDefault(_fs);

var _fsExtra = require('fs-extra');

var _fsExtra2 = _interopRequireDefault(_fsExtra);

var _Instance = require('../../Microservice/Instance');

var _crypto = require('crypto');

var _crypto2 = _interopRequireDefault(_crypto);

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

class PessimisticStrategy extends _AbstractStrategy.AbstractStrategy {
  /**
   * @param {String} path
   * @param {String[]} positiveIdentifiers
   */
  constructor(path, ...positiveIdentifiers) {
    super();

    this._path = path;
    this._identifiers = positiveIdentifiers.sort();
  }

  /**
   * @returns {String}
   */
  path() {
    return this._path;
  }

  /**
   * @param {Microservice|Instance} microservice
   * @returns {Boolean}
   */
  shouldPreserve(microservice) {
    return microservice.isRoot || this._identifiers.indexOf(microservice.identifier) !== -1;
  }

  /**
   * @returns {String|Object}
   */
  config() {
    let configFile = _path2.default.join(this.path(), _Config.Config.DEFAULT_FILENAME);

    if (!_fs2.default.existsSync(configFile)) {
      _fsExtra2.default.outputJsonSync(configFile, _Config.Config.generate());
    }

    let configObj = _fsExtra2.default.readJsonSync(configFile);

    configObj.appIdentifier += `.${this._collectionHash}.`;

    return configObj;
  }

  /**
   * @returns {String}
   * @private
   */
  get _collectionHash() {
    return PessimisticStrategy._hash(JSON.stringify(this._identifiers), 'md5');
  }

  /**
   * @param {String} str
   * @param {String} alg
   * @returns {String}
   * @private
   */
  static _hash(str, alg) {
    return _crypto2.default.createHash(alg).update(str).digest('hex');
  }

  /**
   * @param {String} msPath
   * @returns {PessimisticStrategy}
   */
  static create(msPath) {
    let microservice = _Instance.Instance.create(msPath);
    let identifiers = [microservice.identifier].concat(Object.keys(microservice.config.dependencies));

    return new PessimisticStrategy(_path2.default.join(msPath, '..'), ...identifiers);
  }
}
exports.PessimisticStrategy = PessimisticStrategy;