feat(http): Alternate strategies for http middleware

.set({'strategy':'default'});

Author: thepian

lib/http/strategy.js renamed to lib/http/default.strategy.js

@@ -27,9 +27,7 @@ function init() {
 }
 
 function load(paths,settings) {
-  if (settings.compress) {
-    module.exports.compressMiddleware = connect.compress();
-  }
+  module.exports.compressMiddleware = connect.compress();
   module.exports.assetsMiddleware = serveStatic('/assets',paths.assets, settings['static']);
   module.exports.staticMiddleware = serveStatic(null,paths['static'], settings['static']);
   loadStaticDirs(paths.static, paths.assets);
@@ -58,21 +56,27 @@ function isStatic(url) {
 function loadStaticDirs(staticPath,assetsPath) {
   var pathLength;
 
+  /* Get a list of all static files we know about (used to prevent connect.session from loading unnecessarily) */
+
   if (fs.existsSync(staticPath)) {
+    staticDirs = staticDirs.concat(fs.readdirSync(staticPath));
 
-    /* Get a list of all static files we know about (used to prevent connect.session from loading unnecessarily) */
-    pathLength  = staticPath.length;
+    staticFiles = staticFiles.concat(fileUtils.readDirSync(staticPath).files);
+  }
+
+  if (fs.existsSync(assetsPath)) {
+    fileUtils.readDirSync(assetsPath).files.forEach(function(name) {
+      staticFiles.push('/assets' + name);
+    });
   }
 
   /* Ensure /assets is always present, even if the dir has yet to be created */
   if (staticDirs.indexOf('assets') === -1) {
     staticDirs.push('assets');
   }
 
-  staticFiles = staticFiles.concat(fileUtils.readDirSync(staticPath).files);
-
   return staticFiles.map(function(file) {
-    return file.substr(pathLength);
+    return path.relative(staticPath, file);
   });
 }
 

lib/http/index.js

@@ -5,7 +5,7 @@ var fs          = require('fs'),
     router      = new (require('./router').Router),
     app,
     settings    = {           // User-configurable settings with sensible defaults
-      'strategy': require('./strategy'),
+      'strategy': 'default',
       'static': {
         maxAge: 2592000000    // (30 * 24 * 60 * 60 * 1000) cache static assets in the browser for 30 days
       },
@@ -82,6 +82,9 @@ module.exports = function(root) {
     get middleware() {
       if (app == null) {
         // Create new Connect app instance which can be accessed from your app.js file with ss.http.middleware
+        if (typeof settings.strategy == "string") {
+          settings.strategy = require('./' + settings.strategy + '.strategy');
+        }
         app = settings.strategy.init();
 
         /* Alias app.use to indicate this will be added to the stack BEFORE SocketStream middleware */
@@ -145,30 +148,38 @@ module.exports = function(root) {
 
       staticPath = path.join(root, staticPath);
       assetsPath = path.join(root, assetsPath);
+
       settings.strategy.load({
         root: root,
         static: staticPath,
         assets: assetsPath
       },settings);
 
       /* connect.compress() should be added to middleware stack on highest possible position */
-      app.use(settings.strategy.compressMiddleware);
+      if (settings.strategy.compressMiddleware) {
+        app.use(settings.strategy.compressMiddleware);
+      }
 
       /* Append SocketStream middleware upon server load */
-      app.use(settings.strategy.cookieParser(secret));
-
-
-      app.use(settings.strategy.favicon(staticPath + '/favicon.ico'))
-      app.use(settings.strategy.session({
-        cookie: {
-          path: '/',
-          httpOnly: false,
-          maxAge: sessionOptions.maxAge,
-          secure: settings.secure
-        },
-        store: sessionStore,
-        secret: secret
-      }));
+      if (settings.strategy.cookieParser) {
+        app.use(settings.strategy.cookieParser(secret));
+      }
+
+      if (settings.strategy.favicon) {
+        app.use(settings.strategy.favicon(staticPath + '/favicon.ico'))
+      }
+      if (settings.strategy.session) {
+        app.use(settings.strategy.session({
+          cookie: {
+            path: '/',
+            httpOnly: false,
+            maxAge: sessionOptions.maxAge,
+            secure: settings.secure
+          },
+          store: sessionStore,
+          secret: secret
+        }));
+      }
 
       /* Append any custom-defined middleware (e.g. everyauth) */
       useAfterStack.forEach(function(m) {

lib/http/minimal.strategy.js

@@ -0,0 +1,82 @@
+/**
+ * The minimal strategy for loading HTTP resources. You can set an alternate
+ * strategy with `ss.http.set({'strategy':{..}})`.
+ */
+'use strict';
+
+var fs = require('fs'),
+  path = require('path'),
+  connect     = require('connect'),
+  serveStatic = require('../utils/serve-static'),
+  fileUtils   = require('../utils/file'),
+  staticDirs = [],
+  staticFiles = [];
+
+
+module.exports = {
+  init: init,
+  load: load,
+  cookieParser: connect.cookieParser,
+  favicon: connect.favicon,
+  isStatic: isStatic
+};
+
+function init() {
+  return connect();
+}
+
+function load(paths,settings) {
+  module.exports.assetsMiddleware = serveStatic('/assets',paths.assets, settings['static']);
+  module.exports.staticMiddleware = serveStatic(null,paths['static'], settings['static']);
+  loadStaticDirs(paths.static, paths.assets);
+
+  if (settings.staticCache) {
+    module.exports.cacheMiddleware = connect.staticCache(settings['staticCache']);
+  }
+}
+
+function isStatic(url) {
+  //return staticUrls[url] !== undefined;
+
+  var initialDir = url.split('/')[1];
+
+  return  staticDirs.indexOf(initialDir) >= 0;
+}
+
+
+/**
+ * Loads static directories (client/static)
+ *
+ * @param  {String} staticPath Path string
+ * @param  {String} assetsPath Path string
+ * @return {Array}       Array of all static files we know about (used to prevent connect.session from loading unnecessarily)
+ */
+function loadStaticDirs(staticPath,assetsPath) {
+  var pathLength;
+
+  /* Get a list of all static files we know about (used to prevent connect.session from loading unnecessarily) */
+
+  if (fs.existsSync(staticPath)) {
+    staticDirs = staticDirs.concat(fs.readdirSync(path));
+
+    staticFiles = staticFiles.concat(fileUtils.readDirSync(staticPath).files);
+  }
+
+  if (fs.existsSync(assetsPath)) {
+    staticDirs = staticDirs.concat(fs.readdirSync(path));
+
+    fileUtils.readDirSync(staticPath).files.forEach(function(name) {
+      staticFiles.push('/assets' + name);
+    });
+  }
+
+  /* Ensure /assets is always present, even if the dir has yet to be created */
+  if (staticDirs.indexOf('assets') === -1) {
+    staticDirs.push('assets');
+  }
+
+  return staticFiles.map(function(file) {
+    return path.relative(staticPath, file);
+  });
+}
+

test/unit/http/index.test.js

@@ -21,6 +21,7 @@ var request      = require('supertest'),
     connect      = require('connect'),
     util         = require('util'),
     httpFunc     = require( path.join(process.env.PWD, 'lib/http/index') ),
+    serveStatic  = require('../../../lib/utils/serve-static'),
     http         = null,
     app          = null,
     utils        = require('../../helpers/utils.js'),
@@ -148,11 +149,23 @@ describe('lib/http/index', function () {
             });
         });
 
+        describe('app setup without SS middleware',function() {
+
+        });
+
+        describe('minimal strategy',function() {
+           it('should serve static files',function(){});
+           it('should serve assets',function(){});
+           it('should serve assets outside the static root',function(){});
+        });
+
         describe('#load()', function () {
-            var staticPath = '';
+            var staticPath = '',
+                assetsPath = '';
 
             function setUp(done) {
                 staticPath = 'client/static';
+                assetsPath = 'client/static/assets';
 
                 /* Loading http function */
                 http = httpFunc(root);
@@ -162,7 +175,7 @@ describe('lib/http/index', function () {
                 http.middleware.append(testAppendMiddleware);
 
                 /* loading http server assets */
-                app = http.load(staticPath, sessionStore, sessionOptions);
+                app = http.load(staticPath, assetsPath, sessionStore, sessionOptions);
 
                 done();
             }
@@ -186,7 +199,7 @@ describe('lib/http/index', function () {
 
                 /* testing correct length of http.middleware.stack */
                 http.middleware.stack.should.be.an.instanceOf(Array);
-                http.middleware.stack.should.have.length(8);
+                http.middleware.stack.should.have.length(9);
 
                 /**
                  * testing testPrependMiddleware
@@ -250,11 +263,18 @@ describe('lib/http/index', function () {
                 utils.getfunctionName( http.middleware.stack[6].handle ).should.equal( 'eventMiddleware' );
 
                 /**
-                 * testing connect["static"]()
+                 * testing assets resource middleware
                  * lib/http/index.js:161
                  */
                 http.middleware.stack[7].handle.should.be.an.instanceOf(Function);
-                http.middleware.stack[7].handle.toString().should.equal( connect.static(staticPath, settings.static).toString() );
+                http.middleware.stack[7].handle.toString().should.equal( serveStatic(assetsPath, settings.static).toString() );
+
+                /**
+                 * testing static resource middleware
+                 * lib/http/index.js:161
+                 */
+                http.middleware.stack[8].handle.should.be.an.instanceOf(Function);
+                http.middleware.stack[8].handle.toString().should.equal( serveStatic(staticPath, settings.static).toString() );
 
                 done();
             });