@jsreport/jsreport-core 3.1.2-test.2 → 3.4.1

package/lib/worker/reporter.js

@@ -1,191 +1,197 @@
-const ExtensionsManager = require('./extensionsManager')
-const DocumentStore = require('./documentStore')
-const Templates = require('./templates')
-const createLogger = require('./logger')
-const runInSandbox = require('./sandbox/runInSandbox')
-const createNoneEngine = require('./render/noneEngine')
-const htmlRecipe = require('./render/htmlRecipe')
-const defaultProxyExtend = require('./defaultProxyExtend')
-const Reporter = require('../shared/reporter')
-const BlobStorage = require('./blobStorage.js')
-const Render = require('./render/render')
-const Profiler = require('./render/profiler.js')
-
-class WorkerReporter extends Reporter {
-  constructor (workerData, executeMain) {
-    const { options, documentStore, extensionsDefs } = workerData
-
-    super(options)
-
-    this._executeMain = executeMain
-    this._initialized = false
-    this._documentStoreData = documentStore
-    this._requestContextMetaConfigCollection = new Map()
-    this._proxyRegistrationFns = []
-    this.requestModulesCache = new Map()
-    this._workerActions = new Map()
-    this._registerRenderAction()
-
-    this.afterTemplatingEnginesExecutedListeners = this.createListenerCollection('afterTemplatingEnginesExecuted')
-    this.validateRenderListeners = this.createListenerCollection('validateRender')
-
-    this.extensionsManager = ExtensionsManager(this, extensionsDefs)
-
-    this.extendProxy((proxy, req) => defaultProxyExtend(this)(proxy, req))
-    this.beforeMainActionListeners = this.createListenerCollection('beforeMainAction')
-  }
-
-  async init () {
-    if (this._initialized === true) {
-      throw new Error('jsreport already initialized. Make sure init is called only once')
-    }
-
-    super.init()
-
-    Templates(this)
-
-    this.profiler = Profiler(this)
-    this.logger = createLogger(this.profiler)
-
-    this._render = Render(this)
-    await this.extensionsManager.init()
-
-    this.documentStore = DocumentStore(this._documentStoreData, this.executeMainAction.bind(this))
-    this.blobStorage = BlobStorage(this.executeMainAction.bind(this))
-
-    this.addRequestContextMetaConfig('rootId', { sandboxReadOnly: true })
-    this.addRequestContextMetaConfig('id', { sandboxReadOnly: true })
-    this.addRequestContextMetaConfig('reportCounter', { sandboxReadOnly: true })
-    this.addRequestContextMetaConfig('startTimestamp', { sandboxReadOnly: true })
-    this.addRequestContextMetaConfig('logs', { sandboxReadOnly: true })
-    this.addRequestContextMetaConfig('isChildRequest', { sandboxReadOnly: true })
-    this.addRequestContextMetaConfig('originalInputDataIsEmpty', { sandboxReadOnly: true })
-    this.addRequestContextMetaConfig('skipModificationDateUpdate', { sandboxHidden: true })
-
-    this._runInSandbox = runInSandbox(this)
-
-    const { compile: compileNone, execute: executeNone } = createNoneEngine()
-
-    this.extensionsManager.engines.push({
-      name: 'none',
-      compile: compileNone,
-      execute: executeNone
-    })
-
-    this.extensionsManager.recipes.push({
-      name: 'html',
-      execute: htmlRecipe
-    })
-
-    await this.initializeListeners.fire()
-
-    this._initialized = true
-  }
-
-  /**
-   * @public
-   */
-  addRequestContextMetaConfig (property, options) {
-    this._requestContextMetaConfigCollection.set(property, options)
-  }
-
-  /**
-   * @public
-   */
-  getRequestContextMetaConfig (property) {
-    if (property === undefined) {
-      const all = {}
-
-      for (const [key, value] of this._requestContextMetaConfigCollection.entries()) {
-        all[key] = value
-      }
-
-      return all
-    }
-
-    return this._requestContextMetaConfigCollection.get(property)
-  }
-
-  extendProxy (registrationFn) {
-    this._proxyRegistrationFns.push(registrationFn)
-  }
-
-  createProxy ({ req, runInSandbox, context, getTopLevelFunctions, safeRequire }) {
-    const proxyInstance = {}
-    for (const fn of this._proxyRegistrationFns) {
-      fn(proxyInstance, req, {
-        runInSandbox,
-        context,
-        getTopLevelFunctions,
-        safeRequire
-      })
-    }
-    return proxyInstance
-  }
-
-  render (req, parentReq) {
-    return this._render(req, parentReq)
-  }
-
-  async executeMainAction (actionName, data, req) {
-    await this.beforeMainActionListeners.fire(actionName, data, req)
-    return this._executeMain(actionName, data, req)
-  }
-
-  async runInSandbox ({
-    manager,
-    context,
-    userCode,
-    executionFn,
-    onRequire,
-    propertiesConfig,
-    currentPath,
-    errorLineNumberOffset
-  }, req) {
-    return this._runInSandbox({
-      manager,
-      context,
-      userCode,
-      executionFn,
-      onRequire,
-      propertiesConfig,
-      currentPath,
-      errorLineNumberOffset
-    }, req)
-  }
-
-  registerWorkerAction (actionName, fn) {
-    this._workerActions.set(actionName, fn)
-  }
-
-  async executeWorkerAction (actionName, data, req) {
-    const action = this._workerActions.get(actionName)
-    if (!action) {
-      throw new Error(`Worker action ${actionName} not registered`)
-    }
-    return action(data, req)
-  }
-
-  _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
-      }
-    })
-  }
-
-  async close () {
-    this.logger.debug('Closing jsreport worker')
-    return this.closeListeners.fire()
-  }
-}
-
-module.exports = WorkerReporter
+const ExtensionsManager = require('./extensionsManager')
+const DocumentStore = require('./documentStore')
+const Templates = require('./templates')
+const createLogger = require('./logger')
+const runInSandbox = require('./sandbox/runInSandbox')
+const createNoneEngine = require('./render/noneEngine')
+const htmlRecipe = require('./render/htmlRecipe')
+const defaultProxyExtend = require('./defaultProxyExtend')
+const Reporter = require('../shared/reporter')
+const BlobStorage = require('./blobStorage.js')
+const Render = require('./render/render')
+const Profiler = require('./render/profiler.js')
+
+class WorkerReporter extends Reporter {
+  constructor (workerData, executeMain) {
+    const { options, documentStore, extensionsDefs } = workerData
+
+    super(options)
+
+    this._executeMain = executeMain
+    this._initialized = false
+    this._documentStoreData = documentStore
+    this._requestContextMetaConfigCollection = new Map()
+    this._proxyRegistrationFns = []
+    this.requestModulesCache = new Map()
+    this._workerActions = new Map()
+    this._registerRenderAction()
+
+    this.registerHelpersListeners = this.createListenerCollection('registerHelpers')
+    this.afterTemplatingEnginesExecutedListeners = this.createListenerCollection('afterTemplatingEnginesExecuted')
+    this.validateRenderListeners = this.createListenerCollection('validateRender')
+
+    this.extensionsManager = ExtensionsManager(this, extensionsDefs)
+
+    this.extendProxy((proxy, req) => defaultProxyExtend(this)(proxy, req))
+    this.beforeMainActionListeners = this.createListenerCollection('beforeMainAction')
+  }
+
+  async init () {
+    if (this._initialized === true) {
+      throw new Error('jsreport already initialized. Make sure init is called only once')
+    }
+
+    super.init()
+
+    Templates(this)
+
+    this.profiler = Profiler(this)
+    this.logger = createLogger(this.profiler)
+
+    this._render = Render(this)
+    await this.extensionsManager.init()
+
+    this.documentStore = DocumentStore(this._documentStoreData, this.executeMainAction.bind(this))
+    this.blobStorage = BlobStorage(this.executeMainAction.bind(this))
+
+    this.addRequestContextMetaConfig('rootId', { sandboxReadOnly: true })
+    this.addRequestContextMetaConfig('id', { sandboxReadOnly: true })
+    this.addRequestContextMetaConfig('reportCounter', { sandboxReadOnly: true })
+    this.addRequestContextMetaConfig('startTimestamp', { sandboxReadOnly: true })
+    this.addRequestContextMetaConfig('logs', { sandboxReadOnly: true })
+    this.addRequestContextMetaConfig('isChildRequest', { sandboxReadOnly: true })
+    this.addRequestContextMetaConfig('originalInputDataIsEmpty', { sandboxReadOnly: true })
+    this.addRequestContextMetaConfig('skipModificationDateUpdate', { sandboxHidden: true })
+
+    this._runInSandbox = runInSandbox(this)
+
+    const { compile: compileNone, execute: executeNone } = createNoneEngine()
+
+    this.extensionsManager.engines.push({
+      name: 'none',
+      compile: compileNone,
+      execute: executeNone
+    })
+
+    this.extensionsManager.recipes.push({
+      name: 'html',
+      execute: htmlRecipe
+    })
+
+    await this.initializeListeners.fire()
+
+    this._initialized = true
+  }
+
+  /**
+   * @public
+   */
+  addRequestContextMetaConfig (property, options) {
+    this._requestContextMetaConfigCollection.set(property, options)
+  }
+
+  /**
+   * @public
+   */
+  getRequestContextMetaConfig (property) {
+    if (property === undefined) {
+      const all = {}
+
+      for (const [key, value] of this._requestContextMetaConfigCollection.entries()) {
+        all[key] = value
+      }
+
+      return all
+    }
+
+    return this._requestContextMetaConfigCollection.get(property)
+  }
+
+  extendProxy (registrationFn) {
+    this._proxyRegistrationFns.push(registrationFn)
+  }
+
+  createProxy ({ req, runInSandbox, context, getTopLevelFunctions, safeRequire }) {
+    const proxyInstance = {}
+    for (const fn of this._proxyRegistrationFns) {
+      fn(proxyInstance, req, {
+        runInSandbox,
+        context,
+        getTopLevelFunctions,
+        safeRequire
+      })
+    }
+    return proxyInstance
+  }
+
+  render (req, parentReq) {
+    return this._render(req, parentReq)
+  }
+
+  async executeMainAction (actionName, data, req) {
+    await this.beforeMainActionListeners.fire(actionName, data, req)
+    return this._executeMain(actionName, data, req)
+  }
+
+  async runInSandbox ({
+    manager,
+    context,
+    userCode,
+    executionFn,
+    onRequire,
+    propertiesConfig,
+    currentPath,
+    errorLineNumberOffset
+  }, req) {
+    // we flush before running code in sandbox because it can potentially
+    // include code that blocks the whole process (like `while (true) {}`) and we
+    // want to ensure that the batched messages are flushed before trying to execute the code
+    await this.profiler.flush(req.context.rootId)
+
+    return this._runInSandbox({
+      manager,
+      context,
+      userCode,
+      executionFn,
+      onRequire,
+      propertiesConfig,
+      currentPath,
+      errorLineNumberOffset
+    }, req)
+  }
+
+  registerWorkerAction (actionName, fn) {
+    this._workerActions.set(actionName, fn)
+  }
+
+  async executeWorkerAction (actionName, data, req) {
+    const action = this._workerActions.get(actionName)
+    if (!action) {
+      throw new Error(`Worker action ${actionName} not registered`)
+    }
+    return action(data, req)
+  }
+
+  _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
+      }
+    })
+  }
+
+  async close () {
+    this.logger.debug('Closing jsreport worker')
+    return this.closeListeners.fire()
+  }
+}
+
+module.exports = WorkerReporter

