Add isPromise

README.md

@@ -257,6 +257,8 @@ isOpen|N/A|boolean|Returns `true` if circuit is open
 - **healthCheckInterval**: time in `ms` interval between each execution of health check function
 - **healthCheck**: function to call for the health check (can be defined also with calling `healthCheck` function)
 - **fallback**: function to call for fallback (can be defined also with calling `fallback` function)
+- **isPromise**: `boolean` to opt out of check for callback in function. This affects the passed in function, health check and fallback
+- **isFunction**: `boolean` to opt out of check for callback, always promisifying in function. This affects the passed in function, health check and fallback
 
 ## Stats
 Based on the `opts.statInterval` an event will be fired at regular intervals that contains a snapshot of the running state of the application.

lib/Brakes.js

@@ -3,7 +3,7 @@
 const EventEmitter = require('events').EventEmitter;
 const Promise = require('bluebird');
 const Stats = require('./Stats');
-const hasCallback = require('./utils').hasCallback;
+const promisifyIfFunction = require('./utils').promisifyIfFunction;
 const globalStats = require('./globalStats');
 const consts = require('./consts');
 const Circuit = require('./Circuit');
@@ -21,7 +21,9 @@ const defaultOptions = {
   timeout: 15000,
   healthCheckInterval: 5000,
   healthCheck: undefined,
-  fallback: undefined
+  fallback: undefined,
+  isFunction: false,
+  isPromise: false
 };
 
 class Brakes extends EventEmitter {
@@ -51,9 +53,12 @@ class Brakes extends EventEmitter {
       globalStats.register(this);
     }
 
+    const isPromise = this._opts.isPromise;
+    const isFunction = this._opts.isFunction;
+
     // check if health check is in options
     if (this._opts.healthCheck) {
-      this.healthCheck(this._opts.healthCheck);
+      this.healthCheck(this._opts.healthCheck, isPromise, isFunction);
     }
 
     // create a master circuit
@@ -63,7 +68,7 @@ class Brakes extends EventEmitter {
 
     // check if fallback is in options
     if (this._opts.fallback) {
-      this.fallback(this._opts.fallback);
+      this.fallback(this._opts.fallback, isPromise, isFunction);
     }
   }
 
@@ -154,21 +159,16 @@ class Brakes extends EventEmitter {
   Allow user to pass a function to be used as a health check,
   to close the circuit if the function succeeds.
    */
-  healthCheck(func) {
-    if (hasCallback(func)) {
-      this._healthCheck = Promise.promisify(func);
-    }
-    else {
-      this._healthCheck = func;
-    }
+  healthCheck(func, isPromise, isFunction) {
+    this._healthCheck = promisifyIfFunction(func, isPromise, isFunction);
   }
 
   /*
   Allow user to pass function to be used as a fallback
   */
-  fallback(func) {
+  fallback(func, isPromise, isFunction) {
     if (this._masterCircuit) {
-      this._masterCircuit.fallback(func);
+      this._masterCircuit.fallback(func, isPromise, isFunction);
     }
     else {
       throw new Error(consts.NO_FUNCTION);

lib/Circuit.js

@@ -2,7 +2,7 @@
 
 const EventEmitter = require('events').EventEmitter;
 const Promise = require('bluebird');
-const hasCallback = require('./utils').hasCallback;
+const promisifyIfFunction = require('./utils').promisifyIfFunction;
 const TimeOutError = require('./TimeOutError');
 const CircuitBrokenError = require('../lib/CircuitBrokenError');
 const consts = require('./consts');
@@ -40,15 +40,10 @@ class Circuit extends EventEmitter {
     this._opts = Object.assign({}, defaultOptions, options);
     this._this = this._opts.this || this;
 
-    if (hasCallback(main)) {
-      this._serviceCall = Promise.promisify(main);
-    }
-    else {
-      this._serviceCall = main;
-    }
+    this._serviceCall = promisifyIfFunction(main, this._opts.isPromise, this._opts.isFunction);
 
     if (fallback) {
-      this.fallback(fallback);
+      this.fallback(fallback, this._opts.isPromise, this._opts.isFunction);
     }
   }
 
@@ -114,13 +109,8 @@ class Circuit extends EventEmitter {
     });
   }
 
-  fallback(func) {
-    if (hasCallback(func)) {
-      this._fallback = Promise.promisify(func);
-    }
-    else {
-      this._fallback = func;
-    }
+  fallback(func, isPromise, isFunction) {
+    this._fallback = promisifyIfFunction(func, isPromise, isFunction);
   }
 }
 

lib/utils.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const Promise = require('bluebird');
+
 const callbacks = ['cb', 'callback', 'callback_', 'done'];
 
 function hasCallback(fn) {
@@ -8,6 +10,18 @@ function hasCallback(fn) {
   return callbacks.indexOf(callbackCandidate) > -1;
 }
 
+function promisifyIfFunction(fn, isPromise, isFunction) {
+  if (isPromise) {
+    return fn;
+  }
+
+  if (isFunction || hasCallback(fn)) {
+    return Promise.promisify(fn);
+  }
+
+  return fn;
+}
+
 /*
  * Return a list arguments for a function
  */
@@ -94,6 +108,7 @@ function mapToHystrixJson(json) {
 module.exports = {
   callbacks,
   hasCallback,
+  promisifyIfFunction,
   getFnArgs,
   mapToHystrixJson
 };

test/Brakes.spec.js

@@ -25,7 +25,9 @@ const defaultOptions = {
   timeout: 15000,
   healthCheckInterval: 5000,
   healthCheck: undefined,
-  fallback: undefined
+  fallback: undefined,
+  isFunction: false,
+  isPromise: false
 };
 
 const noop = function noop(foo, err, cb) {
@@ -159,7 +161,9 @@ describe('Brakes Class', () => {
       timeout: 100,
       healthCheckInterval: 1000,
       healthCheck: () => Promise.resolve(),
-      fallback: () => Promise.resolve()
+      fallback: () => Promise.resolve(),
+      isFunction: false,
+      isPromise: false
     };
     brake = new Brakes(noop, overrides);
     expect(brake._opts).to.deep.equal(overrides);

test/utils.spec.js

@@ -153,4 +153,37 @@ describe('utils', () => {
       });
     });
   });
+  describe('promisifyIfFunction', () => {
+    it('should return input if isPromise: true', () => {
+      // eslint-disable-next-line no-unused-vars
+      function cb(done) {}
+
+      expect(utils.promisifyIfFunction(cb, true)).to.be.equal(cb);
+    });
+
+    it('should return input promise', () => {
+      function cb() { return Promise.resolve(); }
+
+      expect(utils.promisifyIfFunction(cb, true)).to.be.equal(cb);
+    });
+
+    it('should promisify if isFunction: true, even if wrong name of argument', () => {
+      // eslint-disable-next-line no-unused-vars
+      function cb(foo) {}
+
+      const promisifyIfFunction = utils.promisifyIfFunction(cb, false, true);
+
+      // Hackish... Might only work with bluebird
+      expect(promisifyIfFunction.__isPromisified__).to.be.equal(true);
+    });
+
+    it('should promisify if is a callback', () => {
+      // eslint-disable-next-line no-unused-vars
+      function cb(done) {}
+
+      const promisifyIfFunction = utils.promisifyIfFunction(cb);
+
+      expect(promisifyIfFunction.__isPromisified__).to.be.equal(true);
+    });
+  });
 });