deepify/lib.compiled/Generator/MicroserviceGenerator.js

DEEP Development Tools

/**
 * Created by CCristi <ccovali@mitocgroup.com> on 4/28/16.
 */

'use strict';

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

var _AbstractGenerator = require('./AbstractGenerator');

var _AngularFrontendGenerator = require('./AngularFrontendGenerator');

var _VanillaFrontendGenerator = require('./VanillaFrontendGenerator');

var _EngineNotSupportedException = require('./Exception/EngineNotSupportedException');

var _deepPackageManager = require('deep-package-manager');

var _joi = require('joi');

var _joi2 = _interopRequireDefault(_joi);

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

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

var _fsExtra2 = _interopRequireDefault(_fsExtra);

var _fs = require('fs');

var _fs2 = _interopRequireDefault(_fs);

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

class MicroserviceGenerator extends _AbstractGenerator.AbstractGenerator {
  /**
   * @param {Object[]} args
   */
  constructor(...args) {
    super(...args);
  }

  /**
   * @param {Function} cb
   * @private
   */
  _generate(cb) {
    let name = this.generationSchema.name;
    let identifier = MicroserviceGenerator.identifier(name);
    let engines = this.generationSchema.engines;
    let msPath = _path2.default.join(this.targetPath, identifier);
    let frontendPath = _path2.default.join(msPath, 'frontend');
    let templateParams = {
      engines: engines,
      name: name,
      identifier: identifier
    };

    this._ensureAppConfig();
    this._ensureTargetDirs(msPath);

    MicroserviceGenerator.MS_RESOURCES.forEach(resource => {
      this.renderFile(resource, _path2.default.join(msPath, resource), templateParams);
    });

    let generateEngineFrontend = (engineIndex = 0) => {
      let engine = engines[engineIndex];
      let frontendGenerator = this._createFrontendGenerator(engine);

      frontendGenerator.generate(frontendPath, { name, identifier }, error => {
        if (error) {
          cb(error);
          return;
        }

        engineIndex++;

        if (engineIndex < engines.length) {
          generateEngineFrontend(engineIndex);
        } else {
          cb(null, msPath);
        }
      });
    };

    generateEngineFrontend();
  }

  /**
   * @private
   */
  _ensureAppConfig() {
    let propertyConfigFile = _path2.default.join(this.targetPath, _deepPackageManager.Property_Config.DEFAULT_FILENAME);

    if (!_fs2.default.existsSync(propertyConfigFile)) {
      _fsExtra2.default.outputJsonSync(propertyConfigFile, _deepPackageManager.Property_Config.generate());
    }
  }

  /**
   * @param {String} frontendEngine
   * @returns {AbstractGenerator}
   * @private
   */
  _createFrontendGenerator(frontendEngine) {
    let GeneratorClass = null;

    switch (frontendEngine) {
      case 'angular':
      case 'angular1':
        GeneratorClass = _AngularFrontendGenerator.AngularFrontendGenerator;
        break;
      case 'vanilla':
        GeneratorClass = _VanillaFrontendGenerator.VanillaFrontendGenerator;
        break;
      default:
        throw new _EngineNotSupportedException.EngineNotSupportedException(frontendEngine);
    }

    return new GeneratorClass(this.templatingEngine, this.skeletonsDirectory);
  }

  /**
   * @todo: import autoload dir from deepkg.schema.js
   * @param {String} msPath
   */
  _ensureTargetDirs(msPath) {
    let dirList = ['backend', 'frontend', 'data/models', 'data/validation'];

    dirList.forEach(dir => {
      _fsExtra2.default.ensureDirSync(_path2.default.join(msPath, dir));
    });
  }

  /**
   * @returns {Object}
   */
  validationSchema() {
    return _joi2.default.object().keys({
      name: _joi2.default.string().required().regex(_AbstractGenerator.AbstractGenerator.DEEP_NAME_REGEXP),
      engines: _joi2.default.array().items(_joi2.default.string().only(MicroserviceGenerator.ALLOWED_ENGINES)).required().min(1)
    });
  }

  /**
   * @param {String} name
   * @returns {string}
   */
  static identifier(name) {
    return name.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
  }

  /**
   * @returns {String[]}
   */
  static get ALLOWED_ENGINES() {
    return ['angular', 'angular1', 'vanilla'];
  }

  /**
   * @returns {String[]}
   */
  static get MS_RESOURCES() {
    return [`backend/${_deepPackageManager.Microservice_Instance.RESOURCES_FILE}`, _deepPackageManager.Microservice_Instance.CONFIG_FILE, _deepPackageManager.Microservice_Instance.PARAMS_FILE];
  }
}
exports.MicroserviceGenerator = MicroserviceGenerator;