@eggjs/bin 7.0.0-beta.0

package/src/cmd/cov.ts

@@ -0,0 +1,89 @@
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { DefineCommand, Option } from '@artus-cli/artus-cli';
+import { importResolve } from '@eggjs/utils';
+import { TestCommand } from './test.js';
+
+@DefineCommand({
+  command: 'cov [files...]',
+  description: 'Run the test with coverage',
+  alias: [ 'c' ],
+})
+export class CovCommand extends TestCommand {
+  // will use on egg-mock https://github.com/eggjs/egg-mock/blob/84a64bd19d0569ec94664c898fb1b28367b95d60/index.js#L7
+  @Option({
+    description: 'prerequire files for coverage instrument',
+    type: 'boolean',
+    default: false,
+  })
+  prerequire: boolean;
+
+  @Option({
+    description: 'coverage ignore, one or more files patterns`',
+    array: true,
+    default: [],
+  })
+  x: string[];
+
+  @Option({
+    description: 'c8 instruments passthrough`',
+    default: '--temp-directory node_modules/.c8_output -r text-summary -r json-summary -r json -r lcov -r cobertura',
+  })
+  c8: string;
+
+  get defaultExcludes() {
+    return [
+      'example/',
+      'examples/',
+      'mocks**/',
+      'docs/',
+      // https://github.com/JaKXz/test-exclude/blob/620a7be412d4fc2070d50f0f63e3228314066fc9/index.js#L73
+      'test/**',
+      'test{,-*}.js',
+      '**/*.test.js',
+      '**/__tests__/**',
+      '**/node_modules/**',
+      'typings',
+      '**/*.d.ts',
+    ];
+  }
+
+  protected async forkNode(modulePath: string, args: string[]) {
+    if (this.prerequire) {
+      this.ctx.env.EGG_BIN_PREREQUIRE = 'true';
+    }
+    // append cobertura
+    if (this.c8) {
+      this.c8 += ' -r cobertura';
+    }
+
+    // add c8 args
+    // https://github.com/eggjs/egg/issues/3930
+    const c8Args = [
+      // '--show-process-tree',
+      ...this.c8.split(' ').filter(a => a.trim()),
+    ];
+    if (this.ctx.args.typescript) {
+      this.ctx.env.SPAWN_WRAP_SHIM_ROOT = path.join(this.base, 'node_modules');
+      c8Args.push('--extension');
+      c8Args.push('.ts');
+    }
+
+    const excludes = new Set([
+      ...process.env.COV_EXCLUDES?.split(',') ?? [],
+      ...this.defaultExcludes,
+      ...this.x,
+    ]);
+    for (const exclude of excludes) {
+      c8Args.push('-x');
+      c8Args.push(exclude);
+    }
+    const c8File = importResolve('c8/bin/c8.js');
+    const outputDir = path.join(this.base, 'node_modules/.c8_output');
+    await fs.rm(outputDir, { force: true, recursive: true });
+    const coverageDir = path.join(this.base, 'coverage');
+    await fs.rm(coverageDir, { force: true, recursive: true });
+
+    await super.forkNode(c8File, [ ...c8Args, process.execPath, ...this.ctx.args.execArgv || [], modulePath, ...args ]);
+  }
+}

package/src/cmd/debug.ts

@@ -0,0 +1,14 @@
+import { DefineCommand, Command, Utils, Inject } from '@artus-cli/artus-cli';
+
+@DefineCommand({
+  command: 'debug',
+  description: 'Alias to `egg-bin dev --inspect`',
+})
+export class DebugCommand extends Command {
+  @Inject()
+  utils: Utils;
+
+  async run() {
+    await this.utils.redirect([ 'dev', '--inspect' ]);
+  }
+}

package/src/cmd/dev.ts

