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

package/lib/shared/templates.js

@@ -1,82 +1,82 @@
-
-module.exports = (reporter) => {
-  return {
-    resolveTemplate: (req) => resolveTemplate(reporter, req)
-  }
-}
-
-async function resolveTemplate (reporter, req) {
-  let queryResult
-
-  if (req.template._id) {
-    queryResult = {
-      query: { _id: req.template._id },
-      meta: { field: '_id', value: req.template._id }
-    }
-  } else if (req.template.shortid) {
-    queryResult = {
-      query: { shortid: req.template.shortid },
-      meta: { field: 'shortid', value: req.template.shortid }
-    }
-  }
-
-  const meta = {}
-  let templates = []
-
-  if (queryResult) {
-    meta.field = queryResult.meta.field
-    meta.value = queryResult.meta.value
-    templates = await reporter.documentStore.collection('templates').find(queryResult.query, req)
-  } else if (req.template.name) {
-    const nameIsPath = req.template.name.indexOf('/') !== -1
-
-    meta.field = 'name'
-    meta.value = req.template.name
-
-    if (!req.template.name.startsWith('/') && nameIsPath && !req.context.currentFolderPath) {
-      throw reporter.createError('Invalid template path, path should be absolute and start with "/"', {
-        statusCode: 400,
-        weak: true
-      })
-    }
-
-    const pathParts = req.template.name.split('/').filter((p) => p)
-
-    if (pathParts.length === 0) {
-      throw reporter.createError('Invalid template path,', {
-        statusCode: 400,
-        weak: true
-      })
-    }
-
-    if (!nameIsPath) {
-      // if name is not path do global search by name (with no folder).
-      // since template name resolution here does not support relative syntax we should not run
-      // resolveEntityFromPath if the name is not path
-      templates = await reporter.documentStore.collection('templates').find({
-        name: req.template.name
-      }, req)
-    } else {
-      const result = await reporter.folders.resolveEntityFromPath(req.template.name, 'templates', req)
-
-      if (result) {
-        templates = [result.entity]
-      }
-    }
-  }
-
-  let template
-
-  if (templates.length > 1) {
-    throw reporter.createError(`Duplicated templates found for query ${meta.field}: ${meta.value}`, {
-      statusCode: 400,
-      weak: true
-    })
-  }
-
-  if (templates.length === 1) {
-    template = templates[0]
-  }
-
-  return template
-}
+
+module.exports = (reporter) => {
+  return {
+    resolveTemplate: (req) => resolveTemplate(reporter, req)
+  }
+}
+
+async function resolveTemplate (reporter, req) {
+  let queryResult
+
+  if (req.template._id) {
+    queryResult = {
+      query: { _id: req.template._id },
+      meta: { field: '_id', value: req.template._id }
+    }
+  } else if (req.template.shortid) {
+    queryResult = {
+      query: { shortid: req.template.shortid },
+      meta: { field: 'shortid', value: req.template.shortid }
+    }
+  }
+
+  const meta = {}
+  let templates = []
+
+  if (queryResult) {
+    meta.field = queryResult.meta.field
+    meta.value = queryResult.meta.value
+    templates = await reporter.documentStore.collection('templates').find(queryResult.query, req)
+  } else if (req.template.name) {
+    const nameIsPath = req.template.name.indexOf('/') !== -1
+
+    meta.field = 'name'
+    meta.value = req.template.name
+
+    if (!req.template.name.startsWith('/') && nameIsPath && !req.context.currentFolderPath) {
+      throw reporter.createError('Invalid template path, path should be absolute and start with "/"', {
+        statusCode: 400,
+        weak: true
+      })
+    }
+
+    const pathParts = req.template.name.split('/').filter((p) => p)
+
+    if (pathParts.length === 0) {
+      throw reporter.createError('Invalid template path,', {
+        statusCode: 400,
+        weak: true
+      })
+    }
+
+    if (!nameIsPath) {
+      // if name is not path do global search by name (with no folder).
+      // since template name resolution here does not support relative syntax we should not run
+      // resolveEntityFromPath if the name is not path
+      templates = await reporter.documentStore.collection('templates').find({
+        name: req.template.name
+      }, req)
+    } else {
+      const result = await reporter.folders.resolveEntityFromPath(req.template.name, 'templates', req)
+
+      if (result) {
+        templates = [result.entity]
+      }
+    }
+  }
+
+  let template
+
+  if (templates.length > 1) {
+    throw reporter.createError(`Duplicated templates found for query ${meta.field}: ${meta.value}`, {
+      statusCode: 400,
+      weak: true
+    })
+  }
+
+  if (templates.length === 1) {
+    template = templates[0]
+  }
+
+  return template
+}

