@jsreport/jsreport-core 4.0.1 → 4.2.0

package/lib/worker/sandbox/isolatedRequire.js

@@ -1,17 +1,18 @@
 const Module = require('module')
 const path = require('path')
 const fs = require('fs')
+const resolveFilename = require('./resolveFilename')
 
-const REQUIRE_RESOLVE_CACHE = new Map()
-const REQUIRE_SCRIPT_CACHE = new Map()
-const PACKAGE_JSON_CACHE = new Map()
+const ISOLATED_REQUIRE_RESOLVE_CACHE = new Map()
+const ISOLATED_REQUIRE_SCRIPT_CACHE = new Map()
+const ISOLATED_PACKAGE_JSON_CACHE = new Map()
 
 // The isolated require is a function that replicates the node.js require but that does not
 // cache the modules with the standard node.js cache, instead its uses its own cache in order
 // to bring isolated modules across renders and without memory leaks.
 // most of the code is copied from node.js source code and adapted a bit
 // (you will see in some parts specific links to node.js source code counterpart for reference)
-function isolatedRequire (_moduleId, requireFromRootDirectory, isolatedModulesMeta) {
+function isolatedRequire (_moduleId, modulesMeta, requireFromRootDirectory) {
   const parentModule = typeof _moduleId !== 'string' ? _moduleId.parent : null
   const moduleId = parentModule ? _moduleId.moduleId : _moduleId
 
@@ -30,19 +31,26 @@ function isolatedRequire (_moduleId, requireFromRootDirectory, isolatedModulesMe
     return require(moduleId)
   }
 
-  const { modulesCache, requireExtensions } = isolatedModulesMeta
-  const fullModulePath = resolveFilename(requireFromRootDirectory, moduleId, { parentModulePath: parentModule?.path })
+  const { rootModule, modulesCache, requireExtensions } = modulesMeta
+
+  const fullModulePath = resolveFilename(ISOLATED_REQUIRE_RESOLVE_CACHE, requireFromRootDirectory.resolve, moduleId, { parentModulePath: parentModule?.path })
 
   if (modulesCache[fullModulePath]) {
     return modulesCache[fullModulePath].exports
   }
 
-  const mod = new IsolatedModule(fullModulePath, parentModule)
+  let targetParentModule = parentModule
+
+  if (targetParentModule == null) {
+    targetParentModule = rootModule
+  }
+
+  const mod = new IsolatedModule(fullModulePath, targetParentModule)
 
   // https://github.com/nodejs/node/blob/v18.14.2/lib/internal/modules/cjs/loader.js#L1133
   // we can not add this to the IsolatedModule.prototype because we need access to other variables
   mod.require = function (id) {
-    return isolatedRequire({ parent: this, moduleId: id }, requireFromRootDirectory, isolatedModulesMeta)
+    return isolatedRequire({ parent: this, moduleId: id }, modulesMeta, requireFromRootDirectory)
   }
 
   modulesCache[fullModulePath] = mod
@@ -88,8 +96,8 @@ function setDefaultRequireExtensions (currentExtensions, requireFromRootDirector
 
     let compiledScript
 
-    if (REQUIRE_SCRIPT_CACHE.has(filename)) {
-      compiledScript = REQUIRE_SCRIPT_CACHE.get(filename)
+    if (ISOLATED_REQUIRE_SCRIPT_CACHE.has(filename)) {
+      compiledScript = ISOLATED_REQUIRE_SCRIPT_CACHE.get(filename)
     } else {
       let moduleContent = fs.readFileSync(filename, 'utf8')
 
@@ -99,7 +107,7 @@ function setDefaultRequireExtensions (currentExtensions, requireFromRootDirector
 
       compiledScript = compileScript(moduleWrappedContent, filename, false)
 
-      REQUIRE_SCRIPT_CACHE.set(filename, compiledScript)
+      ISOLATED_REQUIRE_SCRIPT_CACHE.set(filename, compiledScript)
     }
 
     // we run module in same context than main context because we want to reproduce the same behavior
@@ -163,7 +171,7 @@ function IsolatedModule (id = '', parent) {
   // something here, however if the need appears we can check what we can do about it
   // we should be aware of the expected values it carries according to the node.js docs
   // https://nodejs.org/api/modules.html#moduleparent
-  this.parent = undefined
+  this.parent = parent
 
   // this is always false for our case, because our modules we never run during the
   // Node.js preload phase
@@ -184,7 +192,7 @@ function makeRequireFunction (mod, requireFromRootDirectory, currentExtensions)
       options
     }
 
-    return resolveFilename(requireFromRootDirectory, request, extra)
+    return resolveFilename(ISOLATED_REQUIRE_RESOLVE_CACHE, requireFromRootDirectory.resolve, request, extra)
   }
 
   requireFn.resolve = resolve
@@ -208,36 +216,6 @@ function makeRequireFunction (mod, requireFromRootDirectory, currentExtensions)
   return requireFn
 }
 
-function resolveFilename (requireFromRootDirectory, moduleId, extra) {
-  const { parentModulePath, options } = extra
-  const useCache = options == null
-  const resolveCacheKey = parentModulePath ? `${parentModulePath}::${moduleId}` : moduleId
-  let fullModulePath
-
-  if (useCache && REQUIRE_RESOLVE_CACHE.has(resolveCacheKey)) {
-    fullModulePath = REQUIRE_RESOLVE_CACHE.get(resolveCacheKey)
-  } else {
-    if (parentModulePath) {
-      const optionsToUse = { ...options }
-
-      // search from the parent module path by default if not explicit .paths has been passed
-      if (optionsToUse.paths == null) {
-        optionsToUse.paths = [parentModulePath]
-      }
-
-      fullModulePath = requireFromRootDirectory.resolve(moduleId, optionsToUse)
-    } else {
-      fullModulePath = requireFromRootDirectory.resolve(moduleId)
-    }
-
-    if (useCache) {
-      REQUIRE_RESOLVE_CACHE.set(resolveCacheKey, fullModulePath)
-    }
-  }
-
-  return fullModulePath
-}
-
 // https://github.com/nodejs/node/blob/v18.14.2/lib/internal/modules/cjs/loader.js#L496
 // Find the longest (possibly multi-dot) extension registered in extensions
 function findLongestRegisteredExtension (fullPath, extensions) {
@@ -295,7 +273,7 @@ function readPackageScope (checkPath) {
 function readPackage (requestPath) {
   const jsonPath = path.resolve(requestPath, 'package.json')
 
-  const existing = PACKAGE_JSON_CACHE.get(jsonPath)
+  const existing = ISOLATED_PACKAGE_JSON_CACHE.get(jsonPath)
 
   if (existing !== undefined) {
     return existing
@@ -308,7 +286,7 @@ function readPackage (requestPath) {
   } catch (error) {}
 
   if (json === undefined) {
-    PACKAGE_JSON_CACHE.set(jsonPath, false)
+    ISOLATED_PACKAGE_JSON_CACHE.set(jsonPath, false)
     return false
   }
 
@@ -321,7 +299,7 @@ function readPackage (requestPath) {
       'type'
     ])
 
-    PACKAGE_JSON_CACHE.set(jsonPath, filtered)
+    ISOLATED_PACKAGE_JSON_CACHE.set(jsonPath, filtered)
     return filtered
   } catch (e) {
     e.path = jsonPath
@@ -439,4 +417,5 @@ function validateString (value, name) {
 }
 
 module.exports = isolatedRequire
+module.exports.IsolatedModule = IsolatedModule
 module.exports.setDefaultRequireExtensions = setDefaultRequireExtensions

package/lib/worker/sandbox/requireSandbox.js

@@ -1,8 +1,11 @@
 const Module = require('module')
 const os = require('os')
 const path = require('path')
+const resolveFilename = require('./resolveFilename')
 const isolatedRequire = require('./isolatedRequire')
 
+const REQUIRE_RESOLVE_CACHE = new Map()
+
 module.exports = function createSandboxRequire (safeExecution, isolateModules, modulesCache, {
   rootDirectory,
   requirePaths,
@@ -15,20 +18,28 @@ module.exports = function createSandboxRequire (safeExecution, isolateModules, m
     throw new Error(`rootDirectory must be an absolute path, path: ${rootDirectory}`)
   }
 
-  // we pass directory with trailing slash to ensure node recognize the path as directory
-  const requireFromRootDirectory = Module.createRequire(ensureTrailingSlash(rootDirectory))
+  const rootProxyPath = path.join(rootDirectory, '___sandbox___')
 
-  let isolatedModulesMeta
+  let modulesMeta
 
   if (isolateModules) {
-    const requireExtensions = Object.create(null)
+    const rootModule = new isolatedRequire.IsolatedModule(rootProxyPath, null)
+    rootModule.filename = rootProxyPath
+    rootModule.paths = Module._nodeModulePaths(rootProxyPath)
+    rootModule.loaded = true
+
+    modulesMeta = {
+      rootModule,
+      modulesCache
+    }
+  }
 
-    isolatedRequire.setDefaultRequireExtensions(requireExtensions, modulesCache, compileScript)
+  const requireFromRootDirectory = Module.createRequire(rootProxyPath)
 
-    isolatedModulesMeta = {
-      modulesCache: modulesCache,
-      requireExtensions
-    }
+  if (isolateModules) {
+    const requireExtensions = Object.create(null)
+    isolatedRequire.setDefaultRequireExtensions(requireExtensions, modulesCache, compileScript)
+    modulesMeta.requireExtensions = requireExtensions
   }
 
   return function sandboxRequire (moduleId, { context, useMap = true, allowAllModules = false } = {}) {
@@ -41,13 +52,13 @@ module.exports = function createSandboxRequire (safeExecution, isolateModules, m
     }
 
     if (!safeExecution || allowAllModules || allowedModules === '*') {
-      return doRequire(moduleId, requireFromRootDirectory, requirePaths, isolatedModulesMeta)
+      return doRequire(moduleId, requireFromRootDirectory, requirePaths, modulesMeta)
     }
 
     const m = allowedModules.find(mod => (mod.id || mod) === moduleId)
 
     if (m) {
-      return doRequire(m.path || moduleId, requireFromRootDirectory, requirePaths, isolatedModulesMeta)
+      return doRequire(m.path || moduleId, requireFromRootDirectory, requirePaths, modulesMeta)
     }
 
     const error = new Error(
@@ -62,25 +73,27 @@ module.exports = function createSandboxRequire (safeExecution, isolateModules, m
   }
 }
 
-function doRequire (moduleId, requireFromRootDirectory, _requirePaths, isolatedModulesMeta) {
-  const isolateModules = isolatedModulesMeta != null
+function doRequire (moduleId, requireFromRootDirectory, _requirePaths, modulesMeta) {
+  const isolateModules = modulesMeta != null
   const searchedPaths = []
   const requirePaths = _requirePaths || []
   const _require = isolateModules ? isolatedRequire : requireFromRootDirectory
   const extraRequireParams = []
 
   if (isolateModules) {
-    extraRequireParams.push(requireFromRootDirectory, isolatedModulesMeta)
+    extraRequireParams.push(modulesMeta, requireFromRootDirectory)
   }
 
-  let result = executeRequire(_require, moduleId, searchedPaths, ...extraRequireParams)
+  const resolveModule = requireFromRootDirectory.resolve
+
+  let result = executeRequire(_require, resolveModule, moduleId, searchedPaths, ...extraRequireParams)
 
   if (!result) {
     let pathsSearched = 0
 
     while (!result && pathsSearched < requirePaths.length) {
       const newModuleId = path.join(requirePaths[pathsSearched], moduleId)
-      result = executeRequire(_require, newModuleId, searchedPaths, ...extraRequireParams)
+      result = executeRequire(_require, resolveModule, newModuleId, searchedPaths, ...extraRequireParams)
       pathsSearched++
     }
   }
@@ -92,10 +105,46 @@ function doRequire (moduleId, requireFromRootDirectory, _requirePaths, isolatedM
   return result
 }
 
-function executeRequire (_require, moduleId, searchedPaths, ...restOfParams) {
+function executeRequire (_require, resolveModule, moduleId, searchedPaths, ...restOfParams) {
+  const isolateModules = restOfParams.length > 0
+  const shouldHandleModuleResolveFilenameOptimization = !isolateModules
+
+  const originalModuleResolveFilename = Module._resolveFilename
+
   try {
-    return _require(moduleId, ...restOfParams)
+    if (shouldHandleModuleResolveFilenameOptimization) {
+      // when isolate modules is disabled we add an extra cache here to optimize require resolution,
+      // basically we want to avoid the overhead that node require resolution
+      // adds when trying to resolve the filename/path of a module, because even if the module
+      // is cached in require.cache module filename/path resolution still happens and have a cost
+      const customResolveFilename = (...args) => {
+        const customResolveModule = (...resolveArgs) => {
+          Module._resolveFilename = originalModuleResolveFilename
+          try {
+            return resolveModule(...resolveArgs)
+          } finally {
+            Module._resolveFilename = customResolveFilename
+          }
+        }
+
+        return optimizedResolveFilename(customResolveModule, ...args)
+      }
+
+      Module._resolveFilename = customResolveFilename
+    }
+
+    const result = _require(moduleId, ...restOfParams)
+
+    if (shouldHandleModuleResolveFilenameOptimization) {
+      Module._resolveFilename = originalModuleResolveFilename
+    }
+
+    return result
   } catch (e) {
+    if (shouldHandleModuleResolveFilenameOptimization) {
+      Module._resolveFilename = originalModuleResolveFilename
+    }
+
     if (e.code && e.code === 'MODULE_NOT_FOUND') {
       if (!searchedPaths.includes(moduleId)) {
         searchedPaths.push(moduleId)
@@ -108,10 +157,6 @@ function executeRequire (_require, moduleId, searchedPaths, ...restOfParams) {
   }
 }
 
-function ensureTrailingSlash (fullPath) {
-  if (fullPath.endsWith(path.sep)) {
-    return fullPath
-  }
-
-  return fullPath + path.sep
+function optimizedResolveFilename (resolveModule, request, parent, isMain, options) {
+  return resolveFilename(REQUIRE_RESOLVE_CACHE, resolveModule, request, { parentModulePath: parent?.path, options })
 }

package/lib/worker/sandbox/resolveFilename.js

@@ -0,0 +1,30 @@
+
+module.exports = function resolveFilename (cache, resolveModulePath, moduleId, extra) {
+  const { parentModulePath, options } = extra
+  const useCache = options == null
+  const resolveCacheKey = parentModulePath ? `${parentModulePath}::${moduleId}` : moduleId
+  let fullModulePath
+
+  if (useCache && cache.has(resolveCacheKey)) {
+    fullModulePath = cache.get(resolveCacheKey)
+  } else {
+    if (parentModulePath) {
+      const optionsToUse = { ...options }
+
+      // search from the parent module path by default if not explicit .paths has been passed
+      if (optionsToUse.paths == null) {
+        optionsToUse.paths = [parentModulePath]
+      }
+
+      fullModulePath = resolveModulePath(moduleId, optionsToUse)
+    } else {
+      fullModulePath = resolveModulePath(moduleId)
+    }
+
+    if (useCache) {
+      cache.set(resolveCacheKey, fullModulePath)
+    }
+  }
+
+  return fullModulePath
+}

package/lib/worker/sandbox/runInSandbox.js

@@ -66,6 +66,22 @@ module.exports = function createRunInSandbox (reporter) {
         const m = reporter.options.sandbox.modules.find((m) => m.alias === moduleName || m.path === moduleName)
 
         if (m) {
+          const cachedModuleFromOutside = require.cache[m.path]
+
+          // this is an optimization, the requireMap always go the built-in node require,
+          // which has an overhead, even if the module you are trying to resolve is already cached
+          // node will try to resolve filename when the require happens from different module than
+          // it was requested first time.
+          // this becomes an issue when you do a lazy require inside helper execution, if this helper
+          // is a hot path (executed multiple times during rendering)
+          // then you are adding extra time per the amount of times you call the helper
+          // (which is big if you call this in a loop for 15K items),
+          // the solution is to try first from the require cache directly, and fallback to built-in require
+          // when not found, we can do this because we are sure the m.path is the path to the resolved filename of module
+          if (cachedModuleFromOutside != null) {
+            return cachedModuleFromOutside.exports
+          }
+
           return require(m.path)
         }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsreport/jsreport-core",
-  "version": "4.0.1",
+  "version": "4.2.0",
   "description": "javascript based business reporting",
   "keywords": [
     "report",
@@ -36,15 +36,15 @@
     "test:watch": "mocha --watch --recursive test"
   },
   "dependencies": {
-    "@babel/code-frame": "7.12.13",
-    "@babel/parser": "7.14.4",
-    "@babel/traverse": "7.12.9",
+    "@babel/code-frame": "7.23.5",
+    "@babel/parser": "7.23.5",
+    "@babel/traverse": "7.23.5",
     "@colors/colors": "1.5.0",
-    "@jsreport/advanced-workers": "2.0.0",
+    "@jsreport/advanced-workers": "2.0.2",
     "@jsreport/mingo": "2.4.1",
     "@jsreport/reap": "0.1.0",
     "@jsreport/serializator": "1.0.0",
-    "@jsreport/ses": "1.0.0",
+    "@jsreport/ses": "1.0.1",
     "ajv": "6.12.6",
     "app-root-path": "3.0.0",
     "bytes": "3.1.2",
@@ -78,7 +78,7 @@
   },
   "devDependencies": {
     "@node-rs/jsonwebtoken": "0.2.0",
-    "mocha": "9.2.2",
+    "mocha": "10.1.0",
     "should": "13.2.3",
     "standard": "16.0.4",
     "std-mocks": "1.0.1",

package/test/extensions/validExtensions/listeners/main.js

@@ -8,23 +8,31 @@ module.exports = (reporter, definition) => {
 
   reporter.registerMainAction('test-beforeRender-listeners', async (data, req) => {
     data.req = reporter.Request(data.req)
-    await reporter.tests.beforeRenderListeners.fire(data.req, data.res)
-    return { req: data.req, res: data.res }
+    const localRes = reporter.Response(data.req.context.id)
+    await localRes.parse(data.res)
+    await reporter.tests.beforeRenderListeners.fire(data.req, localRes)
+    return { req: data.req, res: localRes.serialize() }
   })
   reporter.registerMainAction('test-afterRender-listeners', async (data, req) => {
     data.req = reporter.Request(data.req)
-    await reporter.tests.afterRenderListeners.fire(data.req, data.res)
-    return { req: data.req, res: data.res }
+    const localRes = reporter.Response(data.req.context.id)
+    await localRes.parse(data.res)
+    await reporter.tests.afterRenderListeners.fire(data.req, localRes)
+    return { req: data.req, res: localRes.serialize() }
   })
   reporter.registerMainAction('test-validateRender-listeners', async (data, req) => {
     data.req = reporter.Request(data.req)
-    await reporter.tests.validateRenderListeners.fire(data.req, data.res)
-    return { req: data.req, res: data.res }
+    const localRes = reporter.Response(data.req.context.id)
+    await localRes.parse(data.res)
+    await reporter.tests.validateRenderListeners.fire(data.req, localRes)
+    return { req: data.req, res: localRes.serialize() }
   })
   reporter.registerMainAction('test-afterTemplatingEnginesExecuted-listeners', async (data, req) => {
     data.req = reporter.Request(data.req)
-    await reporter.tests.afterTemplatingEnginesExecutedListeners.fire(data.req, data.res)
-    return { req: data.req, res: data.res }
+    const localRes = reporter.Response(data.req.context.id)
+    await localRes.parse(data.res)
+    await reporter.tests.afterTemplatingEnginesExecutedListeners.fire(data.req, localRes)
+    return { req: data.req, res: localRes.serialize() }
   })
 
   let beforeRenderEval

package/test/extensions/validExtensions/listeners/worker.js

@@ -1,81 +1,81 @@
-const extend = require('node.extend.without.arrays')
-const vm = require('vm')
-const Module = require('module')
-const path = require('path')
-const process = require('process')
-
-module.exports = (reporter, definition) => {
-  reporter.initializeListeners.add('test-listeners', () => {
-    reporter.beforeRenderListeners.add('listeners', async (req, res) => {
-      const result = await reporter.executeMainAction('test-beforeRender-listeners', { req, res }, req)
-      extend(true, req, result.req)
-      extend(true, res, result.res)
-    })
-
-    reporter.afterRenderListeners.add('listeners', async (req, res) => {
-      const result = await reporter.executeMainAction('test-afterRender-listeners', { req, res }, req)
-      extend(true, req, result.req)
-      extend(true, res, result.res)
-    })
-
-    reporter.validateRenderListeners.add('listeners', async (req, res) => {
-      const result = await reporter.executeMainAction('test-validateRender-listeners', { req, res }, req)
-      extend(true, req, result.req)
-      extend(true, res, result.res)
-    })
-
-    reporter.afterTemplatingEnginesExecutedListeners.add('listeners', async (req, res) => {
-      const result = await reporter.executeMainAction('test-afterTemplatingEnginesExecuted-listeners', { req, res }, req)
-      extend(true, req, result.req)
-      extend(true, res, result.res)
-    })
-
-    const evalInWorker = (code, req, res) => {
-      const script = new vm.Script(`
-          ;(function () {
-            return ${code}
-          })()
-      `)
-
-      return script.runInThisContext({
-        displayErrors: true
-      })(req, res, {
-        mainModuleFilename: require.main.filename,
-        require: (m) => {
-          if (Module.builtinModules.includes(m)) {
-            return require(m)
-          }
-
-          try {
-            return require(path.join(process.cwd(), 'node_modules', m))
-          } catch (e) {
-            // hack, make it working in monorepo as well as normal extension
-            return require(path.join(process.cwd(), '../../node_modules', m))
-          }
-        },
-        reporter
-      })
-    }
-
-    reporter.afterRenderListeners.add('eval-listeners', async (req, res) => {
-      const code = await reporter.executeMainAction('test-afterRenderEval', {}, req)
-      if (code) {
-        return evalInWorker(code, req, res)
-      }
-    })
-
-    reporter.beforeRenderListeners.insert(0, 'eval-listeners', async (req, res) => {
-      const code = await reporter.executeMainAction('test-beforeRenderEval', {}, req)
-      if (code) {
-        return evalInWorker(code, req, res)
-      }
-    })
-
-    reporter.afterTemplatingEnginesExecutedListeners.add('eval-listeners', async (req, res) => {
-      const code = await reporter.executeMainAction('test-afterTemplatingEnginesExecutedEval', {}, req)
-      if (code) {
-        return evalInWorker(code, req, res)
-      }
-    })
-  })
-}
+const extend = require('node.extend.without.arrays')
+const vm = require('vm')
+const Module = require('module')
+const path = require('path')
+const process = require('process')
+
+module.exports = (reporter, definition) => {
+  reporter.initializeListeners.add('test-listeners', () => {
+    reporter.beforeRenderListeners.add('listeners', async (req, res) => {
+      const result = await reporter.executeMainAction('test-beforeRender-listeners', { req, res: await res.serialize() }, req)
+      extend(true, req, result.req)
+      await res.parse(result.res)
+    })
+
+    reporter.afterRenderListeners.add('listeners', async (req, res) => {
+      const result = await reporter.executeMainAction('test-afterRender-listeners', { req, res: await res.serialize() }, req)
+      extend(true, req, result.req)
+      await res.parse(result.res)
+    })
+
+    reporter.validateRenderListeners.add('listeners', async (req, res) => {
+      const result = await reporter.executeMainAction('test-validateRender-listeners', { req, res: await res.serialize() }, req)
+      extend(true, req, result.req)
+      await res.parse(result.res)
+    })
+
+    reporter.afterTemplatingEnginesExecutedListeners.add('listeners', async (req, res) => {
+      const result = await reporter.executeMainAction('test-afterTemplatingEnginesExecuted-listeners', { req, res: await res.serialize() }, req)
+      extend(true, req, result.req)
+      await res.parse(result.res)
+    })
+
+    const evalInWorker = (code, req, res) => {
+      const script = new vm.Script(`
+          ;(function () {
+            return ${code}
+          })()
+      `)
+
+      return script.runInThisContext({
+        displayErrors: true
+      })(req, res, {
+        mainModuleFilename: require.main.filename,
+        require: (m) => {
+          if (Module.builtinModules.includes(m)) {
+            return require(m)
+          }
+
+          try {
+            return require(path.join(process.cwd(), 'node_modules', m))
+          } catch (e) {
+            // hack, make it working in monorepo as well as normal extension
+            return require(path.join(process.cwd(), '../../node_modules', m))
+          }
+        },
+        reporter
+      })
+    }
+
+    reporter.afterRenderListeners.add('eval-listeners', async (req, res) => {
+      const code = await reporter.executeMainAction('test-afterRenderEval', {}, req)
+      if (code) {
+        return evalInWorker(code, req, res)
+      }
+    })
+
+    reporter.beforeRenderListeners.insert(0, 'eval-listeners', async (req, res) => {
+      const code = await reporter.executeMainAction('test-beforeRenderEval', {}, req)
+      if (code) {
+        return evalInWorker(code, req, res)
+      }
+    })
+
+    reporter.afterTemplatingEnginesExecutedListeners.add('eval-listeners', async (req, res) => {
+      const code = await reporter.executeMainAction('test-afterTemplatingEnginesExecutedEval', {}, req)
+      if (code) {
+        return evalInWorker(code, req, res)
+      }
+    })
+  })
+}