@jsreport/jsreport-core 4.0.0 → 4.0.1

package/README.md

@@ -282,8 +282,13 @@ jsreport.documentStore.collection('templates')
 
 ## Changelog
 
+### 4.0.1
+
+- fix parameter mutations passed to store methods producing unexpected changes in store
+
 ### 4.0.0
 
+- minimum node.js version is now `18.15.0`
 - remove old migration options `migrateXlsxTemplatesToAssets`, `migrateResourcesToAssets`
 - sandbox now uses SES instead of vm2 for evaluating user code
 - internal changes to support multi admin users

package/lib/main/schemaValidator.js

@@ -1,5 +1,5 @@
 const extend = require('node.extend.without.arrays')
-const set = require('lodash.set')
+const set = require('set-value')
 const hasOwn = require('has-own-deep')
 const unsetValue = require('unset-value')
 const ms = require('ms')

package/lib/main/store/memoryStoreProvider.js

@@ -1,99 +1,104 @@
-/*!
- * Copyright(c) 2018 Jan Blaha
- *
- * DocumentStore data layer provider using just memory.
- */
-
-const extend = require('node.extend.without.arrays')
-const { nanoid } = require('nanoid')
-const omit = require('lodash.omit')
-const mingo = require('@jsreport/mingo')
-const Transaction = require('./transaction')
-const Queue = require('./queue')
-
-module.exports = () => {
-  return {
-    load (model) {
-      this.model = model
-      this.transaction = Transaction({ queue: Queue() })
-
-      return this.transaction.operation(async (documents) => {
-        Object.keys(model.entitySets).forEach((e) => (documents[e] = []))
-      })
-    },
-
-    beginTransaction () {
-      return this.transaction.begin()
-    },
-
-    async commitTransaction (tran) {
-      await this.transaction.commit(tran)
-    },
-
-    async rollbackTransaction (tran) {
-      return this.transaction.rollback(tran)
-    },
-
-    find (entitySet, query, fields, opts = {}) {
-      const documents = this.transaction.getCurrentDocuments(opts)
-      const cursor = mingo.find(documents[entitySet], query, fields)
-
-      // the queue is not used here because reads are supposed to not block
-      cursor.toArray = () => cursor.all().map((e) => extend(true, {}, omit(e, '$$etag')))
-
-      return cursor
-    },
-
-    insert (entitySet, doc, opts = {}) {
-      return this.transaction.operation(opts, async (documents) => {
-        doc._id = doc._id || nanoid(16)
-        const newDoc = extend(true, {}, doc)
-        newDoc.$$etag = Date.now()
-        documents[entitySet].push(newDoc)
-        return doc
-      })
-    },
-
-    async update (entitySet, q, u, opts = {}) {
-      let count
-
-      const res = await this.transaction.operation(opts, async (documents) => {
-        const toUpdate = mingo.find(documents[entitySet], q).all()
-
-        count = toUpdate.length
-
-        // need to get of queue first before calling insert, otherwise we get a deathlock
-        if (toUpdate.length === 0 && opts.upsert) {
-          return 'insert'
-        }
-
-        for (const doc of toUpdate) {
-          Object.assign(doc, u.$set || {})
-          doc.$$etag = Date.now()
-        }
-      })
-
-      if (res === 'insert') {
-        await this.insert(entitySet, u.$set, opts)
-        return 1
-      }
-
-      return count
-    },
-
-    remove (entitySet, q, opts = {}) {
-      return this.transaction.operation(opts, async (documents) => {
-        const toRemove = mingo.find(documents[entitySet], q).all()
-        documents[entitySet] = documents[entitySet].filter(d => !toRemove.includes(d))
-      })
-    },
-
-    drop (opts = {}) {
-      return this.transaction.operation(opts, async (documents) => {
-        for (const [entitySetName] of Object.entries(documents)) {
-          documents[entitySetName] = []
-        }
-      })
-    }
-  }
-}
+/*!
+ * Copyright(c) 2018 Jan Blaha
+ *
+ * DocumentStore data layer provider using just memory.
+ */
+
+const extend = require('node.extend.without.arrays')
+const { nanoid } = require('nanoid')
+const omit = require('lodash.omit')
+const mingo = require('@jsreport/mingo')
+const Transaction = require('./transaction')
+const Queue = require('./queue')
+
+module.exports = () => {
+  return {
+    load (model) {
+      this.model = model
+      this.transaction = Transaction({ queue: Queue() })
+
+      return this.transaction.operation(async (documents) => {
+        Object.keys(model.entitySets).forEach((e) => (documents[e] = []))
+      })
+    },
+
+    beginTransaction () {
+      return this.transaction.begin()
+    },
+
+    async commitTransaction (tran) {
+      await this.transaction.commit(tran)
+    },
+
+    async rollbackTransaction (tran) {
+      return this.transaction.rollback(tran)
+    },
+
+    find (entitySet, query, fields, opts = {}) {
+      const documents = this.transaction.getCurrentDocuments(opts)
+      const cursor = mingo.find(documents[entitySet], query, fields)
+
+      // the queue is not used here because reads are supposed to not block
+      cursor.toArray = () => cursor.all().map((e) => extend(true, {}, omit(e, '$$etag')))
+
+      return cursor
+    },
+
+    insert (entitySet, doc, opts = {}) {
+      doc._id = doc._id || nanoid(16)
+      const clonnedDoc = extend(true, {}, doc)
+      clonnedDoc.$$etag = Date.now()
+
+      return this.transaction.operation(opts, async (documents) => {
+        documents[entitySet].push(clonnedDoc)
+        return doc
+      })
+    },
+
+    async update (entitySet, q, u, opts = {}) {
+      let count
+      const qClone = extend(true, {}, q)
+      const setClone = extend(true, {}, u.$set)
+
+      const res = await this.transaction.operation(opts, async (documents) => {
+        const toUpdate = mingo.find(documents[entitySet], qClone).all()
+
+        count = toUpdate.length
+
+        // need to get of queue first before calling insert, otherwise we get a deathlock
+        if (toUpdate.length === 0 && opts.upsert) {
+          return 'insert'
+        }
+
+        for (const doc of toUpdate) {
+          Object.assign(doc, setClone)
+          doc.$$etag = Date.now()
+        }
+      })
+
+      if (res === 'insert') {
+        await this.insert(entitySet, setClone, opts)
+        return 1
+      }
+
+      return count
+    },
+
+    remove (entitySet, q, opts = {}) {
+      const qClone = extend(true, {}, q)
+
+      return this.transaction.operation(opts, async (documents) => {
+        const toRemove = mingo.find(documents[entitySet], qClone).all()
+        documents[entitySet] = documents[entitySet].filter(d => !toRemove.includes(d))
+      })
+    },
+
+    drop (opts = {}) {
+      return this.transaction.operation(opts, async (documents) => {
+        for (const [entitySetName] of Object.entries(documents)) {
+          documents[entitySetName] = []
+        }
+      })
+    }
+  }
+}

