@jsreport/jsreport-core 3.12.0 → 4.0.1

package/lib/worker/sandbox/runInSandbox.js

@@ -21,7 +21,7 @@ module.exports = function createRunInSandbox (reporter) {
   }, req) {
     let jsreportProxy = null
 
-    // we use dynamic name because of the potential nested vm2 execution in the jsreportProxy.assets.require
+    // we use dynamic name because of the potential nested vm execution in the jsreportProxy.assets.require
     // it may turn out it is a bad approach in assets so we gonna delete it here
     const executionFnName = `${nanoid()}_executionFn`
 
@@ -29,11 +29,10 @@ module.exports = function createRunInSandbox (reporter) {
     context.__appDirectory = reporter.options.appDirectory
     context.__rootDirectory = reporter.options.rootDirectory
     context.__parentModuleDirectory = reporter.options.parentModuleDirectory
-    context.setTimeout = setTimeout
     context.__topLevelFunctions = {}
     context.__handleError = (err) => handleError(reporter, err)
 
-    const { sourceFilesInfo, run, compileScript, restore, sandbox, sandboxRequire } = createSandbox(context, {
+    const { sourceFilesInfo, run, compileScript, restore, sandbox, sandboxRequire } = await createSandbox(context, {
       rootDirectory: reporter.options.rootDirectory,
       onLog: (log) => {
         // we mark any log done in sandbox as userLevel: true, this allows us to detect which logs belongs to user
@@ -159,9 +158,23 @@ module.exports = function createRunInSandbox (reporter) {
     }
 
     const functionNames = getTopLevelFunctions(functionsCache, userCode)
-    const functionsCode = `return {${functionNames.map(h => `"${h}": ${h}`).join(',')}}`
-    const executionCode = `;(async () => { ${userCode} \n\n;${functionsCode} })()
-        .then((topLevelFunctions) => {
+
+    // it is better we remove our internal functions so we avoid user having the chance
+    // to call them, as long as we force the execution to be truly async (with the await 1)
+    // then it is safe to delete __handleError from context, when the execution is truly
+    // async then it means the __handleError was already passed to catch handler,
+    // therefore safe to delete
+    const contextNormalizeCode = [
+      'await 1;',
+      `const ${executionFnName}_expose = ${executionFnName};`,
+      'delete this.__handleError;',
+      `delete this['${executionFnName}'];`
+    ].join('')
+
+    const functionsCode = `return {topLevelFunctions: {${functionNames.map(h => `"${h}": ${h}`).join(',')}}, fnToExecute: ${executionFnName}_expose}`
+
+    const executionCode = `;(async () => { ${contextNormalizeCode}${userCode} \n\n;${functionsCode} })()
+        .then(({ topLevelFunctions, fnToExecute }) => {
           const mergedTopLevelFunctions = { ...topLevelFunctions, ...__topLevelFunctions }
 
           // expose top level functions to the sandbox context
@@ -170,7 +183,7 @@ module.exports = function createRunInSandbox (reporter) {
             this[topLevelFnName] = topLevelFn
           }
 
-          return ${executionFnName}({
+          return fnToExecute({
               topLevelFunctions: mergedTopLevelFunctions,
               require,
               console,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsreport/jsreport-core",
-  "version": "3.12.0",
+  "version": "4.0.1",
   "description": "javascript based business reporting",
   "keywords": [
     "report",
@@ -40,9 +40,11 @@
     "@babel/parser": "7.14.4",
     "@babel/traverse": "7.12.9",
     "@colors/colors": "1.5.0",
-    "@jsreport/advanced-workers": "1.3.0",
+    "@jsreport/advanced-workers": "2.0.0",
     "@jsreport/mingo": "2.4.1",
     "@jsreport/reap": "0.1.0",
+    "@jsreport/serializator": "1.0.0",
+    "@jsreport/ses": "1.0.0",
     "ajv": "6.12.6",
     "app-root-path": "3.0.0",
     "bytes": "3.1.2",
@@ -59,19 +61,17 @@
     "lodash.get": "4.4.2",
     "lodash.groupby": "4.6.0",
     "lodash.omit": "4.5.0",
-    "lodash.set": "4.3.2",
     "lru-cache": "4.1.1",
     "ms": "2.1.3",
     "nanoid": "3.2.0",
     "nconf": "0.12.0",
     "node.extend.without.arrays": "1.1.6",
-    "semver": "7.3.5",
-    "serializator": "1.0.2",
+    "semver": "7.5.4",
+    "set-value": "4.1.0",
     "stack-trace": "0.0.10",
     "triple-beam": "1.3.0",
     "unset-value": "2.0.1",
     "uuid": "8.3.2",
-    "vm2": "3.9.19",
     "winston": "3.8.1",
     "winston-transport": "4.5.0",
     "yieldable-json": "2.0.1"
@@ -85,7 +85,7 @@
     "winston-loggly-bulk": "3.2.1"
   },
   "engines": {
-    "node": ">=16.11"
+    "node": ">=18.15"
   },
   "standard": {
     "env": {

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

@@ -1,51 +1,62 @@
-
-module.exports = (reporter, definition) => {
-  reporter.tests = reporter.tests || {}
-  reporter.tests.beforeRenderListeners = reporter.createListenerCollection()
-  reporter.tests.afterRenderListeners = reporter.createListenerCollection()
-  reporter.tests.validateRenderListeners = reporter.createListenerCollection()
-  reporter.tests.afterTemplatingEnginesExecutedListeners = reporter.createListenerCollection()
-
-  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 }
-  })
-  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 }
-  })
-  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 }
-  })
-  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 }
-  })
-
-  let beforeRenderEval
-  reporter.tests.beforeRenderEval = (fn) => {
-    beforeRenderEval = fn
-  }
-  reporter.registerMainAction('test-beforeRenderEval', async (data, req) => {
-    if (beforeRenderEval == null) {
-      return
-    }
-    return beforeRenderEval.toString()
-  })
-
-  let afterRenderEval
-  reporter.tests.afterRenderEval = (fn) => {
-    afterRenderEval = fn
-  }
-  reporter.registerMainAction('test-afterRenderEval', async (data, req) => {
-    if (afterRenderEval == null) {
-      return
-    }
-    return afterRenderEval.toString()
-  })
-}
+
+module.exports = (reporter, definition) => {
+  reporter.tests = reporter.tests || {}
+  reporter.tests.beforeRenderListeners = reporter.createListenerCollection()
+  reporter.tests.afterRenderListeners = reporter.createListenerCollection()
+  reporter.tests.validateRenderListeners = reporter.createListenerCollection()
+  reporter.tests.afterTemplatingEnginesExecutedListeners = reporter.createListenerCollection()
+
+  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 }
+  })
+  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 }
+  })
+  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 }
+  })
+  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 }
+  })
+
+  let beforeRenderEval
+  reporter.tests.beforeRenderEval = (fn) => {
+    beforeRenderEval = fn
+  }
+  reporter.registerMainAction('test-beforeRenderEval', async (data, req) => {
+    if (beforeRenderEval == null) {
+      return
+    }
+    return beforeRenderEval.toString()
+  })
+
+  let afterRenderEval
+  reporter.tests.afterRenderEval = (fn) => {
+    afterRenderEval = fn
+  }
+  reporter.registerMainAction('test-afterRenderEval', async (data, req) => {
+    if (afterRenderEval == null) {
+      return
+    }
+    return afterRenderEval.toString()
+  })
+
+  let afterTemplatingEnginesExecutedEval
+  reporter.tests.afterTemplatingEnginesExecutedEval = (fn) => {
+    afterTemplatingEnginesExecutedEval = fn
+  }
+  reporter.registerMainAction('test-afterTemplatingEnginesExecutedEval', async (data, req) => {
+    if (afterTemplatingEnginesExecutedEval == null) {
+      return
+    }
+    return afterTemplatingEnginesExecutedEval.toString()
+  })
+}

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

