nails-boilerplate 1.2.0 → 1.2.1

package/README.md

@@ -2,8 +2,8 @@
 
 This framework is designed to provide a lightweight, configurable MVC backend
 for node developers.  With minimal dependencies, Nails offers a greater
-syntactical familiarity than php alongside the creative freedom of bleeding edge
-solutions like Rails and Django.
+syntactical familiarity than php alongside the creative freedom of well developed
+server framework solutions like Rails and Django.
 
 This boilerplate offers the basic necessities to get your MVC site off the ground.
 The modules used in Nails Boilerplate can be easily extended to produce the custom
@@ -53,7 +53,7 @@ service.js contains information necessary to run your server. By default, it
 specifies the port and the location of important libraries. To override these
 values in different runtime environments, add a child object.
 ```js
-module.exports = {
+export default {
   ...
   PORT: 3000,
   PROD: {
@@ -77,7 +77,7 @@ var service_config = require('nails-boilerplate').config
 If the config contains a custom field,
 
 ```js
-module.exports = {
+export default {
   ...
   PORT: 3000,
   yourCustomField: 'yourCustomValue'
@@ -137,7 +137,16 @@ parameters work.
   to dynamically route your request to the appropriate handler.
 
 #### db.js
--- Coming soon... For now, take a look at the files in the example config directory --
+
+Quickly configure your database connection here. Nails comes pre-configured to
+use the sequelize connector, giving your models sequelize support. The initial setup
+uses an in-memory *sqlite3* database. Change the address to change the location and
+version of your desired sql database. Check out [Sequelize](https://sequelize.org)
+for more info.
+
+Alternatively, you can configure a connection to MongoDB using the mongoose_connector.js.
+If enabled, models will accept [Mongoose](https://mongoosejs.com/docs/) schemas and will
+be backed by the desired MongoDB. Consider using the in-memory DB during development.
 
 ## Controller
 
@@ -148,8 +157,10 @@ actions, receiving **params**, **request**, and **response** as arguments.
 
 For Example:
 ``` js
-const Controller = requre("nails-boilerplate").Controller
-class HomeController extends Controller {
+// const Controller = requre("nails-boilerplate").Controller
+import nails from 'nails-boilerplate';
+
+class HomeController extends nails.Controller {
   index(params, request, response) {
     // default action
   }
@@ -158,7 +169,7 @@ class HomeController extends Controller {
     // does something then renders a view
   }
 }
-module.exports = HomeController;
+export default HomeController;
 
 function helperMethod() {
   // does something but does not have access to response
@@ -168,6 +179,42 @@ function helperMethod() {
 defines a controller which will match any route to *home#\<action\>*. **index**
 and **signin** are actions which can be used to render a response to the client.
 
+### Local Routes
+
+You can define a local routing table directly in the controller.
+Local routes take precidence over global routes. All local routes
+are prefixed with the controller name unless they start with '/'.
+For example, in HomeController the following route:
+
+`["get", "data", {action: 'getData', json: true}],`
+
+will accept GET requests to /home/data and respond with the json
+object returned by the getData function. If the route is changed to:
+
+`["get", "/data", {action: 'getData', json: true}],`
+
+it will accept GET requests to /data instead. All local routes are
+implicitly routed to their respective parent controllers.
+
+```js
+export default class UsersController extends nails.Controller {
+  routes = [
+    // Routes requests to /absolute/path
+    ['get', '/absolute/path', {action: 'actionA'}],
+    // Routes requests to /users/relative/path
+    ['get', './relative/path', {action: 'actionB'}],
+    // Routes requests to /users/relative/path
+    ['get', 'relative/path', {action: 'actionB'}],
+  ]
+
+  // Handles requests to /absolute/path
+  actionA(request, response, params) {}
+
+  // Handles requests to /users/relative/path
+  actionB(request, response, params) {}
+}
+```
+
 ### Actions
 Actions are used to define how nails should respond to an incoming request.
 If no action has been defined for a route, nails will default to the index
@@ -218,23 +265,50 @@ overridden to allow for the rendering of views by name.
 ## Model
 
 Models are programmatic representations of data you wish to persist in a
-database. By default, models are subclasses of
+database. The constructor for Model accepts two arguments: the `modelName` and an
+`options` object which is passed to the database connector module.
+
+### Sequelize Models
+
+Sequelize models are subclasses of
+[Sequelize Models][sequelize_model_docs], and come with the `count()`, `findAll()`,
+and `create()` methods, to name a few. You can define your own models by
+extending an instance of the `Model` class provided by Nails:
+
+```js
+// const Model = require("nails-boilerplate").Model;
+import nails from 'nails-boilerplate';
+import {DataTypes} from 'sequelize';
+userSchema = {
+  name: {type: DataTypes.STRING, allowNull: false},
+  email: {type: DataTypes.STRING, allowNull: false}
+};
+export default class User extends new Model("User", userSchema) {
+  /**
+   * It is not recommended to add helper methods to Sequelize models. Define
+   * them in the schema instead.
+   */
+};
+
+```
+
+### Mongoose Models
+Mongoose models are subclasses of
 [Mongoose Models][mongoose_model_docs], and come with the `save()`, `find()`,
 and `where()` methods, to name a few. You can define your own models by
 extending an instance of the `Model` class provided by Nails:
 
 ``` js
-const Model = require("nails-boilerplate").Model;
+// const Model = require("nails-boilerplate").Model;
+import nails from 'nails-boilerplate';
 const userSchema = {name: String, email: String};
-module.exports = class User extends new Model("User", {schema: userSchema}) {
+export default class User extends new Model("User", {schema: userSchema}) {
   // Define your helper methods here
 };
 ```
 
-The constructor for Model accepts two arguments: the `modelName` and an
-`options` object which is passed to the database connector module. The
-Mongoose connector accepts a schema field that is used to describe how
-documents are stored in MongoDB.
+The `schema` option for Mongoose Models accepts a schema field that is used
+to define how documents are stored in MongoDB.
 
 ### Database Connectors
 
@@ -268,3 +342,4 @@ Enjoy! Feature requests, bug reports, and comments are welcome on github.
 [express_routing_docs]: https://expressjs.com/en/guide/routing.html
 [express_request_docs]: https://expressjs.com/en/5x/api.html#req
 [mongoose_model_docs]: https://mongoosejs.com/docs/api/model.html
+[sequelize_model_docs]: https://sequelize.org/docs/v6/core-concepts/model-basics/

package/lib/controller.js

@@ -21,8 +21,8 @@ const DISABLE_AUTORENDER = new (class DisableAutorender {});
 class Controller {
   constructor() {
     var subclassName = this.constructor.name;
-    var controllerName =
-        subclassName.toLowerCase().replace(/controller$/, '');
+    var controllerName = this._getControllerName();
+        // subclassName.toLowerCase().replace(/controller$/, '');
     router.removeAllListeners('dispatchTo:' + controllerName);
     router.on('dispatchTo:' + controllerName, this._do.bind(this));
   }
@@ -55,6 +55,29 @@ class Controller {
     return constructed;
   }
 
+  _getControllerName() {
+    return this.constructor.name.toLowerCase().replace(/controller$/, '');
+  }
+
+  /** Initializes local and global routes defined on the Controller subclass */
+  _registerControllerRoutes() {
+    const controllerName = this._getControllerName();
+    if (this.routes && this.routes.length) {
+      const localizedRoutes = this.routes.map(route => {
+        // TODO: throw an error if :controller is present in local routes
+        // TODO: also account for other malformed local routes
+        const routePrefix = `/${controllerName}/`;
+        const modifiedDestination = route[1][0] == '/'
+            ? route[1]
+            : route[1].startsWith('./') ? route[1].replace('./', routePrefix) : routePrefix + route[1];
+        const modifiedOptions = {...route[2]};
+        modifiedOptions.controller = controllerName;
+        return [route[0], modifiedDestination, modifiedOptions];
+      });
+      router.addRoutes(localizedRoutes);
+    }
+  }
+
   /****  Network Methods  *****/
   /**
    *  The main entry function of the controller.

package/lib/nails.js

@@ -66,7 +66,8 @@ async function configure( app_config ) {
   // set up router and controllers
   express_app.set("public_root", app_config.config.PUBLIC_ROOT);
   console.log("Initializing Router...");
-  application.router = new Router( app_config.routes || [] );
+  // application.router = new Router( app_config.routes || [] );
+  application.router = new Router( [] );
   console.log("Application Router initialized");
 
   // init models
@@ -76,7 +77,7 @@ async function configure( app_config ) {
   // TODO: deprecate the old Model style
   if (app_config.config.MODELS_ROOT) {
     Model.set_connector(DBConnector, app_config.db);
-    init_models(app_config.config.MODELS_ROOT);
+    await init_models(app_config.config.MODELS_ROOT);
   }
   // TODO: make this Model style mandatory
   console.log("Connecting to DB...");
@@ -84,7 +85,7 @@ async function configure( app_config ) {
     console.log("Generating model superclass...");
     await DBConnector.connect(app_config.db);
     ModelV2.setConnector(DBConnector);
-    init_models_v2(app_config.config.MODELS_ROOT);
+    await init_models_v2(app_config.config.MODELS_ROOT);
     DBConnector.afterInitialization();
   } else {
     console.log("Instantiating DBConnector...");
@@ -99,7 +100,8 @@ async function configure( app_config ) {
   Controller.setRouter(application.router);
   application.controller = Controller.extend(ApplicationController);
   console.log('initializing controllers: ', app_config.config.CONTROLLERS_ROOT);
-  init_controllers(app_config.config.CONTROLLERS_ROOT);
+  await init_controllers(app_config.config.CONTROLLERS_ROOT);
+  application.router.addRoutes(app_config.routes);
 };
 
 function startServer(config) {
@@ -145,11 +147,11 @@ function startServer(config) {
 }
 
 // TODO: create an initializer lib file.
-function init_controllers(controller_lib) {
-    init_app_lib(Controller, controller_lib);
+async function init_controllers(controller_lib) {
+  await init_app_lib(Controller, controller_lib);
 }
-function init_models(model_lib) {
-    init_app_lib(Model, model_lib);
+async function init_models(model_lib) {
+  await init_app_lib(Model, model_lib);
 }
 async function init_app_lib(superclass, abs_path) {
     console.log('attempting to import:', abs_path);
@@ -161,11 +163,15 @@ async function init_app_lib(superclass, abs_path) {
       if (!superclass.isPrototypeOf(subclass))
           return superclass.extend(subclass);
       // ES6 Class was provided
-      return new subclass();
+      const subInstance = new subclass();
+      if (superclass == Controller) {
+        subInstance._registerControllerRoutes();
+      }
+      return subInstance;
+    }
+    for (const rel_path of fs.readdirSync(abs_path)) {
+      await init_app_lib(superclass, path.join(abs_path, rel_path));
     }
-    fs.readdirSync(abs_path).forEach(function(rel_path) {
-        init_app_lib(superclass, path.join(abs_path, rel_path));
-    });
 }
 
 async function init_models_v2(abs_path) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nails-boilerplate",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "A node.js webserver scaffold",
   "type": "module",
   "main": "index.js",
@@ -8,7 +8,7 @@
     "nails": "./bin/lib/nails.js"
   },
   "scripts": {
-    "copyreadme": "mammoth README.md templates/client/README.html",
+    "copyreadme": "node bin/convertreadmetohtml.js",
     "test": "mocha --exit spec",
     "debug": "mocha --exit debug spec"
   },

package/spec/services/integration/server/controllers/classbased_controller.js

@@ -1,6 +1,11 @@
 import nails from "../../../../../index.js";
     // require("../../../../../index.js").Controller;
 export default class ClassbasedController extends nails.Controller {
+  routes = [
+    ["get", "./arbi/trary/testLocalRoutes", {action: 'testLocalRoutes', json: true}],
+    ["get", "arbi00/trary00/testLocalRoutes", {action: 'testLocalRoutes', json: true}],
+    ["get", "/cl4ssb4sed/arbi/trary/testLocalRoutes", {action: 'testLocalRoutes', json: true}],
+  ];
   // DO NOT OVERRIDE CONSTRUCTOR
   index(params, request, response) {
     response.json({
@@ -19,4 +24,10 @@ export default class ClassbasedController extends nails.Controller {
       classbased_testpromise: true
     });
   }
+
+  testLocalRoutes(params, request, response) {
+    return {
+      testLocalRoutes: true
+    };
+  }
 }

package/spec/services.integration.spec.js

@@ -1,6 +1,6 @@
 // Import the dependencies for testing
 import * as chai from 'chai';
-import {default as chaiHttp, request} from "chai-http";
+import { default as chaiHttp, request } from "chai-http";
 // import chaiHttp from 'chai-http';
 import { assert } from 'chai';
 // import { WebSocket } from 'ws';
@@ -15,110 +15,139 @@ let mongod = null;
 chai.use(chaiHttp);
 chai.should();
 
-describe("Integration", function() {
-  before(async function() {
-      // this.timeout(30000);
-      try {
-        var nails = (await import('./services/integration/server.js')).default;
-      } catch (e) {
-        console.log("could not import server");
-        console.log(e);
-      }
-      console.log("got here");
-      express_app = nails.application;
-      return new Promise((resolve, reject) => {
-        nails.events.on("ready", () => {
-          console.log("ready was emitted!");
-          resolve();
-        });
+describe("Integration", function () {
+  before(async function () {
+    // this.timeout(30000);
+    try {
+      var nails = (await import('./services/integration/server.js')).default;
+    } catch (e) {
+      console.log("could not import server");
+      console.log(e);
+    }
+    console.log("got here");
+    express_app = nails.application;
+    return new Promise((resolve, reject) => {
+      nails.events.on("ready", () => {
+        console.log("ready was emitted!");
+        resolve();
       });
+    });
     // })
     // MongoMemoryServer.create({instance: service_config.db}).then((mongodb) => {
     //   mongod = mongodb;
-      
+
     // });
   });
-  describe("GET /", function() {
-    it('should return the expected JSON from index', function(done) {
+  describe("GET /", function () {
+    it('should return the expected JSON from index', function (done) {
       request.execute(express_app)
-          .get('/')
-          .end((err, res) => {
-            res.should.have.status(200);
-            assert(res.text == JSON.stringify({home_index: true}));
-            done();
-          });
+        .get('/')
+        .end((err, res) => {
+          res.should.have.status(200);
+          assert(res.text == JSON.stringify({ home_index: true }));
+          done();
+        });
     });
   });
-  describe("GET /classbased", function() {
-    it('should return the expected JSON from index', function(done) {
+  describe("GET /classbased", function () {
+    it('should return the expected JSON from index', function (done) {
       request.execute(express_app)
-          .get('/classbased')
-          .end((err, res) => {
-            res.should.have.status(200);
-            assert(res.text == JSON.stringify({classbased_index: true}));
-            done();
-          });
+        .get('/classbased')
+        .end((err, res) => {
+          res.should.have.status(200);
+          assert(res.text == JSON.stringify({ classbased_index: true }));
+          done();
+        });
     });
   });
-  describe("GET /^\\/(\\w+)\\/(\\w+)$/i", function() {
-    it ('should route to home_controller#testaction', function(done) {
+  describe("Get /classbased/arbi/trary/testLocalRoutes", function () {
+    it("Should respect the defined local route and return the expected JSON", function (done) {
       request.execute(express_app)
-          .get('/home/testaction')
-          .end((err, res) => {
-            res.should.have.status(200);
-            assert(res.text == JSON.stringify({home_testaction: true}));
-            done();
-          });
+        .get('/classbased/arbi00/trary00/testLocalRoutes')
+        .end((err, res) => {
+          res.should.have.status(200);
+          assert(res.text == JSON.stringify({ testLocalRoutes: true }));
+          done();
+        });
     });
-    it('should route to classbased_controller#testaction', function(done) {
+    it("Should not rewrite local route prefix and return the expected JSON", function (done) {
       request.execute(express_app)
-          .get('/classbased/testaction')
-          .end((err, res) => {
-            res.should.have.status(200);
-            assert(res.text == JSON.stringify({classbased_testaction: true}));
-            done();
-          });
+        .get('/cl4ssb4sed/arbi/trary/testLocalRoutes')
+        .end((err, res) => {
+          res.should.have.status(200);
+          assert(res.text == JSON.stringify({ testLocalRoutes: true }));
+          done();
+        });
     });
-    it('should render correctly when a promise is returned', function(done) {
+    it("Should rewrite local route prefix, './' and return the expected JSON", function (done) {
       request.execute(express_app)
-          .get('/classbased/testpromise')
-          .end((err, res) => {
-            res.should.have.status(200);
-            assert(res.text == JSON.stringify({classbased_testpromise: true}));
-            done();
-          });
+        .get('/classbased/arbi/trary/testLocalRoutes')
+        .end((err, res) => {
+          res.should.have.status(200);
+          assert(res.text == JSON.stringify({ testLocalRoutes: true }));
+          done();
+        });
+    });
+  });
+  describe("GET /^\\/(\\w+)\\/(\\w+)$/i", function () {
+    it('should route to home_controller#testaction', function (done) {
+      request.execute(express_app)
+        .get('/home/testaction')
+        .end((err, res) => {
+          res.should.have.status(200);
+          assert(res.text == JSON.stringify({ home_testaction: true }));
+          done();
+        });
+    });
+    it('should route to classbased_controller#testaction', function (done) {
+      request.execute(express_app)
+        .get('/classbased/testaction')
+        .end((err, res) => {
+          res.should.have.status(200);
+          assert(res.text == JSON.stringify({ classbased_testaction: true }));
+          done();
+        });
+    });
+    it('should render correctly when a promise is returned', function (done) {
+      request.execute(express_app)
+        .get('/classbased/testpromise')
+        .end((err, res) => {
+          res.should.have.status(200);
+          assert(res.text == JSON.stringify({ classbased_testpromise: true }));
+          done();
+        });
     })
   });
 
-  describe("GET /error/fivehundred", function() {
-    it('should log the stack trace', function(done) {
+  describe("GET /error/fivehundred", function () {
+    it('should log the stack trace', function (done) {
       request.execute(express_app)
-          .get('/error/fivehundred/500')
-          .end((err, res) => {
-            res.should.have.status(500);
-            //console.log(res.text);
-            //console.log(res);
-            //console.log(err);
-            done();
-          })
+        .get('/error/fivehundred/500')
+        .end((err, res) => {
+          res.should.have.status(500);
+          //console.log(res.text);
+          //console.log(res);
+          //console.log(err);
+          done();
+        })
     });
-    it('should return meaningful JSON', function(done) {
+    it('should return meaningful JSON', function (done) {
       request.execute(express_app)
-          .get('/error/fivehundred')
-          .end((err, res) => {
-            res.should.have.status(500);
-            console.log("ZZZZZZZZZZ");
-            console.log(res.text);
-            //console.log(res.text);
-            //console.log(res);
-            //console.log(err);
-            done();
-          })
+        .get('/error/fivehundred')
+        .end((err, res) => {
+          res.should.have.status(500);
+          console.log("ZZZZZZZZZZ");
+          console.log(res.text);
+          //console.log(res.text);
+          //console.log(res);
+          //console.log(err);
+          done();
+        })
     });
   });
 
-  describe("WebSockets", function() {
-    it("should listen on /", function(done) {
+  describe("WebSockets", function () {
+    it("should listen on /", function (done) {
       this.timeout(2000);
       var requester = request.execute(express_app).keepOpen();
       var wsClient = new WebSocket("ws://localhost:3333/");
@@ -128,17 +157,17 @@ describe("Integration", function() {
         assert(message == "It worked");
       });
     });
-    it("should listen on /voodoo", function(done) {
+    it("should listen on /voodoo", function (done) {
       this.timeout(2000);
       var requester = request.execute(express_app).keepOpen();
       var wsClient = new WebSocket("ws://localhost:3333/voodoo");
 
       wsClient.on('message', (message) => {
-          assert(message == "Voodoo worked");
+        assert(message == "Voodoo worked");
       });
       wsClient.on('close', (code, reason) => done());
     });
-    it("should not listen on /voodootwo", function(done) {
+    it("should not listen on /voodootwo", function (done) {
       // TODO: this doesn't fail. Figure out why.
       //done();
       this.timeout(2000);
@@ -157,9 +186,9 @@ describe("Integration", function() {
     it("should correctly handle dynamic controller and action");
   });
 
-  describe("GET /json/:action", function() {
+  describe("GET /json/:action", function () {
     it('should render params if nothing is returned by the action',
-      function(done) {
+      function (done) {
         request.execute(express_app)
           // Route to index action.
           .get('/json/testparams?testkey=testvalue')
@@ -170,79 +199,79 @@ describe("Integration", function() {
           });
       }
     );
-    it('should render the returned object as json', function(done) {
+    it('should render the returned object as json', function (done) {
       request.execute(express_app)
-          .get('/json/testaction')
+        .get('/json/testaction')
+        .end((err, res) => {
+          res.should.have.status(200);
+          assert(res.text == JSON.stringify({ json_testaction: true }));
+          done();
+        });
+    });
+    it('should asynchronously render the resolved promise as json',
+      function (done) {
+        request.execute(express_app)
+          .get('/json/testpromise')
           .end((err, res) => {
             res.should.have.status(200);
-            assert(res.text == JSON.stringify({json_testaction: true}));
+            assert(res.text == JSON.stringify({ json_testpromise: true }));
             done();
           });
-    });
-    it('should asynchronously render the resolved promise as json',
-      function(done) {
-        request.execute(express_app)
-            .get('/json/testpromise')
-            .end((err, res) => {
-              res.should.have.status(200);
-              assert(res.text == JSON.stringify({json_testpromise: true}));
-              done();
-            });
       }
     );
   });
-  describe("Get /ManualRenderAsync", function() {
+  describe("Get /ManualRenderAsync", function () {
     it("./testmanualrenderasync Should not throw an exception after manually"
-       + " rendering json asynchronously",
+      + " rendering json asynchronously",
       done => {
         request.execute(express_app)
-            .get("/manualrenderasync/testmanualrenderasync")
-            .end((err, res) => {
-              res.should.have.status(200);
-              assert(res.text ==
-                JSON.stringify({json_testmanualrenderasync: true}));
-              done();
-            });
+          .get("/manualrenderasync/testmanualrenderasync")
+          .end((err, res) => {
+            res.should.have.status(200);
+            assert(res.text ==
+              JSON.stringify({ json_testmanualrenderasync: true }));
+            done();
+          });
       });
 
-      it("./testmanualrenderexplicitasync Should not throw an exception after"
-         + " manually rendering json asynchronously using the async function"
-         + " tag",
-        done => {
-          request.execute(express_app)
-              .get("/manualrenderasync/testmanualrenderexplicitasync")
-              .end((err, res) => {
-                res.should.have.status(200);
-                assert(res.text ==
-                  JSON.stringify({json_testmanualrenderexplicitasync: true}));
-                done();
-              });
-        });
+    it("./testmanualrenderexplicitasync Should not throw an exception after"
+      + " manually rendering json asynchronously using the async function"
+      + " tag",
+      done => {
+        request.execute(express_app)
+          .get("/manualrenderasync/testmanualrenderexplicitasync")
+          .end((err, res) => {
+            res.should.have.status(200);
+            assert(res.text ==
+              JSON.stringify({ json_testmanualrenderexplicitasync: true }));
+            done();
+          });
+      });
 
   });
-  describe("Mongoose Model", function() {
-    beforeEach(async function() {
+  describe("Mongoose Model", function () {
+    beforeEach(async function () {
       // Used to initialize mongod here
     });
-    afterEach(async function() {
+    afterEach(async function () {
       //await mongod.stop();
     });
-    it('should save to the correct database', function(done) {
+    it('should save to the correct database', function (done) {
       let dogName = "Penny";
       let dogId = null;
       request.execute(express_app)
-          .get(`/modeltest/createdog?name=${dogName}`)
-          .end((err, res) => {
-            res.should.have.status(200);
-            dogId = res.text.replaceAll('"', '');
-            request.execute(express_app)
-                .get(`/modeltest/getdogbyid?id=${dogId}`)
-                .end((err, res) => {
-                  assert.equal(
-                    res.text, JSON.stringify({name: dogName, good: true}));
-                  done();
-                });
-          });
+        .get(`/modeltest/createdog?name=${dogName}`)
+        .end((err, res) => {
+          res.should.have.status(200);
+          dogId = res.text.replaceAll('"', '');
+          request.execute(express_app)
+            .get(`/modeltest/getdogbyid?id=${dogId}`)
+            .end((err, res) => {
+              assert.equal(
+                res.text, JSON.stringify({ name: dogName, good: true }));
+              done();
+            });
+        });
     });
 
   });

package/templates/public/README.xml

@@ -1,8 +1,8 @@
 <h1 id="nailsboilerplateanodewebserviceframework">Nails-Boilerplate: A Node Webservice Framework</h1>
 <p>This framework is designed to provide a lightweight, configurable MVC backend
 for node developers.  With minimal dependencies, Nails offers a greater
-syntactical familiarity than php alongside the creative freedom of bleeding edge
-solutions like Rails and Django.</p>
+syntactical familiarity than php alongside the creative freedom of well developed
+server framework solutions like Rails and Django.</p>
 <p>This boilerplate offers the basic necessities to get your MVC site off the ground.
 The modules used in Nails Boilerplate can be easily extended to produce the custom
 functionality to fit your needs, and you are encouraged to do so.</p>
@@ -37,7 +37,7 @@ help you tailor your service to your needs.</p>
 <p>service.js contains information necessary to run your server. By default, it
 specifies the port and the location of important libraries. To override these
 values in different runtime environments, add a child object.</p>
-<pre><code class="js language-js">module.exports = {
+<pre><code class="js language-js">export default {
   ...
   PORT: 3000,
   PROD: {
@@ -54,7 +54,7 @@ module:</p>
 <pre><code class="js language-js">var service_config = require('nails-boilerplate').config
 </code></pre>
 <p>If the config contains a custom field,</p>
-<pre><code class="js language-js">module.exports = {
+<pre><code class="js language-js">export default {
   ...
   PORT: 3000,
   yourCustomField: 'yourCustomValue'
@@ -107,15 +107,24 @@ than indices. You can name your regex captures "controller" and/or "action"
 to dynamically route your request to the appropriate handler.</li>
 </ul>
 <h4 id="dbjs">db.js</h4>
-<p>-- Coming soon… For now, take a look at the files in the example config directory --</p>
+<p>Quickly configure your database connection here. Nails comes pre-configured to
+use the sequelize connector, giving your models sequelize support. The initial setup
+uses an in-memory <em>sqlite3</em> database. Change the address to change the location and
+version of your desired sql database. Check out <a href="https://sequelize.org">Sequelize</a>
+for more info.</p>
+<p>Alternatively, you can configure a connection to MongoDB using the mongoose_connector.js.
+If enabled, models will accept <a href="https://mongoosejs.com/docs/">Mongoose</a> schemas and will
+be backed by the desired MongoDB. Consider using the in-memory DB during development.</p>
 <h2 id="controller">Controller</h2>
 <p>Controllers are defined in app/controllers/. Each controller module should
 define a Controller subclass. The name will be used to match routes defined in
 config/routes.js for incoming requests. Methods on the controller can be used as
 actions, receiving <strong>params</strong>, <strong>request</strong>, and <strong>response</strong> as arguments.</p>
 <p>For Example:</p>
-<pre><code class="js language-js">const Controller = requre("nails-boilerplate").Controller
-class HomeController extends Controller {
+<pre><code class="js language-js">// const Controller = requre("nails-boilerplate").Controller
+import nails from 'nails-boilerplate';
+
+class HomeController extends nails.Controller {
   index(params, request, response) {
     // default action
   }
@@ -124,7 +133,7 @@ class HomeController extends Controller {
     // does something then renders a view
   }
 }
-module.exports = HomeController;
+export default HomeController;
 
 function helperMethod() {
   // does something but does not have access to response
@@ -132,6 +141,34 @@ function helperMethod() {
 </code></pre>
 <p>defines a controller which will match any route to <em>home#\<action></em>. <strong>index</strong>
 and <strong>signin</strong> are actions which can be used to render a response to the client.</p>
+<h3 id="localroutes">Local Routes</h3>
+<p>You can define a local routing table directly in the controller.
+Local routes take precidence over global routes. All local routes
+are prefixed with the controller name unless they start with '/'.
+For example, in HomeController the following route:</p>
+<p><code>["get", "data", {action: 'getData', json: true}],</code></p>
+<p>will accept GET requests to /home/data and respond with the json
+object returned by the getData function. If the route is changed to:</p>
+<p><code>["get", "/data", {action: 'getData', json: true}],</code></p>
+<p>it will accept GET requests to /data instead. All local routes are
+implicitly routed to their respective parent controllers.</p>
+<pre><code class="js language-js">export default class UsersController extends nails.Controller {
+  routes = [
+    // Routes requests to /absolute/path
+    ['get', '/absolute/path', {action: 'actionA'}],
+    // Routes requests to /users/relative/path
+    ['get', './relative/path', {action: 'actionB'}],
+    // Routes requests to /users/relative/path
+    ['get', 'relative/path', {action: 'actionB'}],
+  ]
+
+  // Handles requests to /absolute/path
+  actionA(request, response, params) {}
+
+  // Handles requests to /users/relative/path
+  actionB(request, response, params) {}
+}
+</code></pre>
 <h3 id="actions">Actions</h3>
 <p>Actions are used to define how nails should respond to an incoming request.
 If no action has been defined for a route, nails will default to the index
@@ -172,20 +209,41 @@ params object:</p>
 overridden to allow for the rendering of views by name.</p>
 <h2 id="model">Model</h2>
 <p>Models are programmatic representations of data you wish to persist in a
-database. By default, models are subclasses of
+database. The constructor for Model accepts two arguments: the <code>modelName</code> and an
+<code>options</code> object which is passed to the database connector module.</p>
+<h3 id="sequelizemodels">Sequelize Models</h3>
+<p>Sequelize models are subclasses of
+<a href="https://sequelize.org/docs/v6/core-concepts/model-basics/">Sequelize Models</a>, and come with the <code>count()</code>, <code>findAll()</code>,
+and <code>create()</code> methods, to name a few. You can define your own models by
+extending an instance of the <code>Model</code> class provided by Nails:</p>
+<pre><code class="js language-js">// const Model = require("nails-boilerplate").Model;
+import nails from 'nails-boilerplate';
+import {DataTypes} from 'sequelize';
+userSchema = {
+  name: {type: DataTypes.STRING, allowNull: false},
+  email: {type: DataTypes.STRING, allowNull: false}
+};
+export default class User extends new Model("User", userSchema) {
+  /**
+   * It is not recommended to add helper methods to Sequelize models. Define
+   * them in the schema instead.
+   */
+};
+</code></pre>
+<h3 id="mongoosemodels">Mongoose Models</h3>
+<p>Mongoose models are subclasses of
 <a href="https://mongoosejs.com/docs/api/model.html">Mongoose Models</a>, and come with the <code>save()</code>, <code>find()</code>,
 and <code>where()</code> methods, to name a few. You can define your own models by
 extending an instance of the <code>Model</code> class provided by Nails:</p>
-<pre><code class="js language-js">const Model = require("nails-boilerplate").Model;
+<pre><code class="js language-js">// const Model = require("nails-boilerplate").Model;
+import nails from 'nails-boilerplate';
 const userSchema = {name: String, email: String};
-module.exports = class User extends new Model("User", {schema: userSchema}) {
+export default class User extends new Model("User", {schema: userSchema}) {
   // Define your helper methods here
 };
 </code></pre>
-<p>The constructor for Model accepts two arguments: the <code>modelName</code> and an
-<code>options</code> object which is passed to the database connector module. The
-Mongoose connector accepts a schema field that is used to describe how
-documents are stored in MongoDB.</p>
+<p>The <code>schema</code> option for Mongoose Models accepts a schema field that is used
+to define how documents are stored in MongoDB.</p>
 <h3 id="databaseconnectors">Database Connectors</h3>
 <p>Database connectors are intermediaries which define how a Model interacts with
 a database. Database connector modules need to export two methods:</p>

package/templates/server/controllers/home_controller.js

@@ -1,10 +1,34 @@
 import nails from "nails-boilerplate";
 
 export default class HomeController extends nails.Controller {
-    index(params, request, response) {
-      return {
-        title: "My first Nails Service",
-        welcome_message: "Welcome to Nails"
-      };
-    }
-  };
+  /**
+   * You can define a local routing table directly in the controller.
+   * Local routes take precidence over global routes. All local routes
+   * are prefixed with the controller name unless they start with '/'.
+   * For example, in HomeController the following route:
+   * 
+   *   ["get", "data", {action: 'getData', json: true}],
+   * 
+   * will accept GET requests to /home/data and respond with the json
+   * object returned by the getData function. If the route is changed to:
+   * 
+   *   ["get", "/data", {action: 'getData', json: true}],
+   * 
+   * it will accept GET requests to /data instead. All local routes are
+   * implicitly routed to their respective parent controllers.
+   */
+  routes = [
+    ["get", "data", {action: 'getData', json: true}],
+  ];
+
+  index(params, request, response) {
+    return {
+      title: "My first Nails Service",
+      welcome_message: "Welcome to Nails"
+    };
+  }
+
+  getData(params, request, response) {
+    return {testData: Math.floor(Math.random() * 10000000)}
+  }
+};