v-next/lazy-plugin-loading (#5273)

Switch to lazy loading of Hardhat plugin dependencies and move the
validation logic for plugin installs into the plugin resolution.

The use of plugin validation within the plugin resolution function
requires exposing the base npm resolution folder as a parameter to
`resolvePluginList`.

Tests have been added to the plugin resolution that test failed
dependency loads fall back to plugin install validation logic.

Author: kanej

v-next/core/src/internal/hook-manager.ts

@@ -9,11 +9,7 @@ import {
 import { HardhatPlugin } from "../types/plugins.js";
 import { LastParameter, Return } from "../types/utils.js";
 
-import { validatePluginNpmDependencies } from "./plugins/plugin-validation.js";
-
 export class HookManagerImplementation implements HookManager {
-  readonly #validatedPlugins = new Set<string>();
-
   readonly #pluginsInReverseOrder: HardhatPlugin[];
 
   /**
@@ -244,11 +240,6 @@ export class HookManagerImplementation implements HookManager {
           return;
         }
 
-        if (!this.#validatedPlugins.has(plugin.id)) {
-          await validatePluginNpmDependencies(plugin);
-          this.#validatedPlugins.add(plugin.id);
-        }
-
         let hookCategory: Partial<HardhatHooks[HookCategoryNameT]>;
 
         if (typeof hookHandlerCategoryFactory === "string") {

v-next/core/src/internal/hre.ts

@@ -37,9 +37,15 @@ export class HardhatRuntimeEnvironmentImplementation
     // TODO: Or maybe don't clone at all
     const clonedUserConfig = inputUserConfig;
 
+    // Resolve plugins from node modules relative to the current working directory
+    const basePathForNpmResolution = process.cwd();
+
     const resolvedPlugins =
       unsafeOptions?.resolvedPlugins ??
-      resolvePluginList(clonedUserConfig.plugins);
+      (await resolvePluginList(
+        clonedUserConfig.plugins,
+        basePathForNpmResolution,
+      ));
 
     const hooks = new HookManagerImplementation(resolvedPlugins);
 

v-next/core/src/internal/plugins/plugin-validation.ts

@@ -1,6 +1,5 @@
 import { createRequire } from "node:module";
 import path from "node:path";
-import process from "node:process";
 
 import { HardhatError } from "@nomicfoundation/hardhat-errors";
 import { PackageJson } from "@nomicfoundation/hardhat-utils/package";
@@ -20,11 +19,7 @@ import { HardhatPlugin } from "../../types/plugins.js";
  */
 export async function validatePluginNpmDependencies(
   plugin: HardhatPlugin,
-  // TODO: When all loads where based on a hardhat config file
-  // on disk we used the config file's directory as the base path
-  // We need to decide if the current working directory is the right
-  // option for module resolution now
-  basePathForNpmResolution?: string,
+  basePathForNpmResolution: string,
 ): Promise<void> {
   if (plugin.npmPackage === undefined) {
     return;
@@ -91,10 +86,10 @@ export async function validatePluginNpmDependencies(
  */
 function readPackageJsonViaNodeRequire(
   packageName: string,
-  baseRequirePath?: string,
+  baseRequirePath: string,
 ): { packageJson: PackageJson; packagePath: string } | undefined {
   try {
-    const require = createRequire(baseRequirePath ?? process.cwd());
+    const require = createRequire(baseRequirePath);
 
     const packagePath = require.resolve(path.join(packageName, "package.json"));
 

v-next/core/src/internal/plugins/resolve-plugin-list.ts

@@ -1,14 +1,18 @@
+import type { HardhatPlugin } from "../../types/plugins.js";
+
 import { HardhatError } from "@nomicfoundation/hardhat-errors";
+import { ensureError } from "@nomicfoundation/hardhat-utils/error";
 
-import { HardhatPlugin } from "../../types/plugins.js";
+import { validatePluginNpmDependencies } from "./plugin-validation.js";
 
 /**
  * Resolves the plugin list, returning them in the right order.
  */
-export function resolvePluginList(
+export async function resolvePluginList(
   userConfigPluginList: HardhatPlugin[] = [],
-): HardhatPlugin[] {
-  return reverseTopologicalSort(userConfigPluginList);
+  basePathForNpmResolution: string,
+): Promise<HardhatPlugin[]> {
+  return reverseTopologicalSort(userConfigPluginList, basePathForNpmResolution);
 }
 
 /**
@@ -19,13 +23,14 @@ export function resolvePluginList(
  * @param plugins The plugins.
  * @returns The ordered plugins.
  */
-export function reverseTopologicalSort(
+async function reverseTopologicalSort(
   plugins: HardhatPlugin[],
-): HardhatPlugin[] {
+  basePathForNpmResolution: string,
+): Promise<HardhatPlugin[]> {
   const visitedPlugins: Map<string, HardhatPlugin> = new Map();
   const result: HardhatPlugin[] = [];
 
-  function dfs(plugin: HardhatPlugin) {
+  async function dfs(plugin: HardhatPlugin) {
     const visited = visitedPlugins.get(plugin.id);
 
     if (visited !== undefined) {
@@ -42,17 +47,54 @@ export function reverseTopologicalSort(
     visitedPlugins.set(plugin.id, plugin);
 
     if (plugin.dependencies !== undefined) {
-      for (const dependency of plugin.dependencies) {
-        dfs(dependency);
+      for (const loadFn of plugin.dependencies) {
+        const dependency = await loadDependency(
+          plugin,
+          loadFn,
+          basePathForNpmResolution,
+        );
+
+        await dfs(dependency);
       }
     }
 
     result.push(plugin);
   }
 
   for (const plugin of plugins) {
-    dfs(plugin);
+    await dfs(plugin);
   }
 
   return result;
 }
+
+/**
+ * Attempt to load a plugins dependency. If there is an error,
+ * first try and validate the npm dependencies of the plugin.
+ *
+ * @param plugin - the plugin has the dependency
+ * @param loadFn - the load function for the dependency
+ * @param basePathForNpmResolution - the directory path to use for node module resolution
+ * @returns the loaded plugin
+ */
+async function loadDependency(
+  plugin: HardhatPlugin,
+  loadFn: () => Promise<HardhatPlugin>,
+  basePathForNpmResolution: string,
+): Promise<HardhatPlugin> {
+  try {
+    return await loadFn();
+  } catch (error) {
+    ensureError(error);
+
+    await validatePluginNpmDependencies(plugin, basePathForNpmResolution);
+
+    throw new HardhatError(
+      HardhatError.ERRORS.PLUGINS.PLUGIN_DEPENDENCY_FAILED_LOAD,
+      {
+        pluginId: plugin.id,
+      },
+      error,
+    );
+  }
+}

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

@@ -33,7 +33,7 @@ export interface HardhatPlugin {
   /**
    * An arary of plugins that this plugins depends on.
    */
-  dependencies?: HardhatPlugin[];
+  dependencies?: Array<() => Promise<HardhatPlugin>>;
 
   /**
    * An object with the different hook handlers that this plugin defines.

v-next/core/test/plugins/plugin-validation.ts

@@ -11,11 +11,18 @@ describe("Plugins - plugin validation", () => {
   };
 
   it("should skip validation if the plugin is not from an npm package", async () => {
+    const peerDepWithWrongVersionFixture = import.meta.resolve(
+      "./fixture-projects/peer-dep-with-wrong-version",
+    );
+
     await assert.doesNotReject(async () =>
-      validatePluginNpmDependencies({
-        ...plugin,
-        npmPackage: undefined,
-      }),
+      validatePluginNpmDependencies(
+        {
+          ...plugin,
+          npmPackage: undefined,
+        },
+        peerDepWithWrongVersionFixture,
+      ),
     );
   });