@jsreport/jsreport-core 3.6.1 → 3.7.0

package/README.md

@@ -282,6 +282,20 @@ jsreport.documentStore.collection('templates')
 
 ## Changelog
 
+### 3.7.0
+
+- add support for multiple source entities when copying and moving
+- fix some issues with blobs and profiles
+- format user logs differently on stdout
+- fix logging of req as http.IncomingRequest
+- fix profile compatibility with jsreport container based execution
+- fix memory leak in profiling
+- add support for logs of main reporter to show in profile
+
+### 3.6.1
+
+- update @jsreport/advanced-workers to fix bug with cloning req.data when `trustUserCode` is true
+
 ### 3.6.0
 
 - improve handling of worker exit

package/index.js

@@ -25,5 +25,5 @@ module.exports.createDefaultLoggerFormat = createDefaultLoggerFormat
 module.exports.tests = {
   documentStore: () => require('./test/store/common.js'),
   blobStorage: () => require('./test/blobStorage/common.js'),
-  listeners: () => require('./test/extensions/validExtensions/listeners/jsreport.config')
+  listeners: () => require('./test/extensions/validExtensions/listeners/jsreport.dontdiscover.config')
 }

package/lib/main/createDefaultLoggerFormat.js

@@ -1,10 +1,11 @@
 const { MESSAGE } = require('triple-beam')
+const colors = require('@colors/colors/safe')
 const winston = require('winston')
 
 module.exports = (options = {}) => {
   return winston.format((info) => {
     const { level, message, ...meta } = info
-    info[MESSAGE] = `${options.timestamp === true ? `${new Date().toISOString()} - ` : ''}${level}: ${message}`
+    info[MESSAGE] = `${options.timestamp === true ? `${new Date().toISOString()} - ` : ''}${level}: ${info.userLevel === true ? colors.cyan(message) : message}`
 
     const metaKeys = Object.keys(meta)
 
@@ -12,6 +13,10 @@ module.exports = (options = {}) => {
       info[MESSAGE] += ` ${metaKeys.map((k) => `${k}=${meta[k]}`).join(', ')}`
     }
 
+    if (info.userLevel === true) {
+      info.level = colors.cyan(info.level)
+    }
+
     return info
   })
 }

package/lib/main/createNormalizeMetaLoggerFormat.js

@@ -0,0 +1,19 @@
+const winston = require('winston')
+const normalizeMetaFromLogs = require('../shared/normalizeMetaFromLogs')
+
+module.exports = () => {
+  return winston.format((info) => {
+    const { level, message, ...meta } = info
+    const newMeta = normalizeMetaFromLogs(level, message, meta)
+
+    if (newMeta != null) {
+      return {
+        level,
+        message,
+        ...newMeta
+      }
+    }
+
+    return info
+  })
+}

package/lib/main/folders/moveBetweenFolders.js