package/lib/static/helpers.js

@@ -1,33 +1,33 @@
-/* eslint-disable no-unused-vars */
-async function module (moduleName) {
-  const jsreport = require('jsreport-proxy')
-  return jsreport.module(moduleName)
-}
-
-function toJS (data) {
-  function jsStringEscape (string) {
-    return ('' + string).replace(/["'\\\n\r\u2028\u2029]/g, function (character) {
-      // Escape all characters not included in SingleStringCharacters and
-      // DoubleStringCharacters on
-      // http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4
-      switch (character) {
-        case '"':
-        case "'":
-        case '\\':
-          return '\\' + character
-          // Four possible LineTerminator characters need to be escaped:
-        case '\n':
-          return '\\n'
-        case '\r':
-          return '\\r'
-        case '\u2028':
-          return '\\u2028'
-        case '\u2029':
-          return '\\u2029'
-      }
-    })
-  }
-
-  const validDataStr = jsStringEscape(JSON.stringify(data))
-  return `JSON.parse('${validDataStr}')`
-}
+/* eslint-disable no-unused-vars */
+async function module (moduleName) {
+  const jsreport = require('jsreport-proxy')
+  return jsreport.module(moduleName)
+}
+
+function toJS (data) {
+  function jsStringEscape (string) {
+    return ('' + string).replace(/["'\\\n\r\u2028\u2029]/g, function (character) {
+      // Escape all characters not included in SingleStringCharacters and
+      // DoubleStringCharacters on
+      // http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4
+      switch (character) {
+        case '"':
+        case "'":
+        case '\\':
+          return '\\' + character
+          // Four possible LineTerminator characters need to be escaped:
+        case '\n':
+          return '\\n'
+        case '\r':
+          return '\\r'
+        case '\u2028':
+          return '\\u2028'
+        case '\u2029':
+          return '\\u2029'
+      }
+    })
+  }
+
+  const validDataStr = jsStringEscape(JSON.stringify(data))
+  return `JSON.parse('${validDataStr}')`
+}

package/lib/worker/blobStorage.js

@@ -1,34 +1,34 @@
-module.exports = (executeMainAction) => {
-  return {
-    async read (blobName, req) {
-      const r = await executeMainAction('blobStorage.read', {
-        blobName
-      }, req)
-      return Buffer.from(r, 'base64')
-    },
-
-    write (blobName, content, req) {
-      return executeMainAction('blobStorage.write', {
-        blobName,
-        content: Buffer.from(content).toString('base64')
-      }, req)
-    },
-
-    remove (blobName, req) {
-      return executeMainAction('blobStorage.remove', {
-        blobName
-      }, req)
-    },
-
-    append (blobName, content, req) {
-      return executeMainAction('blobStorage.append', {
-        blobName,
-        content: Buffer.from(content).toString('base64')
-      }, req)
-    },
-
-    init () {
-
-    }
-  }
-}
+module.exports = (executeMainAction) => {
+  return {
+    async read (blobName, req) {
+      const r = await executeMainAction('blobStorage.read', {
+        blobName
+      }, req)
+      return Buffer.from(r, 'base64')
+    },
+
+    write (blobName, content, req) {
+      return executeMainAction('blobStorage.write', {
+        blobName,
+        content: Buffer.from(content).toString('base64')
+      }, req)
+    },
+
+    remove (blobName, req) {
+      return executeMainAction('blobStorage.remove', {
+        blobName
+      }, req)
+    },
+
+    append (blobName, content, req) {
+      return executeMainAction('blobStorage.append', {
+        blobName,
+        content: Buffer.from(content).toString('base64')
+      }, req)
+    },
+
+    init () {
+
+    }
+  }
+}

