Merge pull request #5517 from NomicFoundation/projext-root

[WIP] Project root resolution

Author: schaable

v-next/core/src/index.ts

@@ -15,22 +15,28 @@ import { HardhatRuntimeEnvironmentImplementation } from "./internal/hre.js";
  * @param config - The user's Hardhat configuration.
  * @param userProvidedGlobalOptions - The global options provided by the
  *  user.
+ * @param projectRoot - The root of the Hardhat project. Hardhat expects this
+ * to be the root of the npm project containing your config file. If none is
+ * provided, it will use the root of the npm project that contains the CWD.
  * @param unsafeOptions - Options used to bypass some initialization, to avoid
  *  redoing it in the CLI. Should only be used in the official CLI.
  * @returns The Hardhat Runtime Environment.
  */
 export async function createBaseHardhatRuntimeEnvironment(
   config: HardhatUserConfig,
   userProvidedGlobalOptions: Partial<GlobalOptions> = {},
+  projectRoot?: string,
   unsafeOptions?: UnsafeHardhatRuntimeEnvironmentOptions,
 ): Promise<HardhatRuntimeEnvironment> {
   return HardhatRuntimeEnvironmentImplementation.create(
     config,
     userProvidedGlobalOptions,
+    projectRoot,
     unsafeOptions,
   );
 }
 
+export { resolveProjectRoot } from "./internal/hre.js";
 export { parseArgumentValue } from "./internal/arguments.js";
 export { resolvePluginList } from "./internal/plugins/resolve-plugin-list.js";
 export { buildGlobalOptionDefinitions } from "./internal/global-options.js";

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

@@ -17,7 +17,11 @@ import {
   assertHardhatInvariant,
 } from "@ignored/hardhat-vnext-errors";
 
