codeceptjs 4.0.0-beta.15 → 4.0.0-beta.17

package/lib/utils/typescript.js

@@ -41,7 +41,37 @@ export async function transpileTypeScript(mainFilePath, typescript) {
         // This ensures dynamic require() calls work with relative paths from the original file location
         const originalFileUrl = `file://${filePath.replace(/\\/g, '/')}`
         esmGlobals += `import { createRequire } from 'module';
-const require = createRequire('${originalFileUrl}');
+import { extname as __extname } from 'path';
+const __baseRequire = createRequire('${originalFileUrl}');
+
+// Wrap require to auto-resolve extensions (mimics CommonJS behavior)
+const require = (id) => {
+  try {
+    return __baseRequire(id);
+  } catch (err) {
+    // If module not found and it's a relative/absolute path without extension, try common extensions
+    if (err.code === 'MODULE_NOT_FOUND' && (id.startsWith('./') || id.startsWith('../') || id.startsWith('/'))) {
+      const ext = __extname(id);
+      // Only treat known file extensions as real extensions (so names like .TEST don't block probing)
+      const __knownExts = ['.js', '.cjs', '.mjs', '.json', '.node'];
+      const hasKnownExt = ext && __knownExts.includes(ext.toLowerCase());
+      if (!hasKnownExt) {
+        // Try common extensions in order: .js, .cjs, .json, .node
+        const extensions = ['.js', '.cjs', '.json', '.node'];
+        for (const testExt of extensions) {
+          try {
+            return __baseRequire(id + testExt);
+          } catch (e) {
+            // Continue to next extension
+          }
+        }
+      }
+    }
+    // Re-throw original error if all attempts failed
+    throw err;
+  }
+};
+
 const module = { exports: {} };
 const exports = module.exports;
 
@@ -74,97 +104,114 @@ const __dirname = __dirname_fn(__filename);
   const transpiledFiles = new Map()
   const baseDir = path.dirname(mainFilePath)
   
-  // Transpile main file
-  let jsContent = transpileTS(mainFilePath)
-  
-  // Find and transpile all relative TypeScript imports
-  // Match: import ... from './file' or '../file' or './file.ts'
-  const importRegex = /from\s+['"](\..+?)(?:\.ts)?['"]/g
-  let match
-  const imports = []
-  
-  while ((match = importRegex.exec(jsContent)) !== null) {
-    imports.push(match[1])
-  }
-  
-  // Transpile each imported TypeScript file
-  for (const relativeImport of imports) {
-    let importedPath = path.resolve(baseDir, relativeImport)
-    
-    // Handle .js extensions that might actually be .ts files
-    if (importedPath.endsWith('.js')) {
-      const tsVersion = importedPath.replace(/\.js$/, '.ts')
-      if (fs.existsSync(tsVersion)) {
-        importedPath = tsVersion
-      }
+  // Recursive function to transpile a file and all its TypeScript dependencies
+  const transpileFileAndDeps = (filePath) => {
+    // Already transpiled, skip
+    if (transpiledFiles.has(filePath)) {
+      return
     }
     
-    // Try adding .ts extension if file doesn't exist and no extension provided
-    if (!path.extname(importedPath)) {
-      const tsPath = importedPath + '.ts'
-      if (fs.existsSync(tsPath)) {
-        importedPath = tsPath
-      } else {
-        // Try .js extension as well
-        const jsPath = importedPath + '.js'
-        if (fs.existsSync(jsPath)) {
-          // Skip .js files, they don't need transpilation
-          continue
-        }
-      }
-    }
+    // Transpile this file
+    let jsContent = transpileTS(filePath)
+    
+    // Find all relative TypeScript imports in this file
+    const importRegex = /from\s+['"](\..+?)(?:\.ts)?['"]/g
+    let match
+    const imports = []
     
-    // If it's a TypeScript file, transpile it
-    if (importedPath.endsWith('.ts') && fs.existsSync(importedPath)) {
-      const transpiledImportContent = transpileTS(importedPath)
-      const tempImportFile = importedPath.replace(/\.ts$/, '.temp.mjs')
-      fs.writeFileSync(tempImportFile, transpiledImportContent)
-      transpiledFiles.set(importedPath, tempImportFile)
+    while ((match = importRegex.exec(jsContent)) !== null) {
+      imports.push(match[1])
     }
-  }
-  
-  // Replace imports in the main file to point to temp .mjs files
-  jsContent = jsContent.replace(
-    /from\s+['"](\..+?)(?:\.ts)?['"]/g,
-    (match, importPath) => {
-      let resolvedPath = path.resolve(baseDir, importPath)
+    
+    // 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 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(baseDir, tempFile).replace(/\\/g, '/')
-          return `from './${relPath}'`
+      // Handle .js extensions that might actually be .ts files
+      if (importedPath.endsWith('.js')) {
+        const tsVersion = importedPath.replace(/\.js$/, '.ts')
+        if (fs.existsSync(tsVersion)) {
+          importedPath = tsVersion
         }
       }
       
-      // 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)
-        // Get relative path from main temp file to this temp file
-        const relPath = path.relative(baseDir, tempFile).replace(/\\/g, '/')
-        // Ensure the path starts with ./
-        if (!relPath.startsWith('.')) {
-          return `from './${relPath}'`
+      // Try adding .ts extension if file doesn't exist and no extension provided
+      if (!path.extname(importedPath)) {
+        const tsPath = importedPath + '.ts'
+        if (fs.existsSync(tsPath)) {
+          importedPath = tsPath
+        } else {
+          // Try .js extension as well
+          const jsPath = importedPath + '.js'
+          if (fs.existsSync(jsPath)) {
+            // Skip .js files, they don't need transpilation
+            continue
+          }
         }
-        return `from '${relPath}'`
       }
       
-      // Otherwise, keep the import as-is
-      return match
+      // If it's a TypeScript file, recursively transpile it and its dependencies
+      if (importedPath.endsWith('.ts') && fs.existsSync(importedPath)) {
+        transpileFileAndDeps(importedPath)
+      }
     }
-  )
-
-  // Create a temporary JS file with .mjs extension for the main file
-  const tempJsFile = mainFilePath.replace(/\.ts$/, '.temp.mjs')
-  fs.writeFileSync(tempJsFile, jsContent)
+    
+    // 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, '/')
+          // Ensure the path starts with ./
+          if (!relPath.startsWith('.')) {
+            return `from './${relPath}'`
+          }
+          return `from '${relPath}'`
+        }
+        
+        // Otherwise, keep the import as-is
+        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 = [tempJsFile, ...Array.from(transpiledFiles.values())]
+  const allTempFiles = Array.from(transpiledFiles.values())
   
   return { tempFile: tempJsFile, allTempFiles }
 }

package/package.json

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