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

package/lib/shared/folders/resolveEntityFromPath.js

@@ -1,88 +1,88 @@
-const normalizeEntityPath = require('./normalizeEntityPath')
-
-module.exports = (reporter) => async (entityPathParam, targetEntitySet, options, req) => {
-  if (req == null) {
-    req = options
-    options = {}
-  }
-
-  const entityPath = normalizeEntityPath(entityPathParam, options, req)
-  const fragments = entityPath.split('/').filter(s => s)
-  let currentEntity = null
-  let currentEntitySet = null
-  let currentFolder = null
-
-  if (targetEntitySet) {
-    const entitySet = reporter.documentStore.model.entitySets[targetEntitySet]
-
-    if (!entitySet) {
-      throw new Error(`Target entity set "${targetEntitySet}" does not exists`)
-    }
-
-    if (!entitySet.entityTypeDef.name) {
-      throw new Error(`Entity set "${targetEntitySet}" does not have a name attribute`)
-    }
-  }
-
-  if (fragments.length === 0) {
-    return
-  }
-
-  const lastIndex = fragments.length - 1
-
-  for (const [index, entityName] of fragments.entries()) {
-    if (lastIndex === index) {
-      if (!targetEntitySet) {
-        for (const c of Object.keys(reporter.documentStore.collections)) {
-          if (!reporter.documentStore.model.entitySets[c].entityTypeDef.name) {
-            continue
-          }
-
-          const query = getSearchQuery(entityName, currentFolder)
-          currentEntitySet = c
-          currentEntity = await reporter.documentStore.collection(c).findOne(query, req)
-
-          if (currentEntity) {
-            break
-          }
-        }
-      } else {
-        const query = getSearchQuery(entityName, currentFolder)
-        currentEntitySet = targetEntitySet
-        currentEntity = await reporter.documentStore.collection(targetEntitySet).findOne(query, req)
-      }
-    } else {
-      const query = getSearchQuery(entityName, currentFolder)
-      const folder = await reporter.documentStore.collection('folders').findOne(query, req)
-
-      if (!folder) {
-        break
-      }
-
-      currentFolder = folder
-    }
-  }
-
-  if (!currentEntity) {
-    return
-  }
-
-  return {
-    entitySet: currentEntitySet,
-    entity: currentEntity
-  }
-}
-
-function getSearchQuery (name, currentFolder) {
-  const query = {
-    name
-  }
-
-  if (currentFolder) {
-    query.folder = { shortid: currentFolder.shortid }
-  } else {
-    query.folder = null
-  }
-
-  return query
-}
+const normalizeEntityPath = require('./normalizeEntityPath')
+
+module.exports = (reporter) => async (entityPathParam, targetEntitySet, options, req) => {
+  if (req == null) {
+    req = options
+    options = {}
+  }
+
+  const entityPath = normalizeEntityPath(entityPathParam, options, req)
+  const fragments = entityPath.split('/').filter(s => s)
+  let currentEntity = null
+  let currentEntitySet = null
+  let currentFolder = null
+
+  if (targetEntitySet) {
+    const entitySet = reporter.documentStore.model.entitySets[targetEntitySet]
+
+    if (!entitySet) {
+      throw new Error(`Target entity set "${targetEntitySet}" does not exists`)
+    }
+
+    if (!entitySet.entityTypeDef.name) {
+      throw new Error(`Entity set "${targetEntitySet}" does not have a name attribute`)
+    }
+  }
+
+  if (fragments.length === 0) {
+    return
+  }
+
+  const lastIndex = fragments.length - 1
+
+  for (const [index, entityName] of fragments.entries()) {
+    if (lastIndex === index) {
+      if (!targetEntitySet) {
+        for (const c of Object.keys(reporter.documentStore.collections)) {
+          if (!reporter.documentStore.model.entitySets[c].entityTypeDef.name) {
+            continue
+          }
+
+          const query = getSearchQuery(entityName, currentFolder)
+          currentEntitySet = c
+          currentEntity = await reporter.documentStore.collection(c).findOne(query, req)
+
+          if (currentEntity) {
+            break
+          }
+        }
+      } else {
+        const query = getSearchQuery(entityName, currentFolder)
+        currentEntitySet = targetEntitySet
+        currentEntity = await reporter.documentStore.collection(targetEntitySet).findOne(query, req)
+      }
+    } else {
+      const query = getSearchQuery(entityName, currentFolder)
+      const folder = await reporter.documentStore.collection('folders').findOne(query, req)
+
+      if (!folder) {
+        break
+      }
+
+      currentFolder = folder
+    }
+  }
+
+  if (!currentEntity) {
+    return
+  }
+
+  return {
+    entitySet: currentEntitySet,
+    entity: currentEntity
+  }
+}
+
+function getSearchQuery (name, currentFolder) {
+  const query = {
+    name
+  }
+
+  if (currentFolder) {
+    query.folder = { shortid: currentFolder.shortid }
+  } else {
+    query.folder = null
+  }
+
+  return query
+}

