@alifd/fusion-collector/lib/index.js

Collect info for fusion based project

'use strict';
/**
* Created at 16/7/8.
* @Author Ling.
* @Email i@zeroling.com
*/

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

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

var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));

var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));

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

var _glob = _interopRequireDefault(require("glob"));

var _gracefulFs = _interopRequireDefault(require("graceful-fs"));

var _log = _interopRequireDefault(require("./retcodelog/src/log.js"));

var _utils = require("./utils");

var _parser = require("@babel/parser");

var _debug = _interopRequireDefault(require("debug"));

var _require = require('ice-npm-utils'),
    checkAliInternal = _require.checkAliInternal;

var BASIC_PACKAGES = ['@alifd/next', '@alife/next', '@icedesign/base'];
var debug = (0, _debug["default"])('next:collect');

/**
* 分析数据
*/
function collect(_x) {
  return _collect.apply(this, arguments);
}

function _collect() {
  _collect = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(options) {
    var rootDir, kit, pkg, packageFilePath, gitConfig, repoName, gitUrl, author, isDefBuild, isInternal, kitVersion, originTemplate, dependencies, peerDependencies, nextComponents, analyzeFiles, analyzed, result;
    return _regenerator["default"].wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            // debug('options', options);
            options = options || {};

            if (Object.prototype.toString.call(options) == '[object String]') {
              rootDir = options;
              options = {};
            }

            rootDir = rootDir || options.rootDir;

            if (rootDir) {
              _context.next = 6;
              break;
            }

            console.error('缺少项目路径，请添加 rootDir 参数');
            return _context.abrupt("return");

          case 6:
            options.rootDir = rootDir;
            kit = options.kit || 'fusion-collector'; // 获取项目的package.json内容

            pkg = {};

            try {
              packageFilePath = _path["default"].join(rootDir, 'package.json');
              pkg = JSON.parse(_gracefulFs["default"].readFileSync(packageFilePath, 'utf-8'));
            } catch (err) {
              debug('读取 package.json 文件错误: ', err.message);
            } // 获取git配置


            gitConfig = (0, _utils.getGitConfig)(rootDir); // 获取git系列信息，以及是否为内网

            isInternal = 0;

            if (process.env.BUILD_GIT_GROUP && process.env.BUILD_GIT_PROJECT) {
              author = process.env.BUILD_USER;
              repoName = process.env.BUILD_GIT_GROUP + '/' + process.env.BUILD_GIT_PROJECT;
              gitUrl = "git@gitlab.alibaba-inc.com:".concat(repoName, ".git");
              isDefBuild = 1;
            }

            _context.next = 15;
            return checkAliInternal();

          case 15:
            isInternal = _context.sent;
            isInternal = isInternal ? 1 : 0; // 获取统计工具的版本号

            kitVersion = '';

            try {
              if ('kitVersion' in options) {
                kitVersion = options.kitVersion;
              } else {
                kitVersion = getVersionFromModules(kit, rootDir, pkg);
              }
            } catch (error) {
              debug('kit version:: ', error);
            } // 获取项目 来自于哪个模版


            originTemplate = pkg.originTemplate || '';
            debug('originTemplate:', originTemplate); // 内网下，获取项目的依赖

            dependencies = {}, peerDependencies = {};

            if (isInternal) {
              Object.keys(pkg.dependencies || {}).forEach(function (plugin) {
                dependencies[plugin] = getVersionFromModules(plugin, rootDir, pkg);
              });
              Object.keys(pkg.peerDependencies || {}).forEach(function (plugin) {
                peerDependencies[plugin] = getVersionFromModules(plugin, rootDir, pkg);
              });
            }

            debug('dependencies: ', dependencies);
            debug('peerDependencies: ', peerDependencies);
            nextComponents = '';

            if (isInternal) {
              // 内网下，获取基础组件的组件使用分布
              analyzeFiles = _glob["default"].sync('**/**/*.@(tsx|jsx|js)', {
                cwd: rootDir,
                ignore: ['**/node_modules/**', 'build/**', 'assets/build/**', 'dist/**', '_output/**', '**.config.js']
              }); // debug('目标文件：', analyzeFiles);

              analyzed = analyzeFiles.reduce(function (obj, current) {
                var analyzeRes = analyze(_path["default"].join(rootDir, current));

                if (analyzeRes) {
                  obj[current] = analyzeRes;
                }

                return obj;
              }, {}); // debug('依赖分析：', analyzed);

              nextComponents = getStatistics(analyzed);
            } // debug('依赖详情：', nextComponents);


            result = {
              // 云构建读取出来的可能是 工号 也可能是 花名，云构建读取数据的优先级高于 git config
              author: author || gitConfig.userName,
              // 项目组名和仓库名
              repoName: repoName || gitConfig.repoName,
              // 仓库地址
              gitUrl: gitUrl || gitConfig.url,
              // 统计工具名称
              kit: kit,
              // 统计工具版本
              kitVersion: kitVersion,
              // 构建类型
              cmdType: options.cmdType || 'build',
              // package.json 信息
              // pkg,
              // 是否是云构建
              isDefBuild: isDefBuild,
              originTemplate: originTemplate,
              // 依赖的业务组件信息，只有内网模式（云构建模式）下才收集
              dependencies: dependencies,
              // 依赖的peerDependencies信息，只有内网模式（云构建模式）下才收集
              peerDependencies: peerDependencies,
              // 使用的基础组件分布，只有内网模式（云构建模式）下才收集
              nextComponents: nextComponents,
              isInternal: isInternal
            };
            debug('上传详情 result: ', result);
            return _context.abrupt("return", result);

          case 30:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));
  return _collect.apply(this, arguments);
}

