@travetto/cli 3.4.9 → 3.4.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/cli",
-  "version": "3.4.9",
+  "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,6 +19,7 @@ export class ExecutionManager {
    */
   static async #runCommand(cmd: CliCommandShape, args: string[]): Promise<RunResponse> {
     const schema = await CliCommandSchemaUtil.getSchema(cmd);
+    args = await CliParseUtil.expandArgs(schema, args);
     cmd._parsed = await CliParseUtil.parse(schema, args);
     const cfg = CliCommandRegistry.getConfig(cmd);
 
@@ -73,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

@@ -12,22 +12,8 @@ const LONG_FLAG_WITH_EQ = /^--[a-z][^= ]+=\S+/i;
 const CONFIG_PRE = '+=';
 const ENV_PRE = 'env.';
 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;
+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;
@@ -46,6 +32,7 @@ const getInput = (cfg: { field?: CliCommandInput, rawText?: string, input: strin
   }
 };
 
+
 /**
  * Parsing support for the cli
  */
@@ -130,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,22 +125,30 @@ 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, mod));
-      } 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
    */

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

@@ -100,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;