package/lib/shared/folders/resolveEntityPath.js

@@ -1,46 +1,46 @@
-
-async function resolveEntityPath (reporter, entity, lookup, req) {
-  const fullPath = []
-  let currentEntity = entity
-
-  while (currentEntity != null) {
-    if (currentEntity.folder != null) {
-      let folder
-
-      if (lookup) {
-        folder = await lookup(currentEntity.folder.shortid)
-      } else {
-        folder = await reporter.documentStore.collection('folders').findOne({
-          shortid: currentEntity.folder.shortid
-        }, req)
-      }
-
-      if (folder != null) {
-        fullPath.unshift(folder.name)
-        currentEntity = folder
-      } else {
-        throw new Error(`Folder with shortid "${currentEntity.folder.shortid}" does not exists`)
-      }
-    } else {
-      currentEntity = null
-    }
-  }
-
-  fullPath.push(entity.name)
-
-  return `/${fullPath.join('/')}`
-}
-
-module.exports = (reporter) => async (entity, entitySet, req, lookup) => {
-  const entitySetInfo = reporter.documentStore.model.entitySets[entitySet]
-
-  if (!entitySetInfo) {
-    throw new Error(`Unknown entitySet "${entitySet}"`)
-  }
-
-  if (entitySetInfo.entityTypeDef.name == null) {
-    throw new Error(`Could not find name attribute of entity of type "${entitySet}"`)
-  }
-
-  return resolveEntityPath(reporter, entity, lookup, req)
-}
+
+async function resolveEntityPath (reporter, entity, lookup, req) {
+  const fullPath = []
+  let currentEntity = entity
+
+  while (currentEntity != null) {
+    if (currentEntity.folder != null) {
+      let folder
+
+      if (lookup) {
+        folder = await lookup(currentEntity.folder.shortid)
+      } else {
+        folder = await reporter.documentStore.collection('folders').findOne({
+          shortid: currentEntity.folder.shortid
+        }, req)
+      }
+
+      if (folder != null) {
+        fullPath.unshift(folder.name)
+        currentEntity = folder
+      } else {
+        throw new Error(`Folder with shortid "${currentEntity.folder.shortid}" does not exists`)
+      }
+    } else {
+      currentEntity = null
+    }
+  }
+
+  fullPath.push(entity.name)
+
+  return `/${fullPath.join('/')}`
+}
+
+module.exports = (reporter) => async (entity, entitySet, req, lookup) => {
+  const entitySetInfo = reporter.documentStore.model.entitySets[entitySet]
+
+  if (!entitySetInfo) {
+    throw new Error(`Unknown entitySet "${entitySet}"`)
+  }
+
+  if (entitySetInfo.entityTypeDef.name == null) {
+    throw new Error(`Could not find name attribute of entity of type "${entitySet}"`)
+  }
+
+  return resolveEntityPath(reporter, entity, lookup, req)
+}

package/lib/shared/folders/resolveFolderFromPath.js

