pass config to services

lib/node.js

@@ -136,9 +136,10 @@ Node.prototype.getServiceOrder = function() {
 
 Node.prototype._instantiateService = function(service) {
   var self = this;
-  var mod = new service.module({
-    node: this
-  });
+
+  var config = service.config || {};
+  config.node = this;
+  var mod = new service.module(config);
 
   $.checkState(
     mod instanceof BaseService,

lib/scaffold/start.js

@@ -6,6 +6,7 @@ var BitcoreNode = require('../node');
 var index = require('../');
 var bitcore = require('bitcore');
 var _ = bitcore.deps._;
+var $ = bitcore.util.preconditions;
 var log = index.log;
 log.debug = function() {};
 
@@ -22,37 +23,42 @@ function start(options) {
 
   if (config.services) {
     for (var i = 0; i < config.services.length; i++) {
-      var serviceName = config.services[i];
-      var service;
+      var service = {};
+      if(typeof config.services[i] === 'object') {
+        $.checkState(config.services[i].name, 'Service name must be specified in config');
+        service.name = config.services[i].name;
+        service.config = config.services[i].config || {};
+      } else {
+        service.name = config.services[i];
+        service.config = {};
+      }
+
       try {
         // first try in the built-in bitcore-node services directory
-        service = require(path.resolve(__dirname, '../services/' + serviceName));
+        service.module = require(path.resolve(__dirname, '../services/' + service.name));
       } catch(e) {
 
         // check if the package.json specifies a specific file to use
-        var servicePackage = require(serviceName + '/package.json');
-        var serviceModule = serviceName;
+        var servicePackage = require(service.name + '/package.json');
+        var serviceModule = service.name;
         if (servicePackage.bitcoreNode) {
-          serviceModule = serviceName + '/' + servicePackage.bitcoreNode;
+          serviceModule = service.name + '/' + servicePackage.bitcoreNode;
         }
-        service = require(serviceModule);
+        service.module = require(serviceModule);
       }
 
       // check that the service supports expected methods
-      if (!service.prototype ||
-          !service.dependencies ||
-          !service.prototype.start ||
-          !service.prototype.stop) {
+      if (!service.module.prototype ||
+          !service.module.dependencies ||
+          !service.module.prototype.start ||
+          !service.module.prototype.stop) {
         throw new Error(
-          'Could not load service "' + serviceName + '" as it does not support necessary methods.'
+          'Could not load service "' + service.name + '" as it does not support necessary methods.'
         );
       }
-      services.push({
-        name: serviceName,
-        module: service,
-        dependencies: service.dependencies
-      });
 
+      service.dependencies = service.module.dependencies;
+      services.push(service);
     }
   }
 

test/scaffold/start.integration.js

@@ -9,13 +9,14 @@ describe('#start', function() {
 
   describe('will dynamically create a node from a configuration', function() {
 
-    it('require each bitcore-node service', function(done) {
+    it('require each bitcore-node service with default config', function(done) {
       var node;
       var TestNode = function(options) {
         options.services[0].should.deep.equal({
           name: 'address',
           module: AddressService,
-          dependencies: ['bitcoind', 'db']
+          dependencies: ['bitcoind', 'db'],
+          config: {}
         });
       };
       TestNode.prototype.on = sinon.stub();
@@ -39,5 +40,44 @@ describe('#start', function() {
       node.should.be.instanceof(TestNode);
       done();
     });
+
+    it('require each bitcore-node service with explicit config', function(done) {
+      var node;
+      var TestNode = function(options) {
+        options.services[0].should.deep.equal({
+          name: 'address',
+          module: AddressService,
+          dependencies: ['bitcoind', 'db'],
+          config: {
+            param: 'test'
+          }
+        });
+      };
+      TestNode.prototype.on = sinon.stub();
+      TestNode.prototype.chain = {
+        on: sinon.stub()
+      };
+
+      var starttest = proxyquire('../../lib/scaffold/start', {
+        '../node': TestNode
+      });
+
+      node = starttest({
+        path: __dirname,
+        config: {
+          services: [
+            {
+              name: 'address',
+              config: {
+                param: 'test'
+              }
+            }
+          ],
+          datadir: './data'
+        }
+      });
+      node.should.be.instanceof(TestNode);
+      done();
+    });
   });
 });