@@ -0,0 +1,102 @@
+import { debuglog } from 'node:util';
+import { DefineCommand, Option } from '@artus-cli/artus-cli';
+import utils from '@eggjs/utils';
+import detect from 'detect-port';
+import { BaseCommand } from './base.js';
+import { getSourceFilename } from '../utils.js';
+
+const debug = debuglog('egg-bin:dev');
+
+@DefineCommand({
+  command: 'dev',
+  description: 'Start server at local dev mode',
+  alias: [ 'd' ],
+})
+export class DevCommand extends BaseCommand {
+  @Option({
+    description: 'listening port, default to 7001',
+    alias: 'p',
+  })
+  port: number;
+
+  @Option({
+    description: 'numbers of app workers, default to 1 at local mode',
+    alias: [ 'c', 'cluster' ],
+    default: 1,
+  })
+  workers: number;
+
+  @Option({
+    description: 'specify framework that can be absolute path or npm package, default is egg',
+  })
+  framework: string;
+
+  @Option({
+    description: 'start a sticky cluster server, default to false',
+    type: 'boolean',
+    default: false,
+  })
+  sticky: boolean;
+
+  async run() {
+    debug('run dev: %o', this.ctx.args);
+    this.ctx.env.NODE_ENV = this.ctx.env.NODE_ENV ?? 'development';
+    this.ctx.env.EGG_MASTER_CLOSE_TIMEOUT = '1000';
+    const serverBin = getSourceFilename('../scripts/start-cluster.mjs');
+    const eggStartOptions = await this.formatEggStartOptions();
+    const args = [ JSON.stringify(eggStartOptions) ];
+    const requires = await this.formatRequires();
+    const execArgv: string[] = [];
+    for (const r of requires) {
+      execArgv.push('--require');
+      execArgv.push(r);
+    }
+    await this.forkNode(serverBin, args, { execArgv });
+  }
+
+  protected async formatEggStartOptions() {
+    this.framework = utils.getFrameworkPath({
+      framework: this.framework,
+      baseDir: this.base,
+    });
+
+    if (!this.port) {
+      let configuredPort: number | undefined;
+      try {
+        const configuration = await utils.getConfig({
+          framework: this.framework,
+          baseDir: this.base,
+          env: 'local',
+        });
+        configuredPort = configuration?.cluster?.listen?.port;
+      } catch (err) {
+        /** skip when failing to read the configuration */
+        debug('getConfig error: %s, framework: %o, baseDir: %o, env: local',
+          err, this.framework, this.base);
+      }
+      if (configuredPort) {
+        this.port = configuredPort;
+        debug(`use port ${this.port} from configuration file`);
+      } else {
+        const defaultPort = process.env.EGG_BIN_DEFAULT_PORT ?? 7001;
+        debug('detect available port');
+        this.port = await detect(defaultPort);
+        if (this.port !== defaultPort) {
+          console.warn('[egg-bin] server port %s is in use, now using port %o',
+            defaultPort, this.port);
+        }
+        debug(`use available port ${this.port}`);
+      }
+    }
+
+    return {
+      baseDir: this.base,
+      workers: this.workers,
+      port: this.port,
+      framework: this.framework,
+      typescript: this.ctx.args.typescript,
+      tscompiler: this.ctx.args.tscompiler,
+      sticky: this.sticky,
+    };
+  }
+}

package/src/cmd/test.ts

