@flowscripter/dynamic-cli-framework 1.1.5 → 1.2.0

package/src/runtime/values/argumentValueValidation.ts

@@ -111,15 +111,54 @@ function validatePrimitiveValue(
   }
 
   // check if the value is valid
-  if (argument.allowableValues && !argument.allowableValues.includes(value)) {
-    return {
-      invalidArgument: {
-        argument,
-        value,
-        reason: InvalidArgumentReason.ILLEGAL_VALUE,
-      },
-    };
+
+  if (argument.allowableValues) {
+    let searchValue = convertedValue;
+    let allowableValues = argument.allowableValues;
+
+    if (
+      (argument.type === ArgumentValueTypeName.STRING) &&
+      argument.isCaseInsensitive
+    ) {
+      searchValue = (convertedValue as string).toLowerCase();
+      allowableValues = argument.allowableValues.map((v) =>
+        (v as string).toLowerCase()
+      );
+    }
+    if (!allowableValues.includes(searchValue)) {
+      return {
+        invalidArgument: {
+          argument,
+          value,
+          reason: InvalidArgumentReason.ILLEGAL_VALUE,
+        },
+      };
+    }
   }
+  if (argument.minValueInclusive !== undefined) {
+    if ((convertedValue as number) < argument.minValueInclusive) {
+      return {
+        invalidArgument: {
+          argument,
+          value,
+          reason: InvalidArgumentReason.ILLEGAL_VALUE,
+        },
+      };
+    }
+  }
+
+  if (argument.maxValueInclusive !== undefined) {
+    if ((convertedValue as number) > argument.maxValueInclusive) {
+      return {
+        invalidArgument: {
+          argument,
+          value,
+          reason: InvalidArgumentReason.ILLEGAL_VALUE,
+        },
+      };
+    }
+  }
+
   return { validValue: convertedValue };
 }
 
