@jsreport/jsreport-core 4.1.0 → 4.2.1

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.1.0",
+  "version": "4.2.1",
   "description": "javascript based business reporting",
   "keywords": [
     "report",
@@ -40,7 +40,7 @@
     "@babel/parser": "7.23.5",
     "@babel/traverse": "7.23.5",
     "@colors/colors": "1.5.0",
-    "@jsreport/advanced-workers": "2.0.1",
+    "@jsreport/advanced-workers": "2.0.2",
     "@jsreport/mingo": "2.4.1",
     "@jsreport/reap": "0.1.0",
     "@jsreport/serializator": "1.0.0",
@@ -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)
+      }
+    })
+  })
+}