Merge pull request #34 from simplabs/chunked-response

Enable chunked response

Author: kratiahuja

README.md

@@ -89,6 +89,22 @@ app.get('/*', middleware);
 fastboot.reload();
 ```
 
+## Response chunking
+
+By default, the middleware writes the complete response at once but response
+chunking (aka HTTP Streaming) is available via a config switch:
+
+```js
+app.get('/*', fastbootMiddleware({
+  distPath: '/path/to/dist',
+  chunkedResponse: true
+}));
+```
+
+Enabling response chunking will result in the response being delivered in
+multiple chunks (one for the head, one for the body and one for each shoebox)
+which helps getting the HTML to clients faster.
+
 [ember-cli-fastboot]: https://github.com/ember-fastboot/ember-cli-fastboot
 
 ## Tests

package.json

@@ -38,7 +38,7 @@
   },
   "dependencies": {
     "chalk": "^2.0.1",
-    "fastboot": "^1.1.0",
+    "fastboot": "^1.1.2",
     "request": "^2.81.0"
   }
 }

src/index.js

@@ -32,28 +32,37 @@ function fastbootExpressMiddleware(distPath, options) {
       .then(success, failure);
 
     function success(result) {
-      result.html()
-        .then(html => {
-          let headers = result.headers;
-          let statusMessage = result.error ? 'NOT OK ' : 'OK ';
-
-          for (var pair of headers.entries()) {
-            res.set(pair[0], pair[1]);
-          }
-
-          if (result.error) {
-            log("RESILIENT MODE CAUGHT:", result.error.stack);
-            next(result.error);
-          }
-
-          log(result.statusCode, statusMessage + path);
-          res.status(result.statusCode);
-          res.send(html);
-        })
-        .catch(error => {
-          res.status(500);
-          next(error);
-        });
+      let responseBody = opts.chunkedResponse ? result.chunks() : result.html();
+
+      responseBody.then(body => {
+        let headers = result.headers;
+        let statusMessage = result.error ? 'NOT OK ' : 'OK ';
+    
+        for (var pair of headers.entries()) {
+          res.set(pair[0], pair[1]);
+        }
+    
+        if (result.error) {
+          log("RESILIENT MODE CAUGHT:", result.error.stack);
+          next(result.error);
+        }
+    
+        log(result.statusCode, statusMessage + path);
+        res.status(result.statusCode);
+
+        if (typeof body === 'string') {
+          res.send(body);
+        } else if (result.error) {
+          res.send(body[0]);
+        } else {
+          body.forEach(chunk => res.write(chunk));
+          res.end();
+        }
+      })
+      .catch(error => {
+        res.status(500);
+        next(error);
+      });
     }
 
     function failure(error) {

test/middleware-test.js

@@ -51,30 +51,6 @@ describe("FastBoot", function() {
       });
   });
 
-  it("returns 404 when navigating to a URL that doesn't exist", function() {
-    let middleware = fastbootMiddleware(fixture('basic-app'));
-    server = new TestHTTPServer(middleware);
-
-    return server.start()
-      .then(() => server.request('/foo-bar-baz/non-existent'))
-      .catch((result) => {
-        expect(result.statusCode).to.equal(404);
-      });
-  });
-
-  it("returns a 500 error if an error occurs", function() {
-    let middleware = fastbootMiddleware({
-      distPath: fixture('rejected-promise')
-    });
-    server = new TestHTTPServer(middleware);
-
-    return server.start()
-      .then(() => server.request('/'))
-      .catch(err => {
-        expect(err.message).to.match(/Rejected on purpose/);
-      });
-  });
-
   it("can be provided with a custom FastBoot instance", function() {
     let fastboot = new FastBoot({
       distPath: fixture('basic-app')
@@ -130,102 +106,156 @@ describe("FastBoot", function() {
     }
   });
 
-  describe('when reslient mode is enabled', function () {
-    it("renders no FastBoot markup", function() {
-      let middleware = fastbootMiddleware({
-        distPath: fixture('rejected-promise'),
-        resilient: true
-      });
-      server = new TestHTTPServer(middleware);
+  [true, false].forEach((chunkedResponse) => {
+    describe(`when chunked response is ${chunkedResponse ? 'enabled' : 'disabled'}`, function() {
+      if (chunkedResponse) {
+        it("responds with a chunked response", function() {
+          let middleware = fastbootMiddleware({
+            distPath: fixture('basic-app'),
+            chunkedResponse
+          });
+          server = new TestHTTPServer(middleware, { errorHandling: true });
+
+          return server.start()
+            .then(() => server.request('/', { resolveWithFullResponse: true }))
+            .then(({ body, _, headers }) => {
+              expect(headers['transfer-encoding']).to.eq('chunked');
+              expect(body).to.match(/Welcome to Ember/);
+            });
+        });
+      }
 
-      return server.start()
-        .then(() => server.request('/'))
-        .then(html => {
-          expect(html).to.not.match(/error/);
+      it("returns 404 when navigating to a URL that doesn't exist", function() {
+        let middleware = fastbootMiddleware({
+          distPath: fixture('basic-app'),
+          chunkedResponse
         });
-    });
+        server = new TestHTTPServer(middleware);
 
-    it("propagates to error handling middleware", function() {
-      let middleware = fastbootMiddleware({
-        distPath: fixture('rejected-promise'),
-        resilient: true
+        return server.start()
+          .then(() => server.request('/foo-bar-baz/non-existent'))
+          .catch((result) => {
+            expect(result.statusCode).to.equal(404);
+          });
       });
-      server = new TestHTTPServer(middleware, { errorHandling: true });
-
-      return server.start()
-        .then(() => server.request('/', { resolveWithFullResponse: true }))
-        .then(({ body, statusCode, headers }) => {
-          expect(statusCode).to.equal(200);
-          expect(headers['x-test-error']).to.match(/error handler called/);
-          expect(body).to.match(/hello world/);
+
+      it("returns a 500 error if an error occurs", function() {
+        let middleware = fastbootMiddleware({
+          distPath: fixture('rejected-promise'),
+          chunkedResponse
         });
-    });
+        server = new TestHTTPServer(middleware);
 
-    it("is does not propagate errors when and there is no error handling middleware", function() {
-      let middleware = fastbootMiddleware({
-        distPath: fixture('rejected-promise'),
-        resilient: true,
+        return server.start()
+          .then(() => server.request('/'))
+          .catch(err => {
+            expect(err.message).to.match(/Rejected on purpose/);
+          });
       });
-      server = new TestHTTPServer(middleware, { errorHandling: false });
-
-      return server.start()
-        .then(() => server.request('/', { resolveWithFullResponse: true }))
-        .then(({ body, statusCode, headers }) => {
-          expect(statusCode).to.equal(200);
-          expect(headers['x-test-error']).to.not.match(/error handler called/);
-          expect(body).to.not.match(/error/);
-          expect(body).to.match(/hello world/);
+
+      describe('when reslient mode is enabled', function () {
+        it("renders no FastBoot markup", function() {
+          let middleware = fastbootMiddleware({
+            distPath: fixture('rejected-promise'),
+            resilient: true,
+            chunkedResponse
+          });
+          server = new TestHTTPServer(middleware);
+
+          return server.start()
+            .then(() => server.request('/'))
+            .then(html => {
+              expect(html).to.not.match(/error/);
+            });
         });
-    });
 
-    it("allows post-fastboot middleware to recover the response when it fails", function() {
-      let middleware = fastbootMiddleware({
-        distPath: fixture('rejected-promise'),
-        resilient: true
-      });
-      server = new TestHTTPServer(middleware, { recoverErrors: true });
-
-      return server.start()
-        .then(() => server.request('/', { resolveWithFullResponse: true }))
-        .then(({ body, statusCode, headers }) => {
-          expect(statusCode).to.equal(200);
-          expect(headers['x-test-recovery']).to.match(/recovered response/);
-          expect(body).to.match(/hello world/);
+        it("propagates to error handling middleware", function() {
+          let middleware = fastbootMiddleware({
+            distPath: fixture('rejected-promise'),
+            resilient: true,
+            chunkedResponse
+          });
+          server = new TestHTTPServer(middleware, { errorHandling: true });
+
+          return server.start()
+            .then(() => server.request('/', { resolveWithFullResponse: true }))
+            .then(({ body, statusCode, headers }) => {
+              expect(statusCode).to.equal(200);
+              expect(headers['x-test-error']).to.match(/error handler called/);
+              expect(body).to.match(/hello world/);
+            });
+        });
+
+        it("is does not propagate errors when and there is no error handling middleware", function() {
+          let middleware = fastbootMiddleware({
+            distPath: fixture('rejected-promise'),
+            resilient: true,
+            chunkedResponse
+          });
+          server = new TestHTTPServer(middleware, { errorHandling: false });
+
+          return server.start()
+            .then(() => server.request('/', { resolveWithFullResponse: true }))
+            .then(({ body, statusCode, headers }) => {
+              expect(statusCode).to.equal(200);
+              expect(headers['x-test-error']).to.not.match(/error handler called/);
+              expect(body).to.not.match(/error/);
+              expect(body).to.match(/hello world/);
+            });
         });
-    });
-  });
 
-  describe('when reslient mode is disabled', function () {
-    it("propagates to error handling middleware", function() {
-      let middleware = fastbootMiddleware({
-        distPath: fixture('rejected-promise'),
-        resilient: false,
+        it("allows post-fastboot middleware to recover the response when it fails", function() {
+          let middleware = fastbootMiddleware({
+            distPath: fixture('rejected-promise'),
+            resilient: true,
+            chunkedResponse
+          });
+          server = new TestHTTPServer(middleware, { recoverErrors: true });
+
+          return server.start()
+            .then(() => server.request('/', { resolveWithFullResponse: true }))
+            .then(({ body, statusCode, headers }) => {
+              expect(statusCode).to.equal(200);
+              expect(headers['x-test-recovery']).to.match(/recovered response/);
+              expect(body).to.match(/hello world/);
+            });
+        });
       });
-      server = new TestHTTPServer(middleware, { errorHandling: true });
 
-      return server.start()
-        .then(() => server.request('/', { resolveWithFullResponse: true }))
-        .catch(({ statusCode, response: { headers } }) => {
-          expect(statusCode).to.equal(500);
-          expect(headers['x-test-error']).to.match(/error handler called/);
+      describe('when reslient mode is disabled', function () {
+        it("propagates to error handling middleware", function() {
+          let middleware = fastbootMiddleware({
+            distPath: fixture('rejected-promise'),
+            resilient: false,
+            chunkedResponse
+          });
+          server = new TestHTTPServer(middleware, { errorHandling: true });
+
+          return server.start()
+            .then(() => server.request('/', { resolveWithFullResponse: true }))
+            .catch(({ statusCode, response: { headers } }) => {
+              expect(statusCode).to.equal(500);
+              expect(headers['x-test-error']).to.match(/error handler called/);
+            });
         });
-    });
 
-    it("allows post-fastboot middleware to recover the response when it fails", function() {
-      let middleware = fastbootMiddleware({
-        distPath: fixture('rejected-promise'),
-        resilient: false
-      });
-      server = new TestHTTPServer(middleware, { recoverErrors: true });
-
-      return server.start()
-        .then(() => server.request('/', { resolveWithFullResponse: true }))
-        .then(({ body, statusCode, headers }) => {
-          expect(statusCode).to.equal(200);
-          expect(headers['x-test-recovery']).to.match(/recovered response/);
-          expect(body).to.match(/hello world/);
+        it("allows post-fastboot middleware to recover the response when it fails", function() {
+          let middleware = fastbootMiddleware({
+            distPath: fixture('rejected-promise'),
+            resilient: false,
+            chunkedResponse
+          });
+          server = new TestHTTPServer(middleware, { recoverErrors: true });
+
+          return server.start()
+            .then(() => server.request('/', { resolveWithFullResponse: true }))
+            .then(({ body, statusCode, headers }) => {
+              expect(statusCode).to.equal(200);
+              expect(headers['x-test-recovery']).to.match(/recovered response/);
+              expect(body).to.match(/hello world/);
+            });
         });
+      });
     });
   });
-
 });