Merge pull request #5344 from NomicFoundation/tasks-run

schaable · web-flow · commit 16a860c263c8 · 2024-06-07T16:59:59.000-03:00
Task run implementation
diff --git a/v-next/core/src/internal/tasks/builders.ts b/v-next/core/src/internal/tasks/builders.ts
@@ -101,11 +101,12 @@ export class NewTaskDefinitionBuilderImplementation
       !isParameterValueValid(parameterType, defaultValue)
     ) {
       throw new HardhatError(
-        HardhatError.ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE,
+        HardhatError.ERRORS.TASK_DEFINITIONS.INVALID_VALUE_FOR_TYPE,
         {
           value: defaultValue,
           name: "defaultValue",
           type: parameterType,
+          task: formatTaskId(this.#id),
         },
       );
     }
@@ -225,11 +226,12 @@ export class NewTaskDefinitionBuilderImplementation
     if (defaultValue !== undefined) {
       if (!isParameterValueValid(parameterType, defaultValue, isVariadic)) {
         throw new HardhatError(
-          HardhatError.ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE,
+          HardhatError.ERRORS.TASK_DEFINITIONS.INVALID_VALUE_FOR_TYPE,
           {
             value: defaultValue,
             name: "defaultValue",
             type: parameterType,
+            task: formatTaskId(this.#id),
           },
         );
       }
@@ -349,11 +351,12 @@ export class TaskOverrideDefinitionBuilderImplementation
       !isParameterValueValid(parameterType, defaultValue)
     ) {
       throw new HardhatError(
-        HardhatError.ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE,
+        HardhatError.ERRORS.TASK_DEFINITIONS.INVALID_VALUE_FOR_TYPE,
         {
           value: defaultValue,
           name: "defaultValue",
           type: parameterType,
+          task: formatTaskId(this.#id),
         },
       );
     }
diff --git a/v-next/core/src/internal/tasks/resolved-task.ts b/v-next/core/src/internal/tasks/resolved-task.ts
@@ -1,13 +1,21 @@
-import { HardhatRuntimeEnvironment } from "../../types/hre.js";
-import {
+import type { ParameterValue } from "../../types/common.js";
+import type { HardhatRuntimeEnvironment } from "../../types/hre.js";
+import type {
   NamedTaskParameter,
   NewTaskActionFunction,
   PositionalTaskParameter,
   Task,
   TaskActions,
   TaskArguments,
+  TaskOverrideActionFunction,
+  TaskParameter,
 } from "../../types/tasks.js";
 
+import { HardhatError } from "@nomicfoundation/hardhat-errors";
+import { ensureError } from "@nomicfoundation/hardhat-utils/error";
+
+import { isParameterValueValid } from "../../types/common.js";
+
 import { formatTaskId } from "./utils.js";
 
 export class ResolvedTask implements Task {
@@ -69,24 +77,193 @@ export class ResolvedTask implements Task {
     return this.actions.length === 1 && this.actions[0].action === undefined;
   }
 
+  /**
+   * This method runs the task with the given arguments.
+   * It validates the arguments, resolves the file actions, and runs the task
+   * actions by calling them in order.
+   *
+   * @param taskArguments The arguments to run the task with.
+   * @returns The result of running the task.
+   * @throws HardhatError if the task is empty, a required parameter is missing,
+   * a parameter has an invalid type, or the file actions can't be resolved.
+   */
   public async run(taskArguments: TaskArguments): Promise<any> {
-    // TODO: Run the task
-    // - Validate the argument types
-    // - Validate that there are no missing required arguments
-    // - Resolve defaults for optional arguments
-    // - Run the tasks actions with a chain of `runSuper`s
-    console.log(`Running task "${formatTaskId(this.id)}"`);
-    for (const action of this.actions) {
-      if (action.pluginId !== undefined) {
-        console.log(
-          `  Running action from plugin ${action.pluginId}: ${action.action?.toString()}`,
+    if (this.isEmpty) {
+      throw new HardhatError(HardhatError.ERRORS.TASK_DEFINITIONS.EMPTY_TASK, {
+        task: formatTaskId(this.id),
+      });
+    }
+
+    // Normalize parameters into a single iterable
+    const allParameters: TaskParameter[] = [
+      ...this.namedParameters.values(),
+      ...this.positionalParameters,
+    ];
+
+    const providedArgumentNames = new Set(Object.keys(taskArguments));
+    for (const parameter of allParameters) {
+      const value = taskArguments[parameter.name];
+
+      this.#validateRequiredParameter(parameter, value);
+      this.#validateParameterType(parameter, value);
+
+      // resolve defaults for optional parameters
+      if (value === undefined && parameter.defaultValue !== undefined) {
+        taskArguments[parameter.name] = parameter.defaultValue;
+      }
+
+      // Remove processed parameter from the set
+      providedArgumentNames.delete(parameter.name);
+    }
+
+    // At this point, the set should be empty as all the task parameters have
+    // been processed. If there are any extra parameters, an error is thrown
+    this.#validateExtraArguments(providedArgumentNames);
+
+    const next = async (
+      nextTaskArguments: TaskArguments,
+      currentIndex = this.actions.length - 1,
+    ): Promise<any> => {
+      // The first action may be empty if the task was originally an empty task
+      const currentAction = this.actions[currentIndex].action ?? (() => {});
+
+      const actionFn =
+        typeof currentAction === "function"
+          ? currentAction
+          : await this.#resolveFileAction(currentAction, this.id);
+
+      if (currentIndex === 0) {
+        /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions --
+        We know that the first action in the array is a NewTaskActionFunction */
+        return (actionFn as NewTaskActionFunction)(
+          nextTaskArguments,
+          this.#hre,
         );
-      } else {
-        console.log(`  Running action: ${action.action?.toString()}`);
       }
+
+      return actionFn(
+        nextTaskArguments,
+        this.#hre,
+        async (newTaskArguments: TaskArguments) => {
+          return next(newTaskArguments, currentIndex - 1);
+        },
+      );
+    };
+
+    return next(taskArguments);
+  }
+
+  /**
+   * Validates that a required parameter has a value. A parameter is required if
+   * it doesn't have a default value.
+   *
+   * @throws HardhatError if the parameter is required and doesn't have a value.
+   */
+  #validateRequiredParameter(
+    parameter: TaskParameter,
+    value: ParameterValue | ParameterValue[],
+  ) {
+    if (parameter.defaultValue === undefined && value === undefined) {
+      throw new HardhatError(
+        HardhatError.ERRORS.TASK_DEFINITIONS.MISSING_VALUE_FOR_PARAMETER,
+        {
+          parameter: parameter.name,
+          task: formatTaskId(this.id),
+        },
+      );
+    }
+  }
+
+  /**
+   * Validates that a parameter has the correct type. If the parameter is optional
+   * and doesn't have a value, the type is not validated as it will be resolved
+   * to the default value.
+   *
+   * @throws HardhatError if the parameter has an invalid type.
+   */
+  #validateParameterType(
+    parameter: TaskParameter,
+    value: ParameterValue | ParameterValue[],
+  ) {
+    // skip type validation for optional parameters with undefined value
+    if (value === undefined && parameter.defaultValue !== undefined) {
+      return;
+    }
+
+    // check if the parameter is variadic
+    const isPositionalParameter = (
+      param: TaskParameter,
+    ): param is PositionalTaskParameter => "isVariadic" in param;
+    const isVariadic = isPositionalParameter(parameter) && parameter.isVariadic;
+
+    // check if the value is valid for the parameter type
+    if (!isParameterValueValid(parameter.parameterType, value, isVariadic)) {
+      throw new HardhatError(
+        HardhatError.ERRORS.TASK_DEFINITIONS.INVALID_VALUE_FOR_TYPE,
+        {
+          value,
+          name: parameter.name,
+          type: parameter.parameterType,
+          task: formatTaskId(this.id),
+        },
+      );
+    }
+  }
+
+  /**
+   * Validates that no extra arguments were provided in the task arguments.
+   *
+   * @throws HardhatError if extra arguments were provided. The error message
+   * includes the name of the first extra argument.
+   */
+  #validateExtraArguments(providedArgumentNames: Set<string>) {
+    if (providedArgumentNames.size > 0) {
+      throw new HardhatError(
+        HardhatError.ERRORS.TASK_DEFINITIONS.UNRECOGNIZED_NAMED_PARAM,
+        {
+          parameter: [...providedArgumentNames][0],
+          task: formatTaskId(this.id),
+        },
+      );
+    }
+  }
+
+  /**
+   * Resolves the action file for a task. The action file is imported and the
+   * default export function is returned.
+   *
+   * @throws HardhatError if the module can't be imported or doesn't have a
+   * default export function.
+   */
+  async #resolveFileAction(
+    actionFileUrl: string,
+    taskId: string[],
+  ): Promise<NewTaskActionFunction | TaskOverrideActionFunction> {
+    let resolvedActionFn;
+    try {
+      resolvedActionFn = await import(actionFileUrl);
+    } catch (error) {
+      ensureError(error);
+      throw new HardhatError(
+        HardhatError.ERRORS.TASK_DEFINITIONS.INVALID_ACTION_URL,
+        {
+          action: actionFileUrl,
+          task: formatTaskId(taskId),
+        },
+        error,
+      );
+    }
+
+    if (typeof resolvedActionFn.default !== "function") {
+      throw new HardhatError(
+        HardhatError.ERRORS.TASK_DEFINITIONS.INVALID_ACTION,
+        {
+          action: actionFileUrl,
+          task: formatTaskId(taskId),
+        },
+      );
     }
 
-    void taskArguments;
-    void this.#hre;
+    return resolvedActionFn.default;
   }
 }
diff --git a/v-next/core/src/types/tasks.ts b/v-next/core/src/types/tasks.ts
@@ -89,7 +89,7 @@ export type NewTaskActionFunction = (
 export type TaskOverrideActionFunction = (
   taskArguments: TaskArguments,
   hre: HardhatRuntimeEnvironment,
-  runSuper: (taskArguments?: TaskArguments) => Promise<any>,
+  runSuper: (taskArguments: TaskArguments) => Promise<any>,
 ) => any;
 
 /**
diff --git a/v-next/core/test/internal/tasks/builders.ts b/v-next/core/test/internal/tasks/builders.ts
@@ -1,6 +1,8 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 
+import { HardhatError } from "@nomicfoundation/hardhat-errors";
+
 import { RESERVED_PARAMETER_NAMES } from "../../../src/internal/parameters.js";
 import {
   NewTaskDefinitionBuilderImplementation,
@@ -643,11 +645,15 @@ describe("Task builders", () => {
                 defaultValue: 123 as any,
                 type: ParameterType.STRING,
               }),
-            {
-              name: "HardhatError",
-              message:
-                "HHE300: Invalid value 123 for argument defaultValue of type STRING",
-            },
+            new HardhatError(
+              HardhatError.ERRORS.TASK_DEFINITIONS.INVALID_VALUE_FOR_TYPE,
+              {
+                value: 123,
+                name: "defaultValue",
+                type: ParameterType.STRING,
+                task: "task-id",
+              },
+            ),
           );
         });
 
@@ -660,11 +666,15 @@ describe("Task builders", () => {
               defaultValue: [123, 456, 789] as any,
               type: ParameterType.STRING,
             }),
-          {
-            name: "HardhatError",
-            message:
-              "HHE300: Invalid value [123,456,789] for argument defaultValue of type STRING",
-          },
+          new HardhatError(
+            HardhatError.ERRORS.TASK_DEFINITIONS.INVALID_VALUE_FOR_TYPE,
+            {
+              value: [123, 456, 789],
+              name: "defaultValue",
+              type: ParameterType.STRING,
+              task: "task-id",
+            },
+          ),
         );
       });
     });
@@ -1097,11 +1107,15 @@ describe("Task builders", () => {
               defaultValue: 123 as any,
               type: ParameterType.STRING,
             }),
-          {
-            name: "HardhatError",
-            message:
-              "HHE300: Invalid value 123 for argument defaultValue of type STRING",
-          },
+          new HardhatError(
+            HardhatError.ERRORS.TASK_DEFINITIONS.INVALID_VALUE_FOR_TYPE,
+            {
+              value: 123,
+              name: "defaultValue",
+              type: ParameterType.STRING,
+              task: "task-id",
+            },
+          ),
         );
       });
     });
diff --git a/v-next/core/test/internal/tasks/fixture-projects/file-actions/action-fn.js b/v-next/core/test/internal/tasks/fixture-projects/file-actions/action-fn.js
@@ -0,0 +1 @@
+export default (args, _, runSuper) => runSuper(args);
diff --git a/v-next/core/test/internal/tasks/fixture-projects/file-actions/no-default-fn.js b/v-next/core/test/internal/tasks/fixture-projects/file-actions/no-default-fn.js
@@ -0,0 +1,3 @@
+export const a = 1;
+
+export default a;
diff --git a/v-next/core/test/internal/tasks/fixture-projects/file-actions/no-default.js b/v-next/core/test/internal/tasks/fixture-projects/file-actions/no-default.js
@@ -0,0 +1 @@
+export const a = 1;
diff --git a/v-next/core/test/internal/tasks/fixture-projects/file-actions/no-run-super.js b/v-next/core/test/internal/tasks/fixture-projects/file-actions/no-run-super.js
@@ -0,0 +1 @@
+export default (args) => `action fn called with args: ${JSON.stringify(args)}`;
diff --git a/v-next/core/test/internal/tasks/task-manager.ts b/v-next/core/test/internal/tasks/task-manager.ts
diff --git a/v-next/hardhat-errors/src/descriptors.ts b/v-next/hardhat-errors/src/descriptors.ts
diff --git a/v-next/hardhat/example.config.ts b/v-next/hardhat/example.config.ts

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+export default (args, _, runSuper) => runSuper(args);`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+export const a = 1;`
	`2`	`+`
	`3`	`+export default a;`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	+export default (args) => `action fn called with args: ${JSON.stringify(args)}`;