expressa 2.0.21 → 2.0.23

package/db/file.js

@@ -1,112 +1,131 @@
-const Store = require('jfs')
-const debug = require('debug')('expressa')
-const { promisify } = require('util')
-Store.prototype.allAsync = promisify(Store.prototype.all)
-Store.prototype.getAsync = promisify(Store.prototype.get)
-Store.prototype.saveAsync = promisify(Store.prototype.save)
-
-const util = require('../util')
-
-module.exports = function (settings, collection) {
-  const store = new Store((settings.file_storage_path || 'data') + '/' + collection, {
-    pretty: true,
-    saveId: '_id'
-  })
-
-  return {
-    init: function () {},
-    all: async function () {
-      return this.find({})
-    },
-    find: async function (query, offset, limit, orderby, fields) {
-      const data = await store.allAsync()
-      const arr = Object.keys(data).map(function (id) {
-        return data[id]
-      })
-      let matches = util.mongoSearch(arr, query)
-      if (orderby) {
-        matches = util.orderBy(matches, orderby)
-      }
-      if (typeof offset !== 'undefined' && typeof limit !== 'undefined') {
-        matches = matches.slice(offset, offset + limit)
-      } else if (typeof offset !== 'undefined') {
-        matches = matches.slice(offset)
-      } else if (typeof limit !== 'undefined') {
-        matches = matches.slice(0, limit)
-      }
-      if (matches) { // prevent store from being modified
-        matches = matches.map(function (m) {
-          return util.clone(m)
-        })
-      } // prevent store from being modified
-      if (fields) {
-        matches = matches.map((doc) => util.mongoProject(doc, fields))
-      }
-      return matches
-    },
-    count: async function(...params) {
-      return (await this.find(...params)).length
-    },
-    get: async function (id, fields) {
-      try {
-        let data = await store.getAsync(id)
-        if (data) {
-          data = util.clone(data) // prevent store from getting modified
-        }
-        if (fields) {
-          data = util.mongoProject(data, fields)
-        }
-        return data
-      } catch (err) {
-        debug(collection + ' ' + id)
-        throw new util.ApiError(404, 'document not found')
-      }
-    },
-    exists: async function (id) {
-      try {
-        await store.getAsync(id)
-        return true
-      } catch (err) {
-        return false
-      }
-    },
-    create: async function (data) {
-      data = util.sortObjectKeys(data)
-      util.addIdIfMissing(data)
-      const id = data._id
-      const existing = await this.exists(id)
-      if (existing) {
-        throw new util.ApiError(409, 'document already exists')
-      }
-      await store.saveAsync(id, data)
-      return id
-    },
-    update: async function (id, data) {
-      data._id = data._id || id
-      data = util.sortObjectKeys(data)
-      await store.saveAsync(data._id, data)
-      if (data._id !== id) {
-        await store.delete(id)
-      }
-      return data
-    },
-    // eslint-disable-next-line no-unused-vars
-    updateWithQuery: async function (query, update, options) {
-      const data = await store.allAsync()
-      const arr = Object.keys(data).map((id) => ({ _id: id, ...data[id]}) )
-      const matches = util.mongoSearch(arr, query)
-      const promises = matches.map((doc) => {
-        util.mongoUpdate(doc, update)
-        return store.saveAsync(doc._id, doc)
-      })
-      await Promise.all(promises)
-      return {
-        matchedCount: promises.length
-      }
-    },
-    delete: async function (id) {
-      await this.get(id) // to check if exists
-      await store.delete(id)
-    }
-  }
-}
+const Store = require('jfs')
+const debug = require('debug')('expressa')
+const { promisify } = require('util')
+Store.prototype.allAsync = promisify(Store.prototype.all)
+Store.prototype.getAsync = promisify(Store.prototype.get)
+Store.prototype.saveAsync = promisify(Store.prototype.save)
+
+const util = require('../util')
+
+module.exports = function (settings, collection) {
+  const store = new Store((settings.file_storage_path || 'data') + '/' + collection, {
+    pretty: true,
+    saveId: '_id'
+  })
+
+  return {
+    init: function () {},
+    all: async function () {
+      return this.find({})
+    },
+    find: async function (query, offset, limit, orderby, fields) {
+      const data = await store.allAsync()
+      const arr = Object.keys(data).map(function (id) {
+        return data[id]
+      })
+      let matches = util.mongoSearch(arr, query)
+      if (orderby) {
+        matches = util.orderBy(matches, orderby)
+      }
+      if (typeof offset !== 'undefined' && typeof limit !== 'undefined') {
+        matches = matches.slice(offset, offset + limit)
+      } else if (typeof offset !== 'undefined') {
+        matches = matches.slice(offset)
+      } else if (typeof limit !== 'undefined') {
+        matches = matches.slice(0, limit)
+      }
+      if (matches) { // prevent store from being modified
+        matches = matches.map(function (m) {
+          return util.clone(m)
+        })
+      } // prevent store from being modified
+      if (fields) {
+        matches = matches.map((doc) => util.mongoProject(doc, fields))
+      }
+      return matches
+    },
+    count: async function(...params) {
+      return (await this.find(...params)).length
+    },
+    get: async function (id, fields) {
+      try {
+        let data = await store.getAsync(id)
+        if (data) {
+          data = util.clone(data) // prevent store from getting modified
+        }
+        if (fields) {
+          data = util.mongoProject(data, fields)
+        }
+        return data
+      } catch (err) {
+        debug(collection + ' ' + id)
+        throw new util.ApiError(404, 'document not found')
+      }
+    },
+    exists: async function (id) {
+      try {
+        await store.getAsync(id)
+        return true
+      } catch (err) {
+        return false
+      }
+    },
+    create: async function (data) {
+      data = util.sortObjectKeys(data)
+      util.addIdIfMissing(data)
+      const id = data._id
+      const existing = await this.exists(id)
+      if (existing) {
+        throw new util.ApiError(409, 'document already exists')
+      }
+      await store.saveAsync(id, data)
+      return id
+    },
+    update: async function (id, data) {
+      data._id = data._id || id
+      data = util.sortObjectKeys(data)
+      await store.saveAsync(data._id, data)
+      if (data._id !== id) {
+        await store.delete(id)
+      }
+      return data
+    },
+    // eslint-disable-next-line no-unused-vars
+    updateWithQuery: async function (query, update, options) {
+      const data = await store.allAsync()
+      const arr = Object.keys(data).map((id) => ({ _id: id, ...data[id]}) )
+      const matches = util.mongoSearch(arr, query)
+      const promises = matches.map((doc) => {
+        util.mongoUpdate(doc, update)
+        return store.saveAsync(doc._id, doc)
+      })
+      await Promise.all(promises)
+      return {
+        matchedCount: promises.length
+      }
+    },
+    updateWithQuerySingle: async function (id, update, options) {
+      try {
+        const doc = await store.getAsync(id)
+        if (!doc) {
+          return {
+            matchedCount: 0
+          }
+        }
+        util.mongoUpdate(doc, update)
+        await store.saveAsync(id, doc)
+        return {
+          matchedCount: 1
+        }
+      } catch (err) {
+        return {
+          matchedCount: 0
+        }
+      }
+    },
+    delete: async function (id) {
+      await this.get(id) // to check if exists
+      await store.delete(id)
+    }
+  }
+}

