@flowscripter/dynamic-cli-framework 11.0.0 → 11.1.0

package/dist/src/service/configuration/KeyValueServiceProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"KeyValueServiceProvider.d.ts","sourceRoot":"","sources":["../../../../src/service/configuration/KeyValueServiceProvider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAC5F,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,KAAK,EACV,eAAe,EAGhB,MAAM,yCAAyC,CAAC;AAIjD,OAAO,KAAK,4BAA4B,MAAM,mCAAmC,CAAC;AAClF,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAoClF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,MAAM,CAAC,OAAO,OAAO,uBAAwB,YAAW,eAAe;;IACrE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAwB;IAClD,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IAIjC,SAAgB,sBAAsB,EAAE,OAAO,CAAC;IAChD,SAAgB,oBAAoB,EAAE,OAAO,CAAC;IAW9C;;;;;;;;OAQG;IACH,YACE,eAAe,EAAE,MAAM,EACvB,4BAA4B,EAAE,4BAA4B,EAC1D,sBAAsB,UAAQ,EAC9B,oBAAoB,UAAQ,EAY7B;IAEM,cAAc,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,WAAW,CAAC,CAUhE;IAED;;;;;;;;;;OAUG;IACI,wBAAwB,CAC7B,SAAS,EAAE,wBAAwB,EACnC,QAAQ,EAAE,MAAM,GACf,eAAe,CAwBjB;IAED;;;;;;;;;;;;;;OAcG;IACI,kBAAkB,CACvB,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,wBAAwB,EACnC,QAAQ,EAAE,MAAM,GACf,OAAO,CAaT;IAqBY,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CASxD;CACF"}
+{"version":3,"file":"KeyValueServiceProvider.d.ts","sourceRoot":"","sources":["../../../../src/service/configuration/KeyValueServiceProvider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAC5F,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,KAAK,EACV,eAAe,EAGhB,MAAM,yCAAyC,CAAC;AAIjD,OAAO,KAAK,4BAA4B,MAAM,mCAAmC,CAAC;AAClF,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAoClF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,MAAM,CAAC,OAAO,OAAO,uBAAwB,YAAW,eAAe;;IACrE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAwB;IAClD,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IAIjC,SAAgB,sBAAsB,EAAE,OAAO,CAAC;IAChD,SAAgB,oBAAoB,EAAE,OAAO,CAAC;IAW9C;;;;;;;;OAQG;IACH,YACE,eAAe,EAAE,MAAM,EACvB,4BAA4B,EAAE,4BAA4B,EAC1D,sBAAsB,UAAQ,EAC9B,oBAAoB,UAAQ,EAY7B;IAEM,cAAc,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,WAAW,CAAC,CAUhE;IAED;;;;;;;;;;OAUG;IACI,wBAAwB,CAC7B,SAAS,EAAE,wBAAwB,EACnC,QAAQ,EAAE,MAAM,GACf,eAAe,CAwBjB;IAED;;;;;;;;;;;;;;OAcG;IACI,kBAAkB,CACvB,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,wBAAwB,EACnC,QAAQ,EAAE,MAAM,GACf,OAAO,CAcT;IAqBY,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CASxD;CACF"}

package/dist/src/service/configuration/KeyValueServiceProvider.js

@@ -180,6 +180,7 @@ export default class KeyValueServiceProvider {
         const scopedKeyValueService = this.getScopedKeyValueService(scopeType, scopeKey);
         return {
             cliConfig: context.cliConfig,
+            isTty: context.isTty,
             getServiceById: (id) => id === KEY_VALUE_SERVICE_ID ? scopedKeyValueService : context.getServiceById(id),
             doesServiceExist: (id) => context.doesServiceExist(id),
             addServiceInstance: (id, serviceInstance) => context.addServiceInstance(id, serviceInstance),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowscripter/dynamic-cli-framework",
-  "version": "11.0.0",
+  "version": "11.1.0",
   "description": "A framework for developing CLI applications which supports dynamic discovery and installation of new commands",
   "keywords": [
     "bun",
@@ -49,7 +49,7 @@
     "build": "tsc -p tsconfig.build.json"
   },
   "dependencies": {
-    "@flowscripter/dynamic-cli-framework-api": "^5.0.2",
+    "@flowscripter/dynamic-cli-framework-api": "^5.1.0",
     "@flowscripter/dynamic-plugin-framework": "^2.2.22",
     "emphasize": "^7.0.0",
     "fastest-levenshtein": "^1.0.16",

package/src/cli/BaseCLI.ts

@@ -196,7 +196,11 @@ export default class BaseCLI implements CLI {
     this.#commandRegistry = new DefaultCommandRegistry([], commandValidator);
 
     // create a context
-    this.#context = new DefaultContext(this.#cliConfig);
+    this.#context = new DefaultContext(this.#cliConfig, {
+      stdin: keyReader !== undefined,
+      stdout: stdoutTerminal.isTty(),
+      stderr: stderrTerminal.isTty(),
+    });
 
     this.#startupServiceProvider = new StartupServiceProvider(STARTUP_SERVICE_PRIORITY);
 
@@ -277,7 +281,7 @@ export default class BaseCLI implements CLI {
     );
     this.addServiceProvider(new TableGeneratorServiceProvider(TABLE_GENERATOR_SERVICE_PRIORITY));
 
-    const canPrompt = this.#keyReader !== undefined && this.#stderrTerminal.isTty();
+    const canPrompt = this.#context.isTty.stdin && this.#context.isTty.stderr;
 
     if (this.#options.promptingEnabled && !canPrompt) {
       throw new Error("promptingEnabled requires a keyReader and a TTY stderr terminal");

package/src/runtime/DefaultContext.ts

@@ -7,7 +7,10 @@ import type { CLIConfig } from "@flowscripter/dynamic-cli-framework-api";
 export default class DefaultContext implements Context {
   readonly #serviceInstancesById: Map<string, unknown> = new Map();
 
-  public constructor(readonly cliConfig: CLIConfig) {}
+  public constructor(
+    readonly cliConfig: CLIConfig,
+    readonly isTty: Context["isTty"] = { stdin: false, stdout: false, stderr: false },
+  ) {}
 
   public addServiceInstance(id: string, serviceInstance: unknown) {
     if (this.#serviceInstancesById.has(id)) {

package/src/runtime/command/CommandValidator.ts

@@ -4,7 +4,7 @@ import type { GlobalCommand } from "@flowscripter/dynamic-cli-framework-api";
 import type { Argument } from "@flowscripter/dynamic-cli-framework-api";
 import type { GroupCommand } from "@flowscripter/dynamic-cli-framework-api";
 import type { SubCommand } from "@flowscripter/dynamic-cli-framework-api";
-import type { SingleValueType } from "@flowscripter/dynamic-cli-framework-api";
+import type { PopulatedValues, SingleValueType } from "@flowscripter/dynamic-cli-framework-api";
 import { ValueTypeName, ComplexValueTypeName } from "@flowscripter/dynamic-cli-framework-api";
 import type { Option } from "@flowscripter/dynamic-cli-framework-api";
 import type { ComplexOption } from "@flowscripter/dynamic-cli-framework-api";
@@ -13,6 +13,8 @@ import {
   getInvalidArgumentString,
   validateGlobalCommandArgumentValue,
   validateOptionValue,
+  runCustomValidation,
+  type DeferredCustomValidation,
 } from "../values/argumentValueValidation.ts";
 import getLogger from "../../util/logger.ts";
 import type { CLIConfig } from "@flowscripter/dynamic-cli-framework-api";
@@ -219,7 +221,16 @@ export default class CommandValidator {
       validateArgument(argument, globalCommand.name);
       if (argument.defaultValue) {
         const invalidArguments: Array<InvalidArgument> = [];
-        validateGlobalCommandArgumentValue(globalCommand, argument.defaultValue, invalidArguments);
+        const deferred: Array<DeferredCustomValidation> = [];
+        validateGlobalCommandArgumentValue(
+          globalCommand,
+          argument.defaultValue,
+          invalidArguments,
+          deferred,
+        );
+        if (invalidArguments.length === 0) {
+          runCustomValidation(deferred, globalCommand, argument.defaultValue, invalidArguments);
+        }
         if (invalidArguments.length > 0) {
           throw new Error(
             `Illegal default value for global command: '${globalCommand.name}' => ${invalidArguments
@@ -440,12 +451,13 @@ export default class CommandValidator {
         option as unknown as SubCommandArgument,
       ]);
     } else {
-      this.#validateOption(option, currentOptionPaths, allOptionPaths);
+      this.#validateOption(subCommand, option, currentOptionPaths, allOptionPaths);
       this.#validateSubCommandArgumentConfigurationKey(subCommand, [...argumentAncestry, option]);
     }
   }
 
   #validateOption(
+    subCommand: SubCommand,
     option: Option,
     currentOptionPaths: Array<string>,
     allOptionPaths: Array<string>,
@@ -460,7 +472,16 @@ export default class CommandValidator {
     }
     if (option.defaultValue) {
       const invalidArguments: Array<InvalidArgument> = [];
-      validateOptionValue(option, option.defaultValue, invalidArguments);
+      const deferred: Array<DeferredCustomValidation> = [];
+      validateOptionValue(option, option.defaultValue, invalidArguments, deferred);
+      if (invalidArguments.length === 0) {
+        runCustomValidation(
+          deferred,
+          subCommand,
+          { [option.name]: option.defaultValue } as PopulatedValues,
+          invalidArguments,
+        );
+      }
       if (invalidArguments.length > 0) {
         throw new Error(
           `Illegal default value for option: '${option.name}' => ${invalidArguments
@@ -515,7 +536,16 @@ export default class CommandValidator {
     }
     if (complexOption.defaultValue) {
       const invalidArguments: Array<InvalidArgument> = [];
-      validateOptionValue(complexOption, complexOption.defaultValue, invalidArguments);
+      const deferred: Array<DeferredCustomValidation> = [];
+      validateOptionValue(complexOption, complexOption.defaultValue, invalidArguments, deferred);
+      if (invalidArguments.length === 0) {
+        runCustomValidation(
+          deferred,
+          subCommand,
+          { [complexOption.name]: complexOption.defaultValue } as PopulatedValues,
+          invalidArguments,
+        );
+      }
       if (invalidArguments.length > 0) {
         throw new Error(
           `Illegal default value for option: '${complexOption.name}' => ${invalidArguments

package/src/runtime/parser.ts

@@ -11,6 +11,8 @@ import {
   validateGlobalCommandArgumentValue,
   validateOptionValue,
   validatePositionalValue,
+  runCustomValidation,
+  type DeferredCustomValidation,
 } from "./values/argumentValueValidation.ts";
 import getLogger from "../util/logger.ts";
 import { redactGlobalCommandValue, redactSubCommandValues } from "../util/secretRedaction.ts";
@@ -64,12 +66,14 @@ export function parseSubCommandClause(
   }
 
   if (invalidArguments.length === 0) {
+    const deferred: Array<DeferredCustomValidation> = [];
     // validate the option values
     command.options.forEach((option) => {
       const validatedValue = validateOptionValue(
         option,
         populatedArgumentValues[option.name] || option.defaultValue,
         invalidArguments,
+        deferred,
       );
       if (validatedValue !== undefined) {
         populatedArgumentValues[option.name] = validatedValue;
@@ -89,11 +93,16 @@ export function parseSubCommandClause(
           positional,
           populatedArgumentValues[positional.name] as ValueType,
           invalidArguments,
+          deferred,
         );
         if (validatedValue !== undefined) {
           populatedArgumentValues[positional.name] = validatedValue;
         }
       });
+      if (invalidArguments.length === 0) {
+        // custom validators run once all built-in validation has passed and see all values
+        runCustomValidation(deferred, command, populatedArgumentValues, invalidArguments);
+      }
       logger.debug(
         "Command arguments after positionals validated: %O with invalid args: %O",
         redactSubCommandValues(command, populatedArgumentValues),
@@ -162,14 +171,19 @@ export function parseGlobalCommandClause(
 
   // don't validate the value if the argument is already invalid
   if (invalidArguments.length === 0) {
+    const deferred: Array<DeferredCustomValidation> = [];
     const validatedValue = validateGlobalCommandArgumentValue(
       command,
       populatedArgumentValue,
       invalidArguments,
+      deferred,
     );
     if (validatedValue !== undefined) {
       populatedArgumentValue = validatedValue;
     }
+    if (invalidArguments.length === 0) {
+      runCustomValidation(deferred, command, populatedArgumentValue, invalidArguments);
+    }
   }
 
   logger.debug(

package/src/runtime/values/argumentValueValidation.ts

@@ -16,6 +16,7 @@ import { InvalidArgumentReason } from "@flowscripter/dynamic-cli-framework-api";
 import type { SubCommandArgument } from "@flowscripter/dynamic-cli-framework-api";
 import type { Argument } from "@flowscripter/dynamic-cli-framework-api";
 import type { GlobalCommand } from "@flowscripter/dynamic-cli-framework-api";
+import type { Command } from "@flowscripter/dynamic-cli-framework-api";
 
 interface ValidationResult {
   invalidArgument?: InvalidArgument;
@@ -41,32 +42,61 @@ function withPrefix(invalidArgument: InvalidArgument, prefix: string): InvalidAr
 }
 
 /**
- * Invokes the custom validate function (if any) of the provided {@link Argument} and returns an
- * {@link InvalidArgument} if the custom validation failed.
- *
- * @param argument the {@link Argument} providing the custom validate function.
- * @param name the name to use for the {@link InvalidArgument}.
- * @param value the validated and type-converted value.
+ * A custom validation to be invoked once all built-in validation has passed.
+ */
+export interface DeferredCustomValidation {
+  readonly argument: Argument | ComplexOption;
+  readonly path: string;
+  readonly value: SingleValueType | Values | Array<SingleValueType | Values>;
+}
+
+/**
+ * Records a custom validation of the provided {@link Argument} (if it has one) for later invocation by
+ * {@link runCustomValidation}. Deferred validations are recorded bottom-up and depth-first.
  */
-function doCustomValidation(
+function deferCustomValidation(
+  deferred: Array<DeferredCustomValidation> | undefined,
   argument: Argument | ComplexOption,
-  name: string,
+  path: string,
   value: SingleValueType | Values | Array<SingleValueType | Values>,
-): InvalidArgument | undefined {
-  if (argument.validate === undefined) {
-    return undefined;
+): void {
+  if (deferred !== undefined && argument.validate !== undefined) {
+    deferred.push({ argument, path, value });
   }
-  const message = argument.validate(value as ValueType | Values | Array<Values>);
-  if (message === undefined) {
-    return undefined;
+}
+
+/**
+ * Invokes the recorded custom validations in order, stopping at the first failure.
+ *
+ * @param deferred the validations recorded while validating the values of the command.
+ * @param command the {@link Command} the validated values belong to.
+ * @param values all validated and converted values of the command.
+ * @param invalidArguments an array of {@link InvalidArgument} which is added to if a custom validation fails.
+ */
+export function runCustomValidation(
+  deferred: ReadonlyArray<DeferredCustomValidation>,
+  command: Command,
+  values: PopulatedValues | PopulatedSingleValueType,
+  invalidArguments: Array<InvalidArgument>,
+): void {
+  for (const { argument, path, value } of deferred) {
+    const message = argument.validate!(value as ValueType | Values | Array<Values>, {
+      argument: argument as Argument,
+      path,
+      values,
+      command,
+    });
+    if (message !== undefined) {
+      invalidArguments.push({
+        argument,
+        name: path,
+        value: value as PopulatedValueType | PopulatedValues,
+        reason: InvalidArgumentReason.CUSTOM_VALIDATION,
+        message,
+      });
+      return;
+    }
   }
-  return {
-    argument,
-    name,
-    value: value as PopulatedValueType | PopulatedValues,
-    reason: InvalidArgumentReason.CUSTOM_VALIDATION,
-    message,
-  };
 }
 
 /**
@@ -193,6 +223,8 @@ function validatePrimitiveValue(
 function validateArrayValue(
   subCommandArgument: SubCommandArgument | ComplexOption,
   arrayValue: Array<PopulatedSingleValueType | PopulatedValues | undefined>,
+  path: string,
+  deferred: Array<DeferredCustomValidation> | undefined,
 ): ArrayValueValidationResult {
   const convertedArrayValue: Array<SingleValueType | Values> = [];
 
@@ -228,7 +260,12 @@ function validateArrayValue(
           },
         };
       }
-      validationResult = validateObjectValue(subCommandArgument as ComplexOption, singleValue);
+      validationResult = validateObjectValue(
+        subCommandArgument as ComplexOption,
+        singleValue,
+        `${path}[${i}]`,
+        deferred,
+      );
     } // if not array and not object, then must be primitive
     else {
       if (isComplexOption(subCommandArgument)) {
@@ -267,11 +304,14 @@ function validateArrayValue(
 function validateObjectValue(
   argument: ComplexOption,
   objectValue: PopulatedValues,
+  path: string,
+  deferred: Array<DeferredCustomValidation> | undefined,
 ): ObjectValueValidationResult {
   const convertedObjectValue: Values = {};
 
   for (let i = 0; i < argument.properties.length; i++) {
     const propertyArg = argument.properties[i]!;
+    const propertyPath = `${path}.${propertyArg.name}`;
     let propertyValue = objectValue[propertyArg.name];
 
     if (propertyValue === undefined && propertyArg.defaultValue !== undefined) {
@@ -311,6 +351,8 @@ function validateObjectValue(
       validationResult = validateArrayValue(
         propertyArg as ComplexOption | SubCommandArgument,
         propertyValue,
+        propertyPath,
+        deferred,
       );
     } else if (typeof propertyValue === "object") {
       if (propertyArg.type !== ComplexValueTypeName.COMPLEX) {
@@ -327,6 +369,8 @@ function validateObjectValue(
       validationResult = validateObjectValue(
         propertyArg as ComplexOption,
         propertyValue as PopulatedValues,
+        propertyPath,
+        deferred,
       );
     } // if not array and not object, then must be primitive
     else {
@@ -356,18 +400,8 @@ function validateObjectValue(
         invalidArgument: withPrefix(validationResult.invalidArgument, `.${propertyArg.name}`),
       };
     }
-    // custom validation runs only once the property (and any nested properties) passed validation
-    const customInvalidArgument = doCustomValidation(
-      propertyArg,
-      `.${propertyArg.name}`,
-      validationResult.validValue!,
-    );
-    if (customInvalidArgument !== undefined) {
-      return {
-        validValue: convertedObjectValue,
-        invalidArgument: customInvalidArgument,
-      };
-    }
+    // custom validation is deferred until all built-in validation has passed
+    deferCustomValidation(deferred, propertyArg, propertyPath, validationResult.validValue!);
   }
   return {
     validValue: convertedObjectValue,
@@ -380,6 +414,7 @@ function doSubCommandArgumentValidation(
   isArray: boolean,
   isOptional: boolean,
   invalidArguments: Array<InvalidArgument>,
+  deferred: Array<DeferredCustomValidation> | undefined,
 ): PopulatedValueType | PopulatedValues | Array<PopulatedValues> {
   // if there is a value, check if it is valid
   if (value !== undefined) {
@@ -395,7 +430,7 @@ function doSubCommandArgumentValidation(
         });
         return undefined;
       }
-      validationResult = validateArrayValue(argument, value);
+      validationResult = validateArrayValue(argument, value, argument.name, deferred);
     } else if (typeof value === "object") {
       if (!isComplexOption(argument)) {
         invalidArguments.push({
@@ -406,7 +441,7 @@ function doSubCommandArgumentValidation(
         });
         return undefined;
       }
-      validationResult = validateObjectValue(argument, value);
+      validationResult = validateObjectValue(argument, value, argument.name, deferred);
     } else {
       if (isComplexOption(argument)) {
         invalidArguments.push({
@@ -424,15 +459,7 @@ function doSubCommandArgumentValidation(
       invalidArguments.push(withPrefix(validationResult.invalidArgument, argument.name));
       return undefined;
     }
-    const customInvalidArgument = doCustomValidation(
-      argument,
-      argument.name,
-      validationResult.validValue!,
-    );
-    if (customInvalidArgument !== undefined) {
-      invalidArguments.push(customInvalidArgument);
-      return undefined;
-    }
+    deferCustomValidation(deferred, argument, argument.name, validationResult.validValue!);
     return validationResult.validValue as PopulatedValueType | PopulatedValues | undefined;
   }
 
@@ -453,11 +480,13 @@ function doSubCommandArgumentValidation(
  * @param option the {@link Option} to validate against.
  * @param value the value (if any) for the {@link Option}.
  * @param invalidArguments an array of {@link InvalidArgument} which may be added to if the provided value is invalid.
+ * @param deferred if provided, custom validations are recorded here for later invocation by {@link runCustomValidation}. If omitted, custom validations are not invoked.
  */
 export function validateOptionValue(
   option: Option | ComplexOption,
   value: PopulatedValueType | PopulatedValues | Array<PopulatedValues | undefined>,
   invalidArguments: Array<InvalidArgument>,
+  deferred?: Array<DeferredCustomValidation>,
 ): PopulatedValueType | PopulatedValues | Array<PopulatedValues> {
   return doSubCommandArgumentValidation(
     option,
@@ -465,6 +494,7 @@ export function validateOptionValue(
     option.isArray || false,
     option.isOptional || false,
     invalidArguments,
+    deferred,
   );
 }
 
@@ -474,11 +504,13 @@ export function validateOptionValue(
  * @param positional the {@link Positional} to validate against.
  * @param value the value (if any) for the {@link Positional}.
  * @param invalidArguments an array of {@link InvalidArgument} which may be added to if the provided value is invalid.
+ * @param deferred if provided, custom validations are recorded here for later invocation by {@link runCustomValidation}. If omitted, custom validations are not invoked.
  */
 export function validatePositionalValue(
   positional: Positional,
   value: PopulatedValueType,
   invalidArguments: Array<InvalidArgument>,
+  deferred?: Array<DeferredCustomValidation>,
 ): PopulatedValueType {
   return doSubCommandArgumentValidation(
     positional,
@@ -486,6 +518,7 @@ export function validatePositionalValue(
     positional.isVarargMultiple || false,
     positional.isVarargOptional || false,
     invalidArguments,
+    deferred,
   ) as PopulatedValueType;
 }
 
@@ -496,11 +529,13 @@ export function validatePositionalValue(
  * @param globalCommand the {@link GlobalCommand} providing the {@link GlobalCommandArgument}.
  * @param value the value (if any) for the {@link GlobalCommandArgument}.
  * @param invalidArguments an array of {@link InvalidArgument} which may be added to if the provided value is invalid.
+ * @param deferred if provided, custom validations are recorded here for later invocation by {@link runCustomValidation}. If omitted, custom validations are not invoked.
  */
 export function validateGlobalCommandArgumentValue(
   globalCommand: GlobalCommand,
   value: PopulatedSingleValueType,
   invalidArguments: Array<InvalidArgument>,
+  deferred?: Array<DeferredCustomValidation>,
 ): PopulatedSingleValueType {
   // if this function is called it is because the argument is defined
   const globalCommandArgument = globalCommand.argument!;
@@ -527,15 +562,12 @@ export function validateGlobalCommandArgumentValue(
       return undefined;
     }
 
-    const customInvalidArgument = doCustomValidation(
+    deferCustomValidation(
+      deferred,
       globalCommandArgument,
       globalCommand.name,
       validationResult.validValue!,
     );
-    if (customInvalidArgument !== undefined) {
-      invalidArguments.push(customInvalidArgument);
-      return undefined;
-    }
     return validationResult.validValue as PopulatedSingleValueType;
   }