Merge pull request #5341 from NomicFoundation/tasks-def

Improve task types & validation

Author: schaable

v-next/core/src/internal/tasks/builders.ts

@@ -223,17 +223,7 @@ export class NewTaskDefinitionBuilderImplementation
     }
 
     if (defaultValue !== undefined) {
-      let isValid = true;
-
-      if (Array.isArray(defaultValue)) {
-        isValid =
-          isVariadic &&
-          defaultValue.every((v) => isParameterValueValid(parameterType, v));
-      } else {
-        isValid = isParameterValueValid(parameterType, defaultValue);
-      }
-
-      if (!isValid) {
+      if (!isParameterValueValid(parameterType, defaultValue, isVariadic)) {
         throw new HardhatError(
           HardhatError.ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE,
           {

v-next/core/src/types/common.ts

@@ -22,6 +22,12 @@ export interface ParameterToValueTypeMap {
   [ParameterType.FILE]: string;
 }
 
+/**
+ * All the possible values for a parameter.
+ */
+export type ParameterValue =
+  ParameterToValueTypeMap[keyof ParameterToValueTypeMap];
+
 /**
  * Maps a `ParameterType` to its corresponding value type.
  *
@@ -57,11 +63,19 @@ const parameterTypeValidators: Record<
  *
  * This function uses a map of validators, where each validator is a function
  * that checks if a value is valid for a specific parameter type.
+ * If the parameter type is variadic, the value is considered valid if it is an
+ * array and all its elements are valid for the parameter type.
  */
 export function isParameterValueValid(
   type: ParameterType,
   value: unknown,
+  isVariadic: boolean = false,
 ): boolean {
   const validator = parameterTypeValidators[type];
+
+  if (isVariadic) {
+    return Array.isArray(value) && value.every(validator);
+  }
+
   return validator(value);
 }

v-next/core/src/types/tasks.ts

@@ -1,4 +1,8 @@
-import type { ParameterType, ParameterTypeToValueType } from "./common.js";
+import type {
+  ParameterType,
+  ParameterTypeToValueType,
+  ParameterValue,
+} from "./common.js";
 import type { HardhatRuntimeEnvironment } from "./hre.js";
 
 // We add the TaskManager to the HRE with a module augmentation to avoid
@@ -23,6 +27,15 @@ declare module "./config.js" {
   }
 }
 
+export interface TaskParameter<T extends ParameterType = ParameterType> {
+  name: string;
+  description: string;
+  parameterType: T;
+  defaultValue?:
+    | ParameterTypeToValueType<T>
+    | Array<ParameterTypeToValueType<T>>;
+}
+
 /**
  * A named task parameter is one that is used as `--<name> value` in the CLI.
  *
@@ -32,11 +45,9 @@ declare module "./config.js" {
  * parameter is considered a flag, and can be used as `--<name>` to set it to
  * `true`.
  */
-export interface NamedTaskParameter {
-  name: string;
-  description: string;
-  parameterType: ParameterType;
-  defaultValue?: any;
+export interface NamedTaskParameter<T extends ParameterType = ParameterType>
+  extends TaskParameter<T> {
+  defaultValue?: ParameterTypeToValueType<T>;
 }
 
 /**
@@ -46,19 +57,17 @@ export interface NamedTaskParameter {
  * If the parameter is variadic, it can have multiple values. A variadic parameter
  * can only be the last positional parameter, and it consumes all the remaining values.
  */
-export interface PositionalTaskParameter {
-  name: string;
-  description: string;
-  parameterType: ParameterType;
-  defaultValue?: any;
+export interface PositionalTaskParameter<
+  T extends ParameterType = ParameterType,
+> extends TaskParameter<T> {
   isVariadic: boolean;
 }
 
 /**
  * A type representing the arguments or concrete parameters of a task. That is,
  * the actual values passed to it.
  */
-export type TaskArguments = Record<string, any>;
+export type TaskArguments = Record<string, ParameterValue | ParameterValue[]>;
 
 /**
  * The type of a new task's action function.

v-next/hardhat/src/internal/cli/main.ts

@@ -1,21 +1,28 @@
-import {
-  buildGlobalParameterMap,
-  resolvePluginList,
-} from "@nomicfoundation/hardhat-core";
-import { ParameterType } from "@nomicfoundation/hardhat-core/types/common";
-import {
+import type { ParameterValue } from "@nomicfoundation/hardhat-core/types/common";
+import type {
   GlobalArguments,
   GlobalParameter,
   GlobalParameterMap,
 } from "@nomicfoundation/hardhat-core/types/global-parameters";
-import { HardhatRuntimeEnvironment } from "@nomicfoundation/hardhat-core/types/hre";
-import {
+import type { HardhatRuntimeEnvironment } from "@nomicfoundation/hardhat-core/types/hre";
+import type {
   NamedTaskParameter,
-  PositionalTaskParameter,
   Task,
+  TaskArguments,
+  TaskParameter,
 } from "@nomicfoundation/hardhat-core/types/tasks";
+
 import "tsx"; // NOTE: This is important, it allows us to load .ts files form the CLI
-import { HardhatError } from "@nomicfoundation/hardhat-errors";
+
+import {
+  buildGlobalParameterMap,
+  resolvePluginList,
+} from "@nomicfoundation/hardhat-core";
+import { ParameterType } from "@nomicfoundation/hardhat-core/types/common";
+import {
+  HardhatError,
+  assertHardhatInvariant,
+} from "@nomicfoundation/hardhat-errors";
 import { isCi } from "@nomicfoundation/hardhat-utils/ci";
 
 import { builtinPlugins } from "../builtin-plugins/index.js";
@@ -231,7 +238,7 @@ export function parseTaskAndArguments(
 ):
   | {
       task: Task;
-      taskArguments: Record<string, any>;
+      taskArguments: TaskArguments;
     }
   | string[] {
   const taskOrId = getTaskFromCliArguments(cliArguments, usedCliArguments, hre);
@@ -312,8 +319,8 @@ function parseTaskArguments(
   cliArguments: string[],
   usedCliArguments: boolean[],
   task: Task,
-): Record<string, any> {
-  const taskArguments: Record<string, unknown> = {};
+): TaskArguments {
+  const taskArguments: TaskArguments = {};
 
   // Parse named parameters
   parseDoubleDashArgs(
@@ -345,7 +352,7 @@ function parseDoubleDashArgs(
   cliArguments: string[],
   usedCliArguments: boolean[],
   parametersMap: Map<string, NamedTaskParameter | GlobalParameter>,
-  argumentsMap: Record<string, any>,
+  argumentsMap: TaskArguments,
 ) {
   for (let i = 0; i < cliArguments.length; i++) {
     if (usedCliArguments[i]) {
@@ -433,7 +440,7 @@ function parsePositionalAndVariadicParameters(
   cliArguments: string[],
   usedCliArguments: boolean[],
   task: Task,
-  taskArguments: Record<string, any>,
+  taskArguments: TaskArguments,
 ) {
   let paramI = 0;
 
@@ -472,16 +479,21 @@ function parsePositionalAndVariadicParameters(
     // Handle variadic parameters. No longer increment "paramI" becuase there can only be one variadic parameter and it
     // will consume all remaining arguments.
     taskArguments[paramInfo.name] = taskArguments[paramInfo.name] ?? [];
-    taskArguments[paramInfo.name].push(formattedValue);
+    const variadicTaskArg = taskArguments[paramInfo.name];
+    assertHardhatInvariant(
+      Array.isArray(variadicTaskArg),
+      "Variadic parameter values should be an array",
+    );
+    variadicTaskArg.push(formattedValue);
   }
 
   // Check if all the required parameters have been used
   validateRequiredParameters(task.positionalParameters, taskArguments);
 }
 
 function validateRequiredParameters(
-  parameters: PositionalTaskParameter[] | NamedTaskParameter[],
-  taskArguments: Record<string, any>,
+  parameters: TaskParameter[],
+  taskArguments: TaskArguments,
 ) {
   const missingRequiredParam = parameters.find(
     (param) =>
@@ -507,7 +519,7 @@ function parseParameterValue(
   strValue: string,
   type: ParameterType,
   argName: string,
-): any {
+): ParameterValue {
   switch (type) {
     case ParameterType.STRING:
       return validateAndParseString(argName, strValue);