package/lib/worker/sandbox/runInSandbox.js

@@ -1,6 +1,7 @@
 const LRU = require('lru-cache')
-const safeSandbox = require('./safeSandbox')
+const stackTrace = require('stack-trace')
 const { customAlphabet } = require('nanoid')
+const safeSandbox = require('./safeSandbox')
 const nanoid = customAlphabet('abcdefghijklmnopqrstuvwxyz', 10)
 
 module.exports = (reporter) => {
@@ -27,7 +28,7 @@ module.exports = (reporter) => {
     context.__topLevelFunctions = {}
     context.__handleError = (err) => handleError(reporter, err)
 
-    const { run, restore, contextifyValue, decontextifyValue, unproxyValue, sandbox, safeRequire } = safeSandbox(context, {
+    const { sourceFilesInfo, run, restore, contextifyValue, decontextifyValue, unproxyValue, sandbox, safeRequire } = safeSandbox(context, {
       onLog: (log) => {
         reporter.logger[log.level](log.message, { ...req, timestamp: log.timestamp })
       },
@@ -61,7 +62,51 @@ module.exports = (reporter) => {
     })
 
     jsreportProxy = reporter.createProxy({ req, runInSandbox: run, context: sandbox, getTopLevelFunctions, safeRequire })
-    jsreportProxy.currentPath = currentPath
+
+    jsreportProxy.currentPath = async () => {
+      // we get the current path by throwing an error, which give us a stack trace
+      // which we analyze and see if some source file is associated to an entity
+      // if it is then we can properly get the path associated to it, if not we
+      // fallback to the current path passed as options
+      const filesCount = sourceFilesInfo.size
+      let resolvedPath = currentPath
+
+      if (filesCount > 0) {
+        const err = new Error('get me stack trace please')
+        const trace = stackTrace.parse(err)
+
+        for (let i = 0; i < trace.length; i++) {
+          const current = trace[i]
+
+          if (sourceFilesInfo.has(current.getFileName())) {
+            const { entity, entitySet } = sourceFilesInfo.get(current.getFileName())
+
+            if (entity != null && entitySet != null) {
+              resolvedPath = await reporter.folders.resolveEntityPath(entity, entitySet, req)
+              break
+            }
+          }
+        }
+      }
+
+      return resolvedPath
+    }
+
+    jsreportProxy.currentDirectoryPath = async () => {
+      const currentPath = await jsreportProxy.currentPath()
+
+      if (currentPath != null) {
+        const localPath = currentPath.substring(0, currentPath.lastIndexOf('/'))
+
+        if (localPath === '') {
+          return '/'
+        }
+
+        return localPath
+      }
+
+      return currentPath
+    }
 
     // NOTE: it is important that cleanup, restore methods are not called from a function attached to the
     // sandbox, because the arguments and return value of such function call will be sandboxed again, to solve this
@@ -75,15 +120,22 @@ module.exports = (reporter) => {
     const functionNames = getTopLevelFunctions(userCode)
     const functionsCode = `return {${functionNames.map(h => `"${h}": ${h}`).join(',')}}`
     const executionCode = `;(async () => { ${userCode}; ${functionsCode} })()
-        .then((topLevelFunctions) => ${executionFnName}({
-            topLevelFunctions: {
-                ...topLevelFunctions,
-                ...__topLevelFunctions
-            },
-            require,
-            console,
-            context: this
-        })).catch(__handleError);`
+        .then((topLevelFunctions) => {
+          const mergedTopLevelFunctions = { ...topLevelFunctions, ...__topLevelFunctions }
+
+          // expose top level functions to the sandbox context
+          // so helpers can call other helpers (from shared asset helpers, or .registerHelpers call from proxy)
+          for (const [topLevelFnName, topLevelFn] of Object.entries(mergedTopLevelFunctions)) {
+            this[topLevelFnName] = topLevelFn
+          }
+
+          return ${executionFnName}({
+              topLevelFunctions: mergedTopLevelFunctions,
+              require,
+              console,
+              context: this
+          })
+        }).catch(__handleError);`
 
     return run(executionCode, {
       filename: 'sandbox.js',