@jsreport/jsreport-core 3.1.1 → 3.3.0

package/lib/main/store/mainActions.js

@@ -1,28 +1,28 @@
-module.exports = (reporter) => {
-  reporter.registerMainAction('documentStore.collection.find', async (spec, originalReq) => {
-    const localReq = reporter.Request(originalReq)
-    localReq.context.userFindCall = true
-    const res = await reporter.documentStore.collection(spec.collection).find(spec.query, localReq)
-    return res
-  })
-
-  reporter.registerMainAction('documentStore.collection.findOne', async (spec, originalReq) => {
-    const localReq = reporter.Request(originalReq)
-    localReq.context.userFindCall = true
-    const res = await reporter.documentStore.collection(spec.collection).findOne(spec.query, localReq)
-    return res
-  })
-
-  reporter.registerMainAction('documentStore.collection.insert', async (spec, originalReq) => {
-    const localReq = reporter.Request(originalReq)
-    const res = await reporter.documentStore.collection(spec.collection).insert(spec.doc, localReq)
-    return res
-  })
-
-  reporter.registerMainAction('documentStore.collection.update', async (spec, originalReq) => {
-    const localReq = reporter.Request(originalReq)
-    const res = await reporter.documentStore.collection(spec.collection).update(spec.query, spec.update, spec.options, localReq)
-
-    return res
-  })
-}
+module.exports = (reporter) => {
+  reporter.registerMainAction('documentStore.collection.find', async (spec, originalReq) => {
+    const localReq = reporter.Request(originalReq)
+    localReq.context.userFindCall = true
+    const res = await reporter.documentStore.collection(spec.collection).find(spec.query, localReq)
+    return res
+  })
+
+  reporter.registerMainAction('documentStore.collection.findOne', async (spec, originalReq) => {
+    const localReq = reporter.Request(originalReq)
+    localReq.context.userFindCall = true
+    const res = await reporter.documentStore.collection(spec.collection).findOne(spec.query, localReq)
+    return res
+  })
+
+  reporter.registerMainAction('documentStore.collection.insert', async (spec, originalReq) => {
+    const localReq = reporter.Request(originalReq)
+    const res = await reporter.documentStore.collection(spec.collection).insert(spec.doc, localReq)
+    return res
+  })
+
+  reporter.registerMainAction('documentStore.collection.update', async (spec, originalReq) => {
+    const localReq = reporter.Request(originalReq)
+    const res = await reporter.documentStore.collection(spec.collection).update(spec.query, spec.update, spec.options, localReq)
+
+    return res
+  })
+}

package/lib/main/store/memoryStoreProvider.js

@@ -1,99 +1,99 @@
-/*!
- * 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 = {}) {
+      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] = []
+        }
+      })
+    }
+  }
+}

package/lib/main/store/queue.js

@@ -1,48 +1,48 @@
-
-module.exports = () => {
-  const items = []
-  let busy = false
-
-  function execute () {
-    if (items.length < 1 || busy) {
-      return
-    }
-
-    busy = true
-    const item = items.shift()
-    item.busy = true
-
-    Promise.resolve(item.fn()).then((res) => {
-      item.resolve(res)
-      busy = false
-      execute()
-      return null
-    }).catch((err) => {
-      item.reject(err)
-      busy = false
-      execute()
-      return null
-    })
-  }
-
-  return {
-    push (fn) {
-      let _resolve, _reject
-
-      const result = new Promise((resolve, reject) => {
-        _resolve = resolve
-        _reject = reject
-      })
-
-      items.push({
-        fn,
-        resolve: _resolve,
-        reject: _reject,
-        submittedOn: new Date().getTime()
-      })
-
-      execute()
-      return result
-    }
-  }
-}
+
+module.exports = () => {
+  const items = []
+  let busy = false
+
+  function execute () {
+    if (items.length < 1 || busy) {
+      return
+    }
+
+    busy = true
+    const item = items.shift()
+    item.busy = true
+
+    Promise.resolve(item.fn()).then((res) => {
+      item.resolve(res)
+      busy = false
+      execute()
+      return null
+    }).catch((err) => {
+      item.reject(err)
+      busy = false
+      execute()
+      return null
+    })
+  }
+
+  return {
+    push (fn) {
+      let _resolve, _reject
+
+      const result = new Promise((resolve, reject) => {
+        _resolve = resolve
+        _reject = reject
+      })
+
+      items.push({
+        fn,
+        resolve: _resolve,
+        reject: _reject,
+        submittedOn: new Date().getTime()
+      })
+
+      execute()
+      return result
+    }
+  }
+}