feat: add support for ESM default export config and corresponding tests

Author: vladholubiev

readme.md

@@ -185,6 +185,10 @@ module.exports = {
 };
 ```
 
+## Node 22.12+ and ESM configs
+
+Node 22.12 turned on `require()` support for ESM by default. If your config is an `.mjs` file with a default export, `@shelf/jest-mongodb` now imports it automatically (and still supports CommonJS configs). If you prefer the old behavior, you can run Jest with `--no-experimental-require-module`.
+
 ## See Also
 
 - [jest-dynamodb](https://github.com/shelfio/jest-dynamodb)

src/helpers.ts

@@ -1,58 +1,114 @@
+import {spawnSync} from 'child_process';
 import {resolve} from 'path';
 import type {MongoMemoryReplSet, MongoMemoryServer} from 'mongodb-memory-server';
 import type {Config} from './types';
 
-const configFile = process.env.MONGO_MEMORY_SERVER_FILE || 'jest-mongodb-config.js';
-
 type MongoMemoryReplSetOpts = NonNullable<ConstructorParameters<typeof MongoMemoryReplSet>[0]>;
 type MongoMemoryServerOpts = NonNullable<ConstructorParameters<typeof MongoMemoryServer>[0]>;
 
 export function isMongoMemoryReplSetOptions(
   options?: MongoMemoryReplSetOpts | MongoMemoryServerOpts
 ): options is MongoMemoryReplSetOpts {
-  return Boolean((options as MongoMemoryReplSetOpts).replSet);
+  return Boolean((options as MongoMemoryReplSetOpts | undefined)?.replSet);
 }
 
-export function getMongodbMemoryOptions(
-  cwd: string
-): MongoMemoryReplSetOpts | MongoMemoryServerOpts | undefined {
+function getConfigFile() {
+  return process.env.MONGO_MEMORY_SERVER_FILE || 'jest-mongodb-config.js';
+}
+
+const configCache = new Map<string, Config | null>();
+
+function importConfig(configPath: string): Config | undefined {
   try {
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const {mongodbMemoryServerOptions}: Config = require(resolve(cwd, configFile));
+    // Node 22.12+ can let `require` load ESM by default. When Jest runs in CJS mode
+    // and the config is `.mjs`, spawn a one-off Node process to import it as ESM
+    // and return the plain JSON payload.
+    const {status, stdout} = spawnSync(
+      process.execPath,
+      [
+        '--input-type=module',
+        '--eval',
+        [
+          'import {pathToFileURL} from "node:url";',
+          `const mod = await import(pathToFileURL(${JSON.stringify(configPath)}).href);`,
+          'const payload = mod.default ?? mod;',
+          'console.log(JSON.stringify(payload));',
+        ].join('\n'),
+      ],
+      {encoding: 'utf8'}
+    );
 
-    return mongodbMemoryServerOptions;
+    if (status === 0 && stdout.trim()) {
+      return JSON.parse(stdout) as Config;
+    }
   } catch {
-    return {
-      binary: {
-        checkMD5: false,
-      },
-      instance: {},
-    };
+    // ignore and fall through to undefined
   }
+
+  return undefined;
 }
 
-export function getMongoURLEnvName(cwd: string) {
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const {mongoURLEnvName}: Config = require(resolve(cwd, configFile));
+function loadConfig(cwd?: string): Config | undefined {
+  const baseDir = cwd || process.cwd();
 
-    return mongoURLEnvName || 'MONGO_URL';
-  } catch {
-    return 'MONGO_URL';
+  if (configCache.has(baseDir)) {
+    return configCache.get(baseDir) ?? undefined;
   }
-}
 
-export function shouldUseSharedDBForAllJestWorkers(cwd: string) {
+  const configPath = resolve(baseDir, getConfigFile());
+
   try {
     // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const {useSharedDBForAllJestWorkers}: Config = require(resolve(cwd, configFile));
+    const loadedConfig = require(configPath) as Config | {default?: Config};
 
-    if (typeof useSharedDBForAllJestWorkers === 'undefined') {
-      return true;
+    if (loadedConfig && typeof (loadedConfig as {default?: Config}).default !== 'undefined') {
+      const config = (loadedConfig as {default?: Config}).default;
+      configCache.set(baseDir, config ?? null);
+
+      return config;
     }
 
-    return useSharedDBForAllJestWorkers;
+    const config = loadedConfig as Config;
+    configCache.set(baseDir, config ?? null);
+
+    return config;
   } catch {
+    const importedConfig = importConfig(configPath);
+    configCache.set(baseDir, importedConfig ?? null);
+
+    return importedConfig;
+  }
+}
+
+export function getMongodbMemoryOptions(
+  cwd?: string
+): MongoMemoryReplSetOpts | MongoMemoryServerOpts | undefined {
+  const config = loadConfig(cwd);
+
+  if (config?.mongodbMemoryServerOptions) {
+    return config.mongodbMemoryServerOptions;
+  }
+
+  return {
+    binary: {
+      checkMD5: false,
+    },
+    instance: {},
+  };
+}
+
+export function getMongoURLEnvName(cwd?: string) {
+  const config = loadConfig(cwd);
+
+  return config?.mongoURLEnvName || 'MONGO_URL';
+}
+
+export function shouldUseSharedDBForAllJestWorkers(cwd?: string) {
+  const config = loadConfig(cwd);
+
+  if (typeof config?.useSharedDBForAllJestWorkers === 'undefined') {
     return true;
   }
+
+  return config.useSharedDBForAllJestWorkers;
 }

test/helpers-esm-config.test.ts

@@ -0,0 +1,52 @@
+import {mkdtempSync, writeFileSync} from 'fs';
+import {tmpdir} from 'os';
+import {join} from 'path';
+import {
+  getMongoURLEnvName,
+  getMongodbMemoryOptions,
+  isMongoMemoryReplSetOptions,
+  shouldUseSharedDBForAllJestWorkers,
+} from '../src/helpers';
+
+describe('helpers with ESM default export config', () => {
+  const originalConfigFile = process.env.MONGO_MEMORY_SERVER_FILE;
+  const tempDir = mkdtempSync(join(tmpdir(), 'jest-mongodb-esm-config-'));
+  const configPath = join(tempDir, 'jest-mongodb-config.mjs');
+
+  beforeAll(() => {
+    writeFileSync(
+      configPath,
+      [
+        'export default {',
+        '  mongodbMemoryServerOptions: {replSet: {count: 1}},',
+        "  mongoURLEnvName: 'CUSTOM_URL',",
+        '  useSharedDBForAllJestWorkers: false,',
+        '};',
+        '',
+      ].join('\n')
+    );
+
+    process.env.MONGO_MEMORY_SERVER_FILE = configPath;
+  });
+
+  afterAll(() => {
+    if (typeof originalConfigFile === 'undefined') {
+      delete process.env.MONGO_MEMORY_SERVER_FILE;
+    } else {
+      process.env.MONGO_MEMORY_SERVER_FILE = originalConfigFile;
+    }
+  });
+
+  it('loads options from default export without throwing', () => {
+    const options = getMongodbMemoryOptions(tempDir);
+
+    expect(options).toEqual(expect.objectContaining({replSet: {count: 1}}));
+    expect(getMongoURLEnvName(tempDir)).toBe('CUSTOM_URL');
+    expect(shouldUseSharedDBForAllJestWorkers(tempDir)).toBe(false);
+    expect(isMongoMemoryReplSetOptions(options)).toBe(true);
+  });
+
+  it('treats missing options as non-replSet', () => {
+    expect(isMongoMemoryReplSetOptions(undefined)).toBe(false);
+  });
+});