@@ -236,7 +275,7 @@ function validateObjectValue(
   const convertedObjectValue: ArgumentValues = {};
 
   for (let i = 0; i < argument.properties.length; i++) {
-    const propertyArg = argument.properties[i];
+    const propertyArg = argument.properties[i]!;
     const propertyValue = objectValue[propertyArg.name];
 
     if (propertyValue === undefined) {
@@ -267,7 +306,10 @@ function validateObjectValue(
           },
         };
       }
-      validationResult = validateArrayValue(propertyArg, propertyValue);
+      validationResult = validateArrayValue(
+        propertyArg as ComplexOption | SubCommandArgument,
+        propertyValue,
+      );
     } else if (typeof propertyValue === "object") {
       if (propertyArg.type !== ComplexValueTypeName.COMPLEX) {
         return {
@@ -429,6 +471,24 @@ function doSubCommandArgumentValidation(
       invalidArguments.push(validationResult.invalidArgument);
       return undefined;
     }
+    if (argument.validate && validationResult.validValue !== undefined) {
+      const customError = argument.validate(
+        validationResult.validValue as
+          | ArgumentValueType
+          | ArgumentValues
+          | Array<ArgumentValues>,
+      );
+      if (customError !== undefined) {
+        invalidArguments.push({
+          argument,
+          name: argument.name,
+          value: validationResult.validValue as PopulatedArgumentValueType,
+          reason: InvalidArgumentReason.CUSTOM_VALIDATION,
+          message: customError,
+        });
+        return undefined;
+      }
+    }
     return validationResult.validValue as
       | PopulatedArgumentValueType
       | PopulatedArgumentValues
@@ -535,6 +595,24 @@ export function validateGlobalCommandArgumentValue(
       return undefined;
     }
 
+    if (
+      globalCommandArgument.validate &&
+      validationResult.validValue !== undefined
+    ) {
+      const customError = globalCommandArgument.validate(
+        validationResult.validValue as ArgumentValueType,
+      );
+      if (customError !== undefined) {
+        invalidArguments.push({
+          argument: globalCommandArgument,
+          name: globalCommand.name,
+          value: validationResult.validValue,
+          reason: InvalidArgumentReason.CUSTOM_VALIDATION,
+          message: customError,
+        });
+        return undefined;
+      }
+    }
     return validationResult.validValue as PopulatedArgumentSingleValueType;
   }
 
@@ -602,6 +680,11 @@ export function getInvalidArgumentString(
     case InvalidArgumentReason.OPTION_IS_COMPLEX:
       invalidString = "(specified option is complex)";
       break;
+    case InvalidArgumentReason.CUSTOM_VALIDATION:
+      invalidString = invalidArgument.message
+        ? `(custom validation: ${invalidArgument.message})`
+        : "(custom validation failed)";
+      break;
     default:
       invalidString = "";
       break;

package/src/runtime/values/globalCommandValuePopulation.ts

@@ -49,7 +49,7 @@ export default function populateGlobalCommandValue(
 
     // don't use potentialArg if it cannot be a boolean value...
     if (argument.type === ArgumentValueTypeName.BOOLEAN) {
-      const firstPotentialArgLower = firstPotentialArg.toLowerCase();
+      const firstPotentialArgLower = firstPotentialArg!.toLowerCase();
 
       if (
         (firstPotentialArgLower !== "true") &&

package/src/runtime/values/subCommandValuePopulation.ts

@@ -175,14 +175,14 @@ class ParseContext {
 
     for (let i = 0; i < complexPathElements.length; i++) {
       let arrayIndexString: string | undefined;
-      let complexPathElement = complexPathElements[i];
+      let complexPathElement = complexPathElements[i]!;
 
       // look for array index
       if (complexPathElement.endsWith("]")) {
         [complexPathElement, arrayIndexString] = complexPathElement.slice(
           0,
           complexPathElement.length - 1,
-        ).split("[");
+        ).split("[") as [string, string | undefined];
       }
 
       let lookupPath = this.subCommand.name;
@@ -237,7 +237,7 @@ class ParseContext {
         }
         option = this.optionLookupMapsByPath.get(lookupPath)!.get(
           complexPathElement,
-        );
+        ) as Option | ComplexOption | undefined;
 
         // now we are parsing properties of complex options it is an error if we cannot match an option name or alias
         if (option === undefined) {
@@ -423,8 +423,8 @@ class ParseContext {
         if (typeof pathElement === "string") {
           if (Array.isArray(optionValue)) {
             optionValue = (optionValue as Array<PopulatedArgumentValues>)[
-              optionValue.length - 1
-            ][pathElement as string] as
+              (optionValue as Array<PopulatedArgumentValues>).length - 1
+            ]![pathElement as string] as
               | Array<PopulatedArgumentValues>
               | PopulatedArgumentValues
               | PopulatedArgumentValueType;
@@ -459,7 +459,8 @@ class ParseContext {
    * @param value the value to attempt to set.
    */
   setPositionalValue(value: ArgumentSingleValueType): boolean {
-    const positional = this.subCommand.positionals[this.currentPositionalIndex];
+    const positional = this.subCommand
+      .positionals[this.currentPositionalIndex]!;
     const currentValue = this.populatedArgumentValues[positional.name];
 
     // if we haven't populated the argument value before...
@@ -536,7 +537,7 @@ class ParseContext {
         // check for option AND value
         if (potentialOptionPath.includes("=")) {
           [potentialOptionPath, potentialOptionValue] = potentialOptionPath
-            .split(/=(.*)/);
+            .split(/=(.*)/) as [string, string | undefined, ...string[]];
 
           // check for illegal syntax e.g. --optionName=
           if (potentialOptionValue === "") {
@@ -623,7 +624,7 @@ export default function populateSubCommandValues(
   const unusedArgs: Array<string> = [];
 
   for (let i = 0; i < potentialArgs.length; i++) {
-    const potentialArg = potentialArgs[i];
+    const potentialArg = potentialArgs[i]!;
 
     // parse the next arg
     parseContext.parse(potentialArg);

package/src/service/argumentPrompter/ArgumentPrompterServiceProvider.ts

@@ -0,0 +1,34 @@
+import type Context from "../../api/Context.ts";
+import type {
+  ServiceInfo,
+  ServiceProvider,
+} from "../../api/service/ServiceProvider.ts";
+import type ArgumentPrompterService from "../../api/service/core/ArgumentPrompterService.ts";
+import { ARGUMENT_PROMPTER_SERVICE_ID } from "../../api/service/core/ArgumentPrompterService.ts";
+import type CLIConfig from "../../api/CLIConfig.ts";
+
+export default class ArgumentPrompterServiceProvider
+  implements ServiceProvider {
+  readonly serviceId: string = ARGUMENT_PROMPTER_SERVICE_ID;
+  readonly servicePriority: number;
+  readonly argumentPrompterService: ArgumentPrompterService;
+
+  public constructor(
+    servicePriority: number,
+    argumentPrompterService: ArgumentPrompterService,
+  ) {
+    this.servicePriority = servicePriority;
+    this.argumentPrompterService = argumentPrompterService;
+  }
+
+  public getServiceInfo(_cliConfig: CLIConfig): Promise<ServiceInfo> {
+    return Promise.resolve({
+      service: this.argumentPrompterService,
+      commands: [],
+    });
+  }
+
+  initService(_context: Context): Promise<void> {
+    return Promise.resolve();
+  }
+}

package/src/service/argumentPrompter/DefaultArgumentPrompterService.ts

@@ -0,0 +1,330 @@
+import type ArgumentPrompterService from "../../api/service/core/ArgumentPrompterService.ts";
+import type { ParseResult } from "../../runtime/parser.ts";
+import type PrompterService from "../../api/service/core/PrompterService.ts";
+import {
+  type Prompt,
+  type PromptOption,
+  PromptType,
+} from "../../api/service/core/PrompterService.ts";
+import { InvalidArgumentReason } from "../../api/RunResult.ts";
+import type { InvalidArgument } from "../../api/RunResult.ts";
+import {
+  type ArgumentSingleValueType,
+  ArgumentValueTypeName,
+  ComplexValueTypeName,
+  type PopulatedArgumentSingleValueType,
+  type PopulatedArgumentValues,
+} from "../../api/argument/ArgumentValueTypes.ts";
+import type Argument from "../../api/argument/Argument.ts";
+import type Option from "../../api/argument/Option.ts";
+import type Positional from "../../api/argument/Positional.ts";
+import type ComplexOption from "../../api/argument/ComplexOption.ts";
+import type SubCommand from "../../api/command/SubCommand.ts";
+import type GlobalCommand from "../../api/command/GlobalCommand.ts";
+import {
+  isGlobalCommand,
+  isSubCommand,
+} from "../../runtime/command/CommandTypeGuards.ts";
+
+export default class DefaultArgumentPrompterService
+  implements ArgumentPrompterService {
+  readonly #prompterService: PrompterService;
+
+  public constructor(prompterService: PrompterService) {
+    this.#prompterService = prompterService;
+  }
+
+  async promptForMissingArguments(
+    parseResult: ParseResult,
+  ): Promise<ParseResult> {
+    if (!this.#prompterService.promptEnabled) {
+      return parseResult;
+    }
+
+    const allMissingValue = parseResult.invalidArguments.every(
+      (ia) => ia.reason === InvalidArgumentReason.MISSING_VALUE,
+    );
+    if (!allMissingValue) {
+      return parseResult;
+    }
+
+    if (parseResult.invalidArguments.length === 0) {
+      return parseResult;
+    }
+
+    try {
+      if (isGlobalCommand(parseResult.command)) {
+        return await this.#promptForGlobalCommand(parseResult);
+      }
+      if (isSubCommand(parseResult.command)) {
+        return await this.#promptForSubCommand(parseResult);
+      }
+    } catch (error) {
+      if ((error as Error).message === "Interrupted") {
+        throw error;
+      }
+      return parseResult;
+    }
+
+    return parseResult;
+  }
+
+  async #promptForGlobalCommand(
+    parseResult: ParseResult,
+  ): Promise<ParseResult> {
+    const command = parseResult.command as GlobalCommand;
+    if (!command.argument) {
+      return parseResult;
+    }
+
+    const prompt = DefaultArgumentPrompterService.#argumentToPrompt(
+      command.name,
+      command.name,
+      command.argument,
+    );
+    const result = await this.#prompterService.prompt(prompt);
+    const value = DefaultArgumentPrompterService.#coerceValue(
+      result.value as ArgumentSingleValueType,
+      command.argument.type,
+    );
+
+    return {
+      command: parseResult.command,
+      groupCommand: parseResult.groupCommand,
+      populatedArgumentValues: value as PopulatedArgumentSingleValueType,
+      invalidArguments: [],
+      unusedArgs: parseResult.unusedArgs,
+    };
+  }
+
+  async #promptForSubCommand(
+    parseResult: ParseResult,
+  ): Promise<ParseResult> {
+    const command = parseResult.command as SubCommand;
+    const existingValues = (parseResult.populatedArgumentValues ??
+      {}) as PopulatedArgumentValues;
+    const newValues: Record<
+      string,
+      PopulatedArgumentValues[string]
+    > = { ...existingValues };
+    const remainingInvalid: InvalidArgument[] = [];
+
+    for (const invalid of parseResult.invalidArguments) {
+      if (
+        invalid.reason !== InvalidArgumentReason.MISSING_VALUE ||
+        !invalid.name
+      ) {
+        remainingInvalid.push(invalid);
+        continue;
+      }
+
+      const arg = DefaultArgumentPrompterService.#findArgument(
+        command,
+        invalid.name,
+      );
+      if (!arg) {
+        remainingInvalid.push(invalid);
+        continue;
+      }
+
+      if (
+        "type" in arg &&
+        (arg as ComplexOption).type === ComplexValueTypeName.COMPLEX
+      ) {
+        const complexValues = await this.#promptForComplexOption(
+          invalid.name,
+          arg as ComplexOption,
+        );
+        newValues[invalid.name] = complexValues;
+      } else if (
+        DefaultArgumentPrompterService.#isArrayArgument(arg)
+      ) {
+        const arrayValues = await this.#promptForArrayArgument(
+          invalid.name,
+          arg as Option | Positional,
+        );
+        newValues[invalid.name] = arrayValues;
+      } else {
+        const prompt = DefaultArgumentPrompterService.#argumentToPrompt(
+          invalid.name,
+          (arg as Option | Positional).description ?? invalid.name,
+          arg as Argument,
+        );
+        const result = await this.#prompterService.prompt(prompt);
+        newValues[invalid.name] = DefaultArgumentPrompterService.#coerceValue(
+          result.value as ArgumentSingleValueType,
+          (arg as Argument).type,
+        );
+      }
+    }
+
+    return {
+      command: parseResult.command,
+      groupCommand: parseResult.groupCommand,
+      populatedArgumentValues: newValues as PopulatedArgumentValues,
+      invalidArguments: remainingInvalid,
+      unusedArgs: parseResult.unusedArgs,
+    };
+  }
+
+  async #promptForComplexOption(
+    name: string,
+    complexOption: ComplexOption,
+  ): Promise<PopulatedArgumentValues> {
+    const values: Record<string, PopulatedArgumentValues[string]> = {};
+
+    for (const prop of complexOption.properties) {
+      if (
+        "type" in prop &&
+        (prop as ComplexOption).type === ComplexValueTypeName.COMPLEX
+      ) {
+        values[(prop as ComplexOption).name] = await this
+          .#promptForComplexOption(
+            `${name}.${(prop as ComplexOption).name}`,
+            prop as ComplexOption,
+          );
+      } else {
+        const option = prop as Option;
+        if (option.isOptional && option.defaultValue !== undefined) {
+          continue;
+        }
+        const prompt = DefaultArgumentPrompterService.#argumentToPrompt(
+          `${name}.${option.name}`,
+          option.description ?? `${name}.${option.name}`,
+          option,
+        );
+        const result = await this.#prompterService.prompt(prompt);
+        values[option.name] = DefaultArgumentPrompterService.#coerceValue(
+          result.value as ArgumentSingleValueType,
+          option.type,
+        );
+      }
+    }
+
+    return values as PopulatedArgumentValues;
+  }
+
+  async #promptForArrayArgument(
+    name: string,
+    arg: Option | Positional,
+  ): Promise<Array<ArgumentSingleValueType>> {
+    const values: ArgumentSingleValueType[] = [];
+
+    while (true) {
+      const prompt = DefaultArgumentPrompterService.#argumentToPrompt(
+        name,
+        `${arg.description ?? name}${
+          values.length > 0 ? ` [${values.length + 1}]` : ""
+        }`,
+        arg as Argument,
+      );
+      const result = await this.#prompterService.prompt(prompt);
+      values.push(
+        DefaultArgumentPrompterService.#coerceValue(
+          result.value as ArgumentSingleValueType,
+          (arg as Argument).type,
+        ),
+      );
+
+      const addAnother: Prompt = {
+        name: `${name}_more`,
+        promptText: `Add another value for ${name}?`,
+        type: PromptType.ACKNOWLEDGE,
+        options: [],
+      };
+      const moreResult = await this.#prompterService.prompt(addAnother);
+      if (moreResult.value !== true) {
+        break;
+      }
+    }
+
+    return values;
+  }
+
+  static #argumentToPrompt(
+    name: string,
+    description: string,
+    arg: Argument,
+  ): Prompt {
+    if (arg.type === ArgumentValueTypeName.BOOLEAN) {
+      return {
+        name,
+        promptText: description,
+        type: PromptType.TOGGLE,
+        options: [],
+      };
+    }
+
+    if (arg.allowableValues && arg.allowableValues.length > 0) {
+      const options: PromptOption[] = arg.allowableValues.map((v) => ({
+        displayValue: String(v),
+        returnedValue: v,
+      }));
+      return {
+        name,
+        promptText: description,
+        type: PromptType.SINGLE_SELECT,
+        options,
+      };
+    }
+
+    const validationOption: PromptOption = {
+      displayValue: arg.type === ArgumentValueTypeName.SECRET
+        ? "__SECRET__"
+        : name,
+      returnedValue: "",
+      min: arg.minValueInclusive,
+      max: arg.maxValueInclusive,
+      validate: arg.validate ? (v) => arg.validate!(v) : undefined,
+    };
+
+    return {
+      name,
+      promptText: description,
+      type: PromptType.TEXT,
+      options: [validationOption],
+    };
+  }
+
+  static #coerceValue(
+    value: ArgumentSingleValueType,
+    type: ArgumentValueTypeName,
+  ): ArgumentSingleValueType {
+    if (typeof value === "string") {
+      switch (type) {
+        case ArgumentValueTypeName.INTEGER:
+          return parseInt(value, 10);
+        case ArgumentValueTypeName.NUMBER:
+          return parseFloat(value);
+        case ArgumentValueTypeName.BOOLEAN:
+          return value.toLowerCase() === "true";
+      }
+    }
+    return value;
+  }
+
+  static #findArgument(
+    command: SubCommand,
+    name: string,
+  ): Option | Positional | ComplexOption | undefined {
+    for (const opt of command.options) {
+      if (opt.name === name) return opt;
+    }
+    for (const pos of command.positionals) {
+      if (pos.name === name) return pos;
+    }
+    return undefined;
+  }
+
+  static #isArrayArgument(
+    arg: Option | Positional | ComplexOption,
+  ): boolean {
+    if ("isArray" in arg && (arg as Option).isArray) {
+      return true;
+    }
+    if ("isVarargMultiple" in arg && (arg as Positional).isVarargMultiple) {
+      return true;
+    }
+    return false;
+  }
+}

package/src/service/asciiBannerGenerator/AsciiBannerGeneratorServiceProvider.ts

@@ -32,7 +32,7 @@ export default class AsciiBannerGeneratorServiceProvider
       new DefaultAsciiBannerGeneratorService();
   }
 
-  public provide(_cliConfig: CLIConfig): Promise<ServiceInfo> {
+  public getServiceInfo(_cliConfig: CLIConfig): Promise<ServiceInfo> {
     return Promise.resolve({
       service: this.#asciiBannerGeneratorService,
       commands: [],