@jsreport/jsreport-core 3.0.0 → 3.1.2-test.1

package/lib/worker/reporter.js

@@ -1,187 +1,192 @@
-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()
-    this.validateRenderListeners = this.createListenerCollection()
-
-    this.extensionsManager = ExtensionsManager(this, extensionsDefs)
-
-    this.extendProxy((proxy, req) => defaultProxyExtend(this)(proxy, req))
-    this.beforeMainActionListeners = this.createListenerCollection()
-  }
-
-  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 ({
-    context,
-    userCode,
-    executionFn,
-    onRequire,
-    propertiesConfig,
-    errorLineNumberOffset
-  }, req) {
-    return this._runInSandbox({
-      context,
-      userCode,
-      executionFn,
-      onRequire,
-      propertiesConfig,
-      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) {
+    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

@@ -5,9 +5,11 @@ const nanoid = customAlphabet('abcdefghijklmnopqrstuvwxyz', 10)
 
 module.exports = (reporter) => {
   return ({
+    manager = {},
     context,
     userCode,
     executionFn,
+    currentPath,
     onRequire,
     propertiesConfig,
     errorLineNumberOffset = 0
@@ -25,14 +27,14 @@ module.exports = (reporter) => {
     context.__topLevelFunctions = {}
     context.__handleError = (err) => handleError(reporter, err)
 
-    const { run, restore, sandbox, safeRequire } = safeSandbox(context, {
+    const { run, restore, contextifyValue, decontextifyValue, unproxyValue, sandbox, safeRequire } = safeSandbox(context, {
       onLog: (log) => {
         reporter.logger[log.level](log.message, { ...req, timestamp: log.timestamp })
       },
       formatError: (error, moduleName) => {
         error.message += ` To be able to require custom modules you need to add to configuration { "allowLocalFilesAccess": true } or enable just specific module using { sandbox: { allowedModules": ["${moduleName}"] }`
       },
-      modulesCache: reporter.requestModulesCache.get(req.context.id),
+      modulesCache: reporter.requestModulesCache.get(req.context.rootId),
       globalModules: reporter.options.sandbox.nativeModules || [],
       allowedModules: reporter.options.sandbox.allowedModules,
       propertiesConfig,
@@ -59,8 +61,16 @@ module.exports = (reporter) => {
     })
 
     jsreportProxy = reporter.createProxy({ req, runInSandbox: run, context: sandbox, getTopLevelFunctions, safeRequire })
+    jsreportProxy.currentPath = currentPath
 
-    sandbox.__restore = restore
+    // 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
+    // we don't attach these methods to the sandbox, and instead share them through a "manager" object that should
+    // be passed in options
+    manager.restore = restore
+    manager.contextifyValue = contextifyValue
+    manager.decontextifyValue = decontextifyValue
+    manager.unproxyValue = unproxyValue
 
     const functionNames = getTopLevelFunctions(userCode)
     const functionsCode = `return {${functionNames.map(h => `"${h}": ${h}`).join(',')}}`
@@ -72,7 +82,6 @@ module.exports = (reporter) => {
             },
             require,
             console,
-            restore: __restore,
             context: this
         })).catch(__handleError);`