mongo-message-queue - npm Package Compare versions

Comparing version 0.1.0 to 0.1.1

package.json

 {
   "name": "mongo-message-queue",
-  "version": "0.1.0",
-  "description": "A promise based message queue for Node.js using a mongo backing store.",
+  "version": "0.1.1",
+  "description": "A promise based message queue for Node.js using a mongodb backing store.",
   "main": "index.js",
@@ -6,0 +6,0 @@ "dependencies": {

README.md

@@ -5,6 +5,12 @@ # mongo-message-queue
 
-### A promise based message queue for Node.js using a mongo backing store.
+### A promise based message queue for Node.js using a mongodb backing store.
 
-## Installation
+## Package Dependency Notice
 
+NOTE:  This package makes use of promises (instead of callbacks) when interacting with mongodb which requires mongodb version 2.0.36 or higher.
+
+## Usage
+
+### Installation
+
 ```
@@ -14,8 +20,5 @@ npm install mongo-message-queue --save
 
-## Package Dependencies
+### Require & Instantiate
 
-NOTE:  This package makes use of promises (instead of callbacks) when interacting with mongodb which requires mongodb version 2.0.36 or higher.
-
-## Usage
-
+Example:
 ```javascript
@@ -25,41 +28,79 @@ var MessageQueue = require('mongo-message-queue');
 var mQueue = new MessageQueue();
-...
+```
 
-// Provide a promise to return a database connection.
+### Database Configuration
+
+Set the .databasePromise property to a function that returns a promise that (eventually) returns a database connection.
+
+Example:
+```javascript
+var MongoClient = require('mongodb').MongoClient;
+
+var mongoUri = ...;
+var mongoOptions = ...;
+
 mQueue.databasePromise = function() {
   // Return a promise to return a mongo database connection here...
+  return MongoClient.connect(mongoUri, mongoOptions);
 };
+```
 
-...
+### Register one or more Workers
 
-// Register a worker that can handle items of a specific type in the queue.
-// This will cause the message queue to start polling for work of the specified type.
+Use the .registerWorker method to provide a processing method for a specific type of message in the queue.
+
+Each registered worker will handle a specific type of item in the queue as specified by the first parameter.  Registering an additional worker for the same type will override the processing method that is used for that type.
+
+The second parameter of the .registerWorker method is used to specify the processing method for work of that type.  When work shows up in the message queue, the provided processing method will be called and provided the queueItem as the first parameter.
+* Use queueItem.message to get access to the enqueued item.
+* Use queueItem.retryCount to get access to the number of retries that have occurred.
+ * This property is not available during the first processing attempt.
+
+The processing method should return a promise (chain) that (eventually) returns a status of "Completed", "Rejected", or "Retry".
+* If the returned status is "Rejected"...
+ * Optionally set queueItem.rejectionReason to indicate why this should no longer be processed.
+ * Optionally set queueItem.releasedReason to indicate why this didn't process this time around.
+* If the returned status is "Retry"...
+ * Optionally set queueItem.releasedReason to indicate why this didn't process this time around.
+ * Optionally set queueItem.nextReceivableTime to indicate when you want this to get picked up and re-processed.
+   * If you don't set queueItem.nextReceivableTime this message will be available for re-procesing immediately.
+
+Registering a worker will cause the message queue to immediately start polling for work of the specified type.  By default, the message queue looks for new messages at least once every second (configurable by overridding the .pollingInterval property).  Polling also occurs immediately following the processing of a previous queue message as long as there is still available work in the queue.  Polling will continue to occur until the .stopPolling() method is called.
+
+Example:
+```javascript
 mQueue.registerWorker('doSomething', function(queueItem) {
   // Return a promise to do something here...
-  
-  // Use queueItem.message to get access to the enqueued item.
-  // Use queueItem.retryCount to get access to the number of retries that have occurred.
-  //    This property is not available if this is the first iteration.
+  return database.collection('somecollection')
+    .updateOne({_id: queueItem.message.id}, {status: queueItem.message.status})
+      .then(function(result) {
+        return "Completed";
+      })
+      .catch(function(err) {
+        queueItem.releasedReason = err.message;
+        if ((queueItem.retryCount || 0) < 5) {
+          queueItem.nextReceivableTime = new Date(Date.now() + (30 * 1000)); // Retry after 30 seconds...
+          return "Retry";
+        } else {
+          queueItem.rejectedReason = "Gave up after 5 retries.";
+          return "Rejected"
+        }
+      });
+  });
+```
 
-  // The final return value in the promise chain should be a status string of:
-  //   "Completed", "Rejected", or "Retry"
-  // If the returned status is "Rejected"...
-  //    Optionally set queueItem.rejectionReason to indicate why this should no longer be processed.
-  //    Optionally set queueItem.releasedReason to indicate why this didn't process this time around.
-  // If the returned status is "Retry"...
-  //    Optionally set queueItem.releasedReason to indicate why this didn't process this time around.
-  //    Optionally set queueItem.nextReceivableTime to indicate when you want this to get picked up and re-processed.
-  //      If you don't set queueItem.nextReceivableTime this will be available for re-procesing immediately.
+### Send work to the message queue
 
-  });
+Enqueue a message to eventually be picked up and processed by one of the workers.
 
-...
+Example:
+```javascript
+mQueue.enqueue('doSomething', { id: 123, status: 'done' });
+```
 
-// Enqueue a message to eventually be picked up by one of the workers.
-// It will get picked up when there is an available worker.
-mQueue.enqueue('doSomething', { some: 'message' });
+You can also enqueue a message and try to process it immediately with a locally registered worker.  If there is not a worker for the specified type registered locally, it will get picked up and processed later when there is an available worker.
 
-// Enqueue a message and try to process it immediately with a locally registered worker.
-// If the specified type is not registered locally, it will get picked up when there is an available worker.
-mQueue.enqueueAndProcess('doSomething', { some: 'message' });
+Example:
+```javascript
+mQueue.enqueueAndProcess('doSomething', { id: 123, status: 'done' });
 ```
@@ -66,0 +107,0 @@

No alert changes

Improved metrics

Total package byte prevSize

13360

17.23%

Number of lines in readme file

129

46.59%

No dependency changes