Merge pull request #1 from startappdev/develop

First Implementation of Express Context Service

Author: nadavsinai

.gitignore

@@ -0,0 +1 @@
+/node_modules

bin/express-context

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+"use strict";
+var path = require('path');
+var fs = require('fs');
+var lib = path.join(path.dirname(fs.realpathSync(__filename)), '../lib');
+
+require(lib+'/index.js');

lib/index.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var contextMiddleware = require('./middleware/context.middleware'),
+    contextService = require('./service/context.service');
+
+/**
+ * Express Middleware to handle context
+ * @param req - {Request}
+ * @param res - {Response}
+ * @param next - {Function} next middleware
+ */
+module.exports.middleware = contextMiddleware.middleware;
+
+/**
+ * API to add a context manipulator
+ * @param manipulatorFn - {Function} in the form of function(contextManipulator, req, next)
+ * @returns {Number} id - unique to get the data with
+ */
+module.exports.addContextManipulator = contextService.addContextManipulator;

lib/middleware/context.middleware.js

@@ -0,0 +1,26 @@
+'use strict';
+
+var contextService = require('../service/context.service');
+
+/**
+ * Express Middleware to handle context
+ * @param req - {Request}
+ * @param res - {Response}
+ * @param next - {Function} next middleware
+ */
+module.exports.middleware = function(req,res,next){
+    // Get a context after manipulation
+    contextService.createContext(req, function(err, context){
+        // Print error and continue
+        if (err){
+            console.log(err);
+        }
+
+        // Piggy bag the context to the request
+        req.getContext = function(){
+            return context;
+        };
+
+        next();
+    })
+};

lib/model/Context.js

@@ -0,0 +1,29 @@
+'use strict';
+
+/**
+ * Context object
+ * @constructor
+ */
+function Context(){
+    this._data = [];
+    this._global = {};
+}
+
+/**
+ * API to get a specific data from a context
+ * @param id - {Number} id returned by addData method
+ * @returns - {Object} the data registered for this module
+ */
+Context.prototype.getData = function(id){
+    return this._data[id];
+};
+
+/**
+ * API to get the global namespace object for the context
+ * @returns {Object} global namespace
+ */
+Context.prototype.getGlobal = function(){
+    return this._global;
+};
+
+module.exports = Context;

lib/model/ContextManipulator.js

@@ -0,0 +1,50 @@
+'use strict';
+
+/**
+ * Helper object to manipulate Context object
+ * @param context - {Context} - to manipulate
+ * @param req - {Request} - the request that been made
+ * @constructor
+ */
+function ContextManipulator(context, req){
+    this._id;
+    this._context = context;
+    this._request = req;
+}
+
+/**
+ * Sed Id of context namespace
+ * @param id - {Number}
+ * @private
+ */
+ContextManipulator.prototype._setId = function(id){
+    this._id = id;
+};
+
+/**
+ * Adds a data to the Context object
+ * @param data - {Object} to add to the private module namespace
+ */
+ContextManipulator.prototype.addData = function(data){
+    this._context._data[this._id] = data;
+};
+
+/**
+ * Adds a data object at the specified key to the global namespace
+ * @param key - {String} key to be saved at in the global namespace
+ * @param data - {Object} data to save for the module
+ */
+ContextManipulator.prototype.addGlobal = function(key, data){
+    this._context._global[key] = data;
+};
+
+/**
+ * Request Getter
+ * @returns {Request}
+ */
+ContextManipulator.prototype.getRequest = function(){
+    return this._request;
+};
+
+
+module.exports = ContextManipulator;

lib/service/context.service.js

