@travetto/cli 3.4.8 → 3.4.10

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.10",
   "description": "CLI infrastructure for Travetto framework",
   "keywords": [
     "cli",

package/src/decorators.ts

@@ -26,8 +26,9 @@ export function CliCommand(cfg: CliCommandConfigOptions = {}) {
     const { commandModule } = CliCommandRegistry.registerClass(target, {
       hidden: cfg.hidden,
       preMain: async (cmd) => {
-        if (addEnv && 'env' in cmd && typeof cmd.env === 'string') {
-          defineEnv({ envName: cmd.env });
+        if (addEnv) {
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          defineEnv({ envName: (cmd as { env?: string }).env ?? 'dev' });
         }
       }
     });
@@ -47,6 +48,7 @@ export function CliCommand(cfg: CliCommandConfigOptions = {}) {
       SchemaRegistry.registerPendingFieldConfig(target, 'module', String, {
         aliases: ['m', CliParseUtil.toEnvField('TRV_MODULE')],
         description: 'Module to run for',
+        specifiers: ['module'],
         required: { active: CliUtil.monoRoot }
       });
     }

package/src/execute.ts

@@ -19,13 +19,12 @@ 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);
+    args = await CliParseUtil.expandArgs(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);
@@ -75,7 +74,7 @@ export class ExecutionManager {
 
     let command: CliCommandShape | undefined;
     try {
-      const { cmd, args, help } = await CliParseUtil.getArgs(argv);
+      const { cmd, args, help } = CliParseUtil.getArgs(argv);
 
       if (!cmd) {
         console.info!(await HelpUtil.renderAllHelp());

package/src/help.ts

@@ -6,6 +6,7 @@ import { CliCommandShape } from './types';
 import { CliCommandRegistry } from './registry';
 import { CliCommandSchemaUtil } from './schema';
 import { CliValidationResultError } from './error';
+import { isBoolFlag } from './parse';
 
 const validationSourceMap = {
   custom: '',
@@ -47,7 +48,7 @@ export class HelpUtil {
       const flagVal = command[key] as unknown as Exclude<Primitive, Error>;
 
       let aliases = flag.flagNames ?? [];
-      if (flag.type === 'boolean' && !flag.array) {
+      if (isBoolFlag(flag)) {
         if (flagVal === true) {
           aliases = (flag.flagNames ?? []).filter(x => !/^[-][^-]/.test(x));
         } else {
@@ -55,7 +56,7 @@ export class HelpUtil {
         }
       }
       const param = [cliTpl`${{ param: aliases.join(', ') }}`];
-      if (!(flag.type === 'boolean' && !flag.array)) {
+      if (!isBoolFlag(flag)) {
         const type = flag.type === 'string' && flag.choices && flag.choices.length <= 3 ? flag.choices?.join('|') : flag.type;
         param.push(cliTpl`${{ type: `<${type}>` }}`);
       }

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,10 +11,9 @@ 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 isBoolFlag = (x?: CliCommandInput): boolean => x?.type === 'boolean' && !x.array;
+export const isBoolFlag = (x?: CliCommandInput): boolean => x?.type === 'boolean' && !x.array;
 
 const getInput = (cfg: { field?: CliCommandInput, rawText?: string, input: string, index?: number, value?: string }): ParsedInput => {
   const { field, input, rawText = input, value, index } = cfg;
@@ -43,6 +32,7 @@ const getInput = (cfg: { field?: CliCommandInput, rawText?: string, input: strin
   }
 };
 
+
 /**
  * Parsing support for the cli
  */
@@ -90,20 +80,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);
@@ -128,7 +117,7 @@ export class CliParseUtil {
    * Parse args to extract command from argv along with other params.  Will skip
    * argv[0] and argv[1] if equal to process.argv[0:2]
    */
-  static async getArgs(argv: string[]): Promise<{ cmd?: string, args: string[], help?: boolean }> {
+  static getArgs(argv: string[]): { cmd?: string, args: string[], help?: boolean } {
     let offset = 0;
     if (argv[0] === process.argv[0] && argv[1] === process.argv[1]) {
       offset = 2;
@@ -138,19 +127,28 @@ export class CliParseUtil {
     const valid = out.slice(0, max);
     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));
-      } else {
-        args.push(item);
-      }
-    }
-    args.push(...out.slice(max));
+    const args = out.slice(cmd ? 1 : 0);
     const res = { cmd, args, help: helpIdx >= 0 };
     return res;
   }
 
+  /**
+   * Expand flag arguments into full argument list
+   */
+  static async expandArgs(schema: CliCommandSchema, args: string[]): Promise<string[]> {
+    const SEP = args.includes(RAW_SEP) ? args.indexOf(RAW_SEP) : args.length;
+    const input = schema.flags.find(x => x.type === 'module');
+    const ENV_KEY = input?.flagNames?.filter(x => x.startsWith(ENV_PRE)).map(x => x.replace(ENV_PRE, ''))[0] ?? '';
+    const flags = new Set(input?.flagNames ?? []);
+    const check = (k?: string, v?: string): string | undefined => flags.has(k!) ? v : undefined;
+    const mod = args.reduce(
+      (m, x, i, arr) =>
+        (i < SEP ? check(arr[i - 1], x) ?? check(...x.split('=')) : undefined) ?? m,
+      process.env[ENV_KEY] || RootIndex.mainModuleName
+    );
+    return (await Promise.all(args.map((x, i) => x.startsWith(CONFIG_PRE) && (i < SEP || SEP < 0) ? this.readFlagFile(x, mod) : x))).flat();
+  }
+
   /**
    * Parse inputs to command
    */
@@ -210,22 +208,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/schema.ts

@@ -2,35 +2,45 @@ import { Class, ConsoleManager, GlobalEnv } from '@travetto/base';
 import { BindUtil, FieldConfig, SchemaRegistry, SchemaValidator, ValidationResultError } from '@travetto/schema';
 
 import { CliCommandRegistry } from './registry';
-import { CliCommandInput, CliCommandSchema, CliCommandShape } from './types';
+import { ParsedState, CliCommandInput, CliCommandSchema, CliCommandShape } from './types';
 import { CliValidationResultError } from './error';
-import { ParsedState } from './parse';
 
 const LONG_FLAG = /^--[a-z][^= ]+/i;
 const SHORT_FLAG = /^-[a-z]/i;
 
 const isBoolFlag = (x?: CliCommandInput): boolean => x?.type === 'boolean' && !x.array;
 
-function fieldToInput(x: FieldConfig): CliCommandInput {
-  const type = x.type === Date ? 'date' :
-    x.type === Boolean ? 'boolean' :
-      x.type === String ? (x.specifiers?.includes('file') ? 'file' : 'string') :
-        x.type === Number ? 'number' :
-          x.type === RegExp ? 'regex' : 'string';
-  return ({
-    name: x.name,
-    description: x.description,
-    array: x.array,
-    required: x.required?.active,
-    choices: x.enum?.values,
-    fileExtensions: type === 'file' ? x.specifiers?.filter(s => s.startsWith('ext:')).map(s => s.split('ext:')[1]) : undefined,
-    type,
-    default: Array.isArray(x.default) ? x.default.slice(0) : x.default,
-    flagNames: (x.aliases ?? []).slice(0).filter(v => !v.startsWith('env.')),
-    envVars: (x.aliases ?? []).slice(0).filter(v => v.startsWith('env.')).map(v => v.replace('env.', ''))
-  });
+function baseType(x: FieldConfig): Pick<CliCommandInput, 'type' | 'fileExtensions'> {
+  switch (x.type) {
+    case Date: return { type: 'date' };
+    case Boolean: return { type: 'boolean' };
+    case Number: return { type: 'number' };
+    case RegExp: return { type: 'regex' };
+    case String: {
+      switch (true) {
+        case x.specifiers?.includes('module'): return { type: 'module' };
+        case x.specifiers?.includes('file'): return {
+          type: 'file',
+          fileExtensions: x.specifiers?.map(s => s.split('ext:')[1]).filter(s => !!s)
+        };
+      }
+    }
+  }
+  return { type: 'string' };
 }
 
+const fieldToInput = (x: FieldConfig): CliCommandInput => ({
+  ...baseType(x),
+  name: x.name,
+  description: x.description,
+  array: x.array,
+  required: x.required?.active,
+  choices: x.enum?.values,
+  default: Array.isArray(x.default) ? x.default.slice(0) : x.default,
+  flagNames: (x.aliases ?? []).slice(0).filter(v => !v.startsWith('env.')),
+  envVars: (x.aliases ?? []).slice(0).filter(v => v.startsWith('env.')).map(v => v.replace('env.', ''))
+});
+
 /**
  * Allows binding describing/binding inputs for commands
  */

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
    */
@@ -84,7 +100,7 @@ export type CliCommandShapeFields = {
 export type CliCommandInput = {
   name: string;
   description?: string;
-  type: 'string' | 'file' | 'number' | 'boolean' | 'date' | 'regex';
+  type: 'string' | 'file' | 'number' | 'boolean' | 'date' | 'regex' | 'module';
   fileExtensions?: string[];
   choices?: unknown[];
   required?: boolean;

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);
     }