beforeMiddleware and and afterMiddleware hooks

Author: Arjan Singh

README.md

@@ -103,6 +103,22 @@ let server = new FastBootAppServer({
 server.start();
 ```
 
+## Pre and Post FastBoot middleware hooks
+
+If you need something less than a custom server and just want to run some middleware
+before or after FastBoot runs, the server provides hooks for you to do so:
+
+```js
+// Custom Middlewares
+function modifyRequest(req, res, next) { /* do pre-fastboot stuff to `req` */ };
+function handleErrors(err, req, res, next) { /* do error recovery stuff */ };
+
+const server = FastBootAppServer({
+  beforeMiddleware: function (app) { app.use(modifyRequest); },
+  afterMiddleware: function (app) { app.use(handleErrors); }
+})
+```
+
 ## Downloaders
 
 You can point the app server at a static path that you manage, but that

src/express-http-server.js

@@ -3,6 +3,8 @@
 const express = require('express');
 const basicAuth = require('./basic-auth');
 
+function noop() {}
+
 class ExpressHTTPServer {
   constructor(options) {
     options = options || {};
@@ -13,8 +15,8 @@ class ExpressHTTPServer {
     this.password = options.password;
     this.cache = options.cache;
     this.gzip = options.gzip || false;
-    this.preFastbootMiddlewares = options.preFastbootMiddlewares || [];
-    this.postFastbootMiddlewares = options.postFastbootMiddlewares || [];
+    this.beforeMiddleware = options.beforeMiddleware || noop;
+    this.afterMiddleware = options.afterMiddleware || noop;
 
     this.app = express();
   }
@@ -24,7 +26,7 @@ class ExpressHTTPServer {
     let username = this.username;
     let password = this.password;
 
-    this.preFastbootMiddlewares.forEach(args => app.use(...args));
+    this.beforeMiddleware(app);
 
     if (this.gzip) {
       this.app.use(require('compression')());
@@ -49,7 +51,7 @@ class ExpressHTTPServer {
 
     app.get('/*', fastbootMiddleware);
 
-    this.postFastbootMiddlewares.forEach(args => app.use(...args));
+    this.afterMiddleware(app);
 
     return new Promise(resolve => {
       let listener = app.listen(process.env.PORT || 3000, () => {

src/fastboot-app-server.js

@@ -17,8 +17,8 @@ class FastBootAppServer {
     this.ui = options.ui;
     this.gzip = options.gzip;
     this.httpServer = options.httpServer;
-    this.preFastbootMiddlewares = options.preFastbootMiddlewares;
-    this.postFastbootMiddlewares = options.postFastbootMiddlewares;
+    this.beforeMiddleware = options.beforeMiddleware;
+    this.afterMiddleware = options.afterMiddleware;
 
     if (!this.ui) {
       let UI = require('./ui');
@@ -33,7 +33,9 @@ class FastBootAppServer {
         distPath: this.distPath || process.env.FASTBOOT_DIST_PATH,
         cache: this.cache,
         gzip: this.gzip,
-        httpServer: this.httpServer
+        httpServer: this.httpServer,
+        beforeMiddleware: this.beforeMiddleware,
+        afterMiddleware: this.afterMiddleware
       });
 
       this.worker.start();

src/worker.js

@@ -11,15 +11,17 @@ class Worker {
     this.ui = options.ui;
     this.cache = options.cache;
     this.gzip = options.gzip;
-    this.preFastbootMiddlewares = options.preFastbootMiddlewares;
-    this.postFastbootMiddlewares = options.postFastbootMiddlewares;
+    this.beforeMiddleware = options.beforeMiddleware;
+    this.afterMiddleware = options.afterMiddleware;
 
     if (!this.httpServer) {
       this.httpServer = new ExpressHTTPServer({
         ui: this.ui,
         distPath: this.distPath,
         cache: this.cache,
-        gzip: this.gzip
+        gzip: this.gzip,
+        beforeMiddleware: this.beforeMiddleware,
+        afterMiddleware: this.afterMiddleware,
       });
     }
 
@@ -60,7 +62,6 @@ class Worker {
   buildMiddleware() {
     this.fastboot = new FastBoot({
       distPath: this.distPath,
-      resilient: true
     });
 
     return fastbootMiddleware({

test/app-server-test.js

@@ -70,6 +70,25 @@ describe("FastBootAppServer", function() {
       });
   });
 
+  it("executes beforeMiddleware", function() {
+    return runServer('before-middleware-server')
+      .then(() => request('http://localhost:3000'))
+      .then(response => {
+        expect(response.statusCode).to.equal(418);
+        expect(response.headers['x-test-header']).to.equal('testing');
+        expect(response.body).to.equal(JSON.stringify({ send: 'json back'}));
+      });
+  });
+
+  it("executes afterMiddleware when there is an error", function() {
+    return runServer('after-middleware-server')
+      .then(() => request('http://localhost:3000'))
+      .then(response => {
+        expect(response.body).to.not.match(/error/);
+        expect(response.headers['x-test-header']).to.equal('testing');
+      })
+  });
+
 });
 
 function runServer(name) {

test/fixtures/after-middleware-server.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var path = require('path');
+var alchemistRequire = require('broccoli-module-alchemist/require');
+var FastBootAppServer = alchemistRequire('fastboot-app-server');
+
+function setXTestHeader(err, req, res, next) {
+  res.set('x-test-header', 'testing')
+  next();
+}
+
+var server = new FastBootAppServer({
+  distPath: path.resolve(__dirname, './broken-app'),
+  afterMiddleware: function (app) {
+    app.use(setXTestHeader);
+  },
+  resilient: true,
+});
+
+server.start();

test/fixtures/before-middleware-server.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var path = require('path');
+var alchemistRequire = require('broccoli-module-alchemist/require');
+var FastBootAppServer = alchemistRequire('fastboot-app-server');
+
+function setStatusCode418(req, res, next) {
+  res.status(418);
+  next();
+}
+
+function setXTestHeader(req, res, next) {
+  res.set('X-Test-Header', 'testing')
+  next();
+}
+
+function sendJsonAndTerminate(req, res, next) {
+  res.json({ send: 'json back' });
+  res.send();
+}
+
+var server = new FastBootAppServer({
+  distPath: path.resolve(__dirname, './basic-app'),
+  beforeMiddleware: function (app) {
+    app.use(setStatusCode418);
+    app.use(setXTestHeader);
+    app.use(sendJsonAndTerminate);
+  }
+});
+
+server.start();