@travetto/cli 3.4.1 → 3.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/cli",
-  "version": "3.4.1",
+  "version": "3.4.3",
   "description": "CLI infrastructure for Travetto framework",
   "keywords": [
     "cli",
@@ -29,7 +29,7 @@
     "directory": "module/cli"
   },
   "dependencies": {
-    "@travetto/schema": "^3.4.0",
+    "@travetto/schema": "^3.4.1",
     "@travetto/terminal": "^3.4.0"
   },
   "travetto": {

package/src/module.ts

@@ -11,19 +11,20 @@ export class CliModuleUtil {
 
   /**
    * Find modules that changed, and the dependent modules
-   * @param hash
+   * @param fromHash
+   * @param toHash
    * @param transitive
    * @returns
    */
-  static async findChangedModulesRecursive(hash?: string, transitive = true): Promise<IndexedModule[]> {
-    hash ??= await CliScmUtil.findLastRelease();
+  static async findChangedModulesRecursive(fromHash?: string, toHash?: string, transitive = true): Promise<IndexedModule[]> {
+    fromHash ??= await CliScmUtil.findLastRelease();
 
-    if (!hash) {
+    if (!fromHash) {
       return RootIndex.getLocalModules();
     }
 
     const out = new Map<string, IndexedModule>();
-    for (const mod of await CliScmUtil.findChangedModulesSince(hash)) {
+    for (const mod of await CliScmUtil.findChangedModules(fromHash, toHash)) {
       out.set(mod.name, mod);
       if (transitive) {
         for (const sub of await RootIndex.getDependentModules(mod)) {
@@ -42,9 +43,9 @@ export class CliModuleUtil {
    * @param transitive
    * @returns
    */
-  static async findModules(mode: 'all' | 'changed', sinceHash?: string): Promise<IndexedModule[]> {
+  static async findModules(mode: 'all' | 'changed', fromHash?: string, toHash?: string): Promise<IndexedModule[]> {
     return (mode === 'changed' ?
-      await this.findChangedModulesRecursive(sinceHash) :
+      await this.findChangedModulesRecursive(fromHash, toHash) :
       [...RootIndex.getModuleList('all')].map(x => RootIndex.getModule(x)!)
     ).filter(x => x.sourcePath !== RootIndex.manifest.workspacePath);
   }

package/src/schema.ts

@@ -12,17 +12,17 @@ const SHORT_FLAG = /^-[a-z]/i;
 
 type ParsedInput =
   { type: 'unknown', input: string } |
-  { type: 'arg', input: string, array?: boolean } |
+  { type: 'arg', input: string, array?: boolean, index: number } |
   { type: 'flag', input: string, array?: boolean, fieldName: string, value?: unknown };
 
 const isBoolFlag = (x?: CliCommandInput): boolean => x?.type === 'boolean' && !x.array;
 
-const getInput = (cfg: { field?: CliCommandInput, rawText?: string, input: string, value?: string }): ParsedInput => {
-  const { field, input, rawText = input, value } = cfg;
+const getInput = (cfg: { field?: CliCommandInput, rawText?: string, input: string, index?: number, value?: string }): ParsedInput => {
+  const { field, input, rawText = input, value, index } = cfg;
   if (!field) {
     return { type: 'unknown', input: rawText };
   } else if (!field.flagNames?.length) {
-    return { type: 'arg', input: field ? input : rawText ?? input, array: field.array };
+    return { type: 'arg', input: field ? input : rawText ?? input, array: field.array, index: index! };
   } else {
     return {
       type: 'flag',
@@ -183,7 +183,7 @@ export class CliCommandSchemaUtil {
         }
       } else {
         const field = schema.args[argIdx];
-        out.push(getInput({ field, input }));
+        out.push(getInput({ field, input, index: argIdx }));
         // Move argIdx along if not in a vararg situation
         if (!field?.array) {
           argIdx += 1;
@@ -225,11 +225,21 @@ export class CliCommandSchemaUtil {
   /**
    * Produce the arguments into the final argument set
    */
-  static async bindArgs(cmd: CliCommandShape, args: ParsedInput[]): Promise<unknown[]> {
+  static async bindArgs(cmd: CliCommandShape, inputs: ParsedInput[]): Promise<unknown[]> {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const cls = cmd.constructor as Class<CliCommandShape>;
-    const out = args.filter(x => x.type === 'arg').map(x => x.input);
-    return BindUtil.coerceMethodParams(cls, 'main', out, true);
+    const bound: unknown[] = [];
+    for (const input of inputs) {
+      if (input.type === 'arg') {
+        if (input.array) {
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          ((bound[input.index] ??= []) as unknown[]).push(input.input);
+        } else {
+          bound[input.index] = input.input;
+        }
+      }
+    }
+    return BindUtil.coerceMethodParams(cls, 'main', bound, true);
   }
 
   /**

package/src/scm.ts

@@ -41,13 +41,13 @@ export class CliScmUtil {
   }
 
   /**
-   * Find all source files that changed since hash
-   * @param hash
+   * Find all source files that changed between from and to hashes
+   * @param fromHash
    * @returns
    */
-  static async findChangedFilesSince(hash: string): Promise<string[]> {
+  static async findChangedFiles(fromHash: string, toHash: string = 'HEAD'): Promise<string[]> {
     const ws = RootIndex.manifest.workspacePath;
-    const res = await ExecUtil.spawn('git', ['diff', '--name-only', `HEAD..${hash}`, ':!**/DOC.*', ':!**/README.*'], { cwd: ws }).result;
+    const res = await ExecUtil.spawn('git', ['diff', '--name-only', `${fromHash}..${toHash}`, ':!**/DOC.*', ':!**/README.*'], { cwd: ws }).result;
     const out = new Set<string>();
     for (const line of res.stdout.split(/\n/g)) {
       const entry = RootIndex.getEntry(path.resolve(ws, line));
@@ -59,12 +59,13 @@ export class CliScmUtil {
   }
 
   /**
-   * Find all modules that changed since hash
-   * @param hash
+   * Find all modules that changed between from and to hashes
+   * @param fromHash
+   * @param toHash
    * @returns
    */
-  static async findChangedModulesSince(hash: string): Promise<IndexedModule[]> {
-    const files = await this.findChangedFilesSince(hash);
+  static async findChangedModules(fromHash: string, toHash?: string): Promise<IndexedModule[]> {
+    const files = await this.findChangedFiles(fromHash, toHash);
     const mods = files
       .map(x => RootIndex.getFromSource(x))
       .filter((x): x is IndexedFile => !!x)