codeceptjs 4.0.0-beta.20 → 4.0.0-beta.22

package/lib/actor.js

@@ -7,6 +7,8 @@ import event from './event.js'
 import store from './store.js'
 import output from './output.js'
 import Container from './container.js'
+import debugModule from 'debug'
+const debug = debugModule('codeceptjs:actor')
 
 /**
  * @interface

package/lib/container.js

@@ -17,6 +17,51 @@ import ai from './ai.js'
 import actorFactory from './actor.js'
 
 let asyncHelperPromise
+let tsxLoaderRegistered = false
+
+/**
+ * Automatically register tsx ESM loader for TypeScript imports
+ * This allows loading .ts files without NODE_OPTIONS
+ */
+async function ensureTsxLoader() {
+  if (tsxLoaderRegistered) return true
+
+  try {
+    // Check if tsx is available
+    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')
+    } catch {
+      debug('tsx not found in user project')
+      return false
+    }
+
+    // Register tsx/esm loader dynamically
+    // Use Node.js register() API from node:module (Node 18.19+, 20.6+)
+    try {
+      const { register } = await import('node:module')
+      if (typeof register === 'function') {
+        debug('Registering tsx ESM loader via node:module register()')
+        const tsxPath = userRequire.resolve('tsx/esm')
+        register(tsxPath, import.meta.url)
+        tsxLoaderRegistered = true
+        return true
+      }
+    } catch (registerErr) {
+      debug('node:module register() not available:', registerErr.message)
+    }
+
+    debug('module.register not available, tsx loader must be set via NODE_OPTIONS')
+    return false
+  } catch (err) {
+    debug('Failed to register tsx loader:', err.message)
+    return false
+  }
+}
 
 let container = {
   helpers: {},
@@ -32,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
 }
 
 /**
@@ -250,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)
     }
@@ -288,39 +333,30 @@ async function createHelpers(config) {
         helperName = HelperClass.constructor.name
       }
 
-      // 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}`)
-              }
-
-              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`)
-            })
+      // Check for inline helper object (plain object with callable methods, no require field)
+      // Inline helpers have methods defined directly on them, unlike config objects
+      if (!HelperClass && !config[helperName].require && typeof config[helperName] === 'object') {
+        // Check if this object has any callable methods (indicates it's an inline helper)
+        const hasMethods = Object.values(config[helperName]).some(val => typeof val === 'function')
+        if (hasMethods) {
+          // This is an inline helper object, use it directly
+          helpers[helperName] = config[helperName]
+          debug(`helper ${helperName} loaded as inline object`)
           continue
-        } else {
-          HelperClass = helperResult
         }
       }
 
-      // handle async CJS modules that use dynamic import
+      // classical require - may be async for ESM modules
+      if (!HelperClass) {
+        // requireHelperFromModule is async, so we need to await it
+        HelperClass = await requireHelperFromModule(helperName, config)
+
+        // Extract default export from ESM module wrapper if needed
+        if (HelperClass && HelperClass.__esModule && HelperClass.default) {
+          HelperClass = HelperClass.default
+          debug(`extracted default export for ${helperName}`)
+        }
+      } // handle async CJS modules that use dynamic import
       if (isAsyncFunction(HelperClass)) {
         helpers[helperName] = {}
 
@@ -349,6 +385,9 @@ 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()
   }
@@ -392,7 +431,85 @@ async function requireHelperFromModule(helperName, config, HelperClass) {
       }
       HelperClass = mod.default || mod
     } catch (err) {
-      if (err.code === 'ERR_REQUIRE_ESM' || (err.message && err.message.includes('ES module'))) {
+      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)
+
+          // 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}`)
+
+          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) {}
+                }
+              } 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` +
+              `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.`,
+          )
+        }
+      } else if (err.code === 'ERR_REQUIRE_ESM' || (err.message && err.message.includes('ES module'))) {
         // This is an ESM module, use dynamic import
         try {
           const pathModule = await import('path')
@@ -677,24 +794,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.`)
         }
@@ -703,7 +819,7 @@ async function loadSupportObject(modulePath, supportObjectName) {
         importPath = `${importPath}.js`
       }
     }
-    
+
     let obj
     try {
       obj = await import(importPath)

package/lib/parser.js

@@ -17,7 +17,18 @@ export const getParamsToString = function (fn) {
 function getParams(fn) {
   if (fn.isSinonProxy) return []
   try {
-    const reflected = parser.parse(fn)
+    // Convert arrow functions to regular functions for parsing
+    let fnString = fn.toString()
+    // Handle async arrow functions: async (...) => expr becomes async function(...) { return expr }
+    // Handle async arrow functions: async (...) => { ... } becomes async function(...) { ... }
+    fnString = fnString.replace(/^async\s*(\([^)]*\))\s*=>\s*\{/, 'async function$1 {')
+    fnString = fnString.replace(/^async\s*(\([^)]*\))\s*=>\s*(.+)$/, 'async function$1 { return $2 }')
+    // Handle regular arrow functions: (...) => expr becomes function(...) { return expr }
+    // Handle regular arrow functions: (...) => { ... } becomes function(...) { ... }
+    fnString = fnString.replace(/^(\([^)]*\))\s*=>\s*\{/, 'function$1 {')
+    fnString = fnString.replace(/^(\([^)]*\))\s*=>\s*(.+)$/, 'function$1 { return $2 }')
+
+    const reflected = parser.parse(fnString)
     if (reflected.args.length > 1 || reflected.args[0] === 'I') {
       output.error('Error: old CodeceptJS v2 format detected. Upgrade your project to the new format -> https://bit.ly/codecept3Up')
     }

package/lib/utils/typescript.js

@@ -4,7 +4,7 @@ import path from 'path'
 /**
  * Transpile TypeScript files to ES modules with CommonJS shim support
  * Handles recursive transpilation of imported TypeScript files
- * 
+ *
  * @param {string} mainFilePath - Path to the main TypeScript file to transpile
  * @param {object} typescript - TypeScript compiler instance
  * @returns {Promise<{tempFile: string, allTempFiles: string[]}>} - Main temp file and all temp files created
@@ -16,9 +16,9 @@ export async function transpileTypeScript(mainFilePath, typescript) {
    * Transpile a single TypeScript file to JavaScript
    * Injects CommonJS shims (require, module, exports, __dirname, __filename) as needed
    */
