@travetto/cli 5.0.0-rc.2 → 5.0.0-rc.4

package/README.md

@@ -59,7 +59,7 @@ This module also has a tight integration with the [VSCode plugin](https://market
 At it's heart, a cli command is the contract defined by what flags, and what arguments the command supports. Within the framework this requires three criteria to be met:
    *  The file must be located in the `support/` folder, and have a name that matches `cli.*.ts`
    *  The file must be a class that has a main method
-   *  The class must use the [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/decorators.ts#L14) decorator
+   *  The class must use the [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/decorators.ts#L85) decorator
 
 **Code: Basic Command**
 ```typescript
@@ -93,7 +93,7 @@ Examples of mappings:
 The pattern is that underscores(_) translate to colons (:), and the `cli.` prefix, and `.ts` suffix are dropped.
 
 ## Binding Flags
-[@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/decorators.ts#L14) is a wrapper for [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L14), and so every class that uses the [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/decorators.ts#L14) decorator is now a full [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L14) class. The fields of the class represent the flags that are available to the command.
+[@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/decorators.ts#L85) is a wrapper for [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L14), and so every class that uses the [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/decorators.ts#L85) decorator is now a full [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L14) class. The fields of the class represent the flags that are available to the command.
 
 **Code: Basic Command with Flag**
 ```typescript
@@ -130,7 +130,7 @@ $ trv basic:flag --loud
 HELLO
 ```
 
-The [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/decorators.ts#L14) supports the following data types for flags:
+The [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/decorators.ts#L85) supports the following data types for flags:
    *  Boolean values
    *  Number values. The [@Integer](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L172), [@Float](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L178), [@Precision](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L166), [@Min](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L107) and [@Max](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L117) decorators help provide additional validation.
    *  String values. [@MinLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L107), [@MaxLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L117), [@Match](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L99) and [@Enum](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L78) provide additional constraints
@@ -388,7 +388,7 @@ npx trv call:db --host localhost --port 3306 --username app --password <custom>
 ```
 
 ## VSCode Integration
-By default, cli commands do not expose themselves to the VSCode extension, as the majority of them are not intended for that sort of operation.  [RESTful API](https://github.com/travetto/travetto/tree/main/module/rest#readme "Declarative api for RESTful APIs with support for the dependency injection module.") does expose a cli target `run:rest` that will show up, to help run/debug a rest application.  Any command can mark itself as being a run target, and will be eligible for running from within the [VSCode plugin](https://marketplace.visualstudio.com/items?itemName=arcsine.travetto-plugin). This is achieved by setting the `runTarget` field on the [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/decorators.ts#L14) decorator.  This means the target will be visible within the editor tooling.
+By default, cli commands do not expose themselves to the VSCode extension, as the majority of them are not intended for that sort of operation.  [RESTful API](https://github.com/travetto/travetto/tree/main/module/rest#readme "Declarative api for RESTful APIs with support for the dependency injection module.") does expose a cli target `run:rest` that will show up, to help run/debug a rest application.  Any command can mark itself as being a run target, and will be eligible for running from within the [VSCode plugin](https://marketplace.visualstudio.com/items?itemName=arcsine.travetto-plugin). This is achieved by setting the `runTarget` field on the [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/decorators.ts#L85) decorator.  This means the target will be visible within the editor tooling.
 
 **Code: Simple Run Target**
 ```typescript
@@ -461,7 +461,7 @@ If the goal is to run a more complex application, which may include depending on
 ```typescript
 import { Runtime } from '@travetto/runtime';
 import { DependencyRegistry } from '@travetto/di';
-import { CliCommand, CliCommandShape, CliUtil } from '@travetto/cli';
+import { CliCommand, CliCommandShape } from '@travetto/cli';
 
 import { ServerHandle } from '../src/types';
 import { RestNetUtil } from '../src/util/net';
@@ -469,15 +469,9 @@ import { RestNetUtil } from '../src/util/net';
 /**
  * Run a rest server as an application
  */
-@CliCommand({ runTarget: true, addModule: true, addEnv: true })
+@CliCommand({ runTarget: true, with: { debugIpc: true, canRestart: true, module: true, env: true } })
 export class RunRestCommand implements CliCommandShape {
 
-  /** IPC debug is enabled */
-  debugIpc?: boolean;
-
-  /** Should the server be able to run with restart*/
-  canRestart?: boolean;
-
   /** Port to run on */
   port?: number;
 
@@ -491,9 +485,6 @@ export class RunRestCommand implements CliCommandShape {
   }
 
   async main(): Promise<ServerHandle | void> {
-    if (await CliUtil.debugIfIpc(this) || await CliUtil.runWithRestart(this)) {
-      return;
-    }
     const { RestApplication } = await import('../src/application/rest');
     try {
       return await DependencyRegistry.runInstance(RestApplication);
@@ -508,7 +499,7 @@ export class RunRestCommand implements CliCommandShape {
 }
 ```
 
-As noted in the example above, `fields` is specified in this execution, with support for `module`, and `env`. These env flag is directly tied to the [Runtime](https://github.com/travetto/travetto/tree/main/module/runtime/src/env.ts#L109) `name` defined in the [Base](https://github.com/travetto/travetto/tree/main/module/runtime#readme "Environment config and common utilities for travetto applications.") module. 
+As noted in the example above, `fields` is specified in this execution, with support for `module`, and `env`. These env flag is directly tied to the [Runtime](https://github.com/travetto/travetto/tree/main/module/runtime/src/env.ts#L108) `name` defined in the [Base](https://github.com/travetto/travetto/tree/main/module/runtime#readme "Environment config and common utilities for travetto applications.") module. 
 
 The `module` field is slightly more complex, but is geared towards supporting commands within a monorepo context.  This flag ensures that a module is specified if running from the root of the monorepo, and that the module provided is real, and can run the desired command.  When running from an explicit module folder in the monorepo, the module flag is ignored.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/cli",
-  "version": "5.0.0-rc.2",
+  "version": "5.0.0-rc.4",
   "description": "CLI infrastructure for Travetto framework",
   "keywords": [
     "cli",
@@ -29,8 +29,8 @@
     "directory": "module/cli"
   },
   "dependencies": {
-    "@travetto/schema": "^5.0.0-rc.2",
-    "@travetto/terminal": "^5.0.0-rc.2"
+    "@travetto/schema": "^5.0.0-rc.4",
+    "@travetto/terminal": "^5.0.0-rc.4"
   },
   "travetto": {
     "displayName": "Command Line Interface",

package/src/decorators.ts

@@ -1,10 +1,81 @@
 import { Class, ClassInstance, Env, Runtime, RuntimeIndex, describeFunction } from '@travetto/runtime';
-import { SchemaRegistry } from '@travetto/schema';
+import { FieldConfig, SchemaRegistry } from '@travetto/schema';
 
 import { CliCommandShape, CliCommandShapeFields } from './types';
-import { CliCommandRegistry, CliCommandConfigOptions } from './registry';
+import { CliCommandRegistry } from './registry';
 import { CliModuleUtil } from './module';
 import { CliParseUtil } from './parse';
+import { CliUtil } from './util';
+
+type Cmd = CliCommandShape & { env?: string };
+
+type CliCommandConfigOptions = {
+  hidden?: boolean;
+  runTarget?: boolean;
+  runtimeModule?: 'current' | 'command';
+  with?: {
+    /** Application environment */
+    env?: boolean;
+    /** Module to run for */
+    module?: boolean;
+    /** Should debug invocation trigger via ipc */
+    debugIpc?: boolean;
+    /** Should the invocation automatically restart on exit */
+    canRestart?: boolean;
+  };
+};
+
+const FIELD_CONFIG: {
+  name: keyof Exclude<CliCommandConfigOptions['with'], undefined>;
+  field: Partial<FieldConfig>;
+  run: (cmd: Cmd) => (Promise<unknown> | unknown);
+}[] =
+  [
+    {
+      name: 'env',
+      run: cmd => Env.TRV_ENV.set(cmd.env || Runtime.envName),
+      field: {
+        type: String,
+        aliases: ['e', CliParseUtil.toEnvField(Env.TRV_ENV.key)],
+        description: 'Application environment',
+        required: { active: false },
+      },
+    },
+    {
+      name: 'module',
+      run: (): void => { },
+      field: {
+        type: String,
+        aliases: ['m', CliParseUtil.toEnvField(Env.TRV_MODULE.key)],
+        description: 'Module to run for',
+        specifiers: ['module'],
+        required: { active: Runtime.monoRoot },
+      },
+    },
+    {
+      name: 'debugIpc',
+      run: cmd => CliUtil.debugIfIpc(cmd).then((v) => v && process.exit(0)),
+      field: {
+        type: Boolean,
+        aliases: ['di'],
+        description: 'Should debug invocation trigger via ipc',
+        default: true,
+        required: { active: false },
+      },
+    },
+    {
+      name: 'canRestart',
+      run: cmd => CliUtil.runWithRestart(cmd)?.then((v) => v && process.exit(0)),
+      field: {
+        type: Boolean,
+        aliases: ['cr'],
+        description: 'Should the invocation automatically restart on exit',
+        default: false,
+        required: { active: false },
+      },
+    }
+  ];
+
 
 /**
  * Decorator to register a CLI command
@@ -17,37 +88,25 @@ export function CliCommand(cfg: CliCommandConfigOptions = {}) {
       return;
     }
 
-    const addModule = cfg.addModule === true || cfg.fields?.includes('module');
-    const runtimeModule = cfg.runtimeModule ?? (cfg.addModule ? 'current' : undefined);
-    const addEnv = cfg.addEnv ?? cfg.fields?.includes('env');
+    const VALID_FIELDS = FIELD_CONFIG.filter(f => !!cfg.with?.[f.name]);
+
     const { commandModule } = CliCommandRegistry.registerClass(target, {
       hidden: cfg.hidden,
       runTarget: cfg.runTarget,
-      preMain: async (cmd: CliCommandShape & { env?: string }) => {
-        if (addEnv) {
-          Env.TRV_ENV.set(cmd.env || Runtime.name);
+      preMain: async (cmd: Cmd) => {
+        for (const field of VALID_FIELDS) {
+          await field.run(cmd);
         }
       }
     });
 
     const pendingCls = SchemaRegistry.getOrCreatePending(target);
 
-    if (addEnv) {
-      SchemaRegistry.registerPendingFieldConfig(target, 'env', String, {
-        aliases: ['e', CliParseUtil.toEnvField(Env.TRV_ENV.key)],
-        description: 'Application environment',
-        required: { active: false }
-      });
+    for (const { name, field: { type, ...field } } of VALID_FIELDS) {
+      SchemaRegistry.registerPendingFieldConfig(target, name, type!, field);
     }
 
-    if (addModule) {
-      SchemaRegistry.registerPendingFieldConfig(target, 'module', String, {
-        aliases: ['m', CliParseUtil.toEnvField(Env.TRV_MODULE.key)],
-        description: 'Module to run for',
-        specifiers: ['module'],
-        required: { active: Runtime.monoRoot }
-      });
-    }
+    const runtimeModule = cfg.runtimeModule ?? (cfg.with?.module ? 'current' : undefined);
 
     if (runtimeModule) { // Validate module
       (pendingCls.validators ??= []).push(async item => {

package/src/help.ts

@@ -1,6 +1,6 @@
 import util from 'node:util';
 
-import { Primitive } from '@travetto/schema';
+import { Primitive } from '@travetto/runtime';
 
 import { cliTpl } from './color';
 import { CliCommandShape } from './types';

package/src/registry.ts

@@ -1,19 +1,9 @@
-import { Class, ConcreteClass, Runtime, RuntimeIndex } from '@travetto/runtime';
+import { Class, ConcreteClass, describeFunction, Runtime, RuntimeIndex } from '@travetto/runtime';
 
 import { CliCommandConfig, CliCommandShape } from './types';
 import { CliUnknownCommandError } from './error';
 
-export type CliCommandConfigOptions = {
-  hidden?: boolean;
-  runTarget?: boolean;
-  addModule?: boolean;
-  addEnv?: boolean;
-  runtimeModule?: 'current' | 'command';
-  /** @deprecated */
-  fields?: ('module' | 'env')[];
-};
-
-const CLI_FILE_REGEX = /\/cli[.](?<name>.*)[.]tsx?$/;
+const CLI_FILE_REGEX = /\/cli[.](?<name>.*?)([.]tsx?)?$/;
 const getName = (s: string): string => (s.match(CLI_FILE_REGEX)?.groups?.name ?? s).replaceAll('_', ':');
 
 class $CliCommandRegistry {
@@ -51,12 +41,12 @@ class $CliCommandRegistry {
    * Registers a cli command
    */
   registerClass(cls: Class, cfg: Partial<CliCommandConfig>): CliCommandConfig {
-    const source = Runtime.getSource(cls);
+    const meta = describeFunction(cls);
     this.#commands.set(cls, {
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       cls: cls as ConcreteClass,
-      name: getName(source),
-      commandModule: RuntimeIndex.getModuleFromSource(source)!.name,
+      name: getName(meta.import),
+      commandModule: meta.module,
       ...cfg,
     });
     return this.#commands.get(cls)!;

package/support/transformer.cli.ts

@@ -20,16 +20,16 @@ export class CliCommandTransformer {
     }
 
     // Find runnable method
-    const runMethod = node.members
+    const mainMethod = node.members
       .find((x): x is ts.MethodDeclaration =>
         ts.isMethodDeclaration(x) && x.name!.getText() === 'main'
       );
 
-    if (!runMethod) {
+    if (!mainMethod) {
       return node;
     }
 
-    const members = node.members.map(x => ts.isMethodDeclaration(x) && x === runMethod ?
+    const members = node.members.map(x => ts.isMethodDeclaration(x) && x === mainMethod ?
       state.factory.updateMethodDeclaration(
         x,
         x.modifiers,