package/lib/worker/sandbox/propertiesSandbox.js

@@ -1,7 +1,7 @@
 const extend = require('node.extend.without.arrays')
 const groupBy = require('lodash.groupby')
 const get = require('lodash.get')
-const set = require('lodash.set')
+const set = require('set-value')
 const hasOwn = require('has-own-deep')
 const unsetValue = require('unset-value')
 
@@ -420,7 +420,7 @@ function sortPropertiesByLevel (a, b) {
 }
 
 function omitProp (context, prop) {
-  // if property has value, then set it to undefined first,
+  // if property has value, then set it to some value first,
   // unsetValue expects that property has some non empty value to remove the property
   // so we set to "true" to ensure it works for all cases,
   // we use unsetValue instead of lodash.omit because

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsreport/jsreport-core",
-  "version": "4.0.0",
+  "version": "4.0.1",
   "description": "javascript based business reporting",
   "keywords": [
     "report",
@@ -61,13 +61,13 @@
     "lodash.get": "4.4.2",
     "lodash.groupby": "4.6.0",
     "lodash.omit": "4.5.0",
-    "lodash.set": "4.3.2",
     "lru-cache": "4.1.1",
     "ms": "2.1.3",
     "nanoid": "3.2.0",
     "nconf": "0.12.0",
     "node.extend.without.arrays": "1.1.6",
     "semver": "7.5.4",
+    "set-value": "4.1.0",
     "stack-trace": "0.0.10",
     "triple-beam": "1.3.0",
     "unset-value": "2.0.1",

package/test/store/common.js

@@ -141,6 +141,34 @@ function collectionTests (store, isInternal, runTransactions) {
     res[0].phantom.header.should.be.eql('original')
   })
 
+  it('update should use clones', async () => {
+    const colName = !isInternal ? 'templates' : 'internalTemplates'
+
+    await store().collection('folders').insert({
+      name: 'f1',
+      shortid: 'f1'
+    })
+
+    await getCollection(colName).insert({
+      name: 'test',
+      engine: 'none',
+      recipe: 'html',
+      content: 'original'
+    })
+
+    const set = {
+      folder: {
+        shortid: 'f1'
+      }
+    }
+
+    await getCollection(colName).update({ name: 'test' }, { $set: set })
+    set.folder.shortid = 'changing'
+
+    const res = await getCollection(colName).findOne({})
+    res.folder.shortid.should.be.eql('f1')
+  })
+
   it('skip and limit', async () => {
     const colName = !isInternal ? 'templates' : 'internalTemplates'
 
@@ -443,6 +471,33 @@ function collectionTests (store, isInternal, runTransactions) {
         should(found != null).be.True()
       })
 
+      it('insert with transaction should use clones', async () => {
+        const colName = !isInternal ? 'templates' : 'internalTemplates'
+        const req = Request({})
+
+        await store().beginTransaction(req)
+
+        try {
+          const t1 = {
+            name: 't1',
+            engine: 'none',
+            recipe: 'html'
+          }
+
+          const newT1 = await getCollection(colName).insert(t1, req)
+
+          newT1.name = 'fake-t1'
+
+          await store().commitTransaction(req)
+        } catch (e) {
+          await store().rollbackTransaction(req)
+          throw e
+        }
+
+        const found = await getCollection(colName).findOne({ name: 't1' })
+        should(found).not.be.null()
+      })
+
       it('should be able to rollback (insert)', async () => {
         const colName = !isInternal ? 'templates' : 'internalTemplates'
         const req = Request({})