@@ -1,74 +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)
-      }
-    })
-  })
-}
+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)
+      }
+    })
+  })
+}

package/test/store/common.js

@@ -141,6 +141,34 @@ function collectionTests (store, isInternal, runTransactions) {
     res[0].phantom.header.should.be.eql('original')
   })
 
+  it('update should use clones', async () => {
+    const colName = !isInternal ? 'templates' : 'internalTemplates'
+
+    await store().collection('folders').insert({
+      name: 'f1',
+      shortid: 'f1'
+    })
+
+    await getCollection(colName).insert({
+      name: 'test',
+      engine: 'none',
+      recipe: 'html',
+      content: 'original'
+    })
+
+    const set = {
+      folder: {
+        shortid: 'f1'
+      }
+    }
+
+    await getCollection(colName).update({ name: 'test' }, { $set: set })
+    set.folder.shortid = 'changing'
+
+    const res = await getCollection(colName).findOne({})
+    res.folder.shortid.should.be.eql('f1')
+  })
+
   it('skip and limit', async () => {
     const colName = !isInternal ? 'templates' : 'internalTemplates'
 
@@ -443,6 +471,33 @@ function collectionTests (store, isInternal, runTransactions) {
         should(found != null).be.True()
       })
 
+      it('insert with transaction should use clones', async () => {
+        const colName = !isInternal ? 'templates' : 'internalTemplates'
+        const req = Request({})
+
+        await store().beginTransaction(req)
+
+        try {
+          const t1 = {
+            name: 't1',
+            engine: 'none',
+            recipe: 'html'
+          }
+
+          const newT1 = await getCollection(colName).insert(t1, req)
+
+          newT1.name = 'fake-t1'
+
+          await store().commitTransaction(req)
+        } catch (e) {
+          await store().rollbackTransaction(req)
+          throw e
+        }
+
+        const found = await getCollection(colName).findOne({ name: 't1' })
+        should(found).not.be.null()
+      })
+
       it('should be able to rollback (insert)', async () => {
         const colName = !isInternal ? 'templates' : 'internalTemplates'
         const req = Request({})

package/lib/main/migration/resourcesToAssets.js

@@ -1,230 +0,0 @@
-const Request = require('../../shared/request')
-
-module.exports = async (reporter) => {
-  if (
-    reporter.options.migrateResourcesToAssets === false ||
-    reporter.documentStore.collection('scripts') == null ||
-    reporter.documentStore.collection('data') == null
-  ) {
-    return
-  }
-
-  const migrated = await reporter.settings.findValue('core-migrated-resources')
-
-  if (migrated) {
-    return
-  }
-
-  const req = Request({})
-  await reporter.documentStore.beginTransaction(req)
-
-  try {
-    const templateIds = await reporter.documentStore.collection('templates').find({}, { _id: 1 }, req)
-
-    if (templateIds.length !== 0) {
-      reporter.logger.debug('Running migration "resourcesToAssets"')
-    }
-
-    const templateToAssetResourcesMap = new Map()
-    const dataToAssetMap = new Map()
-    const dataEntitiesToRemove = []
-
-    for (const templateId of templateIds) {
-      const template = await reporter.documentStore.collection('templates').findOne({ _id: templateId._id }, req)
-
-      if (template.resources == null) {
-        continue
-      }
-
-      if (Array.isArray(template.resources.items)) {
-        for (const dataItem of template.resources.items) {
-          const dataEntity = await reporter.documentStore.collection('data').findOne({ shortid: dataItem.shortid }, req)
-
-          if (dataEntity) {
-            let newAsset
-
-            if (dataToAssetMap.has(dataEntity._id)) {
-              newAsset = dataToAssetMap.get(dataEntity._id)
-            } else {
-              const assetProps = {
-                content: Buffer.from(dataEntity.dataJson || ''),
-                folder: dataEntity.folder || null
-              }
-
-              if (dataEntity.readPermissions != null) {
-                assetProps.readPermissions = dataEntity.readPermissions
-              }
-
-              if (dataEntity.editPermissions != null) {
-                assetProps.editPermissions = dataEntity.editPermissions
-              }
-
-              newAsset = await insertUnique(reporter, 'assets', `${dataEntity.name}.json`, assetProps, req)
-
-              dataToAssetMap.set(dataEntity._id, newAsset)
-            }
-
-            const assetResources = templateToAssetResourcesMap.get(template._id) || []
-
-            assetResources.push({
-              ...newAsset,
-              originalName: dataEntity.name
-            })
-
-            templateToAssetResourcesMap.set(template._id, assetResources)
-            dataEntitiesToRemove.push(dataEntity._id)
-          }
-        }
-      }
-
-      const templateAssetResources = templateToAssetResourcesMap.get(template._id) || []
-
-      if (templateAssetResources.length > 0) {
-        const scriptProps = {
-          content: (
-`
-// THIS SCRIPT WAS GENERATED BY MIGRATION IN V3, IT PROVIDES BACKWARD COMPATIBILITY
-// WITH THE DEPRECATED jsreport-resources https://jsreport.net/learn/resources
-// THE RECOMMENDATION NOW IS TO USE jsreport-localization https://jsreport.net/learn/localization
-// SO WHEN YOU DECIDE TO USE jsreport-localization TO FULLY REPLACE THE jsreport-resources
-// JUST REMOVE THIS SCRIPT FROM YOUR TEMPLATE AND DELETE IT
-const jsreport = require('jsreport-proxy')
-
-async function beforeRender (req, res) {
-  req.options.language = req.options.language || req.template.localization?.language
-  const defaultLanguage = ${template.resources.defaultLanguage != null ? '\'' + template.resources.defaultLanguage + '\'' : 'undefined'}
-  const assetsResources = [${templateAssetResources.map(a => `{ name: '${a.originalName}', shortid: '${a.shortid}' }`).join(', ')}]
-
-  const resources = await Promise.all(assetsResources.map(async (r) => {
-    const asset = await jsreport.documentStore.collection('assets').findOne({ shortid: r.shortid })
-
-    if (asset == null) {
-      throw new Error(\`Asset resources with shortid \${r.shortid} was not found (resource lookup)\`)
-    }
-
-    asset.resourceName = r.name
-    asset.content = asset.content.toString()
-
-    return asset
-  }))
-
-  resources.forEach((r) => {
-    r.dataJson = r.content
-    r.data = JSON.parse(r.content)
-  })
-
-  req.options.resources = resources
-  req.data.$resources = resources
-
-  const resourcesByName = {}
-
-  resources.forEach((r) => {
-    resourcesByName[r.resourceName] = r.data
-  })
-
-  req.options.resource = resourcesByName
-  req.data.$resource = resourcesByName
-
-  const isLocalizedRequest = req.options.language != null || defaultLanguage != null
-
-  if (isLocalizedRequest) {
-    let languageUsed
-    let applicableResources = []
-
-    if (req.options.language) {
-      languageUsed = req.options.language
-      applicableResources = resources.filter((r) => r.resourceName.startsWith(\`\${languageUsed}-\`))
-    }
-
-    if (!applicableResources.length && defaultLanguage) {
-      languageUsed = defaultLanguage
-      applicableResources = resources.filter((r) => r.resourceName.startsWith(\`\${languageUsed}-\`))
-    }
-
-    console.log(\`Found \${applicableResources.length} resources for language "\${languageUsed}"\`)
-
-    req.options.localizedResources = applicableResources
-    req.data.$localizedResources = applicableResources
-
-    const localizedResourceByName = {}
-
-    applicableResources.forEach((r) => {
-      localizedResourceByName[r.resourceName.substring(\`\${languageUsed}-\`.length)] = r.data
-    })
-
-    req.options.localizedResource = applicableResources.length === 1 ? applicableResources[0].data : localizedResourceByName
-    req.data.$localizedResource = req.options.localizedResource
-  }
-}
-`
-          ),
-          folder: template.folder || null
-        }
-
-        if (template.readPermissions != null) {
-          scriptProps.readPermissions = template.readPermissions
-        }
-
-        if (template.editPermissions != null) {
-          scriptProps.editPermissions = template.editPermissions
-        }
-
-        const newScript = await insertUnique(reporter, 'scripts', `${template.name}_resources`, scriptProps, req)
-
-        template.scripts = template.scripts || []
-
-        template.scripts.unshift({
-          shortid: newScript.shortid
-        })
-      }
-
-      template.resources = null
-
-      await reporter.documentStore.collection('templates').update({ _id: template._id }, { $set: template }, req)
-    }
-
-    for (const dataEntityId of dataEntitiesToRemove) {
-      await reporter.documentStore.collection('data').remove({ _id: dataEntityId }, req)
-    }
-
-    if (templateIds.length !== 0) {
-      reporter.logger.debug('Migration "resourcesToAssets" finished')
-    }
-
-    await reporter.documentStore.commitTransaction(req)
-
-    await reporter.settings.addOrSet('core-migrated-resources', true)
-  } catch (migrationErr) {
-    await reporter.documentStore.rollbackTransaction(req)
-
-    migrationErr.message = `Migration "resourcesToAssets" failed: ${migrationErr.message}`
-
-    throw migrationErr
-  }
-}
-
-async function insertUnique (reporter, collectionName, baseName, entity, req) {
-  let newEntity
-  let tryCount = 0
-
-  while (newEntity == null) {
-    try {
-      const entityName = '_'.repeat(tryCount) + baseName
-
-      newEntity = await reporter.documentStore.collection(collectionName).insert({
-        ...entity,
-        name: entityName
-      }, req)
-
-      return newEntity
-    } catch (insertError) {
-      tryCount++
-
-      if (insertError.code === 'DUPLICATED_ENTITY') {
-        continue
-      } else {
-        throw insertError
-      }
-    }
-  }
-}