package/lib/worker/defaultProxyExtend.js

@@ -1,46 +1,46 @@
-
-module.exports = (reporter) => (proxy, req) => {
-  proxy.req = req
-
-  proxy.render = async (renderRequest) => {
-    const res = await reporter.render({
-      ...renderRequest,
-      // new fresh context (user data and cycle control counter is inherit from originalReq during rendering).
-      // this avoids that user can fake user identity by sending context
-      // with information of another user and allows the original request to collect logs
-      // from the render of proxy
-      context: {}
-    }, req)
-
-    return {
-      content: res.content,
-      meta: res.meta
-    }
-  }
-
-  proxy.documentStore = {
-    collection: (name) => ({
-      find: async (q) => {
-        req.context.userFindCall = true
-        const res = await reporter.documentStore.collection(name).find(q, req)
-        return res
-      },
-      findOne: async (q) => {
-        req.context.userFindCall = true
-
-        const res = await reporter.documentStore.collection(name).findOne(q, req)
-
-        return res
-      }
-    })
-  }
-
-  proxy.folders = {
-    resolveEntityFromPath: (path, es, options) => {
-      return reporter.folders.resolveEntityFromPath(path, es, options || {}, req)
-    },
-    resolveEntityPath: (entity, es) => {
-      return reporter.folders.resolveEntityPath(entity, es, req)
-    }
-  }
-}
+
+module.exports = (reporter) => (proxy, req) => {
+  proxy.req = req
+
+  proxy.render = async (renderRequest) => {
+    const res = await reporter.render({
+      ...renderRequest,
+      // new fresh context (user data and cycle control counter is inherit from originalReq during rendering).
+      // this avoids that user can fake user identity by sending context
+      // with information of another user and allows the original request to collect logs
+      // from the render of proxy
+      context: {}
+    }, req)
+
+    return {
+      content: res.content,
+      meta: res.meta
+    }
+  }
+
+  proxy.documentStore = {
+    collection: (name) => ({
+      find: async (q) => {
+        req.context.userFindCall = true
+        const res = await reporter.documentStore.collection(name).find(q, req)
+        return res
+      },
+      findOne: async (q) => {
+        req.context.userFindCall = true
+
+        const res = await reporter.documentStore.collection(name).findOne(q, req)
+
+        return res
+      }
+    })
+  }
+
+  proxy.folders = {
+    resolveEntityFromPath: (path, es, options) => {
+      return reporter.folders.resolveEntityFromPath(path, es, options || {}, req)
+    },
+    resolveEntityPath: (entity, es) => {
+      return reporter.folders.resolveEntityPath(entity, es, req)
+    }
+  }
+}

package/lib/worker/documentStore.js

@@ -1,49 +1,49 @@
-module.exports = ({ model, collections }, executeMainAction) => {
-  const store = {
-    model,
-    collection: (name) => ({
-      find: (q, req) => executeMainAction('documentStore.collection.find', {
-        query: q,
-        collection: name
-      }, req),
-      findOne: (q, req) => executeMainAction('documentStore.collection.findOne', {
-        query: q,
-        collection: name
-      }, req),
-      insert: async (doc, req) => {
-        const entity = await executeMainAction('documentStore.collection.insert', {
-          doc,
-          collection: name
-        }, req)
-        doc._id = entity._id
-        return entity
-      },
-      update: async (query, update, options, req) => {
-        if (req == null) {
-          req = options
-          options = {}
-        }
-
-        const r = await executeMainAction('documentStore.collection.update', {
-          query,
-          update,
-          options,
-          collection: name
-        }, req)
-
-        return r
-      }
-    })
-  }
-
-  store.collections = {}
-
-  for (const colName of collections) {
-    store.collections[colName] = {
-      name: colName,
-      ...store.collection(colName)
-    }
-  }
-
-  return store
-}
+module.exports = ({ model, collections }, executeMainAction) => {
+  const store = {
+    model,
+    collection: (name) => ({
+      find: (q, req) => executeMainAction('documentStore.collection.find', {
+        query: q,
+        collection: name
+      }, req),
+      findOne: (q, req) => executeMainAction('documentStore.collection.findOne', {
+        query: q,
+        collection: name
+      }, req),
+      insert: async (doc, req) => {
+        const entity = await executeMainAction('documentStore.collection.insert', {
+          doc,
+          collection: name
+        }, req)
+        doc._id = entity._id
+        return entity
+      },
+      update: async (query, update, options, req) => {
+        if (req == null) {
+          req = options
+          options = {}
+        }
+
+        const r = await executeMainAction('documentStore.collection.update', {
+          query,
+          update,
+          options,
+          collection: name
+        }, req)
+
+        return r
+      }
+    })
+  }
+
+  store.collections = {}
+
+  for (const colName of collections) {
+    store.collections[colName] = {
+      name: colName,
+      ...store.collection(colName)
+    }
+  }
+
+  return store
+}

