Nest Commander 学习资料

@Command({
  name: 'greet',
  arguments: '<name>',
  description: 'Greet someone',
})
export class GreetCommand implements CommandRunner {
  async run([name]: string[], options: Record<string, any>): Promise<void> {
    console.log(`Hello, ${name}!`);
  }
}

@Option({
  flags: '-l, --love',
  description: 'Express your love',
  defaultValue: false,
})
parseLove(val: string): boolean {
  return JSON.parse(val);
}

import { CommandFactory } from 'nest-commander';

async function bootstrap() {
  await CommandFactory.run(RootModule, ['greet', 'bye']);
}

import { Command, CommandRunner } from 'nest-commander';
import { SubCommand } from 'nest-commander';

// 定义子命令
@SubCommand({ name: 'mid-1' })
export class Mid1Command extends CommandRunner {
  async run() {
    console.log('mid-1 command executed');
  }
}

// 父命令注册子命令
@Command({
  name: 'top',
  subCommands: [Mid1Command],
})
export class TopCommand extends CommandRunner {
  async run() {
    console.log('top command');
  }
}

// 底层子命令
@SubCommand({ name: 'bottom' })
export class BottomCommand extends CommandRunner {
  async run() {
    console.log('bottom command');
  }
}

// 中层子命令（拥有自己的子命令）
@SubCommand({ name: 'mid-1', subCommands: [BottomCommand] })
export class Mid1Command extends CommandRunner {
  async run() {
    console.log('mid-1 command');
  }
}

// 顶层命令
@Command({
  name: 'top',
  subCommands: [Mid1Command],
})
export class TopCommand extends CommandRunner {
  async run() {
    console.log('top command');
  }
}

@SubCommand({
  name: 'mid-1',
  subCommands: [BottomCommand],
  options: { isDefault: true },  // 设置为默认子命令
})
export class Mid1Command extends CommandRunner {
  async run() {
    console.log('default sub command');
  }
}

@SubCommand({ name: 'mid-2', aliases: ['m'] })
export class Mid2Command extends CommandRunner {
  async run() {
    console.log('mid-2 command');
  }
}

// bottom.command.ts
@SubCommand({ name: 'bottom' })
export class BottomCommand extends CommandRunner {
  constructor(private readonly log: LogService) { super(); }
  async run() { this.log.log('bottom command executed'); }
}

// mid-1.command.ts（带默认子命令）
@SubCommand({
  name: 'mid-1',
  subCommands: [BottomCommand],
  options: { isDefault: true },
})
export class Mid1Command extends CommandRunner {
  constructor(private readonly log: LogService) { super(); }
  async run() { this.log.log('mid-1 command executed'); }
}

// mid-2.command.ts（带别名）
@SubCommand({ name: 'mid-2', aliases: ['m'] })
export class Mid2Command extends CommandRunner {
  constructor(private readonly log: LogService) { super(); }
  async run() { this.log.log('mid-2 command executed'); }
}

// top.command.ts
@Command({
  name: 'top',
  subCommands: [Mid1Command, Mid2Command],
})
export class TopCommand extends CommandRunner {
  constructor(private readonly log: LogService) { super(); }
  async run(inputs: string[]) { this.log.log('top command'); }
}

import { Command, CommandRunner, InquirerService } from 'nest-commander';

@Command({ name: 'hello' })
export class HelloCommand extends CommandRunner {
  constructor(private readonly inquirer: InquirerService) {
    super();
  }

  async run(_inputs: string[], options?: HelloOptions): Promise<void> {
    // 询问问题集 'hello'，传入已解析的选项
    options = await this.inquirer.ask('hello', options);
    console.log(`Hello ${options.name}`);
  }
}

import { Question, QuestionSet } from 'nest-commander';

@QuestionSet({ name: 'hello' })
export class WhoQuestion {
  @Question({
    message: 'What is your name?',
    name: 'name',
  })
  parseName(val: string) {
    return val;
  }
}

