Fix ERR_REQUIRE_ESM In Junit-report-merger V9.0.1

Nov 26, 2025 by Alex Johnson 50 views

Understanding and Fixing the ERR_REQUIRE_ESM Error in junit-report-merger v9.0.1

When working with Node.js projects, encountering errors is part of the development process. One common error that developers may face, especially after updating packages, is the ERR_REQUIRE_ESM error. This article delves into the specifics of this error, particularly in the context of junit-report-merger version 9.0.1, and provides a comprehensive guide on how to resolve it. Understanding the root cause and implementing the correct solution is crucial for maintaining a smooth development workflow.

What is the ERR_REQUIRE_ESM Error?

The ERR_REQUIRE_ESM error in Node.js occurs when you attempt to use the require() function to import an ES Module (ESM) in a CommonJS (CJS) module. This is a common issue because Node.js has evolved to support both CJS and ESM formats, but they are not directly interoperable in this way. To fully grasp the error, it's essential to understand the difference between these module systems.

CommonJS (CJS): This is the traditional module system used in Node.js. It uses require() to import modules and module.exports to export them. CJS is synchronous, meaning modules are loaded in the order they are required.
ES Modules (ESM): This is the modern JavaScript module system, introduced with ECMAScript 2015 (ES6). It uses import to import modules and export to export them. ESM is asynchronous, allowing for more efficient loading and better support for features like tree shaking.

The error message you encountered specifically indicates that the require() function is trying to load an ES Module (index.js from @oozcitak/util), which is not supported. The message suggests using a dynamic import() instead, which is available in all CommonJS modules and can handle loading ES Modules.

Why Does This Error Occur in junit-report-merger v9.0.1?

The junit-report-merger is a tool commonly used in CI/CD pipelines to merge JUnit XML reports into a single report. The error arises because a dependency within junit-report-merger, specifically xmlbuilder2, is attempting to load an ES Module using require(). This often happens when a library updates its internal dependencies to use ESM, but the parent package hasn't been fully updated to handle these changes.

In version 9.0.1 of junit-report-merger, it's likely that a dependency like xmlbuilder2 has introduced ESM modules, leading to the ERR_REQUIRE_ESM error when the jrm command is executed. To resolve this, you need to address the way the ES Module is being loaded within the junit-report-merger package.

Step-by-Step Guide to Fixing ERR_REQUIRE_ESM

Resolving the ERR_REQUIRE_ESM error typically involves modifying how the module is loaded or updating the package to a version that correctly handles ES Modules. Here’s a step-by-step guide to help you fix the issue:

1. Identify the Problematic Module

The error message provides valuable information about the location of the issue. In this case, the error occurs in /usr/lib/node_modules/junit-report-merger/node_modules/xmlbuilder2/lib/builder/XMLBuilderImpl.js, where it attempts to require() index.js from @oozcitak/util. This tells us that the xmlbuilder2 package is the source of the problem.

2. Understanding Dynamic Imports

The error message suggests using a dynamic import(). Dynamic imports are a feature of ES Modules that allow you to import modules asynchronously. This is particularly useful in CommonJS modules, where synchronous require() calls cannot load ES Modules. Dynamic imports return a Promise, which resolves with the module's exports.

3. Implementing Dynamic Import

To implement a dynamic import, you need to modify the problematic file (/usr/lib/node_modules/junit-report-merger/node_modules/xmlbuilder2/lib/builder/XMLBuilderImpl.js) and replace the require() call with a dynamic import(). Here’s how you can do it:

Open the file in a text editor.

Locate the line that causes the error:

const util = require('@oozcitak/util/lib/index.js');

Replace it with a dynamic import:
```
let util;
import('@oozcitak/util/lib/index.js')
  .then(module => {
    util = module;
  })
  .catch(err => {
    console.error('Error importing @oozcitak/util:', err);
  });
```
This code snippet does the following:
- Declares a variable util to hold the imported module.
- Uses import('@oozcitak/util/lib/index.js') to asynchronously load the module.
- Uses .then() to handle the successful import and assign the module to util.
- Uses .catch() to handle any errors that occur during the import process.

4. Addressing Asynchronous Loading

Since dynamic imports are asynchronous, you need to ensure that any code that depends on the imported module waits for it to load. This might involve restructuring your code to use Promises or async/await.

For example, if you have a function that uses util, you can modify it to use async/await like this:

async function myFunc() {
  let util;
  try {
    const module = await import('@oozcitak/util/lib/index.js');
    util = module;
    // Use util here
  } catch (err) {
    console.error('Error importing @oozcitak/util:', err);
  }
}

5. Consider Package Updates

Before making manual changes to the node_modules directory, it's always a good idea to check if there are any updates available for junit-report-merger or its dependencies. Newer versions may have addressed the ERR_REQUIRE_ESM issue by correctly handling ES Modules.

You can update the package using npm or yarn:

npm update junit-report-merger
# or
yarn upgrade junit-report-merger

If an update isn't available or doesn't solve the problem, you can try updating the specific dependency (xmlbuilder2) that's causing the issue:

npm install xmlbuilder2@latest
# or
yarn add xmlbuilder2@latest

6. Using an ES Module Wrapper

Another approach is to create a wrapper around the ES Module that can be loaded using require(). This involves creating a new file that imports the ES Module and then exports it in a CommonJS-compatible format.

Create a new file, for example, util-wrapper.js, in the same directory as XMLBuilderImpl.js.

Add the following code to util-wrapper.js:

// util-wrapper.js
import util from '@oozcitak/util/lib/index.js';
module.exports = util;

In XMLBuilderImpl.js, replace the original require() call with:
```
const util = require('./util-wrapper.js');
```

7. Verify Package.json Configuration

Ensure that your package.json file is correctly configured to handle ES Modules. You can do this by adding `