package/lib/worker/extensionsManager.js

@@ -1,17 +1,17 @@
-const path = require('path')
-
-module.exports = (reporter, extensionsDefs) => {
-  return {
-    recipes: [],
-    engines: [],
-    extensions: extensionsDefs,
-
-    async init () {
-      for (const extension of this.extensions) {
-        if (extension.options.enabled !== false) {
-          await require(path.join(extension.directory, extension.worker))(reporter, extension)
-        }
-      }
-    }
-  }
-}
+const path = require('path')
+
+module.exports = (reporter, extensionsDefs) => {
+  return {
+    recipes: [],
+    engines: [],
+    extensions: extensionsDefs,
+
+    async init () {
+      for (const extension of this.extensions) {
+        if (extension.options.enabled !== false) {
+          await require(path.join(extension.directory, extension.worker))(reporter, extension)
+        }
+      }
+    }
+  }
+}

package/lib/worker/logger.js

@@ -1,48 +1,48 @@
-const util = require('util')
-const normalizeMetaFromLogs = require('../shared/normalizeMetaFromLogs')
-
-module.exports = function createLogger (profiler) {
-  return {
-    debug: (...args) => logFn('debug', profiler, ...args),
-    info: (...args) => logFn('info', profiler, ...args),
-    warn: (...args) => logFn('warn', profiler, ...args),
-    error: (...args) => logFn('error', profiler, ...args)
-  }
-}
-
-function logFn (level, profiler, ...args) {
-  const lastArg = args.slice(-1)[0]
-  let req
-
-  if (
-    lastArg != null &&
-    typeof lastArg === 'object' &&
-    lastArg.context != null &&
-    lastArg.context.rootId != null
-  ) {
-    req = lastArg
-  }
-
-  if (req == null) {
-    return
-  }
-
-  const msgArgs = args.slice(0, -1)
-
-  const log = {
-    timestamp: new Date().getTime(),
-    level: level,
-    message: util.format.apply(util, msgArgs)
-  }
-
-  const meta = normalizeMetaFromLogs(level, log.message, lastArg)
-
-  if (meta != null) {
-    log.meta = meta
-  }
-
-  return profiler.emit({
-    type: 'log',
-    ...log
-  }, req)
-}
+const util = require('util')
+const normalizeMetaFromLogs = require('../shared/normalizeMetaFromLogs')
+
+module.exports = function createLogger (profiler) {
+  return {
+    debug: (...args) => logFn('debug', profiler, ...args),
+    info: (...args) => logFn('info', profiler, ...args),
+    warn: (...args) => logFn('warn', profiler, ...args),
+    error: (...args) => logFn('error', profiler, ...args)
+  }
+}
+
+function logFn (level, profiler, ...args) {
+  const lastArg = args.slice(-1)[0]
+  let req
+
+  if (
+    lastArg != null &&
+    typeof lastArg === 'object' &&
+    lastArg.context != null &&
+    lastArg.context.rootId != null
+  ) {
+    req = lastArg
+  }
+
+  if (req == null) {
+    return
+  }
+
+  const msgArgs = args.slice(0, -1)
+
+  const log = {
+    timestamp: new Date().getTime(),
+    level: level,
+    message: util.format.apply(util, msgArgs)
+  }
+
+  const meta = normalizeMetaFromLogs(level, log.message, lastArg)
+
+  if (meta != null) {
+    log.meta = meta
+  }
+
+  return profiler.emit({
+    type: 'log',
+    ...log
+  }, req)
+}