fix: TypeScript config files cannot import from other TypeScript files

- Applied same recursive transpilation fix from container.js to config.js
- When loading TypeScript config files, now recursively transpiles all imported .ts files
- Handles relative imports like '../common/utils' or './helpers/custom'
- Updates import paths to point to temporary .mjs files
- Properly cleans up all temporary files after loading
- Injects __dirname/__filename shims when needed
- Works with 'type: module' in package.json
- Added test case with TypeScript config importing from external TS file
- Version bumped to 4.0.0-beta.13

Fixes issue where users with ESM projects (type: module) got:
'Cannot find module /path/to/file imported from codecept.conf.temp.mjs'

Author: kobenguyent

lib/config.js

@@ -158,28 +158,134 @@ async function loadConfigFile(configFile) {
         try {
           // Try to load ts-node and compile the file
           const { transpile } = require('typescript')
-          const tsContent = fs.readFileSync(configFile, 'utf8')
+          
+          // Recursively transpile the file and its dependencies
+          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
+              target: 99, // ScriptTarget.ESNext
+              esModuleInterop: true,
+              allowSyntheticDefaultImports: true,
+            })
+            
+            // Check if the code uses __dirname or __filename (CommonJS globals)
+            const usesCommonJSGlobals = /__dirname|__filename/.test(jsContent)
+            
+            if (usesCommonJSGlobals) {
+              // Inject ESM equivalents at the top of the file
+              const esmGlobals = `import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __dirname_fn } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __dirname_fn(__filename);
 
-          // Transpile TypeScript to JavaScript with ES module output
-          const jsContent = transpile(tsContent, {
-            module: 99, // ModuleKind.ESNext
-            target: 99, // ScriptTarget.ESNext
-            esModuleInterop: true,
-            allowSyntheticDefaultImports: true,
-          })
+`
+              jsContent = esmGlobals + jsContent
+            }
+            
+            return jsContent
+          }
+          
+          // Create a map to track transpiled files
+          const transpiledFiles = new Map()
+          const baseDir = path.dirname(configFile)
+          
+          // Transpile main file
+          let jsContent = transpileTS(configFile)
+          
+          // 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
+              }
+            }
+            
+            // Try adding .ts extension if file doesn't exist and no extension provided
+            if (!path.extname(importedPath)) {
+              if (fs.existsSync(importedPath + '.ts')) {
+                importedPath = importedPath + '.ts'
+              }
+            }
+            
+            // 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)
+            }
+          }
+          
+          // 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)
+              
+              // 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}'`
+                }
+              }
+              
+              // 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, '/')
+                return `from './${relPath}'`
+              }
+              
+              // Otherwise, keep the import as-is
+              return match
+            }
+          )
 
           // Create a temporary JS file with .mjs extension to force ES module treatment
           const tempJsFile = configFile.replace('.ts', '.temp.mjs')
           fs.writeFileSync(tempJsFile, jsContent)
+          
+          // Store all temp files for cleanup
+          const allTempFiles = [tempJsFile, ...Array.from(transpiledFiles.values())]
 
           try {
             configModule = await import(tempJsFile)
-            // Clean up temp file
-            fs.unlinkSync(tempJsFile)
+            // Clean up all temp files
+            for (const file of allTempFiles) {
+              if (fs.existsSync(file)) {
+                fs.unlinkSync(file)
+              }
+            }
           } catch (err) {
-            // Clean up temp file even on error
-            if (fs.existsSync(tempJsFile)) {
-              fs.unlinkSync(tempJsFile)
+            // Clean up all temp files even on error
+            for (const file of allTempFiles) {
+              if (fs.existsSync(file)) {
+                fs.unlinkSync(file)
+              }
             }
             throw err
           }

package.json

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

test/data/typescript-config-imports/common/utils.ts

@@ -0,0 +1,7 @@
+export function getApiUrl(): string {
+  return 'https://api.example.com'
+}
+
+export function getTimeout(): number {
+  return 5000
+}

test/data/typescript-config-imports/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "typescript-config-test",
+  "version": "1.0.0",
+  "type": "module"
+}

test/data/typescript-config-imports/tests/api/codecept.conf.ts

@@ -0,0 +1,15 @@
+import { getApiUrl, getTimeout } from '../../common/utils'
+
+export const config = {
+  tests: './*_test.js',
+  output: './output',
+  helpers: {
+    REST: {
+      endpoint: getApiUrl(),
+      timeout: getTimeout(),
+    }
+  },
+  bootstrap: null,
+  mocha: {},
+  name: 'typescript-config-test'
+}

test/unit/config_test.js

@@ -60,4 +60,15 @@ describe('Config', () => {
     expect(cfg).to.contain.key('additionalValue')
     expect(cfg.additionalValue).to.eql(true)
   })
+
+  it('should load TypeScript config that imports other TypeScript files', async () => {
+    const configPath = './test/data/typescript-config-imports/tests/api/codecept.conf.ts'
+    const cfg = await config.load(configPath)
+    
+    expect(cfg).to.be.ok
+    expect(cfg.helpers).to.have.property('REST')
+    expect(cfg.helpers.REST.endpoint).to.equal('https://api.example.com')
+    expect(cfg.helpers.REST.timeout).to.equal(5000)
+    expect(cfg.name).to.equal('typescript-config-test')
+  })
 })