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

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)
+}

package/lib/worker/render/diff.js

@@ -1,138 +1,138 @@
-const jsdiff = require('diff')
-const gdiff = new (require('diff-match-patch'))()
-
-function formatPatch (diff) {
-  const ret = []
-  if (diff.oldFileName === diff.newFileName) {
-    ret.push('Index: ' + diff.oldFileName)
-  }
-  ret.push('===================================================================')
-  ret.push('--- ' + diff.oldFileName + (typeof diff.oldHeader === 'undefined' ? '' : '\t' + diff.oldHeader))
-  ret.push('+++ ' + diff.newFileName + (typeof diff.newHeader === 'undefined' ? '' : '\t' + diff.newHeader))
-
-  for (let i = 0; i < diff.hunks.length; i++) {
-    const hunk = diff.hunks[i]
-    ret.push(
-      '@@ -' + hunk.oldStart + ',' + hunk.oldLines +
-            ' +' + hunk.newStart + ',' + hunk.newLines +
-            ' @@'
-    )
-    ret.push.apply(ret, hunk.lines)
-  }
-
-  const res = ret.join('\n') + '\n'
-  return res
-}
-
-function createPatch (name, older, newer, context) {
-  const { chars1, chars2, lineArray } = gdiff.diff_linesToChars_(older, newer)
-  const cdiff = gdiff.diff_main(chars1, chars2, false)
-  gdiff.diff_charsToLines_(cdiff, lineArray)
-
-  const diff = cdiff.map(([op, data]) => {
-    const r = { value: data }
-    if (op === 1) {
-      r.added = true
-    }
-    if (op === -1) {
-      r.removed = true
-    }
-    return r
-  })
-
-  diff.push({ value: '', lines: [] }) // Append an empty value to make cleanup easier
-
-  function contextLines (lines) {
-    return lines.map(function (entry) { return ' ' + entry })
-  }
-
-  const hunks = []
-  let oldRangeStart = 0
-  let newRangeStart = 0
-  let curRange = []
-
-  let oldLine = 1; let newLine = 1
-  for (let i = 0; i < diff.length; i++) {
-    const current = diff[i]
-
-    const lines = current.lines || current.value.replace(/\n$/, '').split('\n')
-    current.lines = lines
-
-    if (current.added || current.removed) {
-      // If we have previous context, start with that
-      if (!oldRangeStart) {
-        const prev = diff[i - 1]
-        oldRangeStart = oldLine
-        newRangeStart = newLine
-
-        if (prev) {
-          curRange = context > 0 ? contextLines(prev.lines.slice(-context)) : []
-          oldRangeStart -= curRange.length
-          newRangeStart -= curRange.length
-        }
-      }
-
-      // Output our changes
-      curRange.push(...lines.map(function (entry) {
-        return (current.added ? '+' : '-') + entry
-      }))
-
-      // Track the updated file position
-      if (current.added) {
-        newLine += lines.length
-      } else {
-        oldLine += lines.length
-      }
-    } else {
-      // Identical context lines. Track line changes
-      if (oldRangeStart) {
-        // Close out any changes that have been output (or join overlapping)
-        if (lines.length <= context * 2 && i < diff.length - 2) {
-          // Overlapping
-          curRange.push(...contextLines(lines))
-        } else {
-          // end the range and output
-          const contextSize = Math.min(lines.length, context)
-          curRange.push(...contextLines(lines.slice(0, contextSize)))
-
-          const hunk = {
-            oldStart: oldRangeStart,
-            oldLines: (oldLine - oldRangeStart + contextSize),
-            newStart: newRangeStart,
-            newLines: (newLine - newRangeStart + contextSize),
-            lines: curRange
-          }
-          if (i >= diff.length - 2 && lines.length <= context) {
-            // EOF is inside this hunk
-            const oldEOFNewline = (/\n$/.test(older))
-            const newEOFNewline = (/\n$/.test(newer))
-            const noNlBeforeAdds = lines.length === 0 && curRange.length > hunk.oldLines
-            if (!oldEOFNewline && noNlBeforeAdds) {
-              // special case: old has no eol and no trailing context; no-nl can end up before adds
-              curRange.splice(hunk.oldLines, 0, '\')
-            }
-            if ((!oldEOFNewline && !noNlBeforeAdds) || !newEOFNewline) {
-              curRange.push('\')
-            }
-          }
-          hunks.push(hunk)
-
-          oldRangeStart = 0
-          newRangeStart = 0
-          curRange = []
-        }
-      }
-      oldLine += lines.length
-      newLine += lines.length
-    }
-  }
-
-  return formatPatch({
-    oldFileName: name,
-    newFileName: name,
-    hunks: hunks
-  })
-}
-
-module.exports.applyPatch = (prev, patch) => jsdiff.applyPatch(prev, patch)
-module.exports.createPatch = createPatch
+const jsdiff = require('diff')
+const gdiff = new (require('diff-match-patch'))()
+
+function formatPatch (diff) {
+  const ret = []
+  if (diff.oldFileName === diff.newFileName) {
+    ret.push('Index: ' + diff.oldFileName)
+  }
+  ret.push('===================================================================')
+  ret.push('--- ' + diff.oldFileName + (typeof diff.oldHeader === 'undefined' ? '' : '\t' + diff.oldHeader))
+  ret.push('+++ ' + diff.newFileName + (typeof diff.newHeader === 'undefined' ? '' : '\t' + diff.newHeader))
+
+  for (let i = 0; i < diff.hunks.length; i++) {
+    const hunk = diff.hunks[i]
+    ret.push(
+      '@@ -' + hunk.oldStart + ',' + hunk.oldLines +
+            ' +' + hunk.newStart + ',' + hunk.newLines +
+            ' @@'
+    )
+    ret.push.apply(ret, hunk.lines)
+  }
+
+  const res = ret.join('\n') + '\n'
+  return res
+}
+
+function createPatch (name, older, newer, context) {
+  const { chars1, chars2, lineArray } = gdiff.diff_linesToChars_(older, newer)
+  const cdiff = gdiff.diff_main(chars1, chars2, false)
+  gdiff.diff_charsToLines_(cdiff, lineArray)
+
+  const diff = cdiff.map(([op, data]) => {
+    const r = { value: data }
+    if (op === 1) {
+      r.added = true
+    }
+    if (op === -1) {
+      r.removed = true
+    }
+    return r
+  })
+
+  diff.push({ value: '', lines: [] }) // Append an empty value to make cleanup easier
+
+  function contextLines (lines) {
+    return lines.map(function (entry) { return ' ' + entry })
+  }
+
+  const hunks = []
+  let oldRangeStart = 0
+  let newRangeStart = 0
+  let curRange = []
+
+  let oldLine = 1; let newLine = 1
+  for (let i = 0; i < diff.length; i++) {
+    const current = diff[i]
+
+    const lines = current.lines || current.value.replace(/\n$/, '').split('\n')
+    current.lines = lines
+
+    if (current.added || current.removed) {
+      // If we have previous context, start with that
+      if (!oldRangeStart) {
+        const prev = diff[i - 1]
+        oldRangeStart = oldLine
+        newRangeStart = newLine
+
+        if (prev) {
+          curRange = context > 0 ? contextLines(prev.lines.slice(-context)) : []
+          oldRangeStart -= curRange.length
+          newRangeStart -= curRange.length
+        }
+      }
+
+      // Output our changes
+      curRange.push(...lines.map(function (entry) {
+        return (current.added ? '+' : '-') + entry
+      }))
+
+      // Track the updated file position
+      if (current.added) {
+        newLine += lines.length
+      } else {
+        oldLine += lines.length
+      }
+    } else {
+      // Identical context lines. Track line changes
+      if (oldRangeStart) {
+        // Close out any changes that have been output (or join overlapping)
+        if (lines.length <= context * 2 && i < diff.length - 2) {
+          // Overlapping
+          curRange.push(...contextLines(lines))
+        } else {
+          // end the range and output
+          const contextSize = Math.min(lines.length, context)
+          curRange.push(...contextLines(lines.slice(0, contextSize)))
+
+          const hunk = {
+            oldStart: oldRangeStart,
+            oldLines: (oldLine - oldRangeStart + contextSize),
+            newStart: newRangeStart,
+            newLines: (newLine - newRangeStart + contextSize),
+            lines: curRange
+          }
+          if (i >= diff.length - 2 && lines.length <= context) {
+            // EOF is inside this hunk
+            const oldEOFNewline = (/\n$/.test(older))
+            const newEOFNewline = (/\n$/.test(newer))
+            const noNlBeforeAdds = lines.length === 0 && curRange.length > hunk.oldLines
+            if (!oldEOFNewline && noNlBeforeAdds) {
+              // special case: old has no eol and no trailing context; no-nl can end up before adds
+              curRange.splice(hunk.oldLines, 0, '\')
+            }
+            if ((!oldEOFNewline && !noNlBeforeAdds) || !newEOFNewline) {
+              curRange.push('\')
+            }
+          }
+          hunks.push(hunk)
+
+          oldRangeStart = 0
+          newRangeStart = 0
+          curRange = []
+        }
+      }
+      oldLine += lines.length
+      newLine += lines.length
+    }
+  }
+
+  return formatPatch({
+    oldFileName: name,
+    newFileName: name,
+    hunks: hunks
+  })
+}
+
+module.exports.applyPatch = (prev, patch) => jsdiff.applyPatch(prev, patch)
+module.exports.createPatch = createPatch