package/db/memory.js

@@ -1,79 +1,92 @@
-/* eslint no-unused-vars: ["error", { "args": "none" }] */
-const util = require('../util')
-
-module.exports = function (settings, collection) {
-  const store = {}
-
-  return {
-    type: 'memory',
-    init: async function () {},
-    all: async function () {
-      return this.find({})
-    },
-    find: async function (query, offset, limit, orderby, fields) {
-      const arr = Object.values(store)
-      let matches = util.mongoSearch(arr, query)
-      if (orderby) {
-        matches = util.orderBy(matches, orderby)
-      }
-      if (typeof offset !== 'undefined' && typeof limit !== 'undefined') {
-        matches = matches.slice(offset, offset + limit)
-      } else if (typeof offset !== 'undefined') {
-        matches = matches.slice(offset)
-      } else if (typeof limit !== 'undefined') {
-        matches = matches.slice(0, limit)
-      }
-      if (fields) {
-        matches = matches.map((doc) => util.mongoProject(doc, fields))
-      }
-      return matches
-    },
-    count: async function(...params) {
-      return (await this.find(...params)).length
-    },
-    get: async function (id, fields) {
-      if (!store[id]) {
-        throw new util.ApiError(404, 'document not found')
-      }
-      let doc = util.clone(store[id])
-      if (fields) {
-        doc = util.mongoProject(doc, fields)
-      }
-      return doc
-    },
-    create: async function (data) {
-      util.addIdIfMissing(data)
-      const id = data._id
-      if (store[id]) {
-        throw new util.ApiError(409, 'document already exists')
-      }
-      store[id] = data
-      return id
-    },
-    update: async function (id, data) {
-      data._id = data._id || id
-      store[id] = data
-      return data
-    },
-    // Designed to match Mongo
-    // https://docs.mongodb.com/manual/reference/method/db.collection.updateMany/
-    updateWithQuery: async function (query, update, options) {
-      const arr = Object.keys(store).map((id) => ({ _id: id, ...store[id]}) )
-      const matches = util.mongoSearch(arr, query)
-      matches.forEach((doc) => {
-        util.mongoUpdate(doc, update)
-        store[doc._id] = doc
-      })
-      return {
-        matchedCount: matches.length
-      }
-    },
-    delete: async function (id) {
-      if (store[id]) {
-        delete store[id]
-      } else {
-        throw new util.ApiError(404, 'document not found')
-      }
-    }
-  }
-}
+/* eslint no-unused-vars: ["error", { "args": "none" }] */
+const util = require('../util')
+
+module.exports = function (settings, collection) {
+  const store = {}
+
+  return {
+    type: 'memory',
+    init: async function () {},
+    all: async function () {
+      return this.find({})
+    },
+    find: async function (query, offset, limit, orderby, fields) {
+      const arr = Object.values(store)
+      let matches = util.mongoSearch(arr, query)
+      if (orderby) {
+        matches = util.orderBy(matches, orderby)
+      }
+      if (typeof offset !== 'undefined' && typeof limit !== 'undefined') {
+        matches = matches.slice(offset, offset + limit)
+      } else if (typeof offset !== 'undefined') {
+        matches = matches.slice(offset)
+      } else if (typeof limit !== 'undefined') {
+        matches = matches.slice(0, limit)
+      }
+      if (fields) {
+        matches = matches.map((doc) => util.mongoProject(doc, fields))
+      }
+      return matches
+    },
+    count: async function(...params) {
+      return (await this.find(...params)).length
+    },
+    get: async function (id, fields) {
+      if (!store[id]) {
+        throw new util.ApiError(404, 'document not found')
+      }
+      let doc = util.clone(store[id])
+      if (fields) {
+        doc = util.mongoProject(doc, fields)
+      }
+      return doc
+    },
+    create: async function (data) {
+      util.addIdIfMissing(data)
+      const id = data._id
+      if (store[id]) {
+        throw new util.ApiError(409, 'document already exists')
+      }
+      store[id] = data
+      return id
+    },
+    update: async function (id, data) {
+      data._id = data._id || id
+      store[id] = data
+      return data
+    },
+    // Designed to match Mongo
+    // https://docs.mongodb.com/manual/reference/method/db.collection.updateMany/
+    updateWithQuery: async function (query, update, options) {
+      const arr = Object.keys(store).map((id) => ({ _id: id, ...store[id]}) )
+      const matches = util.mongoSearch(arr, query)
+      matches.forEach((doc) => {
+        util.mongoUpdate(doc, update)
+        store[doc._id] = doc
+      })
+      return {
+        matchedCount: matches.length
+      }
+    },
+    updateWithQuerySingle: async function (id, update, options) {
+      if (!store[id]) {
+        return {
+          matchedCount: 0
+        }
+      }
+      const doc = { _id: id, ...store[id] }
+      util.mongoUpdate(doc, update)
+      store[id] = doc
+      return {
+        matchedCount: 1
+      }
+    },
+    delete: async function (id) {
+      if (store[id]) {
+        delete store[id]
+      } else {
+        throw new util.ApiError(404, 'document not found')
+      }
+    }
+  }
+}