@@ -31,27 +31,8 @@ async function throwIfEntityIsNotFolder (reporter, targetShortid, req) {
 }
 
 module.exports = (reporter) => async ({ source, target, shouldCopy, shouldReplace }, req) => {
-  const sourceCol = reporter.documentStore.collection(source.entitySet)
-
-  if (!sourceCol) {
-    throw reporter.createError(`Invalid entity set "${source.entitySet}" for source`, {
-      statusCode: 400
-    })
-  }
-
-  const sourceEntity = await sourceCol.findOne({ _id: source.id }, req)
-
-  if (!sourceEntity) {
-    throw reporter.createError('Source entity with specified id does not exists', {
-      statusCode: 400
-    })
-  }
-
-  const onlyChildren = source.onlyChildren === true
-
-  if (onlyChildren && source.entitySet !== 'folders') {
-    throw reporter.createError('onlyChildren option can only be enabled when source is a folder')
-  }
+  const isSingleSource = Array.isArray(source) ? source.length === 1 : true
+  const sourceList = isSingleSource ? [source] : source
 
   if (target.shortid === undefined) {
     throw reporter.createError('target should specify ".shortid"', {
@@ -65,259 +46,307 @@ module.exports = (reporter) => async ({ source, target, shouldCopy, shouldReplac
 
   const targetUpdateReferences = target.updateReferences === true && target.shortid != null
 
-  let entitiesInHierarchy = []
-
-  await collectEntitiesInHierarchy(
-    reporter,
-    entitiesInHierarchy,
-    Object.assign(sourceEntity, { __entitySet: source.entitySet }),
-    onlyChildren,
-    req
-  )
+  const allEntitiesInvolved = []
 
-  let rootChildren
+  for (const sourceInfo of sourceList) {
+    const sourceCol = reporter.documentStore.collection(sourceInfo.entitySet)
 
-  if (onlyChildren) {
-    rootChildren = entitiesInHierarchy.filter((e) => {
-      return e.folder.shortid === sourceEntity.shortid
-    })
-  }
+    if (!sourceCol) {
+      throw reporter.createError(`Invalid entity set "${sourceInfo.entitySet}" for source`, {
+        statusCode: 400
+      })
+    }
 
-  // ignore if we are doing a move at the same level of hierarchy between source and target
-  if (
-    (sourceEntity.folder == null && target.shortid === null) ||
-    (sourceEntity.folder != null &&
-    target.shortid != null &&
-    sourceEntity.folder.shortid === target.shortid)
-  ) {
-    return []
-  }
+    const sourceEntity = await sourceCol.findOne({ _id: sourceInfo.id }, req)
 
-  if (!shouldCopy) {
-    // validates that we can't move entities from higher level
-    // into lower level of the same hierarchy
-    if (entitiesInHierarchy.some((e) => e.shortid === target.shortid)) {
-      return []
+    if (!sourceEntity) {
+      throw reporter.createError('Source entity with specified id does not exists', {
+        statusCode: 400
+      })
     }
 
-    let updateQ
+    const onlyChildren = sourceInfo.onlyChildren === true
 
-    if (target.shortid === null) {
-      updateQ = {
-        $set: {
-          folder: null
-        }
-      }
-    } else {
-      updateQ = {
-        $set: {
-          folder: {
-            shortid: target.shortid
-          }
-        }
-      }
+    if (onlyChildren && sourceInfo.entitySet !== 'folders') {
+      throw reporter.createError('onlyChildren option can only be enabled when source is a folder')
     }
 
-    let sourceEntities
+    let entitiesInHierarchy = []
 
-    if (!onlyChildren) {
-      sourceEntities = [sourceEntity]
-    } else {
-      sourceEntities = rootChildren
-    }
+    await collectEntitiesInHierarchy(
+      reporter,
+      entitiesInHierarchy,
+      Object.assign(sourceEntity, { __entitySet: sourceInfo.entitySet }),
+      onlyChildren,
+      req
+    )
 
-    for (const entity of sourceEntities) {
-      try {
-        await reporter.documentStore.collection(entity.__entitySet).update({
-          _id: entity._id
-        }, updateQ, req)
-      } catch (e) {
-        if (e.code === 'DUPLICATED_ENTITY' && shouldReplace) {
-          // replacing is not supported when it generates a conflict with folder
-          if (e.existingEntityEntitySet === 'folders') {
-            throw e
-          }
+    let rootChildren
 
-          const removeFolderQ = target.shortid === null ? { folder: null } : { folder: { shortid: target.shortid } }
+    if (onlyChildren) {
+      rootChildren = entitiesInHierarchy.filter((e) => {
+        return e.folder.shortid === sourceEntity.shortid
+      })
+    }
 
-          await reporter.documentStore.collection(e.existingEntityEntitySet).remove({
-            _id: e.existingEntity._id,
-            ...removeFolderQ
-          }, req)
+    // ignore if we are doing a copy/move at the same level of hierarchy between source and target
+    if (
+      (sourceEntity.folder == null && target.shortid === null) ||
+      (sourceEntity.folder != null &&
+      target.shortid != null &&
+      sourceEntity.folder.shortid === target.shortid)
+    ) {
+      continue
+    }
 
-          await reporter.documentStore.collection(entity.__entitySet).update({
-            _id: entity._id
-          }, updateQ, req)
-        } else {
-          throw e
-        }
+    if (!shouldCopy) {
+      // validates that we can't move entities from higher level
+      // into lower level of the same hierarchy
+      if (entitiesInHierarchy.some((e) => e.shortid === target.shortid)) {
+        continue
       }
-    }
 
-    const sourceEntityItems = entitiesInHierarchy.filter((e) => {
-      return sourceEntities.find((childE) => childE._id === e._id) != null
-    })
+      let updateQ
 
-    for (const sourceEntityItem of sourceEntityItems) {
       if (target.shortid === null) {
-        sourceEntityItem.folder = null
+        updateQ = {
+          $set: {
+            folder: null
+          }
+        }
       } else {
-        sourceEntityItem.folder = {
-          shortid: target.shortid
+        updateQ = {
+          $set: {
+            folder: {
+              shortid: target.shortid
+            }
+          }
         }
       }
-    }
-  } else {
-    const entitiesInHierarchyByCollection = entitiesInHierarchy.reduce((acu, entity) => {
-      acu[entity.__entitySet] = acu[entity.__entitySet] || []
-      acu[entity.__entitySet].push(entity)
-      return acu
-    }, {})
-
-    const entityReferencesMap = new WeakMap()
-    const originalEntitiesNewMap = new WeakMap()
-    const entityRecordNewValueMap = new WeakMap()
-    const records = []
-
-    // eslint-disable-next-line
-    function createUpdateReferences (record) {
-      return async (newEntity) => {
-        const { entitySet, entity, originalEntity } = record
-        const linkedEntities = entityReferencesMap.get(entity)
-
-        if (linkedEntities.length === 0) {
-          return
-        }
 
-        for (const { properties: linkedProperties, entity: originalLinkedEntity } of linkedEntities) {
-          const currentNewLinkedEntity = originalEntitiesNewMap.get(originalLinkedEntity)
-
-          if (entityRecordNewValueMap.has(currentNewLinkedEntity)) {
-            const currentEntityProcessedNew = entityRecordNewValueMap.get(currentNewLinkedEntity)
-            const currentEntityUpdate = {}
-
-            // if we get here it means that the entity was already processed, so we need to
-            // execute an update directly to the store
-            for (const prop of linkedProperties) {
-              // here we care to use the new object result because we want to preserve other values
-              // in case the property is array with objects
-              reporter.documentStore.updateReference(originalLinkedEntity.__entitySet, currentEntityProcessedNew, entitySet, { referenceProp: prop, referenceValue: originalEntity.shortid }, newEntity.shortid)
-              const rootProp = prop.split('.')[0]
-              currentEntityUpdate[rootProp] = currentEntityProcessedNew[rootProp]
+      let sourceEntities
+
+      if (!onlyChildren) {
+        sourceEntities = [sourceEntity]
+      } else {
+        sourceEntities = rootChildren
+      }
+
+      for (const entity of sourceEntities) {
+        try {
+          await reporter.documentStore.collection(entity.__entitySet).update({
+            _id: entity._id
+          }, updateQ, req)
+        } catch (e) {
+          if (e.code === 'DUPLICATED_ENTITY' && shouldReplace) {
+            // replacing is not supported when it generates a conflict with folder
+            if (e.existingEntityEntitySet === 'folders') {
+              throw e
             }
 
-            await reporter.documentStore.collection(originalLinkedEntity.__entitySet).update({
-              _id: currentEntityProcessedNew._id
-            }, { $set: currentEntityUpdate }, req)
+            const removeFolderQ = target.shortid === null ? { folder: null } : { folder: { shortid: target.shortid } }
+
+            await reporter.documentStore.collection(e.existingEntityEntitySet).remove({
+              _id: e.existingEntity._id,
+              ...removeFolderQ
+            }, req)
+
+            await reporter.documentStore.collection(entity.__entitySet).update({
+              _id: entity._id
+            }, updateQ, req)
           } else {
-            // here we care to update all properties to point to old reference value
-            reporter.documentStore.updateReference(originalLinkedEntity.__entitySet, currentNewLinkedEntity, entitySet, { referenceValue: originalEntity.shortid }, newEntity.shortid)
+            throw e
           }
         }
       }
-    }
 
-    if (targetUpdateReferences) {
-      const targetEntity = await reporter.documentStore.collection('folders').findOne({
-        shortid: target.shortid
-      }, req)
+      const sourceEntityItems = entitiesInHierarchy.filter((e) => {
+        return sourceEntities.find((childE) => childE._id === e._id) != null
+      })
 
-      targetEntity.__entitySet = 'folders'
-      entitiesInHierarchyByCollection.folders = entitiesInHierarchyByCollection.folders || []
-      entitiesInHierarchyByCollection.folders.push(targetEntity)
-      originalEntitiesNewMap.set(targetEntity, targetEntity)
-      entityRecordNewValueMap.set(targetEntity, targetEntity)
-    }
+      for (const sourceEntityItem of sourceEntityItems) {
+        if (target.shortid === null) {
+          sourceEntityItem.folder = null
+        } else {
+          sourceEntityItem.folder = {
+            shortid: target.shortid
+          }
+        }
+      }
+    } else {
+      const entitiesInHierarchyByCollection = entitiesInHierarchy.reduce((acu, entity) => {
+        acu[entity.__entitySet] = acu[entity.__entitySet] || []
+        acu[entity.__entitySet].push(entity)
+        return acu
+      }, {})
+
+      const entityReferencesMap = new WeakMap()
+      const originalEntitiesNewMap = new WeakMap()
+      const entityRecordNewValueMap = new WeakMap()
+      const records = []
+
+      // eslint-disable-next-line
+      function createUpdateReferences (record) {
+        return async (newEntity) => {
+          const { entitySet, entity, originalEntity } = record
+          const linkedEntities = entityReferencesMap.get(entity)
+
+          if (linkedEntities.length === 0) {
+            return
+          }
 
-    for (const entity of entitiesInHierarchy) {
-      const newEntity = {
-        ...omit(entity, ['_id', 'shortid', '__entitySet'])
+          for (const { properties: linkedProperties, entity: originalLinkedEntity } of linkedEntities) {
+            const currentNewLinkedEntity = originalEntitiesNewMap.get(originalLinkedEntity)
+
+            if (entityRecordNewValueMap.has(currentNewLinkedEntity)) {
+              const currentEntityProcessedNew = entityRecordNewValueMap.get(currentNewLinkedEntity)
+              const currentEntityUpdate = {}
+
+              // if we get here it means that the entity was already processed, so we need to
+              // execute an update directly to the store
+              for (const prop of linkedProperties) {
+                // here we care to use the new object result because we want to preserve other values
+                // in case the property is array with objects
+                reporter.documentStore.updateReference(originalLinkedEntity.__entitySet, currentEntityProcessedNew, entitySet, { referenceProp: prop, referenceValue: originalEntity.shortid }, newEntity.shortid)
+                const rootProp = prop.split('.')[0]
+                currentEntityUpdate[rootProp] = currentEntityProcessedNew[rootProp]
+              }
+
+              await reporter.documentStore.collection(originalLinkedEntity.__entitySet).update({
+                _id: currentEntityProcessedNew._id
+              }, { $set: currentEntityUpdate }, req)
+            } else {
+              // here we care to update all properties to point to old reference value
+              reporter.documentStore.updateReference(originalLinkedEntity.__entitySet, currentNewLinkedEntity, entitySet, { referenceValue: originalEntity.shortid }, newEntity.shortid)
+            }
+          }
+        }
       }
 
-      let isSourceEntityItem
+      if (targetUpdateReferences) {
+        const targetEntity = await reporter.documentStore.collection('folders').findOne({
+          shortid: target.shortid
+        }, req)
 
-      if (!onlyChildren) {
-        isSourceEntityItem = source.id === entity._id
-      } else {
-        isSourceEntityItem = rootChildren.find((e) => e._id === entity._id) != null
+        targetEntity.__entitySet = 'folders'
+        entitiesInHierarchyByCollection.folders = entitiesInHierarchyByCollection.folders || []
+        entitiesInHierarchyByCollection.folders.push(targetEntity)
+        originalEntitiesNewMap.set(targetEntity, targetEntity)
+        entityRecordNewValueMap.set(targetEntity, targetEntity)
       }
 
-      if (isSourceEntityItem) {
-        if (target.shortid === null) {
-          newEntity.folder = null
+      for (const entity of entitiesInHierarchy) {
+        const newEntity = {
+          ...omit(entity, ['_id', 'shortid', '__entitySet'])
+        }
+
+        let isSourceEntityItem
+
+        if (!onlyChildren) {
+          isSourceEntityItem = sourceInfo.id === entity._id
         } else {
-          newEntity.folder = {
-            shortid: target.shortid
+          isSourceEntityItem = rootChildren.find((e) => e._id === entity._id) != null
+        }
+
+        if (isSourceEntityItem) {
+          if (target.shortid === null) {
+            newEntity.folder = null
+          } else {
+            newEntity.folder = {
+              shortid: target.shortid
+            }
+          }
+
+          // when we are copying with multi selection we want to normalize names
+          // so in case of duplicates we just add "(copy)" suffix, for single source
+          // we want the replace dialog
+          if (!isSingleSource) {
+            let copyAttempt = 0
+            let existsAtTarget
+
+            do {
+              existsAtTarget = await reporter.documentStore.collection(entity.__entitySet).findOne({
+                name: newEntity.name,
+                folder: newEntity.folder
+              })
+
+              if (existsAtTarget != null) {
+                copyAttempt++
+                newEntity.name = `${entity.name}(copy${copyAttempt > 1 ? copyAttempt : ''})`
+              }
+            } while (existsAtTarget != null)
           }
         }
-      }
 
-      const entitySet = entity.__entitySet
-      newEntity.__entitySet = entitySet
+        const entitySet = entity.__entitySet
+        newEntity.__entitySet = entitySet
 
-      const linkedEntities = reporter.documentStore.findLinkedEntitiesForReference(
-        entitiesInHierarchyByCollection,
-        entitySet,
-        entity.shortid
-      )
+        const linkedEntities = reporter.documentStore.findLinkedEntitiesForReference(
+          entitiesInHierarchyByCollection,
+          entitySet,
+          entity.shortid
+        )
 
-      const record = {
-        entitySet,
-        originalEntity: entity,
-        entity: newEntity
-      }
+        const record = {
+          entitySet,
+          originalEntity: entity,
+          entity: newEntity
+        }
 
-      record.updateReferences = createUpdateReferences(record)
+        record.updateReferences = createUpdateReferences(record)
 
-      originalEntitiesNewMap.set(entity, newEntity)
-      entityReferencesMap.set(newEntity, linkedEntities)
+        originalEntitiesNewMap.set(entity, newEntity)
+        entityReferencesMap.set(newEntity, linkedEntities)
 
-      records.push(record)
-    }
+        records.push(record)
+      }
 
-    const processNewEntity = async (entitySet, entity) => {
-      const newEntityFromStore = await reporter.documentStore.collection(entitySet).insert({
-        ...omit(entity, ['__entitySet'])
-      }, req)
+      const processNewEntity = async (entitySet, entity) => {
+        const newEntityFromStore = await reporter.documentStore.collection(entitySet).insert({
+          ...omit(entity, ['__entitySet'])
+        }, req)
 
-      entityRecordNewValueMap.set(entity, newEntityFromStore)
-    }
+        entityRecordNewValueMap.set(entity, newEntityFromStore)
+      }
 
-    for (const record of records) {
-      try {
-        await processNewEntity(record.entitySet, record.entity)
-      } catch (e) {
-        if (e.code === 'DUPLICATED_ENTITY' && shouldReplace) {
-          // replacing is not supported when it generates a conflict with folder
-          if (e.existingEntityEntitySet === 'folders') {
-            throw e
-          }
+      for (const record of records) {
+        try {
+          await processNewEntity(record.entitySet, record.entity)
+        } catch (e) {
+          if (e.code === 'DUPLICATED_ENTITY' && shouldReplace) {
+            // replacing is not supported when it generates a conflict with folder
+            if (e.existingEntityEntitySet === 'folders') {
+              throw e
+            }
 
-          const removeFolderQ = target.shortid === null ? { folder: null } : { folder: { shortid: target.shortid } }
+            const removeFolderQ = target.shortid === null ? { folder: null } : { folder: { shortid: target.shortid } }
 
-          await reporter.documentStore.collection(e.existingEntityEntitySet).remove({
-            _id: e.existingEntity._id,
-            ...removeFolderQ
-          }, req)
+            await reporter.documentStore.collection(e.existingEntityEntitySet).remove({
+              _id: e.existingEntity._id,
+              ...removeFolderQ
+            }, req)
 
-          await processNewEntity(record.entitySet, record.entity)
-        } else {
-          throw e
+            await processNewEntity(record.entitySet, record.entity)
+          } else {
+            throw e
+          }
         }
+
+        await record.updateReferences(entityRecordNewValueMap.get(record.entity))
       }
 
-      await record.updateReferences(entityRecordNewValueMap.get(record.entity))
+      entitiesInHierarchy = records.map((record) => ({
+        ...omit(entityRecordNewValueMap.get(record.entity), ['$entitySet', '__entitySet']),
+        __entitySet: record.entitySet
+      }))
     }
 
-    entitiesInHierarchy = records.map((record) => ({
-      ...omit(entityRecordNewValueMap.get(record.entity), ['$entitySet', '__entitySet']),
-      __entitySet: record.entitySet
-    }))
+    allEntitiesInvolved.push(...entitiesInHierarchy)
   }
 
   // return fresh version of creationDate, modificationDate in the records.
   // this helps with concurrent validation on studio
-  await Promise.all(entitiesInHierarchy.map(async (entity) => {
+  await Promise.all(allEntitiesInvolved.map(async (entity) => {
     const entitySet = reporter.documentStore.model.entitySets[entity.__entitySet]
     const entityType = entitySet.entityTypeDef
     const projection = {}
@@ -350,5 +379,5 @@ module.exports = (reporter) => async ({ source, target, shouldCopy, shouldReplac
     }
   }))
 
-  return entitiesInHierarchy
+  return allEntitiesInvolved
 }