open-index/open-npm huggingface dataset:
npm package: @fluent/console
Description: Fluent - console component
Author: Eugen Melnychenko
Latest version: 1.0.8
Deprecated: Not maintained anymore

# Console

The command line interface is the basis for application execution. The console operates with commands. That's how the command looks:

```typescript
@Command('ping')
export class PingCommand extends CommandHandler {
  constructor(readonly logger: Logger) {
    super();
  }

  async handle() {
    this.logger.information('pong');
  }
}
```

`@Command(string)` is required. This decorator sets the template and allows you to inject the services on the constructor.

In order to add the command you need to register it in the application:

```typescript
@Main()
export class Startup {
  configure(app: ApplicationBuilder) {
    app.addCommand(PingCommand);
  }
}
```

## Template Definition

The command template consists of three components: name, arguments and options. These components should be separated by a space.

### Name

The name is required and must be unique:

```typescript
@Command('ping')
```

### Argument

Arguments can be several or none.

Here is an example of an required argument:

```typescript
@Command('ping {message}')
```

The argument may also be optional and contain default value:

```typescript
@Command('ping {message?}')

// and with default value

@Command('ping {message=pong}')
```

### Option

Options can be several or none as well. Option always will be optional and can be defined as string or boolean type.

Here is an example of option:

```typescript
@Command('ping {--log}')
```

Option can have multi-definition:

```typescript
@Command('ping {-l|--log}')
```

If the option is not specified then the value will be `false`;

That's how the option with value looks:

```typescript
@Command('ping {--message=}')

// or with default value

@Command('ping {--message=pong}')
```

If the option is not specified then the value will be `undefined`;

Option can receive array value:

```typescript
// ping --to=foo --to=bar

@Command('ping {--to=*}')
```

If the option is not specified then the value will be `[]`;

## Command Handler

the handler of the commands can receive parets through the decorators: `@Argument()` and `@Option()`

```typescript
@Command('ping {message=pong} {--log}')
export class PingCommand extends CommandHandler {
  constructor(readonly logger: Logger) {
    super();
  }

  async handle(@Argument() message: string, @Option() log: boolean) {
    if (log) {
      this.logger.information(message);
    }
  }
}
```

In this case, the name of the argument and options are the name of the parameters. They can also be redefined:

```typescript
async handle(@Argument('message') msg: string, @Option('--log') log: boolean) {
    if (log) {
      this.logger.information(message);
    }
  }
```

## Command Execution

In order to execute the command you need to compile the code and enter:

```bash
node main.js "command template"
```

Example of `PingCommand`:

```bash
node main.js ping pong --log
```

Output will looks:

```bash
information: pong
```