@travetto/cli 3.4.8 → 3.4.9

package/README.md

@@ -411,6 +411,10 @@ export class RunCommand {
 **Code: Anatomy of a Command**
 ```typescript
 export interface CliCommandShape<T extends unknown[] = unknown[]> {
+  /**
+   * Parsed state
+   */
+  _parsed?: ParsedState;
   /**
    * Action target of the command
    */
@@ -493,7 +497,7 @@ As noted in the example above, `fields` is specified in this execution, with sup
 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.
 
 ### Custom Validation
-In addition to dependency injection, the command contract also allows for a custom validation function, which will have access to bound command (flags, and args) as well as the unknown arguments. When a command implements this method, any [CliValidationError](https://github.com/travetto/travetto/tree/main/module/cli/src/types.ts#L10) errors that are returned will be shared with the user, and fail to invoke the `main` method.
+In addition to dependency injection, the command contract also allows for a custom validation function, which will have access to bound command (flags, and args) as well as the unknown arguments. When a command implements this method, any [CliValidationError](https://github.com/travetto/travetto/tree/main/module/cli/src/types.ts#L22) errors that are returned will be shared with the user, and fail to invoke the `main` method.
 
 **Code: CliValidationError**
 ```typescript

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/cli",
-  "version": "3.4.8",
+  "version": "3.4.9",
   "description": "CLI infrastructure for Travetto framework",
   "keywords": [
     "cli",

package/src/execute.ts

@@ -19,13 +19,11 @@ export class ExecutionManager {
    */
   static async #runCommand(cmd: CliCommandShape, args: string[]): Promise<RunResponse> {
     const schema = await CliCommandSchemaUtil.getSchema(cmd);
-    const state = await CliParseUtil.parse(schema, args);
+    cmd._parsed = await CliParseUtil.parse(schema, args);
     const cfg = CliCommandRegistry.getConfig(cmd);
 
-    CliParseUtil.setState(cmd, state);
-
     await cmd.preBind?.();
-    const known = await CliCommandSchemaUtil.bindInput(cmd, state);
+    const known = await CliCommandSchemaUtil.bindInput(cmd, cmd._parsed);
 
     await cmd.preValidate?.();
     await CliCommandSchemaUtil.validate(cmd, known);

package/src/parse.ts

@@ -1,19 +1,9 @@
 import fs from 'fs/promises';
 
 import { RootIndex, path } from '@travetto/manifest';
-import { CliCommandInput, CliCommandSchema, CliCommandShape } from './types';
-
-type ParsedFlag = { type: 'flag', input: string, array?: boolean, fieldName: string, value?: unknown };
-type ParsedArg = { type: 'arg', input: string, array?: boolean, index: number };
-type ParsedUnknown = { type: 'unknown', input: string };
-type ParsedInput = ParsedUnknown | ParsedFlag | ParsedArg;
-
-export type ParsedState = {
-  inputs: string[];
-  all: ParsedInput[];
-  flags: ParsedFlag[];
-  unknown: string[];
-};
+import { CliCommandInput, CliCommandSchema, ParsedState } from './types';
+
+type ParsedInput = ParsedState['all'][number];
 
 const RAW_SEP = '--';
 const VALID_FLAG = /^-{1,2}[a-z]/i;
@@ -21,8 +11,21 @@ const HELP_FLAG = /^-h|--help$/;
 const LONG_FLAG_WITH_EQ = /^--[a-z][^= ]+=\S+/i;
 const CONFIG_PRE = '+=';
 const ENV_PRE = 'env.';
-const ParsedⲐ = Symbol.for('@travetto/cli:parsed');
 const SPACE = new Set([32, 7, 13, 10]);
+const MODULE_FLAG = '--module';
+const MODULE_SHORT = '-m';
+
+const getModuleValue = (arr: string[]): string => {
+  for (let i = 0; i < arr.length; i += 1) {
+    const x = arr[i];
+    if (x.startsWith(`${MODULE_FLAG}=`)) {
+      return x.split('=')[1];
+    } else if (!x.startsWith('-') && (arr[i - 1] === MODULE_SHORT || arr[i - 1] === MODULE_FLAG)) {
+      return x;
+    }
+  }
+  return process.env.TRV_MODULE || RootIndex.mainModuleName;
+};
 
 const isBoolFlag = (x?: CliCommandInput): boolean => x?.type === 'boolean' && !x.array;
 
@@ -90,20 +93,19 @@ export class CliParseUtil {
   /**
    * Read configuration file given flag
    */
-  static async readFlagFile(flag: string): Promise<string[]> {
+  static async readFlagFile(flag: string, mod: string): Promise<string[]> {
     const key = flag.replace(CONFIG_PRE, '');
-    const mod = RootIndex.mainModuleName;
 
     // We have a file
     const rel = (key.includes('/') ? key : `@/support/pack.${key}.flags`)
       .replace('@@/', `${RootIndex.manifest.workspacePath}/`)
       .replace('@/', `${mod}/`)
-      .replace(/^(@[^\/]+\/[^\/]+)/, (_, imp) => {
+      .replace(/^(@[^\/]+\/[^\/]+)(\/.*)$/, (_, imp, rest) => {
         const val = RootIndex.getModule(imp);
         if (!val) {
-          throw new Error(`Unknown module file: ${key}, unable to proceed`);
+          throw new Error(`Unknown module file: ${_}, unable to proceed`);
         }
-        return val.sourcePath;
+        return `${val.sourcePath}${rest}`;
       });
 
     const file = path.resolve(rel);
@@ -136,12 +138,13 @@ export class CliParseUtil {
     const out = argv.slice(offset);
     const max = out.includes(RAW_SEP) ? out.indexOf(RAW_SEP) : out.length;
     const valid = out.slice(0, max);
+    const mod = getModuleValue(valid);
     const cmd = valid.length > 0 && !valid[0].startsWith('-') ? valid[0] : undefined;
     const helpIdx = valid.findIndex(x => HELP_FLAG.test(x));
     const args = [];
     for (const item of out.slice(cmd ? 1 : 0)) {
       if (item.startsWith(CONFIG_PRE)) {
-        args.push(...await this.readFlagFile(item));
+        args.push(...await this.readFlagFile(item, mod));
       } else {
         args.push(item);
       }
@@ -210,22 +213,8 @@ export class CliParseUtil {
     return {
       inputs,
       all: out,
-      unknown: out.filter((x): x is ParsedUnknown => x.type === 'unknown').map(x => x.input),
-      flags: out.filter((x): x is ParsedFlag => x.type === 'flag')
+      unknown: out.filter(x => x.type === 'unknown').map(x => x.input),
+      flags: out.filter((x): x is ParsedInput & { type: 'flag' } => x.type === 'flag')
     };
   }
-
-  /**
-   * Get parse state from the command
-   */
-  static getState(cmd: CliCommandShape & { [ParsedⲐ]?: ParsedState }): ParsedState | undefined {
-    return cmd[ParsedⲐ];
-  }
-
-  /**
-   * Set state for a command
-   */
-  static setState(cmd: CliCommandShape & { [ParsedⲐ]?: ParsedState }, state: ParsedState): void {
-    cmd[ParsedⲐ] = state;
-  }
 }

package/src/types.ts

@@ -4,6 +4,18 @@ type OrProm<T> = T | Promise<T>;
 
 export type RunResponse = { wait(): Promise<unknown> } | { on(event: 'close', cb: Function): unknown } | Closeable | void | undefined;
 
+type ParsedFlag = { type: 'flag', input: string, array?: boolean, fieldName: string, value?: unknown };
+type ParsedArg = { type: 'arg', input: string, array?: boolean, index: number };
+type ParsedUnknown = { type: 'unknown', input: string };
+type ParsedInput = ParsedUnknown | ParsedFlag | ParsedArg;
+
+export type ParsedState = {
+  inputs: string[];
+  all: ParsedInput[];
+  flags: ParsedFlag[];
+  unknown: string[];
+};
+
 /**
  * Constrained version of Schema's Validation Error
  */
@@ -22,6 +34,10 @@ export type CliValidationError = {
  * CLI Command Contract
  */
 export interface CliCommandShape<T extends unknown[] = unknown[]> {
+  /**
+   * Parsed state
+   */
+  _parsed?: ParsedState;
   /**
    * Action target of the command
    */

package/support/cli.main.ts

@@ -1,8 +1,9 @@
 import fs from 'fs/promises';
 
 import { ShutdownManager } from '@travetto/base';
-import { CliCommandShape, CliCommand, CliValidationError, CliParseUtil } from '@travetto/cli';
+import { CliCommandShape, CliCommand, CliValidationError, ParsedState } from '@travetto/cli';
 import { path, RootIndex } from '@travetto/manifest';
+import { Ignore } from '@travetto/schema';
 
 /**
  * Allows for running of main entry points
@@ -10,6 +11,9 @@ import { path, RootIndex } from '@travetto/manifest';
 @CliCommand({ hidden: true })
 export class MainCommand implements CliCommandShape {
 
+  @Ignore()
+  _parsed: ParsedState;
+
   async #getImport(fileOrImport: string): Promise<string | undefined> {
     // If referenced file exists
     let file = fileOrImport;
@@ -32,7 +36,7 @@ export class MainCommand implements CliCommandShape {
       const imp = await this.#getImport(fileOrImport);
       const mod = await import(imp!);
 
-      await ShutdownManager.exitWithResponse(await mod.main(...args, ...CliParseUtil.getState(this)?.unknown ?? []));
+      await ShutdownManager.exitWithResponse(await mod.main(...args, ...this._parsed.unknown));
     } catch (err) {
       await ShutdownManager.exitWithResponse(err, true);
     }