@jsreport/jsreport-core 4.1.0 → 4.2.0

package/lib/worker/render/engineStream.js

@@ -0,0 +1,97 @@
+const bytes = require('bytes')
+const { Readable } = require('stream')
+/*
+This adds jsreport.templatingEngines.createStream to the helpers proxy allowing to write giant texts to output
+which would otherwise hit nodejs max string size limit.
+
+Example usage
+===================
+async function myEach(items, options) {
+    const stream = await jsreport.templatingEngines.createStream()
+    for (let i = 0; i < items.length; i++) {
+        await stream.write(options.fn())
+    }
+    return await stream.toResult()
+}
+*/
+
+module.exports = (reporter) => {
+  reporter.afterTemplatingEnginesExecutedListeners.add('streamedEach', async (req, res) => {
+    if (req.context.engineStreamEnabled !== true) {
+      return
+    }
+
+    const content = (await res.output.getBuffer()).toString()
+
+    const matches = [...content.matchAll(/{#stream ([^{}]{0,500})}/g)]
+
+    async function * transform () {
+      if (matches.length) {
+        yield content.substring(0, matches[0].index)
+
+        for (let i = 0; i < matches.length; i++) {
+          const { stream } = reporter.readTempFileStream(matches[i][1])
+
+          for await (const content of stream) {
+            yield content
+          }
+
+          if (i < matches.length - 1) {
+            yield content.substring(matches[i].index + matches[i][0].length, matches[i + 1].index)
+          } else {
+            yield content.substring(matches[i].index + matches[i][0].length)
+          }
+        }
+      } else {
+        yield content
+      }
+    }
+
+    await res.output.update(Readable.from(transform()))
+  })
+
+  reporter.extendProxy((proxy, req, {
+    runInSandbox,
+    context,
+    getTopLevelFunctions
+  }) => {
+    if (proxy.templatingEngines) {
+      proxy.templatingEngines.createStream = async (opts = {}) => {
+        // limiting the number of temp files to avoid breaking server, otherwise I see no reason why having more than 1000 calls per req should be valid usecase
+        const counter = reporter.reqStorage.get('engine-stream-counter', req) || 0
+        if (counter > 1000) {
+          throw reporter.createError('Reached maximum limit of templatingEngine.createStream calls', {
+            weak: true,
+            statusCode: 400
+          })
+        }
+        reporter.reqStorage.set('engine-stream-counter', counter + 1, req)
+
+        req.context.engineStreamEnabled = true
+
+        const bufferSize = bytes(opts.bufferSize || '10mb')
+        let buf = ''
+
+        const { fileHandle, filename } = await reporter.openTempFile((uuid) => `${uuid}.stream`, 'a')
+        proxy.templatingEngines.addFinishListener(() => fileHandle.close().catch((e) => reporter.logger.error('Failed to close temp file handle', e, req)))
+
+        return {
+          write: async (text) => {
+            const realText = await proxy.templatingEngines.waitForAsyncHelper(text)
+
+            buf += realText
+
+            if (buf.length > bufferSize) {
+              await fileHandle.appendFile(buf)
+              buf = ''
+            }
+          },
+          toResult: async () => {
+            await fileHandle.appendFile(buf)
+            return `{#stream ${filename}}`
+          }
+        }
+      }
+    }
+  })
+}

package/lib/worker/render/executeEngine.js

@@ -16,6 +16,7 @@ module.exports = (reporter) => {
 
   const executionFnParsedParamsMap = new Map()
   const executionAsyncResultsMap = new Map()
+  const executionFinishListenersMap = new Map()
 
   const templatingEnginesEvaluate = async (mainCall, { engine, content, helpers, data }, { entity, entitySet }, req) => {
     const engineImpl = reporter.extensionsManager.engines.find((e) => e.name === engine)
@@ -47,6 +48,7 @@ module.exports = (reporter) => {
       }
 
       executionAsyncResultsMap.delete(executionId)
+      executionFinishListenersMap.delete(executionId)
     }
   }
 
@@ -94,6 +96,11 @@ module.exports = (reporter) => {
           return Promise.all([...asyncResultMap.keys()].map((k) => asyncResultMap.get(k)))
         }
       },
+      addFinishListener: (fn) => {
+        if (executionFinishListenersMap.has(context.__executionId)) {
+          executionFinishListenersMap.get(context.__executionId).add('finish', fn)
+        }
+      },
       createAsyncHelperResult: (v) => {
         const asyncResultMap = executionAsyncResultsMap.get(context.__executionId)
         const asyncResultId = nanoid(7)
@@ -190,6 +197,7 @@ module.exports = (reporter) => {
       context.__executionId = executionId
 
       executionAsyncResultsMap.set(executionId, asyncResultMap)
+      executionFinishListenersMap.set(executionId, reporter.createListenerCollection())
       executionFnParsedParamsMap.get(req.context.id).get(executionFnParsedParamsKey).resolve({ require, console, topLevelFunctions, context })
 
       const key = engine.buildTemplateCacheKey
@@ -210,7 +218,7 @@ module.exports = (reporter) => {
 
       for (const h of Object.keys(topLevelFunctions)) {
         // extra wrapping for enhance the error with the helper name
-        wrappedTopLevelFunctions[h] = wrapHelperForHelperNameWhenError(topLevelFunctions[h], h)
+        wrappedTopLevelFunctions[h] = wrapHelperForHelperNameWhenError(topLevelFunctions[h], h, () => executionFnParsedParamsMap.has(req.context.id))
 
         if (engine.getWrappingHelpersEnabled && engine.getWrappingHelpersEnabled(req) === false) {
           wrappedTopLevelFunctions[h] = engine.wrapHelper(wrappedTopLevelFunctions[h], { context })
@@ -223,19 +231,33 @@ module.exports = (reporter) => {
 
       const resolvedResultsMap = new Map()
 
-      while (asyncResultMap.size > 0) {
-        await Promise.all([...asyncResultMap.keys()].map(async (k) => {
-          resolvedResultsMap.set(k, `${await asyncResultMap.get(k)}`)
-          asyncResultMap.delete(k)
+      // we need to use the cloned map, becuase there can be a waitForAsyncHelper pending that needs the asyncResultMap values
+      const clonedMap = new Map(asyncResultMap)
+      while (clonedMap.size > 0) {
+        await Promise.all([...clonedMap.keys()].map(async (k) => {
+          resolvedResultsMap.set(k, `${await clonedMap.get(k)}`)
+          clonedMap.delete(k)
         }))
       }
+      asyncResultMap.clear()
 
       while (contentResult.includes('{#asyncHelperResult')) {
         contentResult = contentResult.replace(/{#asyncHelperResult ([^{}]+)}/g, (str, p1) => {
           const asyncResultId = p1
+          // this can happen if a child jsreport.templatingEngines.evaluate receives an async value from outer scope
+          // because every evaluate uses a unique map of async resuts
+          // example is the case when component receives as a value async thing
+          // instead of returning "undefined" we let the outer eval to do the replace
+          if (!resolvedResultsMap.has(asyncResultId)) {
+            // returning asyncUnresolvedHelperResult just to avoid endless loop, after replace we put it back to asyncHelperResult
+            return `{#asyncUnresolvedHelperResult ${asyncResultId}}`
+          }
           return `${resolvedResultsMap.get(asyncResultId)}`
         })
       }
+      contentResult = contentResult.replace(/asyncUnresolvedHelperResult/g, 'asyncHelperResult')
+
+      await executionFinishListenersMap.get(context.__executionId).fire()
 
       return {
         // handlebars escapes single brackets before execution to prevent errors on {#asset}
@@ -357,7 +379,7 @@ module.exports = (reporter) => {
     }
   }
 
-  function wrapHelperForHelperNameWhenError (fn, helperName) {
+  function wrapHelperForHelperNameWhenError (fn, helperName, isMainEvalStillRunningFn) {
     return function (...args) {
       let fnResult
 
@@ -375,6 +397,10 @@ module.exports = (reporter) => {
       }
 
       return fnResult.catch((asyncError) => {
+        if (!isMainEvalStillRunningFn()) {
+          // main exec already finished on some error, we just ignore errors of the hanging async calls
+          return
+        }
         throw getEnhancedHelperError(asyncError)
       })
     }

package/lib/worker/render/profiler.js

@@ -72,7 +72,15 @@ class Profiler {
     }
 
     if (m.doDiffs !== false && req.context.profiling.mode === 'full' && (m.type === 'operationStart' || m.type === 'operationEnd')) {
-      let content = res.content
+      let originalResContent = res.content
+
+      // if content is empty assume null to keep old logic working without major changes
+      // (here and in studio)
+      if (originalResContent != null && originalResContent.length === 0) {
+        originalResContent = null
+      }
+
+      let content = originalResContent
 
       if (content != null) {
         if (content.length > this.reporter.options.profiler.maxDiffSize) {
@@ -82,12 +90,12 @@ class Profiler {
         } else {
           if (isbinaryfile(content)) {
             content = {
-              content: res.content.toString('base64'),
+              content: originalResContent.toString('base64'),
               encoding: 'base64'
             }
           } else {
             content = {
-              content: createPatch('res', req.context.profiling.resLastVal ? req.context.profiling.resLastVal.toString() : '', res.content.toString(), 0),
+              content: createPatch('res', req.context.profiling.resLastVal ? req.context.profiling.resLastVal.toString() : '', originalResContent.toString(), 0),
               encoding: 'diff'
             }
           }
@@ -107,7 +115,7 @@ class Profiler {
         m.req.diff = createPatch('req', req.context.profiling.reqLastVal || '', stringifiedReq, 0)
       }
 
-      req.context.profiling.resLastVal = (res.content == null || isbinaryfile(res.content) || content.tooLarge) ? null : res.content.toString()
+      req.context.profiling.resLastVal = (originalResContent == null || isbinaryfile(originalResContent) || content.tooLarge) ? null : originalResContent.toString()
       req.context.profiling.resMetaLastVal = stringifiedResMeta
       req.context.profiling.reqLastVal = stringifiedReq
     }

package/lib/worker/render/render.js

@@ -6,7 +6,7 @@
 const extend = require('node.extend.without.arrays')
 const ExecuteEngine = require('./executeEngine')
 const Request = require('../../shared/request')
-const generateRequestId = require('../../shared/generateRequestId')
+const Response = require('../../shared/response')
 const resolveReferences = require('./resolveReferences.js')
 const moduleHelper = require('./moduleHelper')
 
@@ -59,8 +59,7 @@ module.exports = (reporter) => {
     reporter.logger.debug(`Rendering engine ${engine.name}`, request)
 
     const engineRes = await executeEngine(engine, request)
-
-    response.content = Buffer.from(engineRes.content != null ? engineRes.content : '')
+    await response.output.update(Buffer.from(engineRes.content != null ? engineRes.content : ''))
 
     reporter.profiler.emit({
       type: 'operationEnd',
@@ -92,6 +91,7 @@ module.exports = (reporter) => {
     reporter.logger.debug('Executing recipe ' + request.template.recipe, request)
 
     await recipe.execute(request, response)
+
     reporter.profiler.emit({
       type: 'operationEnd',
       operationId: recipeProfilerEvent.operationId
@@ -105,13 +105,19 @@ module.exports = (reporter) => {
 
   return async (req, parentReq) => {
     const request = Request(req, parentReq)
-    const response = { meta: {} }
+
+    if (request.context.id == null) {
+      request.context.id = reporter.generateRequestId()
+    }
+    if (parentReq == null) {
+      reporter.reqStorage.registerReq(request)
+    }
+
+    const response = Response(reporter, request.context.id)
+
     let renderStartProfilerEvent
-    try {
-      if (request.context.id == null) {
-        request.context.id = generateRequestId()
-      }
 
+    try {
       renderStartProfilerEvent = await reporter.profiler.renderStart(request, parentReq, response)
       request.data = resolveReferences(request.data) || {}
 
@@ -189,6 +195,7 @@ module.exports = (reporter) => {
     } finally {
       if (parentReq == null) {
         reporter.requestModulesCache.delete(request.context.rootId)
+        reporter.reqStorage.unregisterReq(request)
       }
     }
   }

package/lib/worker/reporter.js

@@ -10,6 +10,7 @@ const Reporter = require('../shared/reporter')
 const BlobStorage = require('./blobStorage.js')
 const Render = require('./render/render')
 const Profiler = require('./render/profiler.js')
+const engineStream = require('./render/engineStream.js')
 
 class WorkerReporter extends Reporter {
   constructor (workerData, executeMain) {
@@ -79,6 +80,8 @@ class WorkerReporter extends Reporter {
       execute: htmlRecipe
     })
 
+    engineStream(this)
+
     await this.initializeListeners.fire()
 
     if (!this._lockedDown && this.options.trustUserCode === false) {
@@ -169,8 +172,8 @@ class WorkerReporter extends Reporter {
     return proxyInstance
   }
 
-  render (req, parentReq) {
-    return this._render(req, parentReq)
+  async render (req, parentReq) {
+    return await this._render(req, parentReq)
   }
 
   async executeMainAction (actionName, data, req) {
@@ -221,17 +224,8 @@ class WorkerReporter extends Reporter {
 
   _registerRenderAction () {
     this.registerWorkerAction('render', async (data, req) => {
-      const res = await this.render(req)
-
-      const sharedBuf = new SharedArrayBuffer(res.content.byteLength)
-      const buf = Buffer.from(sharedBuf)
-
-      res.content.copy(buf)
-
-      return {
-        meta: res.meta,
-        content: buf
-      }
+      const response = await this._render(req)
+      return response.serialize()
     })
   }
 

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 })
 }