@jsreport/jsreport-core 3.12.0 → 4.0.0

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

package/lib/main/migration/xlsxTemplatesToAssets.js

@@ -1,128 +0,0 @@
-const Request = require('../../shared/request')
-
-module.exports = async (reporter) => {
-  if (
-    reporter.options.migrateXlsxTemplatesToAssets === false ||
-    reporter.documentStore.collection('xlsxTemplates') == null ||
-    reporter.documentStore.collection('assets') == null
-  ) {
-    return
-  }
-
-  const migrated = await reporter.settings.findValue('core-migrated-xlsxTemplates')
-
-  if (migrated) {
-    return
-  }
-
-  const req = Request({})
-  await reporter.documentStore.beginTransaction(req)
-
-  try {
-    const xlsxTemplateIds = await reporter.documentStore.collection('xlsxTemplates').find({}, { _id: 1 }, req)
-
-    if (xlsxTemplateIds.length !== 0) {
-      reporter.logger.debug('Running migration "xlsxTemplatesToAssets"')
-    }
-
-    const xlsxTemplateToAssetMap = new Map()
-
-    for (const xlsxTemplateId of xlsxTemplateIds) {
-      const xlsxTemplate = await reporter.documentStore.collection('xlsxTemplates').findOne({ _id: xlsxTemplateId._id }, req)
-
-      if (!xlsxTemplateToAssetMap.has(xlsxTemplate.shortid)) {
-        let newAsset
-        let tryCount = 0
-
-        while (newAsset == null) {
-          try {
-            const assetName = `${'_'.repeat(tryCount) + xlsxTemplate.name}.xlsx`
-
-            const assetProps = {
-              name: assetName,
-              content: xlsxTemplate.contentRaw,
-              folder: xlsxTemplate.folder || null
-            }
-
-            if (xlsxTemplate.readPermissions != null) {
-              assetProps.readPermissions = xlsxTemplate.readPermissions
-            }
-
-            if (xlsxTemplate.editPermissions != null) {
-              assetProps.editPermissions = xlsxTemplate.editPermissions
-            }
-
-            newAsset = await reporter.documentStore.collection('assets').insert(assetProps, req)
-          } catch (insertError) {
-            tryCount++
-
-            if (insertError.code === 'DUPLICATED_ENTITY') {
-              continue
-            } else {
-              throw insertError
-            }
-          }
-        }
-
-        xlsxTemplateToAssetMap.set(xlsxTemplate.shortid, newAsset)
-      }
-    }
-
-    const templateIds = await reporter.documentStore.collection('templates').find({}, { _id: 1 }, req)
-
-    for (const templateId of templateIds) {
-      const template = await reporter.documentStore.collection('templates').findOne({ _id: templateId._id }, req)
-      let continueUpdate = false
-
-      // handle jsreport-xlsx migration
-      if (template.xlsxTemplate != null) {
-        continueUpdate = true
-
-        const xlsxTemplateRef = template.xlsxTemplate
-
-        template.xlsxTemplate = null
-
-        if (xlsxTemplateRef.shortid != null && xlsxTemplateToAssetMap.has(xlsxTemplateRef.shortid)) {
-          template.xlsx = template.xlsx || {}
-          template.xlsx.templateAssetShortid = xlsxTemplateToAssetMap.get(xlsxTemplateRef.shortid).shortid
-        }
-      }
-
-      // handle jsreport-html-to-xlsx migration
-      if (template.baseXlsxTemplate != null) {
-        continueUpdate = true
-
-        const baseXlsxTemplateRef = template.baseXlsxTemplate
-
-        template.baseXlsxTemplate = null
-
-        if (baseXlsxTemplateRef.shortid != null && xlsxTemplateToAssetMap.has(baseXlsxTemplateRef.shortid)) {
-          template.htmlToXlsx = template.htmlToXlsx || {}
-          template.htmlToXlsx.templateAssetShortid = xlsxTemplateToAssetMap.get(baseXlsxTemplateRef.shortid).shortid
-        }
-      }
-
-      if (continueUpdate) {
-        await reporter.documentStore.collection('templates').update({ _id: template._id }, { $set: template }, req)
-      }
-    }
-
-    for (const xlsxTemplateId of xlsxTemplateIds) {
-      await reporter.documentStore.collection('xlsxTemplates').remove({ _id: xlsxTemplateId._id }, req)
-    }
-
-    if (xlsxTemplateIds.length !== 0) {
-      reporter.logger.debug('Migration "xlsxTemplatesToAssets" finished')
-    }
-
-    await reporter.documentStore.commitTransaction(req)
-
-    await reporter.settings.addOrSet('core-migrated-xlsxTemplates', true)
-  } catch (migrationErr) {
-    await reporter.documentStore.rollbackTransaction(req)
-
-    migrationErr.message = `Migration "xlsxTemplatesToAssets" failed: ${migrationErr.message}`
-
-    throw migrationErr
-  }
-}