package/db/mongo.js

@@ -1,86 +1,93 @@
-const mongo = require('mongodb')
-const MongoClient = mongo.MongoClient
-const util = require('../util')
-
-module.exports = function (settings, collection) {
-  return {
-    getClient: async function () {
-      const client = await MongoClient.connect(settings.mongodb_uri, { useNewUrlParser: true })
-      const db = client.db(settings.mongodb_uri.split('/')[3])
-      return db
-    },
-    init: function () {
-      if (!settings.mongodb_uri) {
-        console.error('{collection} uses mongo, but mongodb_url is undefined.')
-      }
-    },
-    all: async function () {
-      return this.find({})
-    },
-    find: async function (query, skip, limit, orderby, fields) {
-      const db = await this.getClient()
-      const cursor = db.collection(collection).find(query, { skip, limit, projection: fields, sort: orderby })
-      const docs = await cursor.toArray()
-      docs.forEach((doc) => {
-        if (doc._id) {
-          doc._id = doc._id.toString()
-        }
-      })
-      return docs
-    },
-    count: async function(query, skip, limit) {
-      const db = await this.getClient()
-      const count = await db.collection(collection).count(query, { skip, limit })
-      return count
-    },
-    get: async function (id, fields) {
-      const db = await this.getClient()
-      const doc = await db.collection(collection).findOne({ _id: id }, { projection: fields })
-      if (doc) {
-        doc._id = doc._id.toString()
-      }
-      if (!doc) {
-        throw new util.ApiError(404, 'document not found')
-      }
-      return doc
-    },
-    create: async function (data) {
-      util.addIdIfMissing(data)
-
-      const db = await this.getClient()
-      try {
-        const doc = await db.collection(collection).insertOne(data)
-        return doc.insertedId.toString()
-      } catch (err) {
-        if (err && err.message && err.message.includes('duplicate key error')) {
-          throw new util.ApiError(409, 'document already exists')
-        }
-      }
-    },
-    update: async function (id, data) {
-      data._id = id
-      const db = await this.getClient()
-      await db.collection(collection).replaceOne({
-        _id: id
-      }, data)
-      // doc._id = doc._id.toString()
-      return data
-    },
-    updateWithQuery: async function (query, update, options) {
-      const db = await this.getClient()
-      const res = await db.collection(collection).updateMany(query, update, options)
-      return {
-        matchedCount: res.matchedCount
-      }
-    },
-    delete: async function (id) {
-      const db = await this.getClient()
-      const res = await db.collection(collection).deleteOne({
-        _id: id
-      })
-      if (res.result.n !== 1) {
-        throw new util.ApiError(404, 'document not found')
-      }
-    }
-  }
-}
+const mongo = require('mongodb')
+const MongoClient = mongo.MongoClient
+const util = require('../util')
+
+module.exports = function (settings, collection) {
+  return {
+    getClient: async function () {
+      const client = await MongoClient.connect(settings.mongodb_uri, { useNewUrlParser: true })
+      const db = client.db(settings.mongodb_uri.split('/')[3])
+      return db
+    },
+    init: function () {
+      if (!settings.mongodb_uri) {
+        console.error('{collection} uses mongo, but mongodb_url is undefined.')
+      }
+    },
+    all: async function () {
+      return this.find({})
+    },
+    find: async function (query, skip, limit, orderby, fields) {
+      const db = await this.getClient()
+      const cursor = db.collection(collection).find(query, { skip, limit, projection: fields, sort: orderby })
+      const docs = await cursor.toArray()
+      docs.forEach((doc) => {
+        if (doc._id) {
+          doc._id = doc._id.toString()
+        }
+      })
+      return docs
+    },
+    count: async function(query, skip, limit) {
+      const db = await this.getClient()
+      const count = await db.collection(collection).count(query, { skip, limit })
+      return count
+    },
+    get: async function (id, fields) {
+      const db = await this.getClient()
+      const doc = await db.collection(collection).findOne({ _id: id }, { projection: fields })
+      if (doc) {
+        doc._id = doc._id.toString()
+      }
+      if (!doc) {
+        throw new util.ApiError(404, 'document not found')
+      }
+      return doc
+    },
+    create: async function (data) {
+      util.addIdIfMissing(data)
+
+      const db = await this.getClient()
+      try {
+        const doc = await db.collection(collection).insertOne(data)
+        return doc.insertedId.toString()
+      } catch (err) {
+        if (err && err.message && err.message.includes('duplicate key error')) {
+          throw new util.ApiError(409, 'document already exists')
+        }
+      }
+    },
+    update: async function (id, data) {
+      data._id = id
+      const db = await this.getClient()
+      await db.collection(collection).replaceOne({
+        _id: id
+      }, data)
+      // doc._id = doc._id.toString()
+      return data
+    },
+    updateWithQuery: async function (query, update, options) {
+      const db = await this.getClient()
+      const res = await db.collection(collection).updateMany(query, update, options)
+      return {
+        matchedCount: res.matchedCount
+      }
+    },
+    updateWithQuerySingle: async function (id, update, options) {
+      const db = await this.getClient()
+      const res = await db.collection(collection).updateOne({ _id: id }, update, options)
+      return {
+        matchedCount: res.matchedCount
+      }
+    },
+    delete: async function (id) {
+      const db = await this.getClient()
+      const res = await db.collection(collection).deleteOne({
+        _id: id
+      })
+      if (res.result.n !== 1) {
+        throw new util.ApiError(404, 'document not found')
+      }
+    }
+  }
+}