@@ -0,0 +1,219 @@
+import { debuglog } from 'node:util';
+import os from 'node:os';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import {
+  DefineCommand, Option,
+} from '@artus-cli/artus-cli';
+import globby from 'globby';
+import { importResolve } from '@eggjs/utils';
+import { getChangedFilesForRoots } from 'jest-changed-files';
+import { BaseCommand } from './base.js';
+
+const debug = debuglog('egg-bin:test');
+
+@DefineCommand({
+  command: 'test [files...]',
+  description: 'Run the test',
+  alias: [ 't' ],
+})
+export class TestCommand extends BaseCommand {
+  @Option({
+    default: [],
+    array: true,
+    type: 'string',
+  })
+  files: string[];
+
+  @Option({
+    description: 'set test-case timeout in milliseconds, default is 60000',
+    alias: 't',
+    default: process.env.TEST_TIMEOUT ?? 60000,
+  })
+  timeout: number | boolean;
+
+  @Option({
+    description: 'only run tests matching <pattern>',
+    alias: 'g',
+    type: 'string',
+    array: true,
+    default: [],
+  })
+  grep: string[];
+
+  @Option({
+    description: 'only test with changed files and match test/**/*.test.(js|ts), default is false',
+    alias: 'c',
+    type: 'boolean',
+    default: false,
+  })
+  changed: boolean;
+
+  @Option({
+    description: 'mocha parallel mode, default is false',
+    alias: 'p',
+    type: 'boolean',
+    default: false,
+  })
+  parallel: boolean;
+
+  @Option({
+    description: 'number of jobs to run in parallel',
+    type: 'number',
+    default: os.cpus().length - 1,
+  })
+  jobs: number;
+
+  @Option({
+    description: 'auto bootstrap agent in mocha master process, default is true',
+    type: 'boolean',
+    default: true,
+  })
+  autoAgent: boolean;
+
+  @Option({
+    description: 'enable mochawesome reporter, default is true',
+    type: 'boolean',
+    default: true,
+  })
+  mochawesome: boolean;
+
+  @Option({
+    description: 'bbort ("bail") after first test failure',
+    alias: 'b',
+    type: 'boolean',
+    default: false,
+  })
+  bail: boolean;
+
+  async run() {
+    try {
+      await fs.access(this.base);
+    } catch (err) {
+      console.error('baseDir: %o not exists', this.base);
+      throw err;
+    }
+
+    const mochaFile = process.env.MOCHA_FILE || importResolve('mocha/bin/_mocha');
+    if (this.parallel) {
+      this.ctx.env.ENABLE_MOCHA_PARALLEL = 'true';
+      if (this.autoAgent) {
+        this.ctx.env.AUTO_AGENT = 'true';
+      }
+    }
+    // set NODE_ENV=test, let egg application load unittest logic
+    // https://eggjs.org/basics/env#difference-from-node_env
+    this.ctx.env.NODE_ENV = 'test';
+    debug('run test: %s %o', mochaFile, this.ctx.args);
+
+    const mochaArgs = await this.formatMochaArgs();
+    if (!mochaArgs) return;
+    await this.forkNode(mochaFile, mochaArgs, {
+      execArgv: [
+        ...process.execArgv,
+        // https://github.com/mochajs/mocha/issues/2640#issuecomment-1663388547
+        '--unhandled-rejections=strict',
+      ],
+    });
+  }
+
+  protected async formatMochaArgs() {
+    // collect require
+    const requires = await this.formatRequires();
+    try {
+      const eggMockRegister = importResolve('@eggjs/mock/register', { paths: [ this.base ] });
+      requires.push(eggMockRegister);
+      debug('auto register @eggjs/mock/register: %o', eggMockRegister);
+    } catch (err) {
+      // ignore @eggjs/mock not exists
+      debug('auto register @eggjs/mock fail, can not require @eggjs/mock on %o, error: %s',
+        this.base, (err as Error).message);
+    }
+
+    // handle mochawesome enable
+    let reporter = this.ctx.env.TEST_REPORTER;
+    let reporterOptions = '';
+    if (!reporter && this.mochawesome) {
+      // use https://github.com/node-modules/mochawesome/pull/1 instead
+      reporter = importResolve('mochawesome-with-mocha');
+      reporterOptions = 'reportDir=node_modules/.mochawesome-reports';
+      if (this.parallel) {
+        // https://github.com/adamgruber/mochawesome#parallel-mode
+        requires.push(importResolve('mochawesome-with-mocha/register'));
+      }
+    }
+
+    const ext = this.ctx.args.typescript ? 'ts' : 'js';
+    let pattern = this.files;
+    // changed
+    if (this.changed) {
+      pattern = await this.getChangedTestFiles(this.base, ext);
+      if (!pattern.length) {
+        console.log('No changed test files');
+        return;
+      }
+      debug('changed files: %o', pattern);
+    }
+
+    if (!pattern.length && process.env.TESTS) {
+      pattern = process.env.TESTS.split(',');
+    }
+
+    // collect test files when nothing is changed
+    if (!pattern.length) {
+      pattern = [ `test/**/*.test.${ext}` ];
+    }
+    pattern = pattern.concat([ '!test/fixtures', '!test/node_modules' ]);
+
+    // expand glob and skip node_modules and fixtures
+    const files = globby.sync(pattern, { cwd: this.base });
+    files.sort();
+
+    if (files.length === 0) {
+      console.log(`No test files found with ${pattern}`);
+      return;
+    }
+
+    // auto add setup file as the first test file
+    const setupFile = path.join(this.base, `test/.setup.${ext}`);
+    try {
+      await fs.access(setupFile);
+      files.unshift(setupFile);
+    } catch {
+      // ignore
+    }
+
+    return [
+      this.dryRun ? '--dry-run' : '',
+      // force exit
+      '--exit',
+      this.bail ? '--bail' : '',
+      this.grep.map(pattern => `--grep='${pattern}'`).join(' '),
+      this.timeout === false ? '--no-timeout' : `--timeout=${this.timeout}`,
+      this.parallel ? '--parallel' : '',
+      this.parallel && this.jobs ? `--jobs=${this.jobs}` : '',
+      reporter ? `--reporter=${reporter}` : '',
+      reporterOptions ? `--reporter-options=${reporterOptions}` : '',
+      ...requires.map(r => `--require=${r}`),
+      ...files,
+    ].filter(a => a.trim());
+  }
+
+  protected async getChangedTestFiles(dir: string, ext: string) {
+    const res = await getChangedFilesForRoots([ path.join(dir, 'test') ], {});
+    const changedFiles = res.changedFiles;
+    const files: string[] = [];
+    for (let cf of changedFiles) {
+      // only find test/**/*.test.(js|ts)
+      if (cf.endsWith(`.test.${ext}`)) {
+        // Patterns MUST use forward slashes (not backslashes)
+        // This should be converted on Windows
+        if (process.platform === 'win32') {
+          cf = cf.replace(/\\/g, '/');
+        }
+        files.push(cf);
+      }
+    }
+    return files;
+  }
+}

