rascal 9.1.2 → 9.4.0

package/.snyk

@@ -0,0 +1,8 @@
+# Snyk (https://snyk.io) policy file, patches or ignores known vulnerabilities.
+version: v1.13.5
+ignore: {}
+# patches apply the minimum changes required to fix a vulnerability
+patch:
+  SNYK-JS-LODASH-567746:
+    - lodash:
+        patched: '2020-05-02T09:49:46.494Z'

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Change Log
 
+## 9.4.0
+### Added
+- vhost_initialised event
+- publication paused notifications
+- publication.abort
+
+### Updated
+- broker error events now include vhost connection details
+
+## 9.3.0
+### Updated
+- [Fixed #78](https://github.com/guidesmiths/rascal/issues/78) by using a baseline config, and only laying connection options via withDefaultConfig
+
+## 9.2.0
+### Added
+- [Fixed #93](https://github.com/guidesmiths/rascal/issues/93) through use of setInterval to keep node process active in the event of broker restart.
+
+### Updated
+- Dependencies
+- Patched lodash
+- Added snyk
+
+## 9.1.3
+### Updated
+- Fixed bug where channels were destroyed instead of returned to the pool
+
 ## 9.1.2
 ### Updated
 - Test to see whether setTimeout.unref is available before calling it

package/README.md

@@ -114,8 +114,8 @@ The reason Rascal nacks the message is because the alternative is to rollback an
 1. Immediately after obtaining a broker instance
 
     ```js
-    broker.on('error', (err) => {
-      console.error('Broker error', err)
+    broker.on('error', (err, { vhost, connectionUrl }) => {
+      console.error('Broker error', err, vhost, connectionUrl)
     })
     ```
 
@@ -195,6 +195,28 @@ The reason Rascal nacks the message is because the alternative is to rollback an
     })
     ```
 
+### Other Broker Events
+
+#### vhost_initialised
+The broker emits the `vhost_initialised` event after recovering from a connection error. An object containing the vhost name and connection url (with obfuscated password) are passed to he event handler. e.g.
+
+```js
+broker.on('vhost_initialised', ({ vhost, connectionUrl }) => {
+  console.log(`Vhost: ${vhost} was initialised using connection: ${connectionUrl}`);
+})
+```
+
+#### blocked / unblocked
+RabbitMQ notifies clients of [blocked and unblocked](https://www.rabbitmq.com/connection-blocked.html) connections, which rascal forwards from the connection to the broker. e.g.
+```js
+broker.on('blocked', (reason, { vhost, connectionUrl }) => {
+  console.log(`Vhost: ${vhost} was blocked using connection: ${connectionUrl}. Reason: ${reason}`);
+})
+broker.on('unblocked', ({ vhost, connectionUrl }) => {
+  console.log(`Vhost: ${vhost} was unblocked using connection: ${connectionUrl}.`);
+})
+```
+
 ## Configuration
 Rascal is highly configurable, but ships with what we consider to be sensible defaults (optimised for reliability rather than speed) for production and test environments.
 
@@ -766,7 +788,7 @@ try {
     console.log("Message id was: ", messageId)
   }).on("error", (err, messageId) => {
      console.error("Error was: ", err.message)
-  }).on("return", (messageId) => {
+  }).on("return", (message) => {
      console.warn("Message was returned: ", message.properties.messageId)
   })
 } catch (err) {
@@ -817,6 +839,39 @@ When you publish a message using a confirm channel, amqplib will wait for an ack
 }
 ```
 