function getVersionFromModules(plugin, rootDir, pkgFile) {
  var version = '';

  try {
    var pluginPkgjsonPath = _path["default"].join(rootDir, 'node_modules', plugin, 'package.json');

    if (_gracefulFs["default"].existsSync(pluginPkgjsonPath)) {
      var pluginPkgjson = _gracefulFs["default"].readFileSync(pluginPkgjsonPath, 'utf-8');

      var pluginPkg = JSON.parse(pluginPkgjson);
      version = pluginPkg && pluginPkg.version;
    } else {
      version = pkgFile['dependencies'][plugin] || '';
    }
  } catch (error) {
    debug('get plugin version error: ', error);
  }

  return version;
}
/**
* 格式化数据收集
*/


function formatCollect(originInfo) {
  var author = originInfo.author,
      repoName = originInfo.repoName,
      gitUrl = originInfo.gitUrl,
      kit = originInfo.kit,
      kitVersion = originInfo.kitVersion,
      cmdType = originInfo.cmdType,
      isDefBuild = originInfo.isDefBuild,
      originTemplate = originInfo.originTemplate,
      dependencies = originInfo.dependencies,
      peerDependencies = originInfo.peerDependencies,
      nextComponents = originInfo.nextComponents,
      isInternal = originInfo.isInternal;
  var pkg = originInfo.pkg || {};
  var sshGitUrl = gitUrl ? (0, _utils.gitFormat)(gitUrl) : gitUrl;
  return {
    project_id: sshGitUrl,
    ssh_url: sshGitUrl,
    git_url: gitUrl,
    project_name: pkg.name,
    description: pkg.description,
    author: author,
    repo_name: repoName,
    kit_version: kitVersion,
    kit: kit,
    cmd_type: cmdType,
    is_def_build: isDefBuild,
    is_internal: isInternal,
    origin_template: originTemplate,
    dependencies: JSON.stringify(dependencies),
    peerDependencies: JSON.stringify(peerDependencies),
    next_components: JSON.stringify(nextComponents)
  };
}
/**
* 分析并上报数据,recode使用get上报，数据量如果大的话需要拆分请求。
*/


function collectDetail(_x2) {
  return _collectDetail.apply(this, arguments);
}
/**
* 分析文件依赖
*/


function _collectDetail() {
  _collectDetail = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(options) {
    var retCodeInfo,
        originInfo,
        uploadInfo,
        logMsg,
        _args2 = arguments;
    return _regenerator["default"].wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            retCodeInfo = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : {};
            _context2.prev = 1;
            _context2.next = 4;
            return collect(options);

          case 4:
            originInfo = _context2.sent;
            debug('originInfo', originInfo);
            uploadInfo = formatCollect(originInfo);
            debug('上报数据', uploadInfo);

            _log["default"].setConfig({
              sample: retCodeInfo.sample || 1,
              spmId: retCodeInfo.spmId || 'fusion.materials'
            });

            logMsg = '';
            Object.keys(uploadInfo).forEach(function (key) {
              logMsg += "".concat(key, "=").concat(uploadInfo[key], "&&");
            }); // 可分析类数据

            _log["default"].log(logMsg, 1);

            _context2.next = 17;
            break;

          case 14:
            _context2.prev = 14;
            _context2.t0 = _context2["catch"](1);
            debug('collectDetail error:', _context2.t0);

          case 17:
          case "end":
            return _context2.stop();
        }
      }
    }, _callee2, null, [[1, 14]]);
  }));
  return _collectDetail.apply(this, arguments);
}

function analyze(file) {
  try {
    var source = _gracefulFs["default"].readFileSync(file, 'utf-8');

    var ast = (0, _parser.parse)(source, {
      sourceType: 'module',
      plugins: ['jsx', 'tsx', 'flow', 'asyncFunctions', 'classConstructorCall', 'doExpressions', 'trailingFunctionCommas', 'objectRestSpread', 'decorators-legacy', 'classProperties', 'exportExtensions', 'exponentiationOperator', 'asyncGenerators', 'functionBind', 'functionSent']
    }); // got ast

    return (0, _utils.getImportedOrRequiredModules)(ast);
  } catch (err) {
    debug('分析依赖出错', err, file);
    return null;
  }
}
/**
* 根据依赖信息做进一步计算统计
*/


function getStatistics(analyzed) {
  var basicComponentsTimes = {}; // 基础组件引用次数

  for (var _i = 0, _Object$values = Object.values(analyzed); _i < _Object$values.length; _i++) {
    var arr = _Object$values[_i];
    arr.forEach(function (imported) {
      if (BASIC_PACKAGES.indexOf(imported.fromModule) > -1) {
        // 基础组件
        if (Array.isArray(imported.importedValue)) {
          imported.importedValue.forEach(function (moduleName) {
            basicComponentsTimes[moduleName] = basicComponentsTimes[moduleName] === undefined ? 1 : basicComponentsTimes[moduleName] + 1;
          });
        } else {
          basicComponentsTimes[imported.importedValue] = basicComponentsTimes[imported.importedValue] === undefined ? 1 : basicComponentsTimes[imported.importedValue] + 1;
        }
      }
    });
  }

  return basicComponentsTimes;
}