@@ -1,38 +1,38 @@
-const normalizeEntityPath = require('./normalizeEntityPath')
-
-module.exports = (reporter) => async (entityPathParam, req) => {
-  const entityPath = normalizeEntityPath(entityPathParam, {}, req)
-  const fragments = entityPath.split('/').filter(s => s)
-  let found = false
-  let currentFolder = null
-
-  for (const f of fragments) {
-    if (found) {
-      currentFolder = null
-      break
-    }
-
-    const query = {
-      name: f
-    }
-
-    if (currentFolder) {
-      query.folder = { shortid: currentFolder.shortid }
-    } else {
-      query.folder = null
-    }
-
-    const folder = await reporter.documentStore.collection('folders').findOne(query, req)
-
-    if (!folder) {
-      found = true
-      // we don't know from path /a/b if b is template or folder,
-      // so if folder is not found, we assume it was other entity and continue
-      continue
-    }
-
-    currentFolder = folder
-  }
-
-  return currentFolder
-}
+const normalizeEntityPath = require('./normalizeEntityPath')
+
+module.exports = (reporter) => async (entityPathParam, req) => {
+  const entityPath = normalizeEntityPath(entityPathParam, {}, req)
+  const fragments = entityPath.split('/').filter(s => s)
+  let found = false
+  let currentFolder = null
+
+  for (const f of fragments) {
+    if (found) {
+      currentFolder = null
+      break
+    }
+
+    const query = {
+      name: f
+    }
+
+    if (currentFolder) {
+      query.folder = { shortid: currentFolder.shortid }
+    } else {
+      query.folder = null
+    }
+
+    const folder = await reporter.documentStore.collection('folders').findOne(query, req)
+
+    if (!folder) {
+      found = true
+      // we don't know from path /a/b if b is template or folder,
+      // so if folder is not found, we assume it was other entity and continue
+      continue
+    }
+
+    currentFolder = folder
+  }
+
+  return currentFolder
+}

package/lib/shared/generateRequestId.js

@@ -1,4 +1,4 @@
-const { customAlphabet } = require('nanoid')
-const nanoid = customAlphabet('0123456789abcdefghijklmnopqrstuvwxyz', 15)
-
-module.exports = () => nanoid()
+const { customAlphabet } = require('nanoid')
+const nanoid = customAlphabet('0123456789abcdefghijklmnopqrstuvwxyz', 15)
+
+module.exports = () => nanoid()

package/lib/shared/listenerCollection.js

