@gabrielvgx/tecfoodcli/lib/util/app.js

Projeto para automatizar criação de ambientes TecFood

"use strict";

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

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

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

var _os = _interopRequireDefault(require("os"));

var _fileParser = require("../util/fileParser.js");

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

const app = {
  hasAccess(path) {
    try {
      _fs.default.accessSync(path);

      return true;
    } catch (error) {
      return false;
    }
  },

  getAppRootPath() {
    const APP_NAME = 'tecfood-cli';
    const CURRENT_PATH = process.env.PWD;
    const PATTERN = new RegExp(`(?<=\\b${APP_NAME}\\b).+`, 'gi');
    const APP_ROOT_PATH = CURRENT_PATH.replace(PATTERN, '');
    return APP_ROOT_PATH;
  },

  getFoldersInPath(pathToRead = null, validateFuncOrPattern = null) {
    if (!pathToRead) {
      let workfolderPath = _path.default.join(_os.default.homedir(), 'workfolder');

      let appsPath = _path.default.join(workfolderPath, 'apps');

      return this.getFoldersInPath(workfolderPath, validateFuncOrPattern).concat(this.getFoldersInPath(appsPath, validateFuncOrPattern));
    }

    let structureData = ({
      name
    }) => ({
      name,
      path: pathToRead,
      fullPath: _path.default.join(pathToRead, name)
    });

    return _fs.default.readdirSync(pathToRead, {
      withFileTypes: true
    }).filter(curPath => {
      let isDirectory = curPath.isDirectory();
      let matchByPattern = true;

      if (validateFuncOrPattern instanceof RegExp) {
        matchByPattern = validateFuncOrPattern.exec(curPath);
      } else if (validateFuncOrPattern instanceof Function) {
        matchByPattern = validateFuncOrPattern.apply(null, [curPath.name]);
      }

      return isDirectory && matchByPattern;
    }).map(structureData);
  },

  getEnvFilePath() {
    const APP_ROOT_PATH = this.getAppRootPath();

    const PATH_ENV = _path.default.join(APP_ROOT_PATH, 'src', 'docker', '.docker-compose.json');

    return PATH_ENV;
  },

  getComposeFilePath() {
    const APP_ROOT_PATH = this.getAppRootPath();

    const PATH_ENV = _path.default.join(APP_ROOT_PATH, 'src', 'docker', 'docker-compose.yml');

    return PATH_ENV;
  },

  getEnv() {
    const PATH_ENV = this.getEnvFilePath();
    const ENV = JSON.parse(_fs.default.readFileSync(PATH_ENV, 'utf8'));
    return ENV;
  },

  getPathAppConfig() {
    return _path.default.join(_os.default.homedir(), '.tecfoodcli');
  },

  loadAppConfig(fileName) {
    let configFolder = this.getPathAppConfig();

    let configFile = _path.default.join(configFolder, fileName);

    _fs.default.mkdirSync(configFolder, {
      recursive: true
    });

    if (app.hasAccess(configFile)) {
      let content = _fs.default.readFileSync(configFile, 'utf8');

      return JSON.parse(content);
    } else {
      _fs.default.writeFileSync(configFile, '{}');

      return {};
    }
  },

  updateAppConfig(fileName, config) {
    let oldConfig = this.loadAppConfig(fileName);
    let newConfig = Object.assign(oldConfig, config);
    let pathAppConfig = this.getPathAppConfig();

    _fs.default.writeFileSync(_path.default.join(pathAppConfig, fileName), JSON.stringify(newConfig, null, 4));
  },

  mergeEnv(defaultEnv, {
    services
  }) {
    let copyDefaultEnv = JSON.parse(JSON.stringify(defaultEnv));
    let serviceNames = Object.keys(copyDefaultEnv.services);
    serviceNames.forEach(serviceName => {
      if (serviceName in services) {
        copyDefaultEnv.services[serviceName] = Object.assign(copyDefaultEnv.services[serviceName], services[serviceName]);
      }
    });
    return copyDefaultEnv;
  },

  generateEnvFile(sourceObject = {
    services: {}
  }) {
    const ROOT_PATH = this.getAppRootPath();

    const ENV_PATH = _path.default.join(ROOT_PATH, 'src', 'docker');

    const DEFAULT_CONFIG_FILE = _path.default.join(ENV_PATH, 'docker-compose.json');

    if (this.hasAccess(DEFAULT_CONFIG_FILE)) {
      // has access path and file not exists
      let defaultEnvContent = JSON.parse(_fs.default.readFileSync(DEFAULT_CONFIG_FILE, 'utf8'));
      defaultEnvContent = JSON.stringify(this.mergeEnv(defaultEnvContent, sourceObject), null, 4);

      const ENV_FILE_PATH = _path.default.join(ENV_PATH, '.docker-compose.json');

      _fs.default.writeFileSync(ENV_FILE_PATH, defaultEnvContent);

      return JSON.parse(defaultEnvContent);
    } else {
      return null;
    }
  },

  getPathConfigFolderDocker() {
    return _path.default.join(_os.default.homedir(), '.docker');
  },

  generateComposeFile(sourceObject) {
    (0, _fileParser.json2yml)(sourceObject, false, this.getComposeFilePath());
  }

};
const {
  getAppRootPath,
  getEnv,
  generateEnvFile,
  getPathConfigFolderDocker
} = app;
exports.getPathConfigFolderDocker = getPathConfigFolderDocker;
exports.generateEnvFile = generateEnvFile;
exports.getEnv = getEnv;
exports.getAppRootPath = getAppRootPath;
var _default = app;
exports.default = _default;