MongoDB - loopback.getCurrentContext() return null

server/middleware/context.js

@@ -2,6 +2,7 @@ var loopback = require('../../lib/loopback');
 var juggler = require('loopback-datasource-juggler');
 var remoting = require('strong-remoting');
 var cls = require('continuation-local-storage');
+var domain = require('domain');
 
 module.exports = context;
 
@@ -44,6 +45,13 @@ function context(options) {
   var scope = options.name || name;
   var enableHttpContext = options.enableHttpContext || false;
   var ns = createContext(scope);
+
+  var currentDomain = process.domain = domain.create();
+  currentDomain.oldBind = currentDomain.bind;
+  currentDomain.bind = function(callback, context) {
+    return currentDomain.oldBind(ns.bind(callback, context), context);
+  };
+
   // Return the middleware
   return function contextHandler(req, res, next) {
     if (req.loopbackContext) {
@@ -53,13 +61,19 @@ function context(options) {
     // Bind req/res event emitters to the given namespace
     ns.bindEmitter(req);
     ns.bindEmitter(res);
+
+    currentDomain.add(req);
+    currentDomain.add(res);
+
     // Create namespace for the request context
-    ns.run(function processRequestInContext(context) {
-      // Run the code in the context of the namespace
-      if (enableHttpContext) {
-        ns.set('http', {req: req, res: res}); // Set up the transport context
-      }
-      next();
+    currentDomain.run(function() {
+      ns.run(function processRequestInContext(context) {
+        // Run the code in the context of the namespace
+        if (enableHttpContext) {
+          ns.set('http', {req: req, res: res}); // Set up the transport context
+        }
+        next();
+      });
     });
   };
 }
@@ -115,4 +129,4 @@ function chain(child) {
   } else {
     child.getCurrentContext = loopback.getCurrentContext;
   }
-}
+}

test/context.test.js

@@ -0,0 +1,72 @@
+var loopback = require('loopback');
+var request = require('supertest');
+var Domain = require('domain');
+var assert = require('assert');
+var EventEmitter = require("events").EventEmitter;
+
+describe('check loopback.getCurrentContext', function() {
+  var app = loopback();
+  var runInOtherDomain;
+  var runnerInterval;
+
+  before(function(){
+    var called = false;
+    app.use(loopback.rest());
+    app.dataSource('db', { connector: 'memory' });
+
+    var TestModel = loopback.createModel({name: 'TestModel', properties: {name: String}, options: { base: 'Model'}});
+    app.model(TestModel, {dataSource: "db", public: true});
+
+    var emitterInOtherDomain = new EventEmitter();
+    Domain.create().add(emitterInOtherDomain);
+
+    runInOtherDomain = function(fn) {
+      emitterInOtherDomain.once('run', fn);
+    }
+
+    runnerInterval = setInterval(function() { emitterInOtherDomain.emit('run'); }, 10);
+
+    // function for remote method
+    TestModel.test = function(inst, cb) {
+      tmpCtx = loopback.getCurrentContext();
+      if (tmpCtx) tmpCtx.set('data', 'test');
+      called = true;
+      if (process.domain) cb = process.domain.bind(cb);  // IMPORTANT
+      runInOtherDomain(cb);
+    };
+
+    // remote method
+    TestModel.remoteMethod('test', {
+      accepts: {arg: 'inst', type: 'TestModel'},
+      returns: {root: true},
+      http: {path: '/test', verb: 'get'}
+    });
+
+    // after remote hook
+    TestModel.afterRemote('**', function(ctxx, inst, next){
+      ctxx.result.called = called;
+      tmpCtx = loopback.getCurrentContext();
+      if (tmpCtx) {
+        ctxx.result.data = tmpCtx.get('data');
+      }else {
+        ctxx.result.data = "";
+      }
+      next();
+    });
+  });
+
+  after(function tearDownRunInOtherDomain() {
+    clearInterval(runnerInterval);
+  });
+
+  it('should fail without the patch and it should pass once the patch is applied', function(done) {
+    request(app)
+      .get('/TestModels/test')
+      .end(function(err, res) {
+        if (err) return done(err);
+        assert.equal(res.body.called, true);
+        assert.equal(res.body.data, 'test');
+        done();
+      });
+  });
+});