+#### Aborting
+Rascal uses a channel pool to publish messages. Access to the channel pool is synchronised via an in memory queue, which will be paused if the connection to the broker is temporarily lost. Consequently instead of erroring, publishes will be held until the connection is re-established. If you would rather abort under these circumstances, you can listen for the publication 'paused' event, and call `publication.abort()`. When the connection is re-established any aborted messages will be dropped instead of published.
+
+```js
+broker.publish("p1", "some message", (err, publication) => {
+  if (err) throw err; // publication didn't exist
+  publication.on("success", (messageId) => {
+     console.log("Message id was: ", messageId)
+  }).on("error", (err, messageId) => {
+     console.error("Error was: ", err.message)
+  }).on("paused", (messageId) => {
+     console.warn("Publication was paused. Aborting message: ", messageId)
+     publication.abort();
+  })
+})
+```
+
+```js
+try {
+  const publication = await broker.publish("p1", "some message")
+  publication.on("success", (messageId) => {
+    console.log("Message id was: ", messageId)
+  }).on("error", (err, messageId) => {
+     console.error("Error was: ", err.message)
+  }).on("paused", (messageId) => {
+     console.warn("Publication was paused. Aborting message: ", messageId)
+     publication.abort();
+  })
+} catch (err) {
+  // publication didn't exist
+}
+```
+
 #### Encrypting messages
 Rascal can be configured to automatically encrypt outbound messages.
 ```json

package/examples/advanced/config.js

@@ -10,8 +10,7 @@ module.exports = {
 
         // Define the vhost connection parameters. Specify multiple entries for cluster.
         // Rascal will randomise the list, and cycle through the entries until it finds one that works
-        "connections": [
-          {
+        "connections": [{
             "url": "amqp://does-not-exist-1b9935d9-5066-4b13-84dc-a8e2bb618154:5672/customer-vhost"
           },
           {
@@ -22,17 +21,17 @@ module.exports = {
               "heartbeat": 1
             },
             socketOptions: {
-                timeout: 1000
+              timeout: 1000
             }
           }
         ],
 
         // Define exchanges within the registration vhost
         "exchanges": [
-          "service",      // Shared exchange for all services within this vhost
-          "delay",        // To delay failed messages before a retry
-          "retry",        // To retry failed messages a up to maximum number of times
-          "dead_letters"  // When retring fails messages end up here
+          "service",     // Shared exchange for all services within this vhost
+          "delay",       // To delay failed messages before a retry
+          "retry",       // To retry failed messages a up to maximum number of times
+          "dead_letters" // When retring fails messages end up here
         ],
 
         // Define queues within the registration vhost
@@ -149,7 +148,7 @@ module.exports = {
             // providing the consumer configuration has a matching profile.
             "encryption": "well-known-v1"
           }
-        }
+        },
 
         // Configure confirm channel pools. See https://www.npmjs.com/package/generic-pool
         // The demo application doesn't publish using regular channels. A regular pool will be created by default, but
@@ -167,26 +166,22 @@ module.exports = {
     "recovery": {
 
       // Deferred retry is a good strategy for temporary (connection timeout) or unknown errors
-      "deferred_retry": [
-        {
-         "strategy": "forward",
-          "attempts": 10,
-          "publication": "retry_in_1m",
-          "xDeathFix": true // See https://github.com/rabbitmq/rabbitmq-server/issues/161
-        }, {
-          "strategy": "nack"
-        }
-      ],
+      "deferred_retry": [{
+        "strategy": "forward",
+        "attempts": 10,
+        "publication": "retry_in_1m",
+        "xDeathFix": true // See https://github.com/rabbitmq/rabbitmq-server/issues/161
+      }, {
+        "strategy": "nack"
+      }],
 
       // Republishing with immediate nack returns the message to the original queue but decorates
       // it with error headers. The next time Rascal encounters the message it immedately nacks it
       // causing it to be routed to the services dead letter queue
-      "dead_letter": [
-        {
-          "strategy": "republish",
-          "immediateNack": true
-        }
-      ]
+      "dead_letter": [{
+        "strategy": "republish",
+        "immediateNack": true
+      }]
     },
     // Define counter(s) for counting redeliveries
     "redeliveries": {

package/examples/busy-publisher/config.js

@@ -1,8 +1,8 @@
 module.exports = {
   vhosts: {
     "/": {
-      "publicationChannelPools": {
-        "regularPool": {
+      publicationChannelPools: {
+        regularPool: {
           max: 10,
           min: 5,
           autostart: true
@@ -20,18 +20,18 @@ module.exports = {
         "demo_ex[a.b.c] -> demo_q"
       ],
       publications: {
-        "demo_pub": {
-          "exchange": "demo_ex",
-          "routingKey": "a.b.c",
-          "confirm": false,
-          "options": {
-            "persistent": false
+        demo_pub: {
+          exchange: "demo_ex",
+          routingKey: "a.b.c",
+          confirm: false,
+          options: {
+            persistent: false
           }
         }
       },
       subscriptions: {
-        "demo_sub": {
-          "queue": "demo_q"
+        demo_sub: {
+          queue: "demo_q"
         }
       }
     }

package/examples/default-exchange/config.js

@@ -1,24 +1,24 @@
 module.exports = {
-    vhosts: {
-        "/": {
-            connection: {
-                heartbeat: 1,
-                socketOptions: {
-                    timeout: 1000
-                }
-            },
-            exchanges: [""],
-            queues: ["demo_q"],
-            publications: {
-                "demo_pub": {
-                    "exchange": ""
-                }
-            },
-            subscriptions: {
-                "demo_sub": {
-                    "queue": "demo_q"
-                }
-            }
+  vhosts: {
+    "/": {
+      connection: {
+        heartbeat: 1,
+        socketOptions: {
+          timeout: 1000
         }
+      },
+      exchanges: [""],
+      queues: ["demo_q"],
+      publications: {
+        demo_pub: {
+          exchange: ""
+        }
+      },
+      subscriptions: {
+        demo_sub: {
+          queue: "demo_q"
+        }
+      }
     }
+  }
 }

package/examples/mocha/config.js

@@ -1,22 +1,22 @@
 module.exports = {
-    vhosts: {
-        "/": {
-            exchanges: ["demo_ex"],
-            queues: ["demo_q"],
-            bindings: [
-                "demo_ex[a.b.c] -> demo_q"
-            ],
-            publications: {
-                "demo_pub": {
-                    "exchange": "demo_ex",
-                    "routingKey": "a.b.c"
-                }
-            },
-            subscriptions: {
-                "demo_sub": {
-                    "queue": "demo_q"
-                }
-            }
+  vhosts: {
+    "/": {
+      exchanges: ["demo_ex"],
+      queues: ["demo_q"],
+      bindings: [
+        "demo_ex[a.b.c] -> demo_q"
+      ],
+      publications: {
+        demo_pub: {
+          exchange: "demo_ex",
+          routingKey: "a.b.c"
         }
+      },
+      subscriptions: {
+        demo_sub: {
+          queue: "demo_q"
+        }
+      }
     }
-}
+  }
+}

package/examples/promises/config.js

@@ -1,28 +1,28 @@
 module.exports = {
-    vhosts: {
-        "/": {
-            connection: {
-                heartbeat: 1,
-                socketOptions: {
-                    timeout: 1000
-                }
-            },
-            exchanges: ["demo_ex"],
-            queues: ["demo_q"],
-            bindings: [
-                "demo_ex[a.b.c] -> demo_q"
-            ],
-            publications: {
-                "demo_pub": {
-                    "exchange": "demo_ex",
-                    "routingKey": "a.b.c"
-                }
-            },
-            subscriptions: {
-                "demo_sub": {
-                    "queue": "demo_q"
-                }
-            }
+  vhosts: {
+    "/": {
+      connection: {
+        heartbeat: 1,
+        socketOptions: {
+          timeout: 1000
         }
+      },
+      exchanges: ["demo_ex"],
+      queues: ["demo_q"],
+      bindings: [
+        "demo_ex[a.b.c] -> demo_q"
+      ],
+      publications: {
+        demo_pub: {
+          exchange: "demo_ex",
+          routingKey: "a.b.c"
+        }
+      },
+      subscriptions: {
+        demo_sub: {
+          queue: "demo_q"
+        }
+      }
     }
+  }
 }

package/examples/simple/config.js

@@ -18,17 +18,17 @@ module.exports = {
         "demo_ex[a.b.c] -> demo_q"
       ],
       publications: {
-        "demo_pub": {
-          "exchange": "demo_ex",
-          "routingKey": "a.b.c",
-          "options": {
-            "persistent": false
+        demo_pub: {
+          exchange: "demo_ex",
+          routingKey: "a.b.c",
+          options: {
+            persistent: false
           }
         }
       },
       subscriptions: {
-        "demo_sub": {
-          "queue": "demo_q"
+        demo_sub: {
+          queue: "demo_q"
         }
       }
     }

package/lib/amqp/Broker.js

@@ -13,6 +13,7 @@ var stub = require('../counters/stub');
 var inMemory = require('../counters/inMemory');
 var inMemoryCluster = require('../counters/inMemoryCluster').worker;
 var setTimeoutUnref = require('../utils/setTimeoutUnref');
+var maxInterval = 2147483647;
 
 module.exports = {
   create: function create(config, components, next) {
@@ -50,6 +51,7 @@ function Broker(config, components) {
     subscriptions = {};
     sessions = [];
     init(config, { broker: self, components: { counters: counters } }, function(err, config, ctx) {
+      self.keepActive = setInterval(_.noop, maxInterval);
       setImmediate(function() {
         next(err, self);
       });
@@ -95,6 +97,7 @@ function Broker(config, components) {
         shutdownVhost(config, { vhost: vhost }, callback);
       }, function(err) {
         if (err) return next(err);
+        clearInterval(self.keepActive);
         debug('Finished shutting down broker');
         next();
       });

package/lib/amqp/Publication.js

@@ -2,8 +2,8 @@ var debug = require('debug')('rascal:Publication');
 var format = require('util').format;
 var _ = require('lodash');
 var uuid = require('uuid').v4;
-var EventEmitter = require('events').EventEmitter;
 var crypto = require('crypto');
+var PublicationSession = require('./PublicationSession');
 var setTimeoutUnref = require('../utils/setTimeoutUnref');
 
 module.exports = {
@@ -17,7 +17,7 @@ module.exports = {
 
     if (config.hasOwnProperty('exchange') && config.confirm) return new Publication(vhost, borrowConfirmChannel, returnConfirmChannel, destroyConfirmChannel, publishToConfirmExchange, config).init(next);
     if (config.hasOwnProperty('exchange')) return new Publication(vhost, borrowChannel, returnChannel, destroyChannel, publishToExchange, config).init(next);
-    if (config.queue && config.confirm) return new Publication(vhost, borrowConfirmChannel, destroyConfirmChannel, returnConfirmChannel, sendToConfirmQueue, config).init(next);
+    if (config.queue && config.confirm) return new Publication(vhost, borrowConfirmChannel, returnConfirmChannel, destroyConfirmChannel, sendToConfirmQueue, config).init(next);
     if (config.queue) return new Publication(vhost, borrowChannel, returnChannel, destroyChannel, sendToQueue, config).init(next);
   },
 };
@@ -30,7 +30,7 @@ function Publication(vhost, borrowChannelFn, returnChannelFn, destroyChannelFn,
 
   this.init = function(next) {
     debug('Initialising publication: %s', config.name);
-    return next(null, self);
+    next(null, self);
   };
 
   this.publish = function(payload, overrides, next) {
@@ -39,7 +39,7 @@ function Publication(vhost, borrowChannelFn, returnChannelFn, destroyChannelFn,
     publishConfig.options.contentType = publishConfig.options.contentType || content.type;
     publishConfig.options.messageId = publishConfig.options.messageId || uuid();
 
-    return publishConfig.encryption
+    publishConfig.encryption
       ? _publishEncrypted(content.buffer, publishConfig, next)
       : _publish(content.buffer, publishConfig, next);
   };
@@ -87,32 +87,39 @@ function Publication(vhost, borrowChannelFn, returnChannelFn, destroyChannelFn,
   }
 
   function _publish(buffer, publishConfig, next) {
-    var emitter = new EventEmitter();
     var messageId = publishConfig.options.messageId;
+    var session = new PublicationSession(vhost, messageId);
     borrowChannelFn(function(err, channel) {
-      if (err) return emitter.emit('error', err, messageId);
-      var errorHandler = _.once(handleChannelError.bind(null, channel, messageId, emitter, config));
-      var returnHandler = emitter.emit.bind(emitter, 'return');
+      session._removePausedListener();
+      if (err) return session.emit('error', err, messageId);
+      if (session.isAborted()) return abortPublish(channel, messageId);
+      var errorHandler = _.once(handleChannelError.bind(null, channel, messageId, session, config));
+      var returnHandler = session.emit.bind(session, 'return');
       addListeners(channel, errorHandler, returnHandler);
       try {
         publishFn(channel, buffer, publishConfig, function(err, ok) {
           if (err) {
             destroyChannel(channel, errorHandler, returnHandler);
-            return emitter.emit('error', err, messageId);
+            return session.emit('error', err, messageId);
           }
 
           ok ? returnChannel(channel, errorHandler, returnHandler)
              : deferReturnChannel(channel, errorHandler, returnHandler);
 
-          emitter.emit('success', messageId);
+          session.emit('success', messageId);
         });
       } catch(err) {
         returnChannel(channel, errorHandler, returnHandler);
-        return emitter.emit('error', err, messageId);
+        return session.emit('error', err, messageId);
       };
     });
 
-    next(null, emitter);
+    next(null, session);
+  }
+
+  function abortPublish(channel, messageId) {
+    debug('Publication of message: %s was aborted', messageId);
+    returnChannelFn(channel);
   }
 
   function returnChannel(channel, errorHandler, returnHandler) {

package/lib/amqp/PublicationSession.js

@@ -0,0 +1,36 @@
+var debug = require('debug')('rascal:SubscriberSession');
+var EventEmitter = require('events').EventEmitter;
+var inherits = require('util').inherits;
+
+module.exports = PublicationSession;
+
+inherits(PublicationSession, EventEmitter);
+
+function PublicationSession(vhost, messageId) {
+
+  var self = this;
+  var aborted = false;
+
+  this.abort = function() {
+    aborted = true;
+  };
+
+  this.isAborted = function() {
+    return aborted;
+  };
+
+  this._removePausedListener = function() {
+    vhost.removeListener('paused',emitPaused);
+  };
+
+  function emitPaused() {
+    self.emit('paused', messageId);
+  }
+
+  vhost.on('paused', emitPaused);
+
+  self.on('newListener', function(event) {
+    if (event !== 'paused') return;
+    if (vhost.isPaused()) emitPaused();
+  });
+}

package/lib/amqp/Vhost.js

@@ -3,7 +3,6 @@ var format = require('util').format;
 var inherits = require('util').inherits;
 var EventEmitter = require('events').EventEmitter;
 var async = require('async');
-var forwardEvents = require('forward-emitter');
 var genericPool = require('generic-pool');
 var tasks = require('./tasks');
 var uuid = require('uuid').v4;
@@ -33,6 +32,7 @@ function Vhost(config) {
   var purge = async.compose(tasks.closeConnection, tasks.closeChannel, tasks.purgeQueues, tasks.createChannel, tasks.createConnection);
   var nuke = async.compose(tasks.closeConnection, tasks.closeChannel, tasks.deleteQueues, tasks.deleteExchanges, tasks.createChannel, tasks.createConnection);
   var timer = backoff({});
+  var paused = true;
 
   this.name = config.name;
   this.connectionIndex = 0;
@@ -45,22 +45,22 @@ function Vhost(config) {
 
     init(config, { connectionIndex: self.connectionIndex }, function(err, config, ctx) {
       if (err) return next(err);
-      self.emit('connect');
-
-      attachErrorHandlers(ctx.connection, config);
 
-      forwardEvents(ctx.connection, self, function(eventName) {
-        return eventName === 'blocked' || eventName === 'unblocked';
-      });
-      debug('vhost: %s was initialised with connection: %s', self.name, ctx.connection._rascal_id);
       connection = ctx.connection;
       self.connectionIndex = ctx.connectionIndex;
       connectionConfig = ctx.connectionConfig;
       timer = backoff(ctx.connectionConfig.retry);
 
+      attachErrorHandlers(config);
+      forwardRabbitMQConnectionEvents();
       ensureChannelPools();
       resumeChannelAllocation();
 
+      debug('vhost: %s was initialised with connection: %s', self.name, connection._rascal_id);
+
+      self.emit('connect');
+      self.emit('vhost_initialised', getConnectionDetails());
+
       return next(null, self);
     });
     return self;
@@ -162,6 +162,10 @@ function Vhost(config) {
     confirmChannelPool.destroy(channel);
   };
 
+  this.isPaused = function() {
+    return paused;
+  };
+
   function createChannelPool(options) {
     var pool, poolQueue;
     var mode = getChannelMode(options.confirm);
@@ -326,12 +330,25 @@ function Vhost(config) {
     channelCreator.pause();
     regularChannelPool && regularChannelPool.pause();
     confirmChannelPool && confirmChannelPool.pause();
+    paused = true;
+    self.emit('paused', { vhost: self.name });
   }
 
   function resumeChannelAllocation() {
     channelCreator.resume();
     regularChannelPool && regularChannelPool.resume();
     confirmChannelPool && confirmChannelPool.resume();
+    paused = false;
+    self.emit('resumed', { vhost: self.name });
+  }
+
+  function forwardRabbitMQConnectionEvents() {
+    connection.on('blocked', function(reason) {
+      self.emit('blocked', reason, getConnectionDetails());
+    });
+    connection.on('unblocked', function() {
+      self.emit('unblocked', getConnectionDetails());
+    });
   }
 
   function ensureChannelPools() {
@@ -350,7 +367,7 @@ function Vhost(config) {
     ], next);
   }
 
-  function attachErrorHandlers(connection, config) {
+  function attachErrorHandlers(config) {
     connection.removeAllListeners('error');
     var errorHandler = _.once(handleConnectionError.bind(null, connection, config));
     connection.once('error', errorHandler);
@@ -359,10 +376,10 @@ function Vhost(config) {
 
   function handleConnectionError(borked, config, err) {
     debug('Handling connection error: %s initially from connection: %s, %s', err.message, borked._rascal_id, connectionConfig.loggableUrl);
-    self.emit('disconnect');
     pauseChannelAllocation();
     connection = undefined;
-    self.emit('error', err);
+    self.emit('disconnect');
+    self.emit('error', err, getConnectionDetails());
     connectionConfig.retry && self.init(function(err) {
       if (!err) return;
       var delay = timer.next();
@@ -370,4 +387,8 @@ function Vhost(config) {
       setTimeoutUnref(handleConnectionError.bind(null, borked, config, err), delay);
     });
   }
+
+  function getConnectionDetails() {
+    return { vhost: self.name, connectionUrl: connectionConfig.loggableUrl };
+  }
 }

package/lib/config/baseline.js

@@ -0,0 +1,114 @@
+module.exports = {
+  defaults: {
+    vhosts: {
+      publicationChannelPools: {
+        regularPool: {
+          autostart: false,
+          max: 5,
+          min: 1,
+          evictionRunIntervalMillis: 10000,
+          idleTimeoutMillis: 60000,
+          testOnBorrow: true,
+        },
+        confirmPool: {
+          autostart: false,
+          max: 5,
+          min: 1,
+          evictionRunIntervalMillis: 10000,
+          idleTimeoutMillis: 60000,
+          testOnBorrow: true,
+        },
+      },
+      connectionStrategy: 'random',
+      connection: {
+        slashes: true,
+        protocol: 'amqp',
+        hostname: 'localhost',
+        user: 'guest',
+        password: 'guest',
+        port: '5672',
+        options: {
+        },
+        retry: {
+          min: 1000,
+          max: 60000,
+          factor: 2,
+          strategy: 'exponential',
+        },
+        management: {
+          slashes: true,
+          protocol: "http",
+          port: 15672,
+          options: {
+          },
+        },
+      },
+      exchanges: {
+        assert: true,
+        type: 'topic',
+        options: {
+        },
+      },
+      queues: {
+        assert: true,
+        options: {
+          arguments: {
+          },
+        },
+      },
+      bindings: {
+        destinationType: 'queue',
+        bindingKey: '#',
+        options: {
+        },
+      },
+    },
+    publications: {
+      vhost: '/',
+      confirm: true,
+      timeout: 10000,
+      options: {
+        persistent: true,
+        mandatory: true,
+      },
+    },
+    subscriptions: {
+      vhost: '/',
+      prefetch: 10,
+      retry: {
+        min: 1000,
+        max: 60000,
+        factor: 2,
+        strategy: 'exponential',
+      },
+      redeliveries: {
+        limit: 100,
+        timeout: 1000,
+        counter: 'stub',
+      },
+      deferCloseChannel: 10000,
+      options: {
+      },
+    },
+    redeliveries: {
+      counters: {
+        stub: {},
+        inMemory: {
+          size: 1000,
+        },
+      },
+    },
+    shovels: {
+    },
+  },
+  publications: {
+  },
+  subscriptions: {
+  },
+  redeliveries: {
+    counters: {
+      stub: {
+      },
+    },
+  },
+};

package/lib/config/configure.js

@@ -3,14 +3,14 @@ var format = require('util').format;
 var url = require('url');
 var _ = require('lodash');
 var uuid = require('uuid').v4;
-var emptyConfig = require('./empty');
+var baseline = require('./baseline');
 var fqn = require('./fqn');
 var XRegExp = require('xregexp');
 var freeze = require('deep-freeze');
 
 module.exports = _.curry(function(rascalConfig, next) {
 
-  rascalConfig = _.defaultsDeep(rascalConfig, emptyConfig, { publications: {}, subscriptions: {}, redeliveries: { counters: { stub: {} }}});
+  rascalConfig = _.defaultsDeep(rascalConfig, baseline);
 
   var err;
   var connectionIndexes = {};

package/lib/config/defaults.js

@@ -1,99 +1,21 @@
 module.exports = {
   defaults: {
     vhosts: {
-      publicationChannelPools: {
-        regularPool: {
-          autostart: false,
-          max: 5,
-          min: 1,
-          evictionRunIntervalMillis: 10000,
-          idleTimeoutMillis: 60000,
-          testOnBorrow: true,
-        },
-        confirmPool: {
-          autostart: false,
-          max: 5,
-          min: 1,
-          evictionRunIntervalMillis: 10000,
-          idleTimeoutMillis: 60000,
-          testOnBorrow: true,
-        },
-      },
-      connectionStrategy: 'random',
       connection: {
-        slashes: true,
-        protocol: 'amqp',
-        hostname: 'localhost',
-        user: 'guest',
-        password: 'guest',
-        port: '5672',
         options: {
           heartbeat: 10,
           connection_timeout: 10000,
           channelMax: 100,
         },
-        retry: {
-          min: 1000,
-          max: 60000,
-          factor: 2,
-          strategy: 'exponential',
-        },
         socketOptions: {
           timeout: 10000,
         },
         management: {
-          slashes: true,
-          protocol: "http",
-          port: 15672,
           options: {
             timeout: 1000,
           },
         },
       },
-      exchanges: {
-        assert: true,
-        type: 'topic',
-      },
-      queues: {
-        assert: true,
-      },
-      bindings: {
-        destinationType: 'queue',
-        bindingKey: '#',
-      },
-    },
-    publications: {
-      vhost: '/',
-      confirm: true,
-      timeout: 10000,
-      options: {
-        persistent: true,
-        mandatory: true,
-      },
-    },
-    subscriptions: {
-      vhost: '/',
-      prefetch: 10,
-      retry: {
-        min: 1000,
-        max: 60000,
-        factor: 2,
-        strategy: 'exponential',
-      },
-      redeliveries: {
-        limit: 100,
-        timeout: 1000,
-        counter: 'stub',
-      },
-      deferCloseChannel: 10000,
-    },
-    redeliveries: {
-      counters: {
-        stub: {},
-        inMemory: {
-          size: 1000,
-        },
-      },
     },
   },
 };

package/lib/config/tests.js

@@ -33,7 +33,6 @@ module.exports = _.defaultsDeep({
   },
   redeliveries: {
     "counters": {
-      "stub": {},
       "inMemory": {
         "size": 1000,
       },

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "rascal",
-  "version": "9.1.2",
+  "version": "9.4.0",
   "description": "A config driven wrapper for amqplib supporting multi-host connections, automatic error recovery, redelivery flood protection, transparent encryption / decryption,  channel pooling and publication timeouts",
   "main": "index.js",
   "dependencies": {
-    "async": "^3.1.0",
+    "async": "^3.2.0",
     "debug": "^4.1.1",
     "deep-freeze": "0.0.1",
     "forward-emitter": "^0.1.1",
@@ -12,21 +12,22 @@
     "lodash": "^4.17.15",
     "lru-cache": "^5.1.1",
     "safe-json-parse": "^4.0.0",
-    "stashback": "^1.1.0",
-    "superagent": "^5.2.1",
-    "uuid": "^3.3.3",
-    "xregexp": "^4.2.4"
+    "snyk": "^1.316.2",
+    "stashback": "^1.1.2",
+    "superagent": "^5.2.2",
+    "uuid": "^8.0.0",
+    "xregexp": "^4.3.0"
   },
   "devDependencies": {
     "amqplib": "^0.5.5",
-    "chalk": "^3.0.0",
+    "chalk": "^4.0.0",
     "chance": "^1.1.4",
     "eslint": "^6.8.0",
     "eslint-config-imperative": "^3.0.0",
     "eslint-plugin-imperative": "^3.0.0",
-    "husky": "^4.0.9",
+    "husky": "^4.2.5",
     "mocha": "^7.1.1",
-    "nyc": "^15.0.0",
+    "nyc": "^15.0.1",
     "random-readable": "^1.0.1"
   },
   "peerDependencies": {
@@ -45,7 +46,9 @@
     "lint": "eslint .",
     "docker": "docker run -d --name rascal-rabbitmq -p 5672:5672 -p 15672:15672 rabbitmq:3-management",
     "coverage": "nyc report --reporter lcov --reporter html",
-    "codeclimate": "(test -e .codeclimate && npm run coverage && source .codeclimate && codeclimate-test-reporter < coverage/lcov.info) || echo skipping codeclimate"
+    "codeclimate": "(test -e .codeclimate && npm run coverage && source .codeclimate && codeclimate-test-reporter < coverage/lcov.info) || echo skipping codeclimate",
+    "snyk-protect": "snyk protect",
+    "prepare": "npm run snyk-protect"
   },
   "keywords": [
     "amqplib",
@@ -78,5 +81,6 @@
     "recursive": true,
     "slow": 2000,
     "timeout": 5000
-  }
+  },
+  "snyk": true
 }

package/lib/config/empty.js

@@ -1,38 +0,0 @@
-module.exports = {
-  defaults: {
-    vhosts: {
-      connection: {
-        management: {
-        },
-      },
-      exchanges: {
-        options: {
-        },
-      },
-      queues: {
-        options: {
-          arguments: {
-          },
-        },
-      },
-      bindings: {
-        options: {
-        },
-      },
-    },
-    publications: {
-      options: {
-      },
-    },
-    subscriptions: {
-      options: {
-      },
-    },
-    shovels: {
-    },
-  },
-  redeliveries: {
-    counters: {
-    },
-  },
-};