Merge pull request #5277 from NomicFoundation/config-loading

Dynamically find and load config

Author: zoeyTM

v-next/hardhat-errors/src/descriptors.ts

@@ -118,6 +118,32 @@ Please double check the file path.`,
 
 Please double check whether you have multiple versions of the same plugin installed.`,
     },
+    NO_CONFIG_FILE_FOUND: {
+      number: 5,
+      messageTemplate: "No Hardhat config file found",
+      websiteTitle: "No Hardhat config file found",
+      websiteDescription:
+        "Hardhat couldn't find a config file in the current directory or any of its parents.",
+    },
+    INVALID_CONFIG_PATH: {
+      number: 6,
+      messageTemplate: "Config file %configPath% not found",
+      websiteTitle: "Invalid config path",
+      websiteDescription: "The config file doesn't exist at the provided path.",
+    },
+    NO_CONFIG_EXPORTED: {
+      number: 7,
+      messageTemplate: "No config exported in %configPath%",
+      websiteTitle: "No config exported",
+      websiteDescription: "There is nothing exported from the config file.",
+    },
+    INVALID_CONFIG_OBJECT: {
+      number: 8,
+      messageTemplate: "Invalid config exported in %configPath%",
+      websiteTitle: "Invalid config object",
+      websiteDescription:
+        "The config file doesn't export a valid configuration object.",
+    },
   },
   INTERNAL: {
     ASSERTION_ERROR: {

v-next/hardhat/package.json

@@ -36,6 +36,7 @@
     "eslint": "eslint \"src/**/*.ts\" \"test/**/*.ts\"",
     "prettier": "prettier \"**/*.{ts,js,md,json}\"",
     "test": "glob --cmd=\"node --import tsx/esm --test\" \"test/**/*.ts\"",
+    "test:only": "glob --cmd=\"node --import tsx/esm --test --test-only\" \"test/**/*.ts\"",
     "test:github": "glob --cmd=\"node --import tsx/esm --test --test-reporter=@reporters/github --test-reporter-destination=stdout --test-reporter=spec --test-reporter-destination=stdout\" \"test/**/*.ts\"",
     "pretest": "pnpm build",
     "build": "tsc --build .",

v-next/hardhat/src/index.ts

@@ -1,8 +1,13 @@
+import {
+  importUserConfig,
+  resolveConfigPath,
+} from "./internal/helpers/config-loading.js";
 import { getHardhatRuntimeEnvironmentSingleton } from "./internal/hre-singleton.js";
 
-// TODO:
-//  - Load the config from the file system.
-const hre = await getHardhatRuntimeEnvironmentSingleton({});
+const configPath = await resolveConfigPath();
+const userConfig = await importUserConfig(configPath);
+
+const hre = await getHardhatRuntimeEnvironmentSingleton(userConfig);
 
 export const { config, tasks, globalArguments, hooks, interruptions } = hre;
 

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

@@ -1,5 +1,3 @@
-import { isAbsolute, resolve } from "node:path";
-
 import {
   buildGlobalParameterMap,
   resolvePluginList,
@@ -13,6 +11,10 @@ import { Task } from "@nomicfoundation/hardhat-core/types/tasks";
 
 import "tsx"; // NOTE: This is important, it allows us to load .ts files form the CLI
 import { builtinPlugins } from "../builtin-plugins/index.js";
+import {
+  importUserConfig,
+  resolveConfigPath,
+} from "../helpers/config-loading.js";
 import { getHardhatRuntimeEnvironmentSingleton } from "../hre-singleton.js";
 
 export async function main(cliArguments: string[]) {
@@ -66,9 +68,7 @@ export async function main(cliArguments: string[]) {
   }
 
   if (configPath === undefined) {
-    // TODO: Find the closest config file
-    // if HARDHAT_CONFIG exists, use it
-    throw new Error("Missing --config");
+    configPath = await resolveConfigPath();
   }
 
   try {
@@ -265,29 +265,3 @@ function getTaskFromCliArguments(
 
   return task;
 }
-
-async function importUserConfig(configPath: string) {
-  const normalizedPath = isAbsolute(configPath)
-    ? configPath
-    : resolve(process.cwd(), configPath);
-
-  const { exists } = await import("@nomicfoundation/hardhat-utils/fs");
-
-  if (!(await exists(normalizedPath))) {
-    throw new Error(`Config file ${configPath} not found`);
-  }
-
-  const imported = await import(normalizedPath);
-
-  if (!("default" in imported)) {
-    throw new Error(`No config exported in ${configPath}`);
-  }
-
-  const config = imported.default;
-
-  if (typeof config !== "object" || config === null) {
-    throw new Error(`Invalid config exported in ${configPath}`);
-  }
-
-  return config;
-}

v-next/hardhat/src/internal/helpers/config-loading.ts

@@ -0,0 +1,61 @@
+import { isAbsolute, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+
+import { HardhatError } from "@nomicfoundation/hardhat-errors";
+import { findUp } from "@nomicfoundation/hardhat-utils/fs";
+
+import { ERRORS } from "../../../../hardhat-errors/src/descriptors.js";
+
+async function findClosestHardhatConfig(): Promise<string> {
+  let hardhatConfigPath = await findUp("hardhat.config.ts");
+
+  if (hardhatConfigPath !== undefined) {
+    return hardhatConfigPath;
+  }
+
+  hardhatConfigPath = await findUp("hardhat.config.js");
+
+  if (hardhatConfigPath !== undefined) {
+    return hardhatConfigPath;
+  }
+
+  throw new HardhatError(ERRORS.GENERAL.NO_CONFIG_FILE_FOUND);
+}
+
+export async function resolveConfigPath(): Promise<string> {
+  const configPath = process.env.HARDHAT_CONFIG;
+
+  if (configPath !== undefined) {
+    return configPath;
+  }
+
+  return findClosestHardhatConfig();
+}
+
+export async function importUserConfig(configPath: string) {
+  const normalizedPath = isAbsolute(configPath)
+    ? configPath
+    : resolve(process.cwd(), configPath);
+
+  const { exists } = await import("@nomicfoundation/hardhat-utils/fs");
+
+  if (!(await exists(normalizedPath))) {
+    throw new HardhatError(ERRORS.GENERAL.INVALID_CONFIG_PATH, { configPath });
+  }
+
+  const imported = await import(pathToFileURL(normalizedPath).href);
+
+  if (!("default" in imported)) {
+    throw new HardhatError(ERRORS.GENERAL.NO_CONFIG_EXPORTED, { configPath });
+  }
+
+  const config = imported.default;
+
+  if (typeof config !== "object" || config === null) {
+    throw new HardhatError(ERRORS.GENERAL.INVALID_CONFIG_OBJECT, {
+      configPath,
+    });
+  }
+
+  return config;
+}

v-next/hardhat/src/internal/hre-singleton.ts

@@ -2,7 +2,7 @@ import type { HardhatRuntimeEnvironment } from "../types/hre.js";
 
 import { createHardhatRuntimeEnvironment } from "@nomicfoundation/hardhat-core";
 
-let hre: HardhatRuntimeEnvironment;
+let hre: HardhatRuntimeEnvironment | undefined;
 
 /**
  * This function returns a singleton instance of the Hardhat Runtime Environment.
@@ -20,3 +20,12 @@ export async function getHardhatRuntimeEnvironmentSingleton(
 
   return hre;
 }
+
+/**
+ * This function resets the singleton instance of the Hardhat Runtime Environment.
+ *
+ * It should be used only in tests.
+ */
+export function resetHardhatRuntimeEnvironmentSingleton() {
+  hre = undefined;
+}

v-next/hardhat/test/fixture-projects/config-js/hardhat.config.js

@@ -0,0 +1 @@
+// left empty so github commits the folder

v-next/hardhat/test/fixture-projects/config-js/nested-folder/index.js

@@ -0,0 +1 @@
+// left empty so github commits the folder

v-next/hardhat/test/fixture-projects/config-ts/hardhat.config.ts

@@ -0,0 +1,3 @@
+export default {
+  plugins: [{ id: "test-plugin" }],
+};

v-next/hardhat/test/fixture-projects/config-ts/nested-folder/index.js

@@ -0,0 +1,51 @@
+import path from "node:path";
+import { before, after } from "node:test";
+
+import { exists, getRealPath } from "@nomicfoundation/hardhat-utils/fs";
+
+/**
+ * This helper adds mocha hooks to run the tests inside one of the projects
+ * from test/fixture-projects.
+ *
+ * @param projectName The base name of the folder with the project to use.
+ * @param changeDirTo If provided, the working directory will be changed to this. Must be a child of the project folder.
+ */
+export function useFixtureProject(projectName: string, changeDirTo?: string) {
+  let projectPath: string;
+  let prevWorkingDir: string;
+
+  before(async () => {
+    projectPath = await getFixtureProjectPath(projectName, changeDirTo);
+    prevWorkingDir = process.cwd();
+    process.chdir(projectPath);
+  });
+
+  after(() => {
+    process.chdir(prevWorkingDir);
+  });
+}
+
+async function getFixtureProjectPath(
+  projectName: string,
+  changeDirTo?: string,
+): Promise<string> {
+  const normalizedProjectName = projectName.replaceAll("/", path.sep);
+
+  let projectPath = path.join(
+    import.meta.dirname,
+    "..",
+    "fixture-projects",
+    normalizedProjectName,
+  );
+
+  if (changeDirTo !== undefined) {
+    projectPath = path.join(projectPath, changeDirTo);
+  }
+
+  if (!(await exists(projectPath))) {
+    console.log("projectPath", projectPath);
+    throw new Error(`Fixture project ${projectName} doesn't exist`);
+  }
+
+  return getRealPath(projectPath);
+}

v-next/hardhat/test/fixture-projects/loaded-config/hardhat.config.js

@@ -3,14 +3,21 @@ import { describe, it } from "node:test";
 
 import { createHardhatRuntimeEnvironment } from "../../src/hre.js";
 import { builtinPlugins } from "../../src/internal/builtin-plugins/index.js";
-import { getHardhatRuntimeEnvironmentSingleton } from "../../src/internal/hre-singleton.js";
+import { resolveConfigPath } from "../../src/internal/helpers/config-loading.js";
+import {
+  getHardhatRuntimeEnvironmentSingleton,
+  resetHardhatRuntimeEnvironmentSingleton,
+} from "../../src/internal/hre-singleton.js";
+import { useFixtureProject } from "../helpers/project.js";
 
 describe("HRE", () => {
   describe("createHardhatRuntimeEnvironment", () => {
     it("should include the built-in plugins", async () => {
       const hre = await createHardhatRuntimeEnvironment({});
 
       assert.deepEqual(hre.config.plugins, builtinPlugins);
+
+      resetHardhatRuntimeEnvironmentSingleton();
     });
   });
 
@@ -30,6 +37,82 @@ describe("HRE", () => {
         { id: "custom task" },
       );
       assert.deepEqual(hre1, hre2);
+
+      resetHardhatRuntimeEnvironmentSingleton();
+    });
+  });
+
+  describe("config loading", () => {
+    describe("resolveConfigPath", async () => {
+      it("should return the HARDHAT_CONFIG env variable if it is set", async () => {
+        process.env.HARDHAT_CONFIG = "env.config.js";
+
+        assert.equal(await resolveConfigPath(), "env.config.js");
+
+        delete process.env.HARDHAT_CONFIG;
+      });
+
+      it("should throw if the config file is not found", async () => {
+        await assert.rejects(resolveConfigPath(), {
+          message: "HHE5: No Hardhat config file found",
+        });
+      });
+
+      describe("javascript config", () => {
+        describe("current dir", () => {
+          useFixtureProject("config-js");
+
+          it("should load a config file in the current directory", async () => {
+            const configPath = await resolveConfigPath();
+
+            assert(configPath.endsWith("hardhat.config.js"));
+          });
+        });
+
+        describe("nested dir", () => {
+          useFixtureProject("config-js", "nested-folder");
+
+          it("should load a config file in the parent directory", async () => {
+            const configPath = await resolveConfigPath();
+
+            assert(configPath.endsWith("hardhat.config.js"));
+          });
+        });
+      });
+
+      describe("typescript config", () => {
+        describe("current dir", () => {
+          useFixtureProject("config-ts");
+
+          it("should load a config file in the current directory", async () => {
+            const configPath = await resolveConfigPath();
+
+            assert(configPath.endsWith("hardhat.config.ts"));
+          });
+        });
+
+        describe("nested dir", () => {
+          useFixtureProject("config-ts", "nested-folder");
+
+          it("should load a config file in the parent directory", async () => {
+            const configPath = await resolveConfigPath();
+
+            assert(configPath.endsWith("hardhat.config.ts"));
+          });
+        });
+      });
+    });
+
+    describe("programmatic API", () => {
+      useFixtureProject("loaded-config");
+
+      it("should load the config file", async () => {
+        const hre = await import("../../src/index.js");
+
+        assert.deepEqual(hre.config.plugins, [{ id: "test-plugin" }]);
+
+        resetHardhatRuntimeEnvironmentSingleton();
+      });
     });
   });
 });