keuss 2.0.7 → 2.1.0

package/backends/intraorder.js

@@ -33,7 +33,7 @@ class IntraOrderedQueue extends Queue {
 
   /////////////////////////////////////////
   // add element to queue
-  insert (entry, callback) {
+  insert (entry, cb) {
     const q = { _id: entry.payload.iid || uuid.v4 () };
     const upd = { 
       $push: { q: entry }, 
@@ -42,28 +42,29 @@ class IntraOrderedQueue extends Queue {
     };
     const opts = { upsert: true };
 
-    this._col.updateOne (q, upd, opts, (err, result) => {
-      debug ('insert: updateOne (%j, %j, %j) => (%j, %j)', q, upd, opts, err, result);
-      if (err) return callback (err);
-      callback (null, result.upsertedId || q._id);
-    });
+    this._col.updateOne (q, upd, opts)
+    .then (res => {
+      debug ('insert: updateOne (%j, %j, %j) => (%j)', q, upd, opts, res);
+      cb (null, res.upsertedId || q._id);
+    })
+    .catch (cb);
   }
 
 
   /////////////////////////////////////////
   // get element from queue
-  get (callback) {
+  get (cb) {
     // actually, a reserve followed by a commit
     this.reserve ((err, elem) => {
-      if (err)   return callback (err);
-      if (!elem) return callback ();
+      if (err)   return cb (err);
+      if (!elem) return cb ();
 
       this.commit (elem._id, (err, res) => {
-        if (err) return callback (err);
+        if (err) return cb (err);
 
         // clear _env: not needed here
         delete elem._env;
-        callback (null, elem);
+        cb (null, elem);
       }, elem);
     })
   }
@@ -71,7 +72,7 @@ class IntraOrderedQueue extends Queue {
 
   //////////////////////////////////
   // reserve element: call cb (err, pl) where pl has an id
-  reserve (callback) {
+  reserve (cb) {
     const delay = this._opts.reserve_delay || 120;
 
     const q = {
@@ -89,14 +90,15 @@ class IntraOrderedQueue extends Queue {
 
     const opts = {
       sort: {mature : 1},
-      returnDocument: 'before'
+      returnDocument: 'before',
+      includeResultMetadata: true
     };
 
-    this._col.findOneAndUpdate (q, upd, opts, (err, result) => {
-      debug ('reserve: findOneAndUpdate (%j, %j, %j) => (%j, %j)', q, upd, opts, err, result);
-      if (err) return callback (err);
-      const v = result && result.value;
-      if (!v) return callback ();
+    this._col.findOneAndUpdate (q, upd, opts)
+    .then (res => {
+      debug ('reserve: findOneAndUpdate (%j, %j, %j) => (%j)', q, upd, opts, res);
+      const v = res && res.value;
+      if (!v) return cb ();
 
       // construct the real object to return
       const vq = v.q[0];
@@ -104,17 +106,18 @@ class IntraOrderedQueue extends Queue {
       vq.tries = v.tries
       vq._env = v; // pass along the whole obj too
       if (vq.payload._bsontype == 'Binary') vq.payload = vq.payload.buffer;
-      callback (null, vq);
-    });
+      cb (null, vq);
+    })
+    .catch(cb);
   }
 
 
   //////////////////////////////////
   // commit previous reserve, by p.id
-  commit (id, callback, obj) {
+  commit (id, cb, obj) {
     if (!(obj || (obj && obj._id))) {
       // full obj must be passed to commit
-      return callback ('full obj must be passed to commit');
+      return cb ('full obj must be passed to commit');
     }
 
     const q  =  {
@@ -147,19 +150,20 @@ class IntraOrderedQueue extends Queue {
 
     const opts = {};
 
-    this._col.updateOne (q, upd, opts, (err, result) => {
-      debug ('commit: updateOne (%j, %j, %j) => (%j, %j)', q, upd, opts, err, result);
-      if (err) return callback (err);
-      callback (null, result && (result.modifiedCount == 1));
-    });
+    this._col.updateOne (q, upd, opts)
+    .then (res => {
+      debug ('commit: updateOne (%j, %j, %j) => (%j)', q, upd, opts, res);
+      cb (null, res && (res.modifiedCount == 1));
+    })
+    .catch (cb);
   }
 
 
   //////////////////////////////////
   // rollback previous reserve, by p.id
-  rollback (id, next_t, callback) {
+  rollback (id, next_t, cb) {
     if (_.isFunction (next_t)) {
-      callback = next_t;
+      cb = next_t;
       next_t = null;
     }
 
@@ -175,17 +179,18 @@ class IntraOrderedQueue extends Queue {
 
     const opts = {};
 
-    this._col.updateOne (q, upd, opts, (err, result) => {
-      debug ('rollback: updateOne (%j, %j, %j) => (%j, %j)', q, upd, opts, err, result);
-      if (err) return callback (err);
-      callback (null, result && (result.modifiedCount == 1));
-    });
+    this._col.updateOne (q, upd, opts)
+    .then (res => {
+      debug ('rollback: updateOne (%j, %j, %j) => (%j)', q, upd, opts, res);
+      cb (null, res && (res.modifiedCount == 1));
+    })
+    .catch (cb);
   }
 
 
   //////////////////////////////////
   // queue size of non-mature elements only
-  totalSize (callback) {
+  totalSize (cb) {
     const cursor = this._col.aggregate ([
       {$match: {
         qcnt: {$gt: 0}
@@ -193,18 +198,19 @@ class IntraOrderedQueue extends Queue {
       {$group:{_id:'t', v: {$sum: '$qcnt'}}}
     ]);
 
-    cursor.toArray ((err, res) => {
+    cursor.toArray ()
+    .then (res => {
       debug ('calculating schedSize: aggregation pipeline returns %o', res);
-      if (err) return callback (err);
-      if (res.length == 0) return callback (null, 0);
-      callback (null, res[0].v);
-    });
+      if (res.length == 0) return cb (null, 0);
+      cb (null, res[0].v);
+    })
+    .catch (cb);
   }
 
 
   //////////////////////////////////
   // queue size NOT including non-mature elements
-  size (callback) {
+  size (cb) {
     const cursor = this._col.aggregate ([
       {$match: {
         mature: {$lte: Queue.now ()},
@@ -213,18 +219,19 @@ class IntraOrderedQueue extends Queue {
       {$group:{_id:'t', v: {$sum: '$qcnt'}}}
     ]);
 
-    cursor.toArray ((err, res) => {
+    cursor.toArray ()
+    .then (res => {
       debug ('calculating schedSize: aggregation pipeline returns %o', res);
-      if (err) return callback (err);
-      if (res.length == 0) return callback (null, 0);
-      callback (null, res[0].v);
-    });
+      if (res.length == 0) return cb (null, 0);
+      cb (null, res[0].v);
+    })
+    .catch (cb);
   }
 
 
   //////////////////////////////////
   // queue size of non-mature elements only
-  schedSize (callback) {
+  schedSize (cb) {
     const cursor = this._col.aggregate ([
       {$match: {
         mature: {$gt: Queue.now ()},
@@ -234,18 +241,19 @@ class IntraOrderedQueue extends Queue {
       {$group:{_id:'t', v: {$sum: '$qcnt'}}}
     ]);
 
-    cursor.toArray ((err, res) => {
+    cursor.toArray ()
+    .then (res => {
       debug ('calculating schedSize: aggregation pipeline returns %o', res);
-      if (err) return callback (err);
-      if (res.length == 0) return callback (null, 0);
-      callback (null, res[0].v);
-    });
+      if (res.length == 0) return cb (null, 0);
+      cb (null, res[0].v);
+    })
+    .catch (cb);
   }
 
 
   //////////////////////////////////
   // queue size of reserved elements only
-  resvSize (callback) {
+  resvSize (cb) {
     const cursor = this._col.aggregate ([
       {$match: {
         mature: {$gt: Queue.now ()},
@@ -255,18 +263,19 @@ class IntraOrderedQueue extends Queue {
       {$group:{_id:'t', v: {$sum: '$qcnt'}}}
     ]);
 
-    cursor.toArray ((err, res) => {
+    cursor.toArray ()
+    .then (res => {
       debug ('calculating schedSize: aggregation pipeline returns %o', res);
-      if (err) return callback (err);
-      if (res.length == 0) return callback (null, 0);
-      callback (null, res[0].v);
-    });
+      if (res.length == 0) return cb (null, 0);
+      cb (null, res[0].v);
+    })
+    .catch (cb);
   }
 
 
   //////////////////////////////////////////////
   // remove by id
-  remove (id, callback) {
+  remove (id, cb) {
     const q =  {
       _id: id,
       qcnt: { $eq: 1 },  // allow deletion ONLY if it has just one element in the intraqueue
@@ -275,26 +284,26 @@ class IntraOrderedQueue extends Queue {
 
     const opts = {};
 
-    this._col.deleteOne (q, opts, (err, result) => {
-      debug ('remove: deleteOne (%j, %j) => (%j, %j)', q, opts, err, result);
-      if (err) return callback (err);
-      callback (null, result && (result.deletedCount == 1));
-    });
+    this._col.deleteOne (q, opts)
+    .then (res => {
+      debug ('remove: deleteOne (%j, %j) => (%j)', q, opts, res);
+      cb (null, res && (res.deletedCount == 1));
+    })
+    .catch (cb);
   }
 
 
   /////////////////////////////////////////
   // get element from queue
-  next_t (callback) {
+  next_t (cb) {
     this._col
     .find ()
     .limit(1)
     .sort ({mature:1})
     .project ({mature:1})
-    .next ((err, result) => {
-      if (err) return callback (err);
-      callback (null, result && result.mature);
-    });
+    .next ()
+    .then (res => cb (null, res && res.mature))
+    .catch (cb);
   }
 
 
@@ -305,12 +314,15 @@ class IntraOrderedQueue extends Queue {
   // create needed indexes for O(1) functioning
   _ensureIndexes (cb) {
     async.series ([
-      cb => this._col.createIndex ({mature : 1, qcnt: 1}, err => cb (err)),
-    ], err => cb (err, this));
+      cb => this._col.createIndex ({mature : 1, qcnt: 1}).then (res => cb(null, res)).catch (cb),
+    ])
+    .then (() => cb (null, this))
+    .catch (cb);
   }
 }
 
 
+///////////////////////////////////////////////////////////////////////////////
 class Factory extends QFactory_MongoDB_defaults {
   constructor (opts, mongo_conn) {
     super (opts);
@@ -357,20 +369,18 @@ class Factory extends QFactory_MongoDB_defaults {
   }
 }
 
+
+//////////////////////////////////////////////////////////////////
 function creator (opts, cb) {
-  var _opts = opts || {};
-  var m_url = _opts.url || 'mongodb://localhost:27017/keuss';
+  const _opts = opts || {};
+  const m_url = _opts.url || 'mongodb://localhost:27017/keuss';
 
-  MongoClient.connect (m_url, { useNewUrlParser: true }, (err, cl) => {
-    if (err) return cb (err);
-    var F = new Factory (_opts, cl);
+  MongoClient.connect (m_url)
+  .then (cl => {
+    const F = new Factory (_opts, cl);
     F.async_init (err => cb (null, F));
-  });
+  })
+  .catch (cb);
 }
 
 module.exports = creator;
-
-
-
-
-