@@ -0,0 +1,77 @@
+'use strict';
+
+var Q = require('q'),
+    Context = require('../model/Context'),
+    ContextManipulator = require('../model/ContextManipulator');
+
+var contextManipulators = [];
+
+/**
+ * API to add a context manipulator
+ * @param manipulatorFn - {Function} in the form of function(contextManipulator, req)
+ * @returns {Number} id - unique to get the data with
+ */
+exports.addContextManipulator = function(manipulatorFn){
+    if (typeof manipulatorFn === 'function') {
+        contextManipulators.push(manipulatorFn);
+
+        return contextManipulators.length - 1;
+    } else {
+        return -1;
+    }
+};
+
+/**
+ * Create a context object
+ * @param req - {Request}
+ * @param callback - {Function} in the form of callback(err, context)
+ *          err - Error
+ *          context - {Context}
+ */
+exports.createContext = function(req, callback){
+    var context = new Context();
+    var contextManipulator = new ContextManipulator(context, req);
+
+    var promises = [];
+
+    // For Each one in the context manipulation list
+    for (var i in contextManipulators){
+
+        // create a new promise
+        var promise = Q.defer();
+        promises.push(promise);
+
+        // Set his internal ID
+        contextManipulator._setId(i);
+
+        // Run the manipulator
+        try {
+            contextManipulators[i](contextManipulator, function () {
+                // Manipulation done
+                promise.resolve('');
+            });
+        } catch (e) {
+            // Error in manipulation
+            promise.reject(e);
+            console.log('ERR: ');
+            console.error(e);
+        }
+    }
+
+    // when all manipulation are done
+    Q.allSettled(promises).then(function(results){
+        for (var i in results){
+            var isError = false;
+            var error = '';
+
+            // Add errors if exists
+            if (results[i].state !== "fulfilled") {
+                isError = true;
+                error += '[ ' + results[i].reason + '] ';
+            }
+
+            // continue with a context
+            callback(isError ? new Error(error) : null, context);
+        }
+    });
+};

package.json

@@ -0,0 +1,27 @@
+{
+  "author": "Yarin Podoler",
+  "name": "express-context",
+  "description": "",
+  "version": "0.1.0",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:startappdev/express-context.git"
+  },
+  "main": "./lib/index.js",
+  "keywords": [],
+  "bin": {
+    "express-context": "./bin/express-context"
+  },
+  "dependencies": {
+    "q": "^1.0.1"
+  },
+  "engines": {
+    "node": "*"
+  },
+  "scripts": {
+    "test": "jasmine-node --verbose test/"
+  },
+  "devDependencies": {
+    "jasmine-node": "^1.14.5"
+  }
+}

test/middleware/context.middleware.spec.js

@@ -0,0 +1,90 @@
+'use strict';
+
+describe('Unit Test Context MiddleWare', function(){
+    var expressContext = require('../../lib/index');
+
+    var uniqueId1, uniqueId2;
+
+    it ('Should verify all API\'s', function(){
+        expect(typeof expressContext.sessionContext).toEqual('function');
+        expect(typeof expressContext.addContextManipulator).toEqual('function');
+    });
+
+    it ('Should successfully add context manipulator for namespaces', function(){
+        uniqueId1 = expressContext.addContextManipulator(function(contextManipulator, next){
+            contextManipulator.addData({
+                UNIQUE1 : 'UNIQUE1'
+            });
+
+            next();
+        });
+
+        uniqueId2 = expressContext.addContextManipulator(function(contextManipulator, next){
+            contextManipulator.addData({
+                UNIQUE2 : 'UNIQUE2'
+            });
+
+            next();
+        });
+
+        expressContext.addContextManipulator(function(contextManipulator, next){
+            contextManipulator.addGlobal('test', {
+                GLOBAL : 'GLOBAL'
+            });
+
+            next();
+        });
+
+        expect(uniqueId1).toEqual(jasmine.any(Number));
+        expect(uniqueId1).toBeGreaterThan(-1);
+        expect(uniqueId2).toEqual(jasmine.any(Number));
+        expect(uniqueId2).toBeGreaterThan(-1);
+    });
+
+    it ('Should successfully get the context on the request', function(done){
+        var req = {};
+
+        expressContext.sessionContext(req, {}, function(){
+            expect(typeof req.getContext).toEqual('function');
+
+            done();
+        });
+    });
+
+    it ('Should successfully get the global data from the context', function(done){
+        var req = {};
+
+        expressContext.sessionContext(req, {}, function(){
+            expect(req.getContext().getData(uniqueId1)).toEqual({
+                UNIQUE1 : 'UNIQUE1'
+            });
+
+            expect(req.getContext().getData(uniqueId2)).toEqual({
+                UNIQUE2 : 'UNIQUE2'
+            });
+
+            expect(req.getContext().getGlobal().test).toEqual({
+                GLOBAL : 'GLOBAL'
+            });
+
+            done();
+        });
+    });
+
+    it ('should successfully get Request from the ContextManipulator', function(done){
+        var req = {
+            TEST : 'TEST'
+        };
+
+        expressContext.addContextManipulator(function(contextManipulator, next){
+            expect(typeof contextManipulator.getRequest).toEqual('function');
+            expect(contextManipulator.getRequest().TEST).toEqual('TEST');
+
+            next();
+        });
+
+        expressContext.sessionContext(req, {}, function(){
+            done();
+        });
+    });
+});