package/src/config/framework.ts

@@ -0,0 +1,3 @@
+export default {
+  package: '@artus-cli/artus-cli',
+};

package/src/config/plugin.ts

@@ -0,0 +1,10 @@
+export default {
+  autocomplete: {
+    enable: true,
+    package: '@artus-cli/plugin-autocomplete',
+  },
+  version: {
+    enable: true,
+    package: '@artus-cli/plugin-version',
+  },
+};

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './cmd/dev.js';
+export * from './cmd/debug.js';
+export * from './cmd/test.js';
+export * from './cmd/cov.js';
+export * from './cmd/base.js';

package/src/middleware/global_options.ts

@@ -0,0 +1,169 @@
+import { debuglog } from 'node:util';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import {
+  Inject, ApplicationLifecycle, LifecycleHook, LifecycleHookUnit,
+  Program, CommandContext,
+} from '@artus-cli/artus-cli';
+import { importResolve } from '@eggjs/utils';
+import { runScript } from 'runscript';
+import {
+  addNodeOptionsToEnv,
+  getSourceDirname,
+  readPackageJSON, hasTsConfig, getSourceFilename,
+} from '../utils.js';
+
+const debug = debuglog('@eggjs/bin/middleware/global_options');
+
+@LifecycleHookUnit()
+export default class GlobalOptions implements ApplicationLifecycle {
+  @Inject()
+  private readonly program: Program;
+
+  @LifecycleHook()
+  async configDidLoad() {
+    // add global options
+    this.program.option({
+      base: {
+        description: 'directory of application, default to `process.cwd()`',
+        type: 'string',
+        alias: 'baseDir',
+      },
+      declarations: {
+        description: 'whether create typings, will add `--require egg-ts-helper/register`',
+        type: 'boolean',
+        alias: 'dts',
+      },
+      typescript: {
+        description: 'whether enable typescript support',
+        type: 'boolean',
+        alias: 'ts',
+      },
+      tscompiler: {
+        description: 'ts compiler, like ts-node/register, ts-node/register/transpile-only, @swc-node/register, esbuild-register etc',
+        type: 'string',
+        alias: 'tsc',
+      },
+    });
+
+    this.program.use(async (ctx: CommandContext, next) => {
+      debug('before next');
+      if (!ctx.args.base) {
+        ctx.args.base = ctx.cwd;
+        debug('ctx.args.base not set, auto set it to cwd: %o', ctx.cwd);
+      }
+      if (!path.isAbsolute(ctx.args.base)) {
+        ctx.args.base = path.join(ctx.cwd, ctx.args.base);
+      }
+      debug('matched cmd: %o, ctx.args.base: %o', ctx.matched?.cmd, ctx.args.base);
+      const pkg = await readPackageJSON(ctx.args.base);
+      ctx.args.pkgEgg = pkg.egg ?? {};
+      const tscompiler = ctx.args.tscompiler ?? ctx.env.TS_COMPILER ?? ctx.args.pkgEgg.tscompiler;
+      if (ctx.args.typescript === undefined) {
+        // try to ready EGG_TYPESCRIPT env first, only accept 'true' or 'false' string
+        if (ctx.env.EGG_TYPESCRIPT === 'false') {
+          ctx.args.typescript = false;
+          debug('detect typescript=%o from EGG_TYPESCRIPT=%o', false, ctx.env.EGG_TYPESCRIPT);
+        } else if (ctx.env.EGG_TYPESCRIPT === 'true') {
+          ctx.args.typescript = true;
+          debug('detect typescript=%o from EGG_TYPESCRIPT=%o', true, ctx.env.EGG_TYPESCRIPT);
+        } else if (typeof ctx.args.pkgEgg.typescript === 'boolean') {
+          // read `egg.typescript` from package.json if not pass argv
+          ctx.args.typescript = ctx.args.pkgEgg.typescript;
+          debug('detect typescript=%o from pkg.egg.typescript=%o', true, ctx.args.pkgEgg.typescript);
+        } else if (pkg.dependencies?.typescript) {
+          // auto detect pkg.dependencies.typescript or pkg.devDependencies.typescript
+          ctx.args.typescript = true;
+          debug('detect typescript=%o from pkg.dependencies.typescript=%o', true, pkg.dependencies.typescript);
+        } else if (pkg.devDependencies?.typescript) {
+          ctx.args.typescript = true;
+          debug('detect typescript=%o from pkg.devDependencies.typescript=%o', true, pkg.devDependencies.typescript);
+        } else if (await hasTsConfig(ctx.args.base)) {
+          // tsconfig.json exists
+          ctx.args.typescript = true;
+          debug('detect typescript=%o cause tsconfig.json exists', true);
+        } else if (tscompiler) {
+          ctx.args.typescript = true;
+          debug('detect typescript=%o from --tscompiler=%o', true, tscompiler);
+        }
+      }
+
+      const isESM = pkg.type === 'module';
+      if (ctx.args.typescript) {
+        const findPaths = [ getSourceFilename('middleware') ];
+        if (tscompiler) {
+          // try app baseDir first on custom tscompiler
+          findPaths.unshift(ctx.args.base);
+        }
+        ctx.args.tscompiler = tscompiler ?? 'ts-node/register';
+        const tsNodeRegister = importResolve(ctx.args.tscompiler, {
+          paths: findPaths,
+        });
+        // should require tsNodeRegister on current process, let it can require *.ts files
+        // e.g.: dev command will execute egg loader to find configs and plugins
+        // await importModule(tsNodeRegister);
+        // let child process auto require ts-node too
+        if (isESM) {
+          addNodeOptionsToEnv(`--import ${tsNodeRegister}`, ctx.env);
+        } else {
+          addNodeOptionsToEnv(`--require ${tsNodeRegister}`, ctx.env);
+        }
+        // addNodeOptionsToEnv(`--require ${tsNodeRegister}`, ctx.env);
+        // tell egg loader to load ts file
+        // see https://github.com/eggjs/egg-core/blob/master/lib/loader/egg_loader.js#L443
+        ctx.env.EGG_TYPESCRIPT = 'true';
+        // set current process.env.EGG_TYPESCRIPT too
+        process.env.EGG_TYPESCRIPT = 'true';
+        // load files from tsconfig on startup
+        ctx.env.TS_NODE_FILES = process.env.TS_NODE_FILES ?? 'true';
+        // keep same logic with egg-core, test cmd load files need it
+        // see https://github.com/eggjs/egg-core/blob/master/lib/loader/egg_loader.js#L49
+        // addNodeOptionsToEnv(`--require ${importResolve('tsconfig-paths/register', {
+        //   paths: [ getSourceDirname() ],
+        // })}`, ctx.env);
+      }
+      if (isESM) {
+        // use ts-node/esm loader on esm
+        let esmLoader = importResolve('ts-node/esm', {
+          paths: [ getSourceDirname() ],
+        });
+        if (process.platform === 'win32') {
+          // ES Module loading with absolute path fails on windows
+          // https://github.com/nodejs/node/issues/31710#issuecomment-583916239
+          // https://nodejs.org/api/url.html#url_url_pathtofileurl_path
+          esmLoader = pathToFileURL(esmLoader).href;
+        }
+        // wait for https://github.com/nodejs/node/issues/40940
+        addNodeOptionsToEnv('--no-warnings', ctx.env);
+        addNodeOptionsToEnv(`--loader ${esmLoader}`, ctx.env);
+      }
+
+      if (ctx.args.declarations === undefined) {
+        if (typeof ctx.args.pkgEgg.declarations === 'boolean') {
+          // read `egg.declarations` from package.json if not pass argv
+          ctx.args.declarations = ctx.args.pkgEgg.declarations;
+          debug('detect declarations from pkg.egg.declarations=%o', ctx.args.pkgEgg.declarations);
+        }
+      }
+      if (ctx.args.declarations) {
+        const etsBin = importResolve('egg-ts-helper/dist/bin');
+        debug('run ets first: %o', etsBin);
+        await runScript(`node ${etsBin}`);
+      }
+
+      if (ctx.args.pkgEgg.revert) {
+        ctx.args.execArgv = ctx.args.execArgv || [];
+        const reverts = Array.isArray(ctx.args.pkgEgg.revert) ? ctx.args.pkgEgg.revert : [ ctx.args.pkgEgg.revert ];
+        for (const revert of reverts) {
+          ctx.args.execArgv.push(`--security-revert=${revert}`);
+        }
+      }
+
+      debug('set NODE_OPTIONS: %o', ctx.env.NODE_OPTIONS);
+      debug('ctx.args: %o', ctx.args);
+      debug('enter next');
+      await next();
+      debug('after next');
+    });
+  }
+}

package/src/middleware/handle_error.ts

@@ -0,0 +1,30 @@
+import { debuglog } from 'node:util';
+import {
+  Inject, ApplicationLifecycle, LifecycleHook, LifecycleHookUnit, Program,
+  ArtusCliError,
+} from '@artus-cli/artus-cli';
+
+const debug = debuglog('@eggjs/bin/middleware/handle_error');
+
+@LifecycleHookUnit()
+export default class implements ApplicationLifecycle {
+  @Inject()
+  private readonly program: Program;
+
+  @LifecycleHook()
+  async configDidLoad() {
+    this.program.use(async (_, next) => {
+      debug('enter next');
+      try {
+        await next();
+        debug('after next');
+      } catch (err: any) {
+        debug('next error: %o', err);
+        // let artus cli to handle it
+        if (err instanceof ArtusCliError) throw err;
+        console.error(err);
+        process.exit(typeof err.code === 'number' ? err.code : 1);
+      }
+    });
+  }
+}