search up dir tree for hardhat config

Author: zoeyTM

Diff for: 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 .",

Diff for: 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;
 

Diff for: 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;
-}

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

@@ -0,0 +1,55 @@
+import { isAbsolute, resolve } from "node:path";
+
+import { findUp } from "@nomicfoundation/hardhat-utils/fs";
+
+async function findClosestHardhatConfig(): Promise<string> {
+  let hardhatConfigPath = await findUp("hardhat.config.js");
+
+  if (hardhatConfigPath !== undefined) {
+    return hardhatConfigPath;
+  }
+
+  hardhatConfigPath = await findUp("hardhat.config.ts");
+
+  if (hardhatConfigPath !== undefined) {
+    return hardhatConfigPath;
+  }
+
+  throw new Error("No Hardhat 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 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;
+}

Diff for: v-next/hardhat/test/fixture-projects/config-js/hardhat.config.js

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

Diff for: v-next/hardhat/test/fixture-projects/config-ts/hardhat.config.ts

@@ -0,0 +1,67 @@
+import fsPromises from "node:fs/promises";
+import path from "node:path";
+import { before, after } from "node:test";
+
+import { exists } 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);
+}
+
+/**
+ * Returns the real path of absolutePath, resolving symlinks.
+ *
+ * @throws Error if absolutePath doesn't exist.
+ */
+async function getRealPath(absolutePath: string): Promise<string> {
+  try {
+    // This method returns the actual casing.
+    // Please read Node.js' docs to learn more.
+    return await fsPromises.realpath(path.normalize(absolutePath));
+  } catch {
+    throw new Error(`Invalid directory ${absolutePath}`);
+  }
+}

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

@@ -3,7 +3,9 @@ import { describe, it } from "node:test";
 
 import { createHardhatRuntimeEnvironment } from "../../src/hre.js";
 import { builtinPlugins } from "../../src/internal/builtin-plugins/index.js";
+import { resolveConfigPath } from "../../src/internal/helpers/config-loading.js";
 import { getHardhatRuntimeEnvironmentSingleton } from "../../src/internal/hre-singleton.js";
+import { useFixtureProject } from "../helpers/project.js";
 
 describe("HRE", () => {
   describe("createHardhatRuntimeEnvironment", () => {
@@ -32,4 +34,81 @@ describe("HRE", () => {
       assert.deepEqual(hre1, hre2);
     });
   });
+
+  describe("config loading", () => {
+    describe("resolveConfigPath", async () => {
+      it("should return the HARDHAT_CONFIG env variable if it is set", async () => {
+        process.env.HARDHAT_CONFIG = "hardhat.config.js";
+
+        assert.equal(await resolveConfigPath(), "hardhat.config.js");
+
+        delete process.env.HARDHAT_CONFIG;
+      });
+
+      it("should throw if the config file is not found", async () => {
+        await assert.rejects(resolveConfigPath(), {
+          message: "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"));
+          });
+        });
+      });
+    });
+
+    // This test works individually but fails when running all tests
+    // due to the hre singleton being used in tests above.
+    // ESM modules cache is not accessible like `require.cache` in CJS,
+    // so a workaround is needed.
+    // TODO: Fix this test
+    describe.skip("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" }]);
+      });
+    });
+  });
 });