+import { detectPluginNpmDependencyProblems } from "./plugins/detect-plugin-npm-dependency-problems.js";
+
 export class HookManagerImplementation implements HookManager {
+  readonly #projectRoot: string;
+
   readonly #pluginsInReverseOrder: HardhatPlugin[];
 
   /**
@@ -44,7 +48,8 @@ export class HookManagerImplementation implements HookManager {
     Array<Partial<HardhatHooks[keyof HardhatHooks]>>
   > = new Map();
 
-  constructor(plugins: HardhatPlugin[]) {
+  constructor(projectRoot: string, plugins: HardhatPlugin[]) {
+    this.#projectRoot = projectRoot;
     this.#pluginsInReverseOrder = plugins.toReversed();
   }
 
@@ -252,7 +257,7 @@ export class HookManagerImplementation implements HookManager {
 
         if (typeof hookHandlerCategoryFactory === "string") {
           hookCategory = await this.#loadHookCategoryFactory(
-            plugin.id,
+            plugin,
             hookCategoryName,
             hookHandlerCategoryFactory,
           );
@@ -288,35 +293,42 @@ export class HookManagerImplementation implements HookManager {
   }
 
   async #loadHookCategoryFactory<HookCategoryNameT extends keyof HardhatHooks>(
-    pluginId: string,
+    plugin: HardhatPlugin,
     hookCategoryName: HookCategoryNameT,
     path: string,
   ): Promise<Partial<HardhatHooks[HookCategoryNameT]>> {
     if (!path.startsWith("file://")) {
       throw new HardhatError(
         HardhatError.ERRORS.HOOKS.INVALID_HOOK_FACTORY_PATH,
         {
-          pluginId,
+          pluginId: plugin.id,
           hookCategoryName,
           path,
         },
       );
     }
 
-    const mod = await import(path);
+    let mod;
+
+    try {
+      mod = await import(path);
+    } catch (error) {
+      await detectPluginNpmDependencyProblems(this.#projectRoot, plugin);
+      throw error;
+    }
 
     const factory = mod.default;
 
     assertHardhatInvariant(
       typeof factory === "function",
-      `Plugin ${pluginId} doesn't export a hook factory for category ${hookCategoryName} in ${path}`,
+      `Plugin ${plugin.id} doesn't export a hook factory for category ${hookCategoryName} in ${path}`,
     );
 
     const category = await factory();
 
     assertHardhatInvariant(
       category !== null && typeof category === "object",
-      `Plugin ${pluginId} doesn't export a valid factory for category ${hookCategoryName} in ${path}, it didn't return an object`,
+      `Plugin ${plugin.id} doesn't export a valid factory for category ${hookCategoryName} in ${path}, it didn't return an object`,
     );
 
     return category;

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

@@ -15,6 +15,7 @@ import type { TaskManager } from "../types/tasks.js";
 import type { UserInterruptionManager } from "../types/user-interruptions.js";
 
 import { HardhatError } from "@ignored/hardhat-vnext-errors";
+import { findClosestPackageRoot } from "@ignored/hardhat-vnext-utils/package";
 
 import { ResolvedConfigurationVariableImplementation } from "./configuration-variables.js";
 import {
@@ -32,28 +33,24 @@ export class HardhatRuntimeEnvironmentImplementation
   public static async create(
     inputUserConfig: HardhatUserConfig,
     userProvidedGlobalOptions: Partial<GlobalOptions>,
+    projectRoot?: string,
     unsafeOptions?: UnsafeHardhatRuntimeEnvironmentOptions,
   ): Promise<HardhatRuntimeEnvironmentImplementation> {
-    // TODO: Clone with lodash or https://github.com/davidmarkclements/rfdc
-    // 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 resolvedProjectRoot = await resolveProjectRoot(projectRoot);
 
     const resolvedPlugins =
       unsafeOptions?.resolvedPlugins ??
-      (await resolvePluginList(
-        clonedUserConfig.plugins,
-        basePathForNpmResolution,
-      ));
+      (await resolvePluginList(resolvedProjectRoot, inputUserConfig.plugins));
 
-    const hooks = new HookManagerImplementation(resolvedPlugins);
+    const hooks = new HookManagerImplementation(
+      resolvedProjectRoot,
+      resolvedPlugins,
+    );
 
     // extend user config:
     const extendedUserConfig = await runUserConfigExtensions(
       hooks,
-      clonedUserConfig,
+      inputUserConfig,
     );
 
     // validate config
@@ -76,14 +73,20 @@ export class HardhatRuntimeEnvironmentImplementation
     // Resolve config
 
     const resolvedConfig = await resolveUserConfig(
+      resolvedProjectRoot,
       hooks,
       resolvedPlugins,
       inputUserConfig,
     );
 
-    // We override the plugins, as we want to prevent plugins from changing this
-    const config = {
+    // We override the plugins and the proejct root, as we want to prevent
+    // the plugins from changing them
+    const config: HardhatConfig = {
       ...resolvedConfig,
+      paths: {
+        ...resolvedConfig.paths,
+        root: resolvedProjectRoot,
+      },
       plugins: resolvedPlugins,
     };
 
@@ -138,6 +141,20 @@ export class HardhatRuntimeEnvironmentImplementation
   }
 }
 
+/**
+ * Resolves the project root of a Hardhat project based on the config file or
+ * another path within the project. If not provided, it will be resolved from
+ * the current working directory.
+ *
+ * @param absolutePathWithinProject An absolute path within the project, usually
+ * the config file.
+ */
+export async function resolveProjectRoot(
+  absolutePathWithinProject: string | undefined,
+): Promise<string> {
+  return findClosestPackageRoot(absolutePathWithinProject ?? process.cwd());
+}
+
 async function runUserConfigExtensions(
   hooks: HookManager,
   config: HardhatUserConfig,
@@ -169,13 +186,17 @@ async function validateUserConfig(
 }
 
 async function resolveUserConfig(
+  projectRoot: string,
   hooks: HookManager,
   sortedPlugins: HardhatPlugin[],
   config: HardhatUserConfig,
 ): Promise<HardhatConfig> {
   const initialResolvedConfig: HardhatConfig = {
     plugins: sortedPlugins,
     tasks: config.tasks ?? [],
+    paths: {
+      root: projectRoot,
+    },
   };
 
   return hooks.runHandlerChain(

v-next/core/src/internal/plugins/detect-plugin-npm-dependency-problems.ts

@@ -8,26 +8,30 @@ import { HardhatError } from "@ignored/hardhat-vnext-errors";
 import semver from "semver";
 
 /**
- * Validate that a plugin is installed and that its peer dependencies are installed and satisfy the version constraints.
+ * Validate that a plugin is installed and that its peer dependencies are
+ * installed and satisfy the version constraints.
  *
- * @param plugin - the plugin to be validated
- * @param basePathForNpmResolution - the directory path to use for node module resolution, defaulting to `process.cwd()`
+ * @param basePathForNpmResolution the dir path for node module resolution
+ * @param plugin the plugin to be validated
  * @throws {HardhatError} with descriptor:
- * - {@link HardhatError.ERRORS.PLUGINS.PLUGIN_NOT_INSTALLED} if the plugin is not installed as an npm package
- * - {@link HardhatError.ERRORS.PLUGINS.PLUGIN_MISSING_DEPENDENCY} if the plugin's package peer dependency is not installed
- * - {@link HardhatError.ERRORS.PLUGINS.DEPENDENCY_VERSION_MISMATCH} if the plugin's package peer dependency is installed but has the wrong version
+ * - {@link HardhatError.ERRORS.PLUGINS.PLUGIN_NOT_INSTALLED} if the plugin is
+ * not installed as an npm package
+ * - {@link HardhatError.ERRORS.PLUGINS.PLUGIN_MISSING_DEPENDENCY} if the
+ * plugin's package peer dependency is not installed
+ * - {@link HardhatError.ERRORS.PLUGINS.DEPENDENCY_VERSION_MISMATCH} if the
+ * plugin's package peer dependency is installed but has the wrong version
  */
 export async function detectPluginNpmDependencyProblems(
+  basePathForNpmResolution: string,
   plugin: HardhatPlugin,
-  basePathForNpmResolution: string = process.cwd(),
 ): Promise<void> {
   if (plugin.npmPackage === undefined) {
     return;
   }
 
   const pluginPackageResult = readPackageJsonViaNodeRequire(
-    plugin.npmPackage,
     basePathForNpmResolution,
+    plugin.npmPackage,
   );
 
   if (pluginPackageResult === undefined) {
@@ -46,8 +50,8 @@ export async function detectPluginNpmDependencyProblems(
     pluginPackageJson.peerDependencies,
   )) {
     const dependencyPackageJsonResult = readPackageJsonViaNodeRequire(
-      dependencyName,
       packagePath,
+      dependencyName,
     );
 
     if (dependencyPackageJsonResult === undefined) {
@@ -77,16 +81,16 @@ export async function detectPluginNpmDependencyProblems(
 }
 
 /**
- * Read the package.json of a named package resolved through the node
- * require system.
+ * Read the package.json of a named package resolved through the node require
+ * system.
  *
- * @param packageName - the package name i.e. "@nomiclabs/hardhat-waffle"
- * @param baseRequirePath - the directory path to use for resolution, defaults to `process.cwd()`
+ * @param packageName the package name i.e. "@nomiclabs/hardhat-waffle"
+ * @param baseRequirePath  the dir path for node module resolution
  * @returns the package.json object or undefined if the package is not found
  */
 function readPackageJsonViaNodeRequire(
-  packageName: string,
   baseRequirePath: string,
+  packageName: string,
 ): { packageJson: PackageJson; packagePath: string } | undefined {
   try {
     const require = createRequire(baseRequirePath);

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

@@ -9,10 +9,10 @@ import { detectPluginNpmDependencyProblems } from "./detect-plugin-npm-dependenc
  * Resolves the plugin list, returning them in the right order.
  */
 export async function resolvePluginList(
+  projectRoot: string,
   userConfigPluginList: HardhatPlugin[] = [],
-  basePathForNpmResolution: string,
 ): Promise<HardhatPlugin[]> {
-  return reverseTopologicalSort(userConfigPluginList, basePathForNpmResolution);
+  return reverseTopologicalSort(projectRoot, userConfigPluginList);
 }
 
 /**
@@ -24,8 +24,8 @@ export async function resolvePluginList(
  * @returns The ordered plugins.
  */
 async function reverseTopologicalSort(
+  projectRoot: string,
   plugins: HardhatPlugin[],
-  basePathForNpmResolution: string,
 ): Promise<HardhatPlugin[]> {
   const visitedPlugins: Map<string, HardhatPlugin> = new Map();
   const result: HardhatPlugin[] = [];
@@ -48,11 +48,7 @@ async function reverseTopologicalSort(
 
     if (plugin.dependencies !== undefined) {
       for (const loadFn of plugin.dependencies) {
-        const dependency = await loadDependency(
-          plugin,
-          loadFn,
-          basePathForNpmResolution,
-        );
+        const dependency = await loadDependency(projectRoot, plugin, loadFn);
 
         await dfs(dependency);
       }
@@ -72,22 +68,22 @@ async function reverseTopologicalSort(
  * Attempt to load a plugins dependency. If there is an error,
  * first try and validate the npm dependencies of the plugin.
  *
+ * @param projectRoot - The root of the Hardhat project.
  * @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(
+  projectRoot: string,
   plugin: HardhatPlugin,
   loadFn: () => Promise<HardhatPlugin>,
-  basePathForNpmResolution: string,
 ): Promise<HardhatPlugin> {
   try {
     return await loadFn();
   } catch (error) {
     ensureError(error);
 
-    await detectPluginNpmDependencyProblems(plugin, basePathForNpmResolution);
+    await detectPluginNpmDependencyProblems(projectRoot, plugin);
 
     throw new HardhatError(
       HardhatError.ERRORS.PLUGINS.PLUGIN_DEPENDENCY_FAILED_LOAD,

v-next/core/src/internal/tasks/resolved-task.ts

@@ -235,7 +235,10 @@ export class ResolvedTask implements Task {
           `Plugin with id ${actionPluginId} not found.`,
         );
 
-        await detectPluginNpmDependencyProblems(plugin);
+        await detectPluginNpmDependencyProblems(
+          this.#hre.config.paths.root,
+          plugin,
+        );
       }
 
       throw new HardhatError(

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

@@ -45,11 +45,23 @@ export type SensitiveString = string | ConfigurationVariable;
  * The user's Hardhat configuration, as exported in their
  * config file.
  */
-// eslint-disable-next-line @typescript-eslint/no-empty-interface -- Used through module aumentation
-export interface HardhatUserConfig {}
+export interface HardhatUserConfig {
+  paths?: ProjectPathsUserConfig;
+}
+
+/**
+ * The different paths that conform a Hardhat project.
+ */
+// eslint-disable-next-line @typescript-eslint/no-empty-interface -- TODO: add the paths
+export interface ProjectPathsUserConfig {}
 
 /**
  * The resolved Hardhat configuration.
  */
-// eslint-disable-next-line @typescript-eslint/no-empty-interface -- Used through module aumentation
-export interface HardhatConfig {}
+export interface HardhatConfig {
+  paths: ProjectPathsConfig;
+}
+
+export interface ProjectPathsConfig {
+  root: string;
+}