fix: simplify async helper loading and fix container tests

- Simplified async helper loading by properly awaiting requireHelperFromModule
- Removed redundant Promise checking and async chain handling
- Fixed container tests to properly await Container.create()
- Reduced test failures from 4 to 2 (remaining 2 are pre-existing)
- All _init calls now happen in a single loop after helpers are loaded

Test results: 482 passed, 2 failed (pre-existing), 16 skipped

Author: kobenguyent

lib/container.js

@@ -31,7 +31,7 @@ async function ensureTsxLoader() {
     const { createRequire } = await import('module')
     const { pathToFileURL } = await import('url')
     const userRequire = createRequire(pathToFileURL(path.join(global.codecept_dir || process.cwd(), 'package.json')).href)
-    
+
     // Try to resolve tsx from user's project
     try {
       userRequire.resolve('tsx')
@@ -77,7 +77,7 @@ let container = {
   translation: {},
   /** @type {Result | null} */
   result: null,
-  sharedKeys: new Set() // Track keys shared via share() function
+  sharedKeys: new Set(), // Track keys shared via share() function
 }
 
 /**
@@ -295,10 +295,10 @@ class Container {
     // Instead of using append which replaces the entire container,
     // directly update the support object to maintain proxy references
     Object.assign(container.support, data)
-    
+
     // Track which keys were explicitly shared
     Object.keys(data).forEach(key => container.sharedKeys.add(key))
-    
+
     if (!options.local) {
       WorkerStorage.share(data)
     }
@@ -335,33 +335,13 @@ async function createHelpers(config) {
 
       // classical require - may be async for ESM modules
       if (!HelperClass) {
-        const helperResult = requireHelperFromModule(helperName, config)
-        if (helperResult instanceof Promise) {
-          // Handle async ESM loading
-          helpers[helperName] = {}
-          asyncHelperPromise = asyncHelperPromise
-            .then(() => helperResult)
-            .then(async ResolvedHelperClass => {
-              debug(`helper ${helperName} resolved type: ${typeof ResolvedHelperClass}`, ResolvedHelperClass)
-
-              // Extract default export from ESM module wrapper if needed
-              if (ResolvedHelperClass && ResolvedHelperClass.__esModule && ResolvedHelperClass.default) {
-                ResolvedHelperClass = ResolvedHelperClass.default
-                debug(`extracted default export for ${helperName}, new type: ${typeof ResolvedHelperClass}`)
-              }
+        // requireHelperFromModule is async, so we need to await it
+        HelperClass = await requireHelperFromModule(helperName, config)
 
-              if (typeof ResolvedHelperClass !== 'function') {
-                throw new Error(`Helper '${helperName}' is not a class. Got: ${typeof ResolvedHelperClass}`)
-              }
-
-              checkHelperRequirements(ResolvedHelperClass)
-              helpers[helperName] = new ResolvedHelperClass(config[helperName])
-              if (helpers[helperName]._init) await helpers[helperName]._init()
-              debug(`helper ${helperName} async initialized`)
-            })
-          continue
-        } else {
-          HelperClass = helperResult
+        // Extract default export from ESM module wrapper if needed
+        if (HelperClass && HelperClass.__esModule && HelperClass.default) {
+          HelperClass = HelperClass.default
+          debug(`extracted default export for ${helperName}`)
         }
       }
 
@@ -396,7 +376,7 @@ async function createHelpers(config) {
 
   // Wait for all async helpers to be resolved before calling _init
   await asyncHelperPromise
-  
+
   for (const name in helpers) {
     if (helpers[name]._init) await helpers[name]._init()
   }
@@ -441,81 +421,83 @@ async function requireHelperFromModule(helperName, config, HelperClass) {
       HelperClass = mod.default || mod
     } catch (err) {
       if (err.code === 'ERR_UNKNOWN_FILE_EXTENSION' || (err.message && err.message.includes('Unknown file extension'))) {
-          // This is likely a TypeScript helper file. Transpile it to a temporary JS file
-          // and import that as a reliable fallback (no NODE_OPTIONS required).
-          try {
-            const pathModule = await import('path')
-            const absolutePath = pathModule.default.resolve(moduleName)
+        // This is likely a TypeScript helper file. Transpile it to a temporary JS file
+        // and import that as a reliable fallback (no NODE_OPTIONS required).
+        try {
+          const pathModule = await import('path')
+          const absolutePath = pathModule.default.resolve(moduleName)
 
-            // Attempt to load local 'typescript' to transpile the helper
-            let typescript
-            try {
-              typescript = await import('typescript')
-            } catch (tsImportErr) {
-              throw new Error(`TypeScript helper detected (${moduleName}). Please install 'typescript' in your project: npm install --save-dev typescript`)
-            }
+          // Attempt to load local 'typescript' to transpile the helper
+          let typescript
+          try {
+            typescript = await import('typescript')
+          } catch (tsImportErr) {
+            throw new Error(`TypeScript helper detected (${moduleName}). Please install 'typescript' in your project: npm install --save-dev typescript`)
+          }
 
-            const { tempFile, allTempFiles } = await transpileTypeScript(absolutePath, typescript)
-            debug(`Transpiled TypeScript helper: ${moduleName} -> ${tempFile}`)
+          const { tempFile, allTempFiles } = await transpileTypeScript(absolutePath, typescript)
+          debug(`Transpiled TypeScript helper: ${moduleName} -> ${tempFile}`)
 
+          try {
             try {
-              try {
-                const mod = await import(tempFile)
-                HelperClass = mod.default || mod
-                debug(`helper ${helperName} loaded from transpiled JS: ${tempFile}`)
-              } catch (importTempErr) {
-                // If import fails due to CommonJS named export incompatibility,
-                // try a quick transform: convert named imports from CommonJS packages
-                // into default import + destructuring. This resolves cases like
-                // "Named export 'Helper' not found. The requested module '@codeceptjs/helper' is a CommonJS module"
-                const msg = importTempErr && importTempErr.message || ''
-                const commonJsMatch = msg.match(/The requested module '(.+?)' is a CommonJS module/)
-                if (commonJsMatch) {
-                  // Read the transpiled file, perform heuristic replacement, and import again
-                  const fs = await import('fs')
-                  let content = fs.readFileSync(tempFile, 'utf8')
-                  // Heuristic: replace "import { X, Y } from 'mod'" with default import + destructure
-                  content = content.replace(/import\s+\{([^}]+)\}\s+from\s+(['"])([^'"\)]+)\2/gm, (m, names, q, modName) => {
-                    // Only adjust imports for the module reported in the error or for local modules
-                    if (modName === commonJsMatch[1] || modName.startsWith('.') || !modName.includes('/')) {
-                      const cleanedNames = names.trim()
-                      return `import pkg__interop from ${q}${modName}${q};\nconst { ${cleanedNames} } = pkg__interop`
-                    }
-                    return m
-                  })
-
-                  // Write to a secondary temp file
-                  const os = await import('os')
-                  const path = await import('path')
-                  const fallbackTemp = path.default.join(os.default.tmpdir(), `helper-fallback-${Date.now()}.mjs`)
-                  fs.writeFileSync(fallbackTemp, content, 'utf8')
-                  try {
-                    const mod = await import(fallbackTemp)
-                    HelperClass = mod.default || mod
-                    debug(`helper ${helperName} loaded from transpiled JS after CommonJS interop fix: ${fallbackTemp}`)
-                  } finally {
-                    try { fs.unlinkSync(fallbackTemp) } catch (e) {}
+              const mod = await import(tempFile)
+              HelperClass = mod.default || mod
+              debug(`helper ${helperName} loaded from transpiled JS: ${tempFile}`)
+            } catch (importTempErr) {
+              // If import fails due to CommonJS named export incompatibility,
+              // try a quick transform: convert named imports from CommonJS packages
+              // into default import + destructuring. This resolves cases like
+              // "Named export 'Helper' not found. The requested module '@codeceptjs/helper' is a CommonJS module"
+              const msg = (importTempErr && importTempErr.message) || ''
+              const commonJsMatch = msg.match(/The requested module '(.+?)' is a CommonJS module/)
+              if (commonJsMatch) {
+                // Read the transpiled file, perform heuristic replacement, and import again
+                const fs = await import('fs')
+                let content = fs.readFileSync(tempFile, 'utf8')
+                // Heuristic: replace "import { X, Y } from 'mod'" with default import + destructure
+                content = content.replace(/import\s+\{([^}]+)\}\s+from\s+(['"])([^'"\)]+)\2/gm, (m, names, q, modName) => {
+                  // Only adjust imports for the module reported in the error or for local modules
+                  if (modName === commonJsMatch[1] || modName.startsWith('.') || !modName.includes('/')) {
+                    const cleanedNames = names.trim()
+                    return `import pkg__interop from ${q}${modName}${q};\nconst { ${cleanedNames} } = pkg__interop`
                   }
-                } else {
-                  throw importTempErr
+                  return m
+                })
+
+                // Write to a secondary temp file
+                const os = await import('os')
+                const path = await import('path')
+                const fallbackTemp = path.default.join(os.default.tmpdir(), `helper-fallback-${Date.now()}.mjs`)
+                fs.writeFileSync(fallbackTemp, content, 'utf8')
+                try {
+                  const mod = await import(fallbackTemp)
+                  HelperClass = mod.default || mod
+                  debug(`helper ${helperName} loaded from transpiled JS after CommonJS interop fix: ${fallbackTemp}`)
+                } finally {
+                  try {
+                    fs.unlinkSync(fallbackTemp)
+                  } catch (e) {}
                 }
+              } else {
+                throw importTempErr
               }
-            } finally {
-              // Cleanup transpiled temporary files
-              const filesToClean = Array.isArray(allTempFiles) ? allTempFiles : [allTempFiles]
-              cleanupTempFiles(filesToClean)
             }
-          } catch (importErr) {
-            throw new Error(
-              `Helper '${helperName}' is a TypeScript file but could not be loaded.\n` +
+          } finally {
+            // Cleanup transpiled temporary files
+            const filesToClean = Array.isArray(allTempFiles) ? allTempFiles : [allTempFiles]
+            cleanupTempFiles(filesToClean)
+          }
+        } catch (importErr) {
+          throw new Error(
+            `Helper '${helperName}' is a TypeScript file but could not be loaded.\n` +
               `Path: ${moduleName}\n` +
               `Error: ${importErr.message}\n\n` +
               `To load TypeScript helpers, install 'typescript' in your project or use an ESM loader (e.g. tsx):\n` +
               `  npm install --save-dev typescript\n` +
               `  OR run CodeceptJS with an ESM loader: NODE_OPTIONS='--import tsx' npx codeceptjs run\n\n` +
-              `CodeceptJS will transpile TypeScript helpers automatically at runtime if 'typescript' is available.`
-            )
-          }
+              `CodeceptJS will transpile TypeScript helpers automatically at runtime if 'typescript' is available.`,
+          )
+        }
       } else if (err.code === 'ERR_REQUIRE_ESM' || (err.message && err.message.includes('ES module'))) {
         // This is an ESM module, use dynamic import
         try {
@@ -801,24 +783,23 @@ async function loadSupportObject(modulePath, supportObjectName) {
     // Use dynamic import for both ESM and CJS modules
     let importPath = modulePath
     let tempJsFile = null
-    
+
     if (typeof importPath === 'string') {
       const ext = path.extname(importPath)
-      
+
       // Handle TypeScript files
       if (ext === '.ts') {
         try {
           // Use the TypeScript transpilation utility
           const typescript = await import('typescript')
           const { tempFile, allTempFiles } = await transpileTypeScript(importPath, typescript)
-          
+
           debug(`Transpiled TypeScript file: ${importPath} -> ${tempFile}`)
-          
+
           // Attach cleanup handler
           importPath = tempFile
           // Store temp files list in a way that cleanup can access them
           tempJsFile = allTempFiles
-          
         } catch (tsError) {
           throw new Error(`Failed to load TypeScript file ${importPath}: ${tsError.message}. Make sure 'typescript' package is installed.`)
         }
@@ -827,7 +808,7 @@ async function loadSupportObject(modulePath, supportObjectName) {
         importPath = `${importPath}.js`
       }
     }
-    
+
     let obj
     try {
       obj = await import(importPath)

test/unit/container_test.js

@@ -161,7 +161,7 @@ describe('Container', () => {
           FileSystem: {},
         },
       }
-      container.create(config)
+      await container.create(config)
       await container.started()
       // custom helpers
       expect(container.helpers('MyHelper')).is.ok
@@ -266,7 +266,7 @@ describe('Container', () => {
           FileSystem: {},
         },
       }
-      container.create(config)
+      await container.create(config)
       await container.started()
       container.append({
         helpers: {
@@ -294,10 +294,10 @@ describe('Container', () => {
       const tsStepsPath = path.join(__dirname, '../data/typescript-support/steps_file.ts')
       await container.create({
         include: {
-          I: tsStepsPath
-        }
+          I: tsStepsPath,
+        },
       })
-      
+
       const I = container.support('I')
       expect(I).to.be.ok
       expect(I.testMethod).to.be.a('function')
@@ -309,10 +309,10 @@ describe('Container', () => {
       const tsStepsPath = path.join(__dirname, '../data/typescript-support/steps_file.ts')
       await container.create({
         include: {
-          I: tsStepsPath
-        }
+          I: tsStepsPath,
+        },
       })
-      
+
       const I = container.support('I')
       // Note: These are proxied through MetaStep, so we can't call them directly in tests
       // The test verifies that the file loads and the structure is correct
@@ -325,10 +325,10 @@ describe('Container', () => {
       const tsStepsPath = path.join(__dirname, '../data/typescript-support/steps_with_dirname.ts')
       await container.create({
         include: {
-          I: tsStepsPath
-        }
+          I: tsStepsPath,
+        },
       })
-      
+
       const I = container.support('I')
       expect(I).to.be.ok
       expect(I.getConfigPath).to.be.a('function')
@@ -340,10 +340,10 @@ describe('Container', () => {
       const tsStepsPath = path.join(__dirname, '../data/typescript-support/steps_with_require.ts')
       await container.create({
         include: {
-          I: tsStepsPath
-        }
+          I: tsStepsPath,
+        },
       })
-      
+
       const I = container.support('I')
       expect(I).to.be.ok
       expect(I.getPluginPath).to.be.a('function')