fix(config): make config.get() work from tests/page objects under tsx/cjs (#5635)

The internal API `config` imported via `import { config } from "codeceptjs"`
returned an empty object `{}` from tests, page objects and fragments, while it
worked from helpers.

Test files are loaded through Mocha's synchronous require() (the CommonJS realm)
under a CJS loader such as tsx/cjs, while the framework runs as native ESM. So a
test importing `config` gets a second, disconnected CJS copy of config.js whose
module-scoped `config` is an empty `{}` that the runner never populates. Helpers
don't hit this because they are loaded via import() (the ESM realm) and share the
live singleton.

Bridge the live config through globalThis, the same way recorder.js and
container.js were fixed in #5634: setConfig() mirrors the config onto
globalThis.__codeceptjs_config on every create/append/reset, and Config.get()
prefers it, falling back to the local module copy. Under pure ESM both point at
the same object, so there is no behavior change on the ESM path.

Adds a runner regression test driving a real tsx/cjs project that asserts a test
(CJS realm) and a helper (ESM realm) both read the live config. It fails without
the fix and passes with it.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: mirao

lib/config.js

@@ -37,6 +37,20 @@ const defaultConfig = {
 let hooks = []
 let config = {}
 
+// Expose the live config object globally so a duplicate copy of the framework
+// (loaded as CommonJS when a test, page object or fragment does
+// `import { config } from 'codeceptjs'` through a CJS loader such as tsx/cjs)
+// reads the same config the runner actually loaded. Test files are loaded via
+// Mocha's synchronous require() (CJS realm) while the framework runs as ESM, so
+// the CJS copy would otherwise see its own empty module-scoped `config = {}`.
+// Helpers don't hit this because they're loaded via import() (the ESM realm).
+// Mirrors the globalThis bridges in recorder.js and container.js.
+function setConfig(value) {
+  config = value
+  if (typeof globalThis !== 'undefined') globalThis.__codeceptjs_config = config
+  return config
+}
+
 // Apply a single hook against `cfg`, swallowing errors so one broken hook
 // can't take down the whole run. The failure is logged through the
 // framework's own output module (when available) so it shows up in test
@@ -67,7 +81,7 @@ class Config {
    * @return {Object<string, *>}
    */
   static create(newConfig) {
-    config = deepMerge(deepClone(defaultConfig), newConfig)
+    setConfig(deepMerge(deepClone(defaultConfig), newConfig))
     // Re-apply every hook against the freshly built config; hooks added later
     // (e.g. from plugin boot) stay pending until runPendingHooks. Array
     // iterators re-check length on each step, so hooks pushed during a hook
@@ -137,10 +151,11 @@ class Config {
    * @return {*}
    */
   static get(key, val) {
+    const cfg = (typeof globalThis !== 'undefined' && globalThis.__codeceptjs_config) || config
     if (key) {
-      return config[key] || val
+      return cfg[key] || val
     }
-    return config
+    return cfg
   }
 
   static addHook(fn) {
@@ -195,7 +210,7 @@ class Config {
    * @return {Object<string, *>}
    */
   static append(additionalConfig) {
-    return (config = deepMerge(config, additionalConfig))
+    return setConfig(deepMerge(config, additionalConfig))
   }
 
   /**
@@ -204,7 +219,7 @@ class Config {
    */
   static reset() {
     hooks = []
-    return (config = { ...defaultConfig })
+    return setConfig({ ...defaultConfig })
   }
 }
 

test/data/config-tsx-cjs/codecept.conf.ts

@@ -0,0 +1,12 @@
+export const config: CodeceptJS.MainConfig = {
+  tests: "./*_test.ts",
+  output: "./output",
+  helpers: {
+    ConfigHelper: {
+      require: "./config_helper.js",
+      marker: "config-marker-123"
+    }
+  },
+  name: "config-tsx-cjs-test",
+  require: ["tsx/cjs"]
+};

test/data/config-tsx-cjs/config_helper.js

@@ -0,0 +1,14 @@
+import HelperModule from '../../../lib/helper.js'
+import ConfigModule from '../../../lib/config.js'
+
+const Helper = HelperModule.default || HelperModule
+const Config = ConfigModule.default || ConfigModule
+
+class ConfigHelper extends Helper {
+  reportConfig() {
+    // Helper is loaded via import() (ESM realm), so it has always shared the live config.
+    console.log(`CONFIG_FROM_HELPER marker=${Config.get().helpers.ConfigHelper.marker}`)
+  }
+}
+
+export default ConfigHelper

test/data/config-tsx-cjs/config_test.ts

@@ -0,0 +1,18 @@
+// Regression test for https://github.com/codeceptjs/CodeceptJS/issues/5635
+// Importing the internal API (config) through a CommonJS loader (tsx/cjs) used to load
+// a second, disconnected copy of config.js whose module-scoped `config` was an empty
+// object, so `config.get()` returned {} from tests/page objects/fragments while helpers
+// (loaded via import(), the ESM realm) saw the real config. The relative path is loaded
+// as CJS here while the runner loads the same module as ESM, reproducing the split that
+// the globalThis bridge fixes.
+import ConfigModule from "../../../lib/config.js";
+
+const Config = (ConfigModule as any).default || ConfigModule;
+
+Feature("config under tsx/cjs");
+
+Scenario("config.get() reads the live config from a test", ({ I }) => {
+  console.log(`CONFIG_FROM_TEST name=${Config.get("name")}`);
+  console.log(`CONFIG_FROM_TEST marker=${Config.get().helpers.ConfigHelper.marker}`);
+  I.reportConfig();
+});

test/data/config-tsx-cjs/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "config-tsx-cjs",
+  "version": "1.0.0",
+  "type": "module",
+  "devDependencies": {
+    "tsx": "^4.20.6"
+  }
+}

test/data/config-tsx-cjs/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "es2022",
+    "lib": ["es2022", "DOM"],
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "node",
+    "strictNullChecks": false,
+    "types": ["codeceptjs", "node"],
+    "declaration": true,
+    "skipLibCheck": true
+  },
+  "exclude": ["node_modules"]
+}

test/runner/config_tsx_test.js

@@ -0,0 +1,33 @@
+import * as chai from 'chai'
+chai.should()
+import path from 'path'
+import { exec } from 'child_process'
+import { fileURLToPath } from 'url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+const runner = path.join(__dirname, '/../../bin/codecept.js')
+const codecept_dir = path.join(__dirname, '/../data/config-tsx-cjs')
+const codecept_run = `${runner} run --config ${codecept_dir}/codecept.conf.ts`
+
+// Regression test for https://github.com/codeceptjs/CodeceptJS/issues/5635
+// When the internal API (config) is imported through a CommonJS loader (tsx/cjs) a second,
+// disconnected copy of config.js was loaded, so config.get() returned {} from tests/page
+// objects while helpers (loaded via import()) saw the real config.
+describe('CodeceptJS config under tsx/cjs', function () {
+  this.timeout(40000)
+
+  it('config.get() reads the live config from a test imported via tsx/cjs', done => {
+    exec(`${codecept_run}`, { timeout: 30000 }, (err, stdout) => {
+      stdout.should.include('1 passed')
+      // the test (CJS realm) reads the real config the runner loaded, not an empty {}
+      stdout.should.include('CONFIG_FROM_TEST name=config-tsx-cjs-test')
+      stdout.should.include('CONFIG_FROM_TEST marker=config-marker-123')
+      // the helper (ESM realm) reads the same live config
+      stdout.should.include('CONFIG_FROM_HELPER marker=config-marker-123')
+      chai.expect(err).to.be.null
+      done()
+    })
+  })
+})