Lerna 运行流程剖析

// package.json 添加
"workspaces":[
 "packages/*"
]
// lerna.json 添加
 "useWorkspaces":true,
 "npmClient": "yarn",
 // 配置好后，所有依赖就会安装在最外层的 node_modules 中，且支持软链接方式
 // npm 7.x 之后，同样支持工作区域

#!/usr/bin/env node

"use strict";

/* eslint-disable import/no-dynamic-require, global-require */
const importLocal = require("import-local");
// 判断是否处于本地包文件，下文会介绍
if (importLocal(__filename)) {
  require("npmlog").info("cli", "using local version of lerna");
} else {
// 进入真实的入口执行代码
  require(".")(process.argv.slice(2)); // [node, lerna, 指令]
}

/** 省略相同代码 */

// 导入 @lerna/cli 文件 
const cli = require("@lerna/cli");

// ..... 省略相同指令导入
// 导入 publish 指令文件
const publishCmd = require("@lerna/publish/command");
const pkg = require("./package.json");

module.exports = main;

// 最终导出方法
function main(argv) {
  const context = {
    lernaVersion: pkg.version,
  };

  return cli()
  // ..... 省略 
    .command(publishCmd)
    .parse(argv, context); // 解析注入指令 & 参数(版本号) 
}

const dedent = require("dedent"); // 去除空行
const log = require("npmlog");
const yargs = require("yargs/yargs");
const { globalOptions } = require("@lerna/global-options");

module.exports = lernaCLI;

function lernaCLI(argv, cwd) {
  const cli = yargs(argv, cwd);

  return globalOptions(cli)
    .usage("Usage: $0 <command> [options]")
    .demandCommand(1, "A command is required. Pass --help to see all available commands and options.") // 期望命令个数
    .recommendCommands() // 推荐命令
    .strict()  // 严格模式
    .fail((msg, err) => {
     // ... 省略
    })
    .alias("h", "help") // 别名
    .alias("v", "version")
    .wrap(cli.terminalWidth()) // 宽高 
   .epilogue(dedent`
      When a command fails, all logs are written to lerna-debug.log in the current working directory.
      For more information, find our manual at https://github.com/lerna/lerna
    `);  // 结尾
}

const { Command } = require("@lerna/command");
const listable = require("@lerna/listable");
const { output } = require("@lerna/output");
const { getFilteredPackages } = require("@lerna/filter-options");

module.exports = factory;

function factory(argv) {
  return new ListCommand(argv);
}

class ListCommand extends Command {
  get requiresGit() {
    return false;
  }

  initialize() {
    let chain = Promise.resolve();

    chain = chain.then(() => getFilteredPackages(this.packageGraph, this.execOpts, this.options));
    chain = chain.then((filteredPackages) => {
      this.result = listable.format(filteredPackages, this.options);
    });

    return chain;
  }

  execute() {
    // piping to `wc -l` should not yield 1 when no packages matched
    if (this.result.text.length) {
      output(this.result.text);
    }

    this.logger.success(
      "found",
      "%d %s",
      this.result.count,
      this.result.count === 1 ? "package" : "packages"
    );
  }
}

module.exports.ListCommand = ListCommand;

const { Project } = require("@lerna/project");
// 省略大部分容错 和 log
class Command {
  constructor(_argv) {
    const argv = cloneDeep(_argv);

    // "FooCommand" => "foo"
    this.name = this.constructor.name.replace(/Command$/, "").toLowerCase();

    // composed commands are called from other commands, like publish -> version
    this.composed = typeof argv.composed === "string" && argv.composed !== this.name;

    // launch the command
    let runner = new Promise((resolve, reject) => {
      // run everything inside a Promise chain
      // 异步链
      let chain = Promise.resolve();

      chain = chain.then(() => {
        this.project = new Project(argv.cwd);
      });
      // 配置、环境初始化等
      chain = chain.then(() => this.configureEnvironment());
      chain = chain.then(() => this.configureOptions());
      chain = chain.then(() => this.configureProperties());
      chain = chain.then(() => this.configureLogging());
      chain = chain.then(() => this.runValidations());
      chain = chain.then(() => this.runPreparations());
      // 最终执行逻辑
      chain = chain.then(() => this.runCommand());

      chain.then(
        (result) => {
          warnIfHanging();

          resolve(result);
        },
        (err) => {
          if (err.pkg) {
            // Cleanly log specific package error details
            logPackageError(err, this.options.stream);
          } else if (err.name !== "ValidationError") {
            // npmlog does some funny stuff to the stack by default,
            // so pass it directly to avoid duplication.
            log.error("", cleanStack(err, this.constructor.name));
          }

          // ValidationError does not trigger a log dump, nor do external package errors
          if (err.name !== "ValidationError" && !err.pkg) {
            writeLogFile(this.project.rootPath);
          }

          warnIfHanging();
          // error code is handled by cli.fail()
          reject(err);
        }
      );
    });
 // ...省略部分代码
  }



