1、脚手架命令注册

  1. //注册命令
  2. function registerCommander() {
  3.   program
  4.     .name(Object.keys(pkg.bin)[0])
  5.     .usage('<command> [options]')
  6.     .version(pkg.version)
  7.     .option('-d,--debug', 'Is debugging mode turned on?', false)
  9.   //初始化模式
  10.   program
  11.     .command('init [name]')
  12.     .alias('i') //添加别名
  13.     .option('-f,--force', '是否强制初始化')
  14.     .action(init)
  16.   //注册debug模式
  17.   program //记得加上program 否则init 命令的name参数打印不对
  18.     .on('option:debug', () => {
  19.       if (program.opts()?.debug) {
  20.         process.env.LOG_LEVEL = 'verbose'
  21.       } else {
  22.         process.env.LOG_LEVEL = 'info'
  23.       }
  24.       log.level = process.env.LOG_LEVEL
  25.       log.verbose('test debug')
  26.     })
  27.   // 监听未注册的所有命令
  28.   program
  29.     .on('command:*', obj => {
  30.       const availableCommand = program.commands.map(command => command.name)
  31.       log.info(colors.red('未知的命令 ' + obj[0]))
  32.       if (availableCommand.length) {
  33.         log.info(colors.blue('支持的命令 ' + availableCommand.join(',')))
  34.       }
  35.     })
  36.     .parse(process.argv)
  38.   //判断是否输入命令， 没输入则显示帮助文档
  39.   if (process.args && program.args.length < 1) {
  40.     program.outputHelp()
  41.   }
  42. }

lerna create @haha-cli-dev/init

  1. 'use strict'
  3. module.exports = init
  5. function init(projectName, cmdObj) {
  6.   console.log('init', projectName, cmdObj)
  7. }

image.png
image.png

2、当前脚手架架构痛点

5、脚手架命令注册和执行过程开发 - 图3
问题：
1、脚手架安装速度慢：所有的package都集成在cli里，因此当命令较多，会减慢脚手架的安装速度。
2、灵活性差：init命令只能使用@haha-cli-dev/init包，对于大公司而言，每个团队的init可能各不相同，需要init命令动态化。虽然增加了脚手架的复杂度，但是大大提升了脚手架的可扩展性，将脚手架框架和业务逻辑解耦。

3、脚手架架构优化

5、脚手架命令注册和执行过程开发 - 图4
5、脚手架命令注册和执行过程开发 - 图5
指令执行代码 node -e

4、是否执行本地代码

  1.   program
  2.       .option('-tp,--targetPath <targetPath>', '是否指定本地调试文件路径？')
  3.       .on('option:targetPath', () => {
  4.     //本地调试代码地址
  5.     process.env.CLI_TARGET_PATH = program._optionValues.targetPath
  6.   })

lerna create exec
将初始化时改成exec

  1.   //初始化模式
  2.   program
  3.     .command('init [name]')
  4.     .description('初始化项目')
  5.     .alias('i') //添加别名
  6.     .option('-f,--force', '是否强制初始化')
  7.     .action(exec)

lerna create packages 移到models中

  1. 'use strict'
  3. class Packages {
  4.   constructor() {
  5.     console.log('Packages')
  6.   }
  7. }
  9. module.exports = Packages

exec中引用packages的内容

  1. 'use strict'
  3. const pkg = require('@haha-cli-dev/packages')
  5. function exec() {
  6.   const _pkg = new pkg()
  7.   console.log(_pkg)
  8.   console.log(process.env.CLI_TARGET_PATH)
  9.   console.log(process.env.CLI_HOME)
  10.   //1、targetPath ->modulePath(通过targetPath 拿到实际的modulePath)
  11.   //2、modulePath ->Package(npm模块) 将modulePath生成一个通用的package
  12.   //3、Package.getRootFIle(获取入口文件)  这样以后扩展直接处理package的逻辑就可以，而不需要将getRootFIle暴露在外面
  14.   //封装--->复用
  15. }
  17. module.exports = exec

image.png