@ValidateFor({ name: 'phone' })
validatePhone(value: string) {
  const pass = value.match(/^\d{10}$/);
  if (pass) {
    return true;
  }
  return 'Please enter a valid 10-digit phone number';
}

@WhenFor({ name: 'prize' })
whenPrize(answers: { comments: string }): boolean {
  // 只有当 comments 不是默认值时才显示 prize 问题
  return answers.comments !== 'Nope, all good!';
}

// pizza.interface.ts
export interface PizzaOptions {
  toppings?: string;
  toBeDelivered?: boolean;
  phone?: string;
  size?: string;
  quantity?: number;
  beverage?: string;
  comments?: string;
  prize?: string;
}

// pizza.question.ts
import { Question, QuestionSet, ValidateFor, WhenFor } from 'nest-commander';

@QuestionSet({ name: 'pizza' })
export class PizzaQuestion {
  // 展开列表选择
  @Question({
    type: 'expand',
    name: 'toppings',
    message: 'What about the toppings?',
    choices: [
      { key: 'p', name: 'Pepperoni and cheese', value: 'PepperoniCheese' },
      { key: 'a', name: 'All dressed', value: 'alldressed' },
      { key: 'w', name: 'Hawaiian', value: 'hawaiian' },
    ],
  })
  parseToppings(val: string) { return val; }

  // 确认问题
  @Question({
    type: 'confirm',
    name: 'toBeDelivered',
    message: 'Is this for delivery?',
    default: false,
  })
  parseToBeConfirmed(val: boolean) { return val; }

  // 带验证的输入
  @Question({
    type: 'input',
    name: 'phone',
    message: "What's your phone number?",
  })
  parsePhone(val: string) { return val; }

  @ValidateFor({ name: 'phone' })
  validatePhone(value: string) {
    const pass = value.match(/^\d{10}$/);
    return pass ? true : 'Please enter a valid phone number';
  }

  // 列表选择
  @Question({
    type: 'list',
    name: 'size',
    message: 'What size do you need?',
    choices: ['Large', 'Medium', 'Small'],
  })
  parseSize(val: string) { return val.toLowerCase(); }

  // 条件问题
  @WhenFor({ name: 'prize' })
  whenPrize(answers: { comments: string }): boolean {
    return answers.comments !== 'Nope, all good!';
  }
}

// pizza.command.ts
import { Command, CommandRunner, InquirerService } from 'nest-commander';
import { PizzaOptions } from './pizza.interface';

@Command({ name: 'pizza', options: { isDefault: true } })
export class PizzaCommand extends CommandRunner {
  constructor(private readonly inquirerService: InquirerService) {
    super();
  }

  async run(_inputs: string[], options?: PizzaOptions): Promise<void> {
    options = await this.inquirerService.ask('pizza', options);
    console.log(options);  // 输出完整订单
  }
}

import { Module } from '@nestjs/common';
import { PizzaCommand } from './pizza.command';
import { PizzaQuestion } from './pizza.question';

@Module({
  providers: [PizzaCommand, PizzaQuestion],
})
export class PizzaModule {}

import { Command, CommandRunner, Option } from 'nest-commander';

@Command({ name: 'config' })
export class ConfigCommand extends CommandRunner {
  async run() {
    console.log('Config loaded from environment');
  }

  @Option({
    flags: '-u, --username <username>',
    description: 'Username',
    env: 'MYCLI_USERNAME',  // 绑定环境变量
  })
  parseUsername(val: string): string {
    return val;
  }

  @Option({
    flags: '-t, --token <token>',
    description: 'API Token',
    env: 'MYCLI_TOKEN',  // 绑定环境变量
  })
  parseToken(val: string): string {
    return val;
  }
}

// bootstrap.ts
import { CommandFactory } from 'nest-commander';
import { AppModule } from './app.module';

async function bootstrap() {
  await CommandFactory.run(AppModule);
}

bootstrap();

import { CommandFactory } from 'nest-commander';

class CustomCommandFactory extends CommandFactory {
  // 自定义逻辑
}