  runCommand() {
    return Promise.resolve()
     // 命令初始化
      .then(() => this.initialize())
      .then((proceed) => {
        if (proceed !== false) {
          // 指令执行
          return this.execute();
        }
        // early exits set their own exitCode (if non-zero)
      });
  }
 // 子类不存在 时 抛出错误
  initialize() {
    throw new ValidationError(this.name, "initialize() needs to be implemented.");
  }

  execute() {
    throw new ValidationError(this.name, "execute() needs to be implemented.");
  }
}

module.exports.Command = Command;

const path = require('path');
const resolveCwd = require('resolve-cwd');
const pkgDir = require('pkg-dir');

module.exports = filename => {
  // '/Users/nvm/versions/node/v14.17.3/lib/node_modules/lerna' 全局文件夹
  const globalDir = pkgDir.sync(path.dirname(filename));
  const relativePath = path.relative(globalDir, filename); // 'cli.js'
  const pkg = require(path.join(globalDir, 'package.json'));
  // '/Users/Desktop/person/lerna-demo/node_modules/lerna/cli.js' // 本地文件
  const localFile = resolveCwd.silent(path.join(pkg.name, relativePath)); 
  // '/Users/Desktop/person/lerna-demo/node_modules'  // 本地文件的 node_modules
  const localNodeModules = path.join(process.cwd(), 'node_modules'); 
  const filenameInLocalNodeModules = !path.relative(localNodeModules, filename).startsWith('..') &&
    // On Windows, if `localNodeModules` and `filename` are on different partitions, `path.relative()` returns the value of `filename`, resulting in `filenameInLocalNodeModules` incorrectly becoming `true`.
    path.parse(localNodeModules).root === path.parse(filename).root;

  // Use `path.relative()` to detect local package installation,
  // because __filename's case is inconsistent on Windows
  // Can use `===` when targeting Node.js 8
  // See https://github.com/nodejs/node/issues/6624

  // 导入使用本地包
  return !filenameInLocalNodeModules && localFile && path.relative(localFile, filename) !== '' && require(localFile);
};

const path = require('path');
const Module = require('module');
// 省略部分代码
const fromFile = path.join(fromDirectory, 'noop.js');
 // '/Users/Desktop/home/person/lerna-demo/noop.js'

const resolveFileName = () => Module._resolveFilename(moduleId, {
    id: fromFile,
    filename: fromFile,
    paths: Module._nodeModulePaths(fromDirectory)
});

const locatePath = require('locate-path');
const stop = Symbol('findUp.stop');

module.exports.sync = (name, options = {}) => {
  let directory = path.resolve(options.cwd || '');
  const {root} = path.parse(directory);
  const paths = [].concat(name);

  const runMatcher = locateOptions => {
    if (typeof name !== 'function') {
      return locatePath.sync(paths, locateOptions);
    }
    const foundPath = name(locateOptions.cwd);
    if (typeof foundPath === 'string') {
      return locatePath.sync([foundPath], locateOptions);
    }
    return foundPath;
  };
  // eslint-disable-next-line no-constant-condition
  while (true) {
    const foundPath = runMatcher({...options, cwd: directory});

    if (foundPath === stop) {
      return;
    }
    if (foundPath) {
        return path.resolve(directory, foundPath);
    }
    if (directory === root) {
      return;
    }
    directory = path.dirname(directory);
  }
};

target <string> | <Buffer> | <URL>   // 目标文件
path <string> | <Buffer> | <URL>  // 创建软链对应的地址
type <string>