Initial commit

Author: tomdale

.gitignore

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

.jshintignore

@@ -0,0 +1,2 @@
+node_modules/**
+test/fixtures/**

.travis.yml

@@ -0,0 +1,14 @@
+language: node_js
+node_js:
+  - "stable"
+  - "4"
+  - "0.12"
+
+env:
+  - CXX=g++-4.8 WORKER_COUNT=2
+addons:
+  apt:
+    sources:
+      - ubuntu-toolchain-r-test
+    packages:
+      - g++-4.8

README.md

@@ -0,0 +1,80 @@
+# FastBoot Express Middleware
+
+This middleware is a small wrapper around the
+[`fastboot`](https://github.com/ember-fastboot/fastboot) package, which
+renders Ember.js apps in Node.js.
+
+By adding this middleware to your Express app, you can serve HTML from a
+rendered Ember.js app to clients that don't support JavaScript, such as
+`curl`, search crawlers, or users with JavaScript disabled.
+
+Note that this is _just an Express middleware_ and there is more needed
+to serve apps in a production environment. If you want to server-side
+rendered Ember applications without doing a lot of work, you are
+recommended to consider the [FastBoot App
+Server](https://github.com/ember-fastboot/fastboot-app-server), which
+manages many of the hard parts for you.
+
+That said, this middleware is designed to be easy to integrate for those
+who already have existing Express stacks, or who want maximum
+flexibility in how requests are handled.
+
+## Usage
+
+```js
+const express = require('express');
+const fastbootMiddleware = require('fastboot-express-middleware');
+
+let app = express();
+
+app.get('/*', fastbootMiddleware('/path/to/dist'));
+
+app.listen(3000, function () {
+  console.log('FastBoot app listening on port 3000!');
+});
+```
+
+## Building Your Ember App
+
+Before you can use your app with FastBoot, you must first install the
+[ember-cli-fastboot][ember-cli-fastboot] addon and build your app by
+running `ember build`. The build process will compile your app into a
+version that is compatible with both Node.js and the browser and put it
+in the `dist` directory. This `dist` directory is the path you should
+provide to the middleware to specify which Ember app to load and render.
+
+## Resilient Mode
+
+By default, errors during render will cause the middleware to send an
+HTTP 500 status code as the response. In order to swallow errors and
+return a `200 OK` with an empty HTML page, set the `resilient` flag to
+true:
+
+```js
+app.get('/*', fastbootMiddleware('/path/to/dist', {
+  resilient: true
+}));
+```
+
+## Custom FastBoot Instance
+
+For more control over the FastBoot instance that is created to render
+the Ember app, you can pass a custom instance that the middleware will
+use instead of creating its own:
+
+```js
+let fastboot = new FastBoot({
+  distPath: 'path/to/dist'
+});
+
+let middleware = fastbootMiddleware({
+  fastboot: fastboot
+});
+
+app.get('/*', middleware);
+
+// ...later
+fastboot.reload();
+```
+
+[ember-cli-fastboot]: https://github.com/ember-fastboot/ember-cli-fastboot

index.js

@@ -0,0 +1,77 @@
+'use strict';
+
+const FastBoot = require('fastboot');
+const chalk = require('chalk');
+
+function fastbootExpressMiddleware(distPath, options) {
+  let opts = options;
+
+  if (arguments.length === 1) {
+    if (typeof distPath === 'string') {
+      opts = { distPath: distPath };
+    } else {
+      opts = distPath;
+    }
+  }
+
+  opts = opts || {};
+
+  let log = opts.log !== false ? _log : function() {};
+
+  let fastboot = opts.fastboot;
+
+  if (!fastboot) {
+    fastboot = new FastBoot({
+      distPath: opts.distPath,
+      resilient: opts.resilient
+    });
+  }
+
+  return function(req, res, next) {
+    let path = req.url;
+    fastboot.visit(path, { request: req, response: res })
+      .then(success, failure);
+
+    function success(result) {
+      result.html()
+        .then(html => {
+          let headers = result.headers;
+
+          for (var pair of headers.entries()) {
+            res.set(pair[0], pair[1]);
+          }
+
+          log(result.statusCode, 'OK ' + path);
+          res.status(result.statusCode);
+          res.send(html);
+        })
+        .catch(error => {
+          console.log(error.stack);
+          res.sendStatus(500);
+        });
+    }
+
+    function failure(error) {
+      if (error.name === "UnrecognizedURLError") {
+        next();
+      } else {
+        log(500, "Unknown Error: " + error.stack);
+        res.status(500).send(error.stack);
+      }
+    }
+  };
+}
+
+function _log(statusCode, message, startTime) {
+  let color = statusCode === 200 ? 'green' : 'red';
+  let now = new Date();
+
+  if (startTime) {
+    let diff = Date.now() - startTime;
+    message = message + chalk.blue(" " + diff + "ms");
+  }
+
+  console.log(chalk.blue(now.toISOString()) + " " + chalk[color](statusCode) + " " + message);
+}
+
+module.exports = fastbootExpressMiddleware;

package.json

@@ -0,0 +1,36 @@
+{
+  "name": "fastboot-express-middleware",
+  "version": "0.1.0",
+  "description": "An Express middleware for rendering Ember apps with FastBoot",
+  "main": "index.js",
+  "scripts": {
+    "test": "mocha"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ember-fastboot/fastboot-express-middleware.git"
+  },
+  "keywords": [
+    "fastboot",
+    "ember",
+    "express",
+    "middleware"
+  ],
+  "author": "Tom Dale <[email protected]>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/ember-fastboot/fastboot-express-middleware/issues"
+  },
+  "homepage": "https://github.com/ember-fastboot/fastboot-express-middleware#readme",
+  "devDependencies": {
+    "chai": "^3.5.0",
+    "chai-as-promised": "^5.3.0",
+    "express": "^4.13.4",
+    "mocha": "^2.4.5",
+    "mocha-jshint": "^2.3.1",
+    "request-promise": "^3.0.0"
+  },
+  "dependencies": {
+    "chalk": "^1.1.3"
+  }
+}

test/.jshintrc

@@ -0,0 +1,5 @@
+{
+  "mocha": true,
+  "esnext": true,
+  "node": true
+}