@@ -0,0 +1,169 @@
+
+module.exports = function createListenerCollection (_name) {
+  const name = _name != null ? `${_name}` : 'Anonymous'
+  return new ListenerCollection(name)
+}
+
+class ListenerCollection {
+  constructor (name) {
+    this._name = name
+    this._listeners = []
+    this._pre = []
+    this._post = []
+    this._postFail = []
+  }
+
+  /**
+   * Add listener cb at the end of the current chain.
+   * @param {String} key
+   * @param {Object|Function} context
+   * @param {Function} listener
+   */
+  add (key, context, listener) {
+    const fn = listener || context
+    const _context = listener === null ? this : context
+
+    this._listeners.push({
+      key: key,
+      fn,
+      context: _context
+    })
+  }
+
+  /**
+   * Add the listener callback to the particular position in the chain.
+   * The position is specified by the index in the array or a condition
+   * Example
+   * listeners.insert({ pre: "another", post: "another2" }, "foo", this, function() {... });
+   *
+   * @param {Number|Object} indexOrCondition
+   * @param {String} key
+   * @param {Object} context
+   * @param {Function} listener
+   */
+  insert (indexOrCondition, key, context, listener) {
+    const listenerOpts = {
+      key: key,
+      fn: listener || context,
+      context: listener === null ? this : context
+    }
+
+    if (!isNaN(indexOrCondition)) {
+      return this._listeners.splice(indexOrCondition, 0, listenerOpts)
+    }
+
+    let afterInsertIndex = null
+    let beforeInsertIndex = null
+
+    for (let i = 0; i < this._listeners.length; i++) {
+      if (this._listeners[i].key === indexOrCondition.after) {
+        afterInsertIndex = i + 1
+      }
+
+      if (this._listeners[i].key === indexOrCondition.before) {
+        beforeInsertIndex = i
+      }
+    }
+
+    const index = afterInsertIndex !== null
+      ? afterInsertIndex
+      : (beforeInsertIndex !== null ? beforeInsertIndex : this._listeners.length)
+
+    this._listeners.splice(index, 0, listenerOpts)
+  }
+
+  /**
+   * Remove the listener specified by its key from the collection
+   * @param {String} key
+   */
+  remove (key) {
+    this._listeners = this._listeners.filter((l) => {
+      return l.key !== key
+    })
+  }
+
+  /* Add hook that will be executed before actual listener */
+  pre (fn) {
+    this._pre.push(fn)
+  }
+
+  /* Add hook that will be executed after actual listener */
+  post (fn) {
+    this._post.push(fn)
+  }
+
+  /* Add hook that will be executed after actual listener when execution will fail */
+  postFail (fn) {
+    this._postFail.push(fn)
+  }
+
+  /**
+   * Fires listeners and returns value composed from all boolean results into the single bool
+   * @returns {Promise<Boolean>}
+   */
+  async fireAndJoinResults (...args) {
+    const results = await this.fire(...args)
+
+    const successes = results.filter((r) => {
+      return r === true
+    })
+
+    const failures = results.filter((r) => {
+      return r === false
+    })
+
+    const dontCares = results.filter((r) => {
+      return r === null || r === undefined
+    })
+
+    if (successes.length && (successes.length + dontCares.length === results.length)) {
+      // override pass
+      return true
+    }
+
+    if (failures.length && (failures.length + dontCares.length === results.length)) {
+      return false
+    }
+
+    if (dontCares.length === results.length) {
+      return null
+    }
+
+    return true
+  }
+
+  /**
+   * Fire registered listeners in sequence and returns a promise containing wrapping an array of all
+   * individual results.
+   * The parameters passed to the fire are forwarded in the same order to the listeners.
+   * @returns {Promise<U>}
+   */
+  async fire (...args) {
+    const self = this
+
+    const applyHook = function applyHook (l, hookArrayName, outerArgs) {
+      self[hookArrayName].forEach((p) => {
+        p.apply(l, outerArgs)
+      })
+    }
+
+    const results = []
+
+    for (const l of this._listeners) {
+      const currentArgs = [...args]
+      applyHook(l, '_pre', currentArgs)
+
+      try {
+        const val = await l.fn.apply(l.context, currentArgs)
+        applyHook(l, '_post', currentArgs)
+        results.push(val)
+      } catch (e) {
+        currentArgs.unshift(e)
+        applyHook(l, '_postFail', currentArgs)
+        throw e
+      }
+    }
+
+    return results
+  }
+}

package/lib/shared/normalizeMetaFromLogs.js

@@ -1,30 +1,30 @@
-const omit = require('lodash.omit')
-
-module.exports = (level, msg, meta) => {
-  // detecting if meta is jsreport request object
-  if (meta != null && meta.context) {
-    meta.context.logs = meta.context.logs || []
-
-    meta.context.logs.push({
-      level: level,
-      message: msg,
-      timestamp: meta.timestamp || new Date().getTime()
-    })
-
-    // TODO adding cancel looks bad, its before script is adding req.cancel()
-    // excluding non relevant properties for the log
-    const newMeta = Object.assign({}, omit(meta, ['template', 'options', 'data', 'context', 'timestamp', 'cancel']))
-
-    if (newMeta.rootId == null && meta.context.rootId != null) {
-      newMeta.rootId = meta.context.rootId
-    }
-
-    if (newMeta.id == null && meta.context.id != null) {
-      newMeta.id = meta.context.id
-    }
-
-    return newMeta
-  }
-
-  return meta
-}
+const omit = require('lodash.omit')
+
+module.exports = (level, msg, meta) => {
+  // detecting if meta is jsreport request object
+  if (meta != null && meta.context) {
+    meta.context.logs = meta.context.logs || []
+
+    meta.context.logs.push({
+      level: level,
+      message: msg,
+      timestamp: meta.timestamp || new Date().getTime()
+    })
+
+    // TODO adding cancel looks bad, its before script is adding req.cancel()
+    // excluding non relevant properties for the log
+    const newMeta = Object.assign({}, omit(meta, ['template', 'options', 'data', 'context', 'timestamp', 'cancel']))
+
+    if (newMeta.rootId == null && meta.context.rootId != null) {
+      newMeta.rootId = meta.context.rootId
+    }
+
+    if (newMeta.id == null && meta.context.id != null) {
+      newMeta.id = meta.context.id
+    }
+
+    return newMeta
+  }
+
+  return meta
+}