nails-boilerplate 0.8.2 → 0.10.1

package/lib/application.js

@@ -6,4 +6,4 @@ var app = express();
 module.exports = app;
 
 app.Router = express.Router;
-app.static = express.static;
+app.static = express.static;

package/lib/controller.js

@@ -60,8 +60,9 @@ class Controller {
    *  @param {object} params     The parameter hash for this action
    *  @param {object} request     The http request object from the http server
    *  @param {object} response    The http response object from the http server
+   *  @param {object} ws          The WebSocket instance
    */
-  _do (action, params, request, response) {
+  _do (action, params, request, response, ws) {
     request.handled_by_controller = true;
     var doAction = this[action];
     console.log(this.constructor.name, 'doing', action);
@@ -69,9 +70,15 @@ class Controller {
     if (typeof doAction != 'function') {
       //return this['404'](params, request, response);
       var error = new Error('Action Not Available: #' + action);
-      return response.status(404).send({
-        error: error.stack
-      });
+      if (response) {
+        return response.status(404).send({
+          error: error.stack
+        });
+      }
+      return ws.close(1003, "Action Not available: #" + action);
+    }
+    if (ws && !response) {
+      return doAction.call(this, params, ws, request);
     }
     // Override async with Controller definition.
     if (doAction.async != undefined) params._async = !!doAction.async;

package/lib/mongoose_connector.js

@@ -12,9 +12,11 @@ module.exports.connect = function(options) {
 }
 
 module.exports.generateModelSuperclass = function(name, options) {
-  let schema = new mongoose.Schema(options.schema);
+  let schema = options.schema instanceof mongoose.Schema
+    ? options.schema
+    : new mongoose.Schema(options.schema);
   if (options.indexes) {
-    options.indexes.forEach(index => schema.createIndex(index));
+    options.indexes.forEach(index => schema.index(index));
   }
   return mongoose.model(name, options.schema);
 }

package/lib/nails.js

@@ -24,7 +24,7 @@ module.exports = nails;
 
 function nails(app_config) {
   nails.config = app_config.config;
-  configure(app_config);
+  application._onceConfigured = configure(app_config);
   return {startServer: startServer};
 }
 
@@ -33,7 +33,7 @@ nails.Controller = Controller;
 nails.Model = ModelV2;
 nails.ModelDeprecated = Model;
 
-function configure( app_config ) {
+async function configure( app_config ) {
   express_app.set('nails_config', application);
   application.config = app_config.config;
   // TODO: may not need mimes any more.
@@ -66,8 +66,8 @@ function configure( app_config ) {
   }
   // TODO: make this Model style mandatory
   if (DBConnector.connect && DBConnector.generateModelSuperclass) {
-    DBConnector.connect(app_config.db);
-    ModelV2.setConnector(DBConnector);
+    await DBConnector.connect(app_config.db);
+    await ModelV2.setConnector(DBConnector);
   }
 
   // init Controllers
@@ -80,15 +80,16 @@ function configure( app_config ) {
 function startServer(config) {
     // Log the config.
     console.log(config);
-
-    // TODO: Use logging middleware.
-
-    // Use the router middleware.
-    express_app.use(application.router.express_router);
-    var ip = application.config.IP || 'localhost';
-    var port = application.config.PORT || 3000;
-    console.log("starting nails. listening to ", ip + ':' + port);
-    express_app.listen(port, ip);
+    application._onceConfigured.then(() => {
+      // TODO: Use logging middleware.
+
+      // Use the router middleware.
+      express_app.use(application.router.express_router);
+      var ip = application.config.IP || 'localhost';
+      var port = application.config.PORT || 3000;
+      console.log("starting nails. listening to ", ip + ':' + port);
+      express_app.listen(port, ip);
+    });
 }
 
 // TODO: create an initializer lib file.
@@ -98,12 +99,12 @@ function init_controllers(controller_lib) {
 function init_models(model_lib) {
     init_app_lib(Model, model_lib);
 }
-function init_app_lib(superclass, abs_path) {
+async function init_app_lib(superclass, abs_path) {
     console.log('attempting to import:', abs_path);
     if (!fs.existsSync(abs_path))
       return console.log('Cannot initialize. Path not found.', abs_path);
     if (fs.statSync(abs_path).isFile()) {
-      let subclass = require(abs_path);
+      let subclass = (await import(abs_path)).default;
       // Constructor function was provided
       if (!superclass.isPrototypeOf(subclass))
           return superclass.extend(subclass);

package/lib/router.js

@@ -6,6 +6,7 @@ var EventEmitter = require('events').EventEmitter;
 var URL = require('url');
 var path = require('path');
 var querystring = require('querystring');
+var expressWs = require('express-ws');
 var app = require('./application.js');
 //var nails = require('./nails.js');
 var _extend = require('util')._extend;
@@ -20,6 +21,25 @@ var _extend = require('util')._extend;
  *  @param application the nails application singleton.
  */
 class Router extends EventEmitter {
+  static get webSocketsEnabled() {
+    return this._webSocketsEnabled;
+  }
+  static set webSocketsEnabled(enabled) {
+    this._webSocketsEnabled = enabled;
+  }
+
+  static set expressWs(ews) {
+    this._expressWs = ews;
+  }
+  static get expressWs() {
+    return this._expressWs;
+  }
+
+  enableWebSockets() {
+    if (Router.webSocketsEnabled) return;
+    Router.webSocketsEnabled = true;
+    Router.expressWs = expressWs(this.application);
+  }
   constructor(routes, application) {
     super();
     this.application = application || app;
@@ -38,7 +58,12 @@ class Router extends EventEmitter {
     var consequences = route[2];
     var is_public = consequences && consequences.public;
     console.log("setting route for", method, path_matcher, consequences);
-    if (consequences && consequences.public)
+    if (method.match(/ws/i)) {
+      this.enableWebSockets();
+      this.express_router.ws(
+        path_matcher,
+        this.get_websocket_handler(consequences));
+    } else if (consequences && consequences.public)
       this.express_router.use(path_matcher,
           this.application.static(this.application.get('public_root')));
     else this.express_router[method](path_matcher,
@@ -52,6 +77,32 @@ class Router extends EventEmitter {
 // Router.prototype.delete;
 // end crud methods
 
+  // TODO: Combine this with the regular route method
+  routeWs(ws, request) {
+    console.log(
+      '\nSERVER_LOG:: WebSocket Router received request for: ',
+      request.method,
+      request.url,
+      '\n'
+    );
+    var params = _extend({}, request.params);
+    _extend(params, request.querty);
+
+    var controller = params._controller;
+    var action = params._action;
+    console.log('the action is:', controller, action, params);
+    console.log('the params are:', params);
+    console.log('ws router emitting:', 'dispatchTo:' + controller);
+    this.emit('dispatchTo:' + controller, action, params, request, null, ws);
+
+    if (!request.handled_by_controller) {
+      params.error = {message: 'controller ' + controller + ' does not exist'};
+      console.log('closing websocket');
+      return ws.close(1003, "Action Not available: #" + action);
+      //this.emit('dispatchTo:application', 404, params, request, null, ws);
+    }
+  }
+
   route(request, response) {
     // TODO: use express logging.
     console.log(
@@ -76,6 +127,26 @@ class Router extends EventEmitter {
       this.emit('dispatchTo:application', 404, params, request, response);
   }
 
+  get_websocket_handler(route_options) {
+    route_options = route_options || {};
+    return (ws, request) => {
+      console.log("handling a websocket request");
+      var controller = route_options['controller'];
+      var action = route_options['action'];
+      for (var i = 0; route_options[i]; i++) {
+        if (route_options[i] == 'action') action = action || request.params[i];
+        else if (route_options[i] == 'controller')
+          controller = controller || request.params[i];
+        else request.params[route_options[i]] = request.params[i];
+      }
+      request.params._action = action || request.params.action || "index";
+      request.params._controller =
+          controller || request.params.controller || "application";
+
+      this.routeWs(ws, request);
+    };
+  }
+
   get_express_route_handler(route_options) {
     route_options = route_options || {};
     return (request, response) => {
@@ -109,7 +180,7 @@ class Router extends EventEmitter {
       request.params._autorender = autorender ? !!autorender : true;
 
       this.route(request, response);
-    }
+    };
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nails-boilerplate",
-  "version": "0.8.2",
+  "version": "0.10.1",
   "description": "A node.js webserver scaffold",
   "main": "index.js",
   "bin": {
@@ -23,24 +23,26 @@
     "rails"
   ],
   "dependencies": {
+    "@babel/core": "*",
+    "@babel/preset-react": "*",
     "ejs": "*",
     "express": "*",
     "express-react-views": "*",
-    "@babel/core": "*",
-    "@babel/preset-react": "*",
+    "express-ws": "*",
     "mime": "*",
-    "mongodb": "*",
+    "mongodb": "^3.5.7",
+    "mongoose": "*",
     "react": "*",
-    "react-dom": "*",
-    "wrench": "*",
-    "mongoose": "*"
+    "react-dom": "^16.13.1",
+    "wrench": "*"
   },
   "devDependencies": {
-    "mocha": ">= 0.4.0",
-    "sinon": "*",
     "chai": "*",
     "chai-http": "*",
-    "mongodb-memory-server": "*"
+    "mocha": "^7.1.2",
+    "mongodb-memory-server": "*",
+    "sinon": "*",
+    "ws": "*"
   },
   "author": "Stanton W. Jones",
   "license": "MIT"

package/spec/services/integration/app/controllers/mjs_controller.mjs

@@ -0,0 +1,13 @@
+/*
+const Controller =
+    require("../../../../../index.js").Controller;
+    */
+import nails from "../../../../../index.js";
+export default class MjsController extends nails.Controller {
+  // DO NOT OVERRIDE CONSTRUCTOR
+  index(params, request, response) {
+    response.json({
+      classbased_index: true
+    });
+  }
+}

package/spec/services/integration/app/controllers/websocket_controller.js

@@ -0,0 +1,13 @@
+const Controller =
+    require("../../../../../index.js").Controller;
+module.exports = class WebsocketController extends Controller {
+  index(params, ws, request) {
+    ws.send("It worked");
+    ws.close();
+  }
+
+  voodoo(params, ws, request) {
+    ws.send("Voodoo worked");
+    ws.close();
+  }
+}

package/spec/services/integration/config/routes.js

@@ -31,7 +31,10 @@ var routes = [
   // A test route which routes the first part of pathname to controller and the second to the action
   ['get', /^\/(\w+)\/(\w+)$/i, {0: 'controller', 1: 'action'}],
   // Maps the first two parts of the path to controller and action, and the third to the id parameter
-  ['get', "/:controller/:action/:id"]
+  ['get', "/:controller/:action/:id"],
+
+  ['ws', "/", {controller: 'websocket'}],
+  ['ws', "/voodoo", {controller: 'websocket', action: 'voodoo'}]
 ];
 
 module.exports = routes;

package/spec/services.integration.spec.js

@@ -1,6 +1,8 @@
 // Import the dependencies for testing
 var chai = require('chai');
 var chaiHttp = require('chai-http');
+const WebSocket = require('ws');
+
 var nails = require('./services/integration/server.js');
 var express_app = nails.application;
 const assert = require('assert');
@@ -62,6 +64,47 @@ describe("Integration", function() {
           });
     })
   });
+
+  describe("WebSockets", function() {
+    it("should listen on /", function(done) {
+      this.timeout(2000);
+      var requester = chai.request(express_app).keepOpen();
+      var wsClient = new WebSocket("ws://localhost:3333/");
+
+      wsClient.on('close', () => done());
+      wsClient.on('message', (message) => {
+        assert(message == "It worked");
+      });
+    });
+    it("should listen on /voodoo", function(done) {
+      this.timeout(2000);
+      var requester = chai.request(express_app).keepOpen();
+      var wsClient = new WebSocket("ws://localhost:3333/voodoo");
+
+      wsClient.on('message', (message) => {
+          assert(message == "Voodoo worked");
+      });
+      wsClient.on('close', (code, reason) => done());
+    });
+    it("should not listen on /voodootwo", function(done) {
+      // TODO: this doesn't fail. Figure out why.
+      //done();
+      this.timeout(2000);
+      var requester = chai.request(express_app).keepOpen();
+      var wsClient = new WebSocket("ws://localhost:3333/voodootwo");
+
+      wsClient.on('close', (code, reason) => {
+        console.log('voodootwo closed', code, reason);
+        done();
+      });
+      debugger;
+    });
+    it("should be closed with the correct code if the action is absent");
+    it("should be closed with the correct code if the controller is absent");
+    it("should correctly parse the params");
+    it("should correctly handle dynamic controller and action");
+  });
+
   describe("GET /json/:action", function() {
     it('should render params if nothing is returned by the action',
       function(done) {chai.request(express_app)

package/templates/config/routes.js

@@ -26,6 +26,9 @@ var routes = [
 	['get', /^\/(\w+)\/(\w+)$/i, {0: 'controller', 1: 'action'}],
   // Maps the first two parts of the path to controller and action, and the third to the id parameter
   ['get', "/:controller/:action/:id"]
+
+  // Defines a WebSocket handler
+  ['ws', "/:controller/:action/:id"]
 ];
 
 module.exports = routes;

package/templates/spec/home_controller.spec.js

@@ -0,0 +1,15 @@
+var assert = require('assert');
+var sinon = require('sinon');
+var chai = require('chai');
+var chaiHttp = require('chai-http');
+var nails = require('../server.js');
+var express_app = nails.application;
+
+chai.use(chaiHttp);
+chai.should();
+
+describe("GET /", () => {
+  it('Should render the home page', done => {
+
+  });
+});