-  const transpileTS = (filePath) => {
+  const transpileTS = filePath => {
     const tsContent = fs.readFileSync(filePath, 'utf8')
-    
+
     // Transpile TypeScript to JavaScript with ES module output
     let jsContent = transpile(tsContent, {
       module: 99, // ModuleKind.ESNext
@@ -29,16 +29,16 @@ export async function transpileTypeScript(mainFilePath, typescript) {
       suppressOutputPathCheck: true,
       skipLibCheck: true,
     })
-    
+
     // Check if the code uses CommonJS globals
     const usesCommonJSGlobals = /__dirname|__filename/.test(jsContent)
     const usesRequire = /\brequire\s*\(/.test(jsContent)
     const usesModuleExports = /\b(module\.exports|exports\.)/.test(jsContent)
-    
+
     if (usesCommonJSGlobals || usesRequire || usesModuleExports) {
       // Inject ESM equivalents at the top of the file
       let esmGlobals = ''
-      
+
       if (usesRequire || usesModuleExports) {
         // IMPORTANT: Use the original .ts file path as the base for require()
         // This ensures dynamic require() calls work with relative paths from the original file location
@@ -81,7 +81,7 @@ const exports = module.exports;
 
 `
       }
-      
+
       if (usesCommonJSGlobals) {
         // For __dirname and __filename, also use the original file path
         const originalFileUrl = `file://${filePath.replace(/\\/g, '/')}`
@@ -92,48 +92,49 @@ const __dirname = __dirname_fn(__filename);
 
 `
       }
-      
+
       jsContent = esmGlobals + jsContent
-      
+
       // If module.exports is used, we need to export it as default
       if (usesModuleExports) {
         jsContent += `\nexport default module.exports;\n`
       }
     }
-    
+
     return jsContent
   }
-  
+
   // Create a map to track transpiled files
   const transpiledFiles = new Map()
   const baseDir = path.dirname(mainFilePath)
-  
+
   // Recursive function to transpile a file and all its TypeScript dependencies
-  const transpileFileAndDeps = (filePath) => {
+  const transpileFileAndDeps = filePath => {
     // Already transpiled, skip
     if (transpiledFiles.has(filePath)) {
       return
     }
-    
+
     // Transpile this file
     let jsContent = transpileTS(filePath)
-    
+
     // Find all relative TypeScript imports in this file
-    const importRegex = /from\s+['"](\..+?)(?:\.ts)?['"]/g
+    // Match imports that start with ./ or ../
+    const importRegex = /from\s+['"](\.\.?\/[^'"]+?)(?:\.ts)?['"]/g
     let match
     const imports = []
-    
+
     while ((match = importRegex.exec(jsContent)) !== null) {
       imports.push(match[1])
     }
-    
+
     // Get the base directory for this file
     const fileBaseDir = path.dirname(filePath)
-    
+
     // Recursively transpile each imported TypeScript file
     for (const relativeImport of imports) {
       let importedPath = path.resolve(fileBaseDir, relativeImport)
-      
+
       // Handle .js extensions that might actually be .ts files
       if (importedPath.endsWith('.js')) {
         const tsVersion = importedPath.replace(/\.js$/, '.ts')
@@ -141,7 +142,7 @@ const __dirname = __dirname_fn(__filename);
           importedPath = tsVersion
         }
       }
-      
+
       // Try adding .ts extension if file doesn't exist and no extension provided
       if (!path.extname(importedPath)) {
         const tsPath = importedPath + '.ts'
@@ -155,68 +156,76 @@ const __dirname = __dirname_fn(__filename);
             continue
           }
         }
+      } else if (importedPath.match(/\.[^./\\]+$/)) {
+        // Has an extension that's not .ts - check if .ts version exists by appending .ts
+        const tsPath = importedPath + '.ts'
+        if (fs.existsSync(tsPath)) {
+          importedPath = tsPath
+        }
       }
-      
+
       // If it's a TypeScript file, recursively transpile it and its dependencies
       if (importedPath.endsWith('.ts') && fs.existsSync(importedPath)) {
         transpileFileAndDeps(importedPath)
       }
     }
-    
+
     // After all dependencies are transpiled, rewrite imports in this file
-    jsContent = jsContent.replace(
-      /from\s+['"](\..+?)(?:\.ts)?['"]/g,
-      (match, importPath) => {
-        let resolvedPath = path.resolve(fileBaseDir, importPath)
-        
-        // Handle .js extension that might be .ts
-        if (resolvedPath.endsWith('.js')) {
-          const tsVersion = resolvedPath.replace(/\.js$/, '.ts')
-          if (transpiledFiles.has(tsVersion)) {
-            const tempFile = transpiledFiles.get(tsVersion)
-            const relPath = path.relative(fileBaseDir, tempFile).replace(/\\/g, '/')
-            // Ensure the path starts with ./
-            if (!relPath.startsWith('.')) {
-              return `from './${relPath}'`
-            }
-            return `from '${relPath}'`
-          }
-        }
-        
-        // Try with .ts extension
-        const tsPath = resolvedPath.endsWith('.ts') ? resolvedPath : resolvedPath + '.ts'
-        
-        // If we transpiled this file, use the temp file
-        if (transpiledFiles.has(tsPath)) {
-          const tempFile = transpiledFiles.get(tsPath)
-          const relPath = path.relative(fileBaseDir, tempFile).replace(/\\/g, '/')
+    // IMPORTANT: We need to calculate temp file location first so we can compute correct relative paths
+    const tempFile = filePath.replace(/\.ts$/, '.temp.mjs')
+    const tempFileDir = path.dirname(tempFile)
+
+    jsContent = jsContent.replace(/from\s+['"](\.\.?\/[^'"]+?)(?:\.ts)?['"]/g, (match, importPath) => {
+      let resolvedPath = path.resolve(fileBaseDir, importPath)
+
+      // Handle .js extension that might be .ts
+      if (resolvedPath.endsWith('.js')) {
+        const tsVersion = resolvedPath.replace(/\.js$/, '.ts')
+        if (transpiledFiles.has(tsVersion)) {
+          const importedTempFile = transpiledFiles.get(tsVersion)
+          // Calculate relative path from THIS temp file to the imported temp file
+          const relPath = path.relative(tempFileDir, importedTempFile).replace(/\\/g, '/')
           // Ensure the path starts with ./
           if (!relPath.startsWith('.')) {
             return `from './${relPath}'`
           }
           return `from '${relPath}'`
         }
-        
-        // Otherwise, keep the import as-is
-        return match
       }
-    )
-    
+
+      // Try with .ts extension
+      const tsPath = resolvedPath.endsWith('.ts') ? resolvedPath : resolvedPath + '.ts'
+
+      // If we transpiled this file, use the temp file
+      if (transpiledFiles.has(tsPath)) {
+        const importedTempFile = transpiledFiles.get(tsPath)
+        // Calculate relative path from THIS temp file to the imported temp file
+        const relPath = path.relative(tempFileDir, importedTempFile).replace(/\\/g, '/')
+        // Ensure the path starts with ./
+        if (!relPath.startsWith('.')) {
+          return `from './${relPath}'`
+        }
+        return `from '${relPath}'`
+      }
+
+      // Otherwise, keep the import as-is (for npm packages)
+      return match
+    })
+
     // Write the transpiled file with updated imports
-    const tempFile = filePath.replace(/\.ts$/, '.temp.mjs')
     fs.writeFileSync(tempFile, jsContent)
     transpiledFiles.set(filePath, tempFile)
   }
-  
+
   // Start recursive transpilation from the main file
   transpileFileAndDeps(mainFilePath)
-  
+
   // Get the main transpiled file
   const tempJsFile = transpiledFiles.get(mainFilePath)
-  
+
   // Store all temp files for cleanup
   const allTempFiles = Array.from(transpiledFiles.values())
-  
+
   return { tempFile: tempJsFile, allTempFiles }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeceptjs",
-  "version": "4.0.0-beta.20",
+  "version": "4.0.0-beta.22",
   "type": "module",
   "description": "Supercharged End 2 End Testing Framework for NodeJS",
   "keywords": [