rascal 14.0.1 → 14.3.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Change Log
 
+## 14.3.0
+
+- Clone config instead of freezing it so buffers will work - See https://github.com/guidesmiths/rascal/issues/92
+
+## 14.2.1
+
+- Fix schema bug
+
+## 14.2.0
+
+- Add json schema (lib/config/schema.json) - See https://github.com/guidesmiths/rascal/issues/168
+
+## 14.1.0
+
+- Adds support for custom user agents - See https://github.com/guidesmiths/rascal/issues/170
+
 ## 14.0.1
 
 - Fixes https://github.com/guidesmiths/rascal/issues/178

package/README.md

@@ -273,10 +273,11 @@ The most common configuration options are
 - [publications](#publications)
 - [subscriptions](#subscriptions)
 
-A simple configuration is shown below.
+A simple configuration is shown below. You can reference Rascal's JSON schema from the config to enable validation and suggestions in compatible IDEs.
 
 ```json
 {
+  "$schema": "./node_modules/rascal/lib/config/schema.json",
   "vhosts": {
     "/": {
       "connection": {
@@ -483,6 +484,15 @@ Rascal uses [superagent](https://github.com/visionmedia/superagent) under the ho
 }
 ```
 
+You can also supply your own agent via the broker components. Use this when you need to set [TLS options](https://visionmedia.github.io/superagent/#tls-options).
+
+```js
+const superagent = require('superagent-defaults');
+const agent = superagent().on('request', (req) => console.log(req.url));
+const components = { agent };
+const broker = await Broker.create(config, components);
+```
+
 #### assert
 
 When set to true, Rascal will create the vhost if one doesn't exist using the RabbitMQ management API. This requires the [management plugin](https://www.rabbitmq.com/management.html) to be installed on the broker and for the management user to have necessary permissions.

package/examples/busy-publisher/config.json

@@ -0,0 +1,40 @@
+{
+  "$schema": "../../lib/config/schema.json",
+  "vhosts": {
+    "/": {
+      "publicationChannelPools": {
+        "confirmPool": {
+          "max": 10,
+          "min": 10,
+          "evictionRunIntervalMillis": 1000,
+          "idleTimeoutMillis": 5000,
+          "autostart": true
+        }
+      },
+      "connection": {
+        "heartbeat": 5,
+        "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",
+          "confirm": false,
+          "options": {
+            "persistent": false
+          }
+        }
+      },
+      "subscriptions": {
+        "demo_sub": {
+          "queue": "demo_q"
+        }
+      }
+    }
+  }
+}

package/examples/default-exchange/config.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "../../lib/config/schema.json",
+  "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.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "../../lib/config/schema.json",
+  "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.json

@@ -0,0 +1,27 @@
+{
+  "$schema": "../../lib/config/schema.json",
+  "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.json

@@ -0,0 +1,37 @@
+{
+  "$schema": "../../lib/config/schema.json",
+  "vhosts": {
+    "/": {
+      "publicationChannelPools": {
+        "confirmPool": {
+          "autostart": true
+        }
+      },
+      "connection": {
+        "options": {
+          "heartbeat": 10
+        },
+        "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",
+          "options": {
+            "persistent": false
+          }
+        }
+      },
+      "subscriptions": {
+        "demo_sub": {
+          "queue": "demo_q"
+        }
+      }
+    }
+  }
+}

package/lib/amqp/Broker.js

@@ -18,9 +18,16 @@ const maxInterval = 2147483647;
 module.exports = {
   create: function create(config, components, next) {
     if (arguments.length === 2) return create(config, {}, arguments[1]);
+
+    const counters = _.defaults({}, components.counters, {
+      stub,
+      inMemory,
+      inMemoryCluster,
+    });
+
     preflight(_.cloneDeep(config), (err, config) => {
       if (err) return next(err);
-      new Broker(config, components)._init(next);
+      new Broker(config, _.assign({}, components, { counters }))._init(next);
     });
   },
 };
@@ -39,13 +46,8 @@ function Broker(config, components) {
   const forewarnVhost = tasks.forewarnVhost;
   const shutdownVhost = tasks.shutdownVhost;
   const bounceVhost = tasks.bounceVhost;
-  const counters = _.defaults({}, components.counters, {
-    stub,
-    inMemory,
-    inMemoryCluster,
-  });
 
-  this.config = config;
+  this.config = _.cloneDeep(config);
   this.promises = false;
 
   this._init = function (next) {
@@ -54,7 +56,7 @@ function Broker(config, components) {
     publications = {};
     subscriptions = {};
     sessions = [];
-    init(config, { broker: self, components: { counters } }, (err) => {
+    init(config, { broker: self, components }, (err) => {
       self.keepActive = setInterval(_.noop, maxInterval);
       setImmediate(() => {
         next(err, self);
@@ -135,7 +137,7 @@ function Broker(config, components) {
       async.eachSeries(
         _.values(vhosts),
         (vhost, callback) => {
-          nukeVhost(config, { vhost }, callback);
+          nukeVhost(config, { vhost, components }, callback);
         },
         (err) => {
           if (err) return next(err);

package/lib/amqp/Vhost.js

@@ -11,14 +11,14 @@ const backoff = require('../backoff');
 const setTimeoutUnref = require('../utils/setTimeoutUnref');
 
 module.exports = {
-  create(config, next) {
-    new Vhost(config).init(next);
+  create(config, components, next) {
+    new Vhost(config, components).init(next);
   },
 };
 
 inherits(Vhost, EventEmitter);
 
-function Vhost(config) {
+function Vhost(config, components) {
   const self = this;
   let connection;
   let connectionConfig;
@@ -49,7 +49,7 @@ function Vhost(config) {
     debug('Initialising vhost: %s', self.name);
     pauseChannelAllocation();
 
-    init(config, { connectionIndex: self.connectionIndex }, (err, config, ctx) => {
+    init(config, { connectionIndex: self.connectionIndex, components }, (err, config, ctx) => {
       if (err) return next(err);
 
       connection = ctx.connection;

package/lib/amqp/tasks/assertVhost.js

@@ -1,11 +1,13 @@
 const debug = require('debug')('rascal:tasks:assertVhost');
 const _ = require('lodash');
 const async = require('async');
-const client = require('../../management/client');
+const Client = require('../../management/Client');
 
 module.exports = _.curry((config, ctx, next) => {
   if (!config.assert) return next(null, config, ctx);
+
   const candidates = config.connections;
+  const client = new Client(ctx.components.agent);
 
   async.retry(
     candidates.length,

package/lib/amqp/tasks/checkVhost.js

@@ -1,11 +1,13 @@
 const debug = require('debug')('rascal:tasks:checkVhost');
 const _ = require('lodash');
 const async = require('async');
-const client = require('../../management/client');
+const Client = require('../../management/Client');
 
 module.exports = _.curry((config, ctx, next) => {
   if (!config.check) return next(null, config, ctx);
+
   const candidates = config.connections;
+  const client = new Client(ctx.components.agent);
 
   async.retry(
     candidates.length,

package/lib/amqp/tasks/deleteVhost.js

@@ -1,13 +1,14 @@
 const debug = require('debug')('rascal:tasks:deleteVhost');
 const _ = require('lodash');
 const async = require('async');
-const client = require('../../management/client');
+const Client = require('../../management/Client');
 
 module.exports = _.curry((config, ctx, next) => {
   const vhostConfig = config.vhosts[ctx.vhost.name];
   if (!vhostConfig.assert) return next(null, config, ctx);
 
   const candidates = vhostConfig.connections;
+  const client = new Client(ctx.components.agent);
 
   async.retry(
     candidates.length,

package/lib/amqp/tasks/initVhosts.js

@@ -9,7 +9,7 @@ module.exports = _.curry((config, ctx, next) => {
   async.eachSeries(
     _.values(config.vhosts),
     (vhostConfig, callback) => {
-      initVhost(vhostConfig, (err, vhost) => {
+      initVhost(vhostConfig, ctx.components, (err, vhost) => {
         if (err) return callback(err);
         vhost.setMaxListeners(0);
         forwardEvents(vhost, ctx.broker);
@@ -24,6 +24,6 @@ module.exports = _.curry((config, ctx, next) => {
   );
 });
 
-function initVhost(config, next) {
-  Vhost.create(config, next);
+function initVhost(config, components, next) {
+  Vhost.create(config, components, next);
 }

package/lib/config/configure.js

@@ -6,7 +6,6 @@ const uuid = require('uuid').v4;
 const baseline = require('./baseline');
 const fqn = require('./fqn');
 const XRegExp = require('xregexp');
-const freeze = require('deep-freeze');
 
 module.exports = _.curry((rascalConfig, next) => {
   rascalConfig = _.defaultsDeep(rascalConfig, baseline);
@@ -24,7 +23,7 @@ module.exports = _.curry((rascalConfig, next) => {
     err = _err;
   }
 
-  return err ? next(err) : next(null, freeze(rascalConfig));
+  return err ? next(err) : next(null, rascalConfig);
 
   function configureVhosts(vhosts) {
     _.each(vhosts, (vhostConfig, name) => {

package/lib/config/schema.json

@@ -0,0 +1,682 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "type": "object",
+  "properties": {
+    "vhosts": {
+      "type": "object",
+      "patternProperties": {
+        ".*": {
+          "$ref": "#/definitions/vhost"
+        }
+      }
+    },
+    "publications": {
+      "type": "object",
+      "patternProperties": {
+        ".*": {
+          "$ref": "#/definitions/publication"
+        }
+      }
+    },
+    "subscriptions": {
+      "type": "object",
+      "patternProperties": {
+        ".*": {
+          "$ref": "#/definitions/subscription"
+        }
+      }
+    },
+    "redeliveries": {
+      "$ref": "#/definitions/redeliveries"
+    },
+    "encryption": {
+      "type": "object",
+      "$ref": "#/definitions/encryption"
+    }
+  },
+  "definitions": {
+    "vhost": {
+      "type": "object",
+      "properties": {
+        "assert": {
+          "type": "boolean"
+        },
+        "check": {
+          "type": "boolean"
+        },
+        "connectionStrategy": {
+          "type": "string",
+          "enum": ["random", "fixed"]
+        },
+        "connection": {
+          "$ref": "#/definitions/connection"
+        },
+        "connections": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/connection"
+          }
+        },
+        "exchanges": {
+          "oneOf": [
+            {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            {
+              "type": "object",
+              "patternProperties": {
+                ".*": {
+                  "$ref": "#/definitions/exchange"
+                }
+              }
+            }
+          ]
+        },
+        "queues": {
+          "oneOf": [
+            {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            {
+              "type": "object",
+              "patternProperties": {
+                ".*": {
+                  "$ref": "#/definitions/queue"
+                }
+              }
+            }
+          ]
+        },
+        "bindings": {
+          "oneOf": [
+            {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            {
+              "type": "object",
+              "patternProperties": {
+                ".*": {
+                  "$ref": "#/definitions/binding"
+                }
+              }
+            }
+          ]
+        },
+        "publications": {
+          "type": "object",
+          "patternProperties": {
+            ".*": {
+              "$ref": "#/definitions/publication"
+            }
+          }
+        },
+        "subscriptions": {
+          "type": "object",
+          "patternProperties": {
+            ".*": {
+              "$ref": "#/definitions/subscription"
+            }
+          }
+        },
+        "publicationChannelPools": {
+          "type": "object",
+          "properties": {
+            "regularPool": {
+              "$ref": "#/definitions/channelPool"
+            },
+            "confirmPool": {
+              "$ref": "#/definitions/channelPool"
+            }
+          }
+        }
+      }
+    },
+    "channelPool": {
+      "type": "object",
+      "properties": {
+        "autostart": {
+          "type": "boolean"
+        },
+        "max": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "min": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "evictionRunIntervalMillis": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "idleTimeoutMillis": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "rejectionDelayMillis": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "testOnBorrow": {
+          "type": "boolean"
+        },
+        "acquireTimeoutMillis": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "destroyTimeoutMillis": {
+          "type": "integer",
+          "minimum": 0
+        }
+      }
+    },
+    "connection": {
+      "anyOf": [
+        {
+          "type": "string"
+        },
+        {
+          "type": "object",
+          "properties": {
+            "url": {
+              "type": "string"
+            },
+            "options": {
+              "$ref": "#/definitions/connectOptions"
+            },
+            "socketOptions": {
+              "$ref": "#/definitions/socketOptions"
+            },
+            "retry": {
+              "$ref": "#/definitions/retry"
+            },
+            "management": {
+              "$ref": "#/definitions/management"
+            }
+          }
+        },
+        {
+          "type": "object",
+          "properties": {
+            "protocol": {
+              "type": "string",
+              "enum": ["amqp", "amqps"]
+            },
+            "hostname": {
+              "type": "string"
+            },
+            "user": {
+              "type": "string"
+            },
+            "password": {
+              "type": "string"
+            },
+            "port": {
+              "type": "integer",
+              "minimum": 1
+            },
+            "vhost": {
+              "type": "string"
+            },
+            "options": {
+              "$ref": "#/definitions/connectOptions"
+            },
+            "socketOptions": {
+              "type": "object"
+            },
+            "retry": {
+              "$ref": "#/definitions/retry"
+            },
+            "management": {
+              "$ref": "#/definitions/management"
+            }
+          }
+        }
+      ]
+    },
+    "connectOptions": {
+      "type": "object",
+      "properties": {
+        "frameMax": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "heartbeat": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "connection_timeout": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "channelMax": {
+          "type": "integer",
+          "minimum": 0
+        }
+      }
+    },
+    "socketOptions": {
+      "type": "object",
+      "properties": {
+        "timeout": {
+          "type": "integer",
+          "minimum": 0
+        }
+      }
+    },
+    "management": {
+      "anyOf": [
+        {
+          "type": "object",
+          "properties": {
+            "url": {
+              "type": "string"
+            },
+            "options": {
+              "type": "object",
+              "properties": {
+                "timeout": {
+                  "type": "integer",
+                  "minimum": 0
+                }
+              }
+            }
+          }
+        },
+        {
+          "type": "object",
+          "properties": {
+            "protocol": {
+              "type": "string",
+              "enum": ["http", "https"]
+            },
+            "hostname": {
+              "type": "string"
+            },
+            "user": {
+              "type": "string"
+            },
+            "password": {
+              "type": "string"
+            },
+            "port": {
+              "type": "integer",
+              "minimum": 1
+            },
+            "options": {
+              "type": "object",
+              "properties": {
+                "timeout": {
+                  "type": "integer",
+                  "minimum": 0
+                }
+              }
+            }
+          }
+        }
+      ]
+    },
+    "exchange": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "assert": {
+          "type": "boolean"
+        },
+        "check": {
+          "type": "boolean"
+        },
+        "type": {
+          "type": "string"
+        },
+        "options": {
+          "type": "object",
+          "properties": {
+            "durable": {
+              "type": "boolean"
+            },
+            "internal": {
+              "type": "boolean"
+            },
+            "autoDelete": {
+              "type": "boolean"
+            },
+            "alternateExchange": {
+              "type": "string"
+            },
+            "expires": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "arguments": {
+              "type": "object"
+            }
+          }
+        }
+      }
+    },
+    "queue": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "assert": {
+          "type": "boolean"
+        },
+        "check": {
+          "type": "boolean"
+        },
+        "type": {
+          "type": "string"
+        },
+        "purge": {
+          "type": "boolean"
+        },
+        "options": {
+          "type": "object",
+          "properties": {
+            "exclusive": {
+              "type": "boolean"
+            },
+            "durable": {
+              "type": "boolean"
+            },
+            "autoDelete": {
+              "type": "boolean"
+            },
+            "messageTtl": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "expires": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "deadLetterExchange": {
+              "type": "string"
+            },
+            "deadLetterRoutingKey": {
+              "type": "string"
+            },
+            "maxLength": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "maxPriority": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "arguments": {
+              "type": "object"
+            }
+          }
+        }
+      }
+    },
+    "binding": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "source": {
+          "type": "string"
+        },
+        "destination": {
+          "type": "string"
+        },
+        "destinationType": {
+          "type": "string",
+          "enum": ["queue", "exchange"]
+        },
+        "bindingKey": {
+          "type": "string"
+        },
+        "bindingKeys": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "qualifyBindingKeys": {
+          "type": "boolean"
+        },
+        "options": {
+          "type": "object"
+        }
+      }
+    },
+    "publication": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "vhost": {
+          "type": "string"
+        },
+        "exchange": {
+          "type": "string"
+        },
+        "queue": {
+          "type": "string"
+        },
+        "routingKey": {
+          "type": "string"
+        },
+        "confirm": {
+          "type": "boolean"
+        },
+        "timeout": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "encryption": {
+          "type": "string"
+        },
+        "options": {
+          "type": "object",
+          "properties": {
+            "expiration": {
+              "type": "string"
+            },
+            "userId": {
+              "type": "string"
+            },
+            "CC": {
+              "oneOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  }
+                }
+              ]
+            },
+            "BCC": {
+              "oneOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  }
+                }
+              ]
+            },
+            "priority": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "persistent": {
+              "type": "boolean"
+            },
+            "mandatory": {
+              "type": "boolean"
+            },
+            "contentType": {
+              "type": "string"
+            },
+            "contentEncoding": {
+              "type": "string"
+            },
+            "headers": {
+              "type": "object"
+            },
+            "replyTo": {
+              "type": "string"
+            },
+            "type": {
+              "type": "string"
+            },
+            "appId": {
+              "type": "string"
+            }
+          }
+        }
+      }
+    },
+    "subscription": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "vhost": {
+          "type": "string"
+        },
+        "queue": {
+          "type": "string"
+        },
+        "contentType": {
+          "type": "string"
+        },
+        "prefetch": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "retry": {
+          "$ref": "#/definitions/retry"
+        },
+        "redeliveries": {
+          "properties": {
+            "limit": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "timeout": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "counter": {
+              "type": "string"
+            }
+          }
+        },
+        "closeTimeout": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "encryption": {
+          "type": "string"
+        },
+        "promisifyAckOrNack": {
+          "type": "boolean"
+        },
+        "options": {
+          "type": "object",
+          "properties": {
+            "noAck": {
+              "type": "boolean"
+            },
+            "exclusive": {
+              "type": "boolean"
+            },
+            "priority": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "arguments": {
+              "type": "object"
+            }
+          }
+        }
+      }
+    },
+    "shovel": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "subscription": {
+          "type": "string"
+        },
+        "publication": {
+          "type": "string"
+        }
+      }
+    },
+    "retry": {
+      "type": "object",
+      "properties": {
+        "min": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "max": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "factor": {
+          "type": "number",
+          "minimum": 0
+        },
+        "strategy": {
+          "type": "string",
+          "enum": ["exponential", "linear"]
+        }
+      }
+    },
+    "redeliveries": {
+      "type": "object",
+      "properties": {
+        "counters": {
+          "type": "object"
+        }
+      }
+    },
+    "encryption": {
+      "type": "object",
+      "properties": {
+        "key": {
+          "type": "string"
+        },
+        "algorithm": {
+          "type": "string"
+        },
+        "ivLength": {
+          "type": "integer",
+          "minimum": 1
+        }
+      }
+    }
+  }
+}

package/lib/management/Client.js

@@ -0,0 +1,55 @@
+const debug = require('debug')('rascal:management:client');
+const format = require('util').format;
+const _ = require('lodash');
+const defaultAgent = require('superagent');
+
+function Client(suppliedAgent) {
+  const agent = suppliedAgent || defaultAgent;
+  const self = this;
+
+  this.assertVhost = function (name, config, next) {
+    debug('Asserting vhost: %s', name);
+    const options = getVhostOptions(name, config);
+    self._request('put', options.url, options.timeout, (err) => {
+      if (!err) return next();
+      const message = err.status ? format('Failed to assert vhost: %s. %s returned status %d', name, config.loggableUrl, err.status) : format('Failed to assert vhost: %s. %s errored with: %s', name, config.loggableUrl, err.message);
+      return next(new Error(message));
+    });
+  };
+
+  this.checkVhost = function (name, config, next) {
+    debug('Checking vhost: %s', name);
+    const options = getVhostOptions(name, config);
+    self._request('get', options.url, options.timeout, (err) => {
+      if (!err) return next();
+      const message = err.status ? format('Failed to check vhost: %s. %s returned status %d', name, config.loggableUrl, err.status) : format('Failed to check vhost: %s. %s errored with: %s', name, config.loggableUrl, err.message);
+      return next(new Error(message));
+    });
+  };
+
+  this.deleteVhost = function (name, config, next) {
+    debug('Deleting vhost: %s', name);
+    const options = getVhostOptions(name, config);
+    self._request('delete', options.url, options.timeout, (err) => {
+      if (!err) return next();
+      const message = err.status ? format('Failed to delete vhost: %s. %s returned status %d', name, config.loggableUrl, err.status) : format('Failed to delete vhost: %s. %s errored with: %s', name, config.loggableUrl, err.message);
+      return next(new Error(message));
+    });
+  };
+
+  this._request = function (method, url, timeout, next) {
+    agent[method](url)
+      .timeout({ deadline: timeout })
+      .then(() => {
+        next();
+      })
+      .catch(next);
+  };
+
+  function getVhostOptions(name, config) {
+    const url = format('%s/%s/%s', config.url, 'api/vhosts', name);
+    return _.defaultsDeep({ url }, config.options);
+  }
+}
+
+module.exports = Client;

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "rascal",
-  "version": "14.0.1",
+  "version": "14.3.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.2.1",
     "debug": "^4.1.1",
-    "deep-freeze": "0.0.1",
     "forward-emitter": "^0.1.1",
     "generic-pool": "^3.7.1",
     "lodash": "^4.17.21",
@@ -29,6 +28,7 @@
     "nyc": "^15.1.0",
     "prettier": "2.4.1",
     "random-readable": "^1.0.1",
+    "superagent-defaults": "^0.1.14",
     "zunit": "^3.0.8"
   },
   "peerDependencies": {

package/examples/busy-publisher/config.js

@@ -1,39 +0,0 @@
-module.exports = {
-  vhosts: {
-    '/': {
-      publicationChannelPools: {
-        confirmPool: {
-          max: 10,
-          min: 10,
-          evictionRunIntervalMillis: 1000,
-          idleTimeoutMillis: 5000,
-          autostart: true,
-        },
-      },
-      connection: {
-        heartbeat: 5,
-        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',
-          confirm: false,
-          options: {
-            persistent: false,
-          },
-        },
-      },
-      subscriptions: {
-        demo_sub: {
-          queue: 'demo_q',
-        },
-      },
-    },
-  },
-};

package/examples/default-exchange/config.js

@@ -1,24 +0,0 @@
-module.exports = {
-  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,20 +0,0 @@
-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',
-        },
-      },
-    },
-  },
-};

package/examples/promises/config.js

@@ -1,26 +0,0 @@
-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',
-        },
-      },
-    },
-  },
-};

package/examples/simple/config.js

@@ -1,36 +0,0 @@
-module.exports = {
-  vhosts: {
-    '/': {
-      publicationChannelPools: {
-        confirmPool: {
-          autostart: true,
-        },
-      },
-      connection: {
-        options: {
-          heartbeat: 10,
-        },
-        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',
-          options: {
-            persistent: false,
-          },
-        },
-      },
-      subscriptions: {
-        demo_sub: {
-          queue: 'demo_q',
-        },
-      },
-    },
-  },
-};

package/lib/management/client.js

@@ -1,54 +0,0 @@
-const debug = require('debug')('rascal:management:client');
-const format = require('util').format;
-const _ = require('lodash');
-const agent = require('superagent');
-
-function assertVhost(name, config, next) {
-  debug('Asserting vhost: %s', name);
-  const options = getVhostOptions(name, config);
-  request('put', options.url, options.timeout, (err) => {
-    if (!err) return next();
-    const message = err.status ? format('Failed to assert vhost: %s. %s returned status %d', name, config.loggableUrl, err.status) : format('Failed to assert vhost: %s. %s errored with: %s', name, config.loggableUrl, err.message);
-    return next(new Error(message));
-  });
-}
-
-function checkVhost(name, config, next) {
-  debug('Checking vhost: %s', name);
-  const options = getVhostOptions(name, config);
-  request('get', options.url, options.timeout, (err) => {
-    if (!err) return next();
-    const message = err.status ? format('Failed to check vhost: %s. %s returned status %d', name, config.loggableUrl, err.status) : format('Failed to check vhost: %s. %s errored with: %s', name, config.loggableUrl, err.message);
-    return next(new Error(message));
-  });
-}
-
-function deleteVhost(name, config, next) {
-  debug('Deleting vhost: %s', name);
-  const options = getVhostOptions(name, config);
-  request('delete', options.url, options.timeout, (err) => {
-    if (!err) return next();
-    const message = err.status ? format('Failed to delete vhost: %s. %s returned status %d', name, config.loggableUrl, err.status) : format('Failed to delete vhost: %s. %s errored with: %s', name, config.loggableUrl, err.message);
-    return next(new Error(message));
-  });
-}
-
-function getVhostOptions(name, config) {
-  const url = format('%s/%s/%s', config.url, 'api/vhosts', name);
-  return _.defaultsDeep({ url }, config.options);
-}
-
-function request(method, url, timeout, next) {
-  agent[method](url)
-    .timeout({ deadline: timeout })
-    .then(() => {
-      next();
-    })
-    .catch(next);
-}
-
-module.exports = {
-  assertVhost,
-  checkVhost,
-  deleteVhost,
-};