5、通用类packages

  1. 'use strict';
  3. const { isObject } = require('@hzw-cli-dev/utils');
  4. const { getRegister, getLatestVersion } = require('@hzw-cli-dev/get-npm-info');
  5. const formatPath = require('@hzw-cli-dev/format-path');
  6. const npmInstall = require('npminstall');
  7. const fse = require('fs-extra');
  8. const pathExists = require('path-exists').sync;
  9. const pkgDir = require('pkg-dir').sync;
  10. const path = require('path');
  11. // Package 类 管理模块
  12. class Package {
  13.   /**
  14.    * @description: 构造函数
  15.    * @param {*} options 用户传入的配置信息
  16.    * @return {*}
  17.    */
  18.   constructor(options) {
  19.     if (!options) {
  20.       throw new Error('Package 类的参数不能为空!');
  21.     }
  22.     if (!isObject(options)) {
  23.       throw new Error('Package 类的参数必须是对象类型!');
  24.     }
  25.     // 获取 targetPath ,如果没有 则说明不是一个本地的package
  26.     this.targetPath = options.targetPath;
  27.     // 模块安装位置 缓存路径
  28.     this.storeDir = options.storeDir;
  29.     // package 的 name
  30.     this.packageName = options.packageName;
  31.     // package 的 Version
  32.     this.packageVersion = options.packageVersion;
  33.     // 缓存路径的前缀
  34.     this.cacheFilePathPrefix = this.packageName.replace('/', '_');
  35.   }
  37.   /**
  38.    * @description: 准备工作
  39.    * @param {*}
  40.    * @return {*}
  41.    */
  42.   async prepare() {}
  44.   /**
  45.    * @description: 获取当前模块缓存路径
  46.    * @param {*}
  47.    * @return {*}
  48.    */
  49.   get cacheFilePath() {}
  51.   /**
  52.    * @description: 获取最新版本模块缓存路径
  53.    * @param {*}
  54.    * @return {*}
  55.    */
  56.   getSpecificFilePath(packageVersion) {}
  58.   /**
  59.    * @description: 判断当前 package 是否存在
  60.    * @param {*}
  61.    * @return {*}
  62.    */
  63.   async exists() {}
  65.   /**
  66.    * @description: 安装 package
  67.    * @param {*}
  68.    * @return {*}
  69.    */
  70.   async install() {}
  72.   /**
  73.    * @description: 更新 package
  74.    * @param {*}
  75.    * @return {*}
  76.    */
  77.   async update() {}
  79.   /**
  80.    * @description:获取入口文件的路径
  81.    * 1.获取package.json所在的目录 pkg-dir
  82.    * 2.读取package.json
  83.    * 3.找到main或者lib属性 形成路径
  84.    * 4.路径的兼容(macOs/windows)
  85.    * @param {*}
  86.    * @return {*}
  87.    */
  88.   getRootFilePath() {}
  89. module.exports = Package;

6、npmInstall用法

  1. const npminstall = require('npminstall');
  3. (async () => {
  4.   await npminstall({
  5.     //安装根目录
  6.     root: process.cwd(),
  7.     pkgs: [
  8.        { name: 'foo', version: '~1.0.0' },
  9.      ],
  10.     registry: 'https://registry.npmjs.org',
  11.     //安装缓存目录
  12.     storeDir: root + 'node_modules'
  13.   });
  14. })().catch(err => {
  15.   console.error(err);
  16. });

7、Command

  1. 'use strict'
  2. const semver = require('semver')
  3. const colors = require('colors')
  5. const LOWEST_NODE_VERSION = '12.0.0'
  7. class Command {
  8.   constructor(argv) {
  9.     if (!argv || argv.length === 0 || !argv[0]) {
  10.       throw new Error('参数不能为空')
  11.     }
  12.     if (!Array.isArray(argv)) {
  13.       throw new Error('参数必须是数组')
  14.     }
  16.     let runner = new Promise((resolve, reject) => {
  17.       let chain = Promise.resolve()
  18.       chain = chain
  19.         .then(() => this.checkNodeVersion())
  20.         .then(() => this.checkArgs(argv))
  21.         .then(() => this.init())
  22.         .then(() => this.exec())
  23.         .catch(error => console.log(error.message))
  24.     })
  25.   }
  27.   //检查node版本
  28.   checkNodeVersion() {
  29.     const currentVersion = process.version
  30.     if (!semver.gte(currentVersion, LOWEST_NODE_VERSION)) {
  31.       throw new Error(colors.red('错误:node版本过低'))
  32.     }
  33.   }
  35.   //初始化参数
  36.   checkArgs(argv) {
  37.     this._cmd = argv[arguments.length - 1]
  38.     this._argv = argv.slice(0, argv.length - 1)
  39.   }
  41.   init() {
  42.     throw new Error('command 必须拥有一个 init 方法')
  43.   }
  45.   exec() {
  46.     throw new Error('command 必须拥有一个 exec 方法')
  47.   }
  48. }
  50. module.exports = Command

8、initCommand

  1. 'use strict'
  3. const Command = require('@haha-cli-dev/command')
  5. class initCommand extends Command {
  6.   init() {
  7.     this.projectName = this._argv[0]
  8.     console.log('projectName', this.projectName)
  9.   }
  10. }
  12. function init(argv) {
  13.   return new initCommand(argv)
  14. }
  16. function exec() {}
  18. module.exports = init
  19. module.exports.initCommand = initCommand

9、exec

  1. 'use strict'
  3. const path = require('path')
  4. const childProcess = require('child_process')
  6. const packages = require('@haha-cli-dev/packages')
  7. const log = require('@haha-cli-dev/log')
  9. const SETTINGS = {
  10.   init: '@haha-cli-dev/init'
  11. }
  13. const CACHE_DIR = 'dependencies'
  15. async function exec(...argv) {
  16.   log.level = process.env.LOG_LEVEL
  17.   let targetPath = process.env.CLI_TARGET_PATH
  18.   const homePath = process.env.CLI_HOME_PATH
  19.   let storeDir = ''
  20.   const cmdObj = arguments[arguments.length - 1]
  21.   const packageName = SETTINGS[cmdObj._name]
  22.   let pkg
  23.   //是否执行本地代码
  24.   if (!targetPath) {
  25.     targetPath = path.resolve(homePath, CACHE_DIR)
  26.     storeDir = path.resolve(targetPath, 'node_modules')
  27.     log.verbose('targetPath', targetPath)
  28.     log.verbose('storeDir', storeDir)
  29.     pkg = new packages({
  30.       targetPath,
  31.       storeDir,
  32.       packageName,
  33.       packageVersion: 'latest'
  34.     })
  35.     if (await pkg.exists()) {
  36.       //更新
  37.       pkg.update()
  38.     } else {
  39.       //初始化
  40.       pkg.install()
  41.     }
  42.   } else {
  43.     pkg = new packages({
  44.       targetPath,
  45.       packageName,
  46.       packageVersion: 'latest'
  47.     })
  48.   }
  49.   //获取本地代码入口文件
  50.   const rootFile = pkg.getRootFilePath()
  51.   log.verbose('rootFile', rootFile)
  52.   if (rootFile) {
  53.     //cli已经对全局的异常进行了捕获，为什么在这里仍需要使用try，catch捕获command的异常，因为在使用了program.action异步处理了。异常处理的都需要重新捕获异常
  54.     try {
  55.       const cmd = argv[argv.length - 1]
  56.       const newCmd = Object.create(null)
  57.       Object.keys(cmd).forEach(key => {
  58.         if (cmd.hasOwnProperty(key) && !key.startsWith('_') && key !== 'parent') {
  59.           newCmd[key] = cmd[key]
  60.         }
  61.       })
  62.       argv[argv.length - 1] = newCmd
  63.       try {
  64.         //code是字符串 ！！！ require(路径（字符串）)(参数（字符串）)
  65.         const code = `require('${rootFile}')(${JSON.stringify(argv)})`
  66.         //在 node 子进程中调用 提高速度
  67.         const cp = spawn('node', ['-e', code], {
  68.           cwd: process.cwd(), //cwd 子进程的当前工作目录
  69.           stdio: 'inherit' //inherit  将相应的stdio传给父进程或者从父进程传入，相当于process.stdin,process.stout和process.stderr
  70.         })
  71.         cp.on('error', function (error) {
  72.           console.log(error.message)
  73.           process.exit(1)
  74.         })
  75.         cp.on('exit', e => {
  76.           log.verbose('命令执行成功', e)
  77.           process.exit(e)
  78.         })
  79.       } catch (error) {
  80.         console.log(error.message)
  81.       }
  82.     } catch (error) {
  83.       console.log(error.message)
  84.     }
  85.   }
  87.   function spawn(command, args, options = {}) {
  88.     const win32 = process.platform === 'win32'
  89.     const cmd = win32 ? 'cmd' : command
  90.     const cmdArgs = win32 ? ['/c'].concat(command, args) : args
  91.     return childProcess.spawn(cmd, cmdArgs, options)
  92.   }
  93. }
  95. module.exports = exec