@projectinvicta/nails 2.0.15

package/lib/router.js

@@ -0,0 +1,202 @@
+// The Router object which handles incoming urls and executes the correct
+// server-side logic based on the matching route in the Routing Table
+// ( See example/config/routes.js or config/routes.js for a description of the routes )
+
+import {EventEmitter} from 'node:events';
+// var EventEmitter = require('events').EventEmitter;
+import URL from 'node:url';
+// var URL = require('url');
+
+import path from 'node:path';
+import querystring from 'node:querystring';
+import express from 'express';
+import expressWs from 'express-ws';
+import app from './application.js'
+// TODO use modular js only
+import {_extend} from 'util';
+
+// 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;
+
+/**
+ *  Creates a Router from an Array of route definitions
+ *  may want to change this to singleton... just to continue paradigm
+ *  emits: "contoller_name:action" on successful route
+ *  controllers and the viewer listen to this object for instructions on doing shit
+ *
+ *  @param routes the array of route definitions from the application config.
+ *  @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);
+    expressWs(this.express_router);
+    // console.log("WS is still:", this.express_router.ws);
+  }
+  constructor(routes) {
+    super();
+    this.application = app;
+    // this.express_router = express.Router();
+    // console.log("the router is:", this.express_router);
+    // console.log("the ws is:", this.express_router.ws);
+    this.express_router = app.Router();
+    this.addRoutes(routes);
+  }
+
+  addRoutes(routes) {
+    this.routes = routes;
+    routes.forEach(this.addRoute.bind(this));
+  }
+
+  addRoute(route) {
+    var method = route[0].toLowerCase();
+    var path_matcher = route[1];
+    var consequences = route[2];
+    console.log("setting route for", method, path_matcher, consequences);
+    if (method.match(/ws/i)) { // For some reason this hangs
+      this.enableWebSockets();
+      this.express_router.ws(
+        path_matcher,
+        this.get_websocket_handler(consequences));
+    } else if (consequences && consequences.public) // Is a request for public asset
+      this.express_router.use(path_matcher,
+          this.application.static(this.application.get('public_root')));
+    else this.express_router[method](path_matcher,
+        this.get_express_route_handler(consequences));
+  }
+
+// TODO: override these for shortcutting crud methods
+// Router.prototype.get;
+// Router.prototype.put;
+// Router.prototype.post;
+// 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(
+        '\nSERVER_LOG:: Router recieved request for: ',
+        request.method, request.url, '\n');
+
+    var params = _extend({}, request.params);
+    _extend(params, request.query);
+
+    var controller = params._controller;
+    //var action = routeParams.action || routeParams.file || routeParams.path;
+    //var params = routeParams.params || {};
+    var action = params._action;
+    console.log('the action is:', controller, action, params);
+    console.log('the params are:', params);
+
+    console.log('router emitting:', 'dispatchTo:' + controller);
+    this.emit('dispatchTo:' + controller, action, params, request, response);
+    // TODO: raise 404 error using express
+    params.error = {message: 'controller ' + controller + ' does not exist'};
+    if (!request.handled_by_controller)
+      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) => {
+      // See if controller and action are set explicitly.
+      var controller = route_options['controller'];
+      var action = route_options['action'];
+      // TODO: see if there is a way to use mimie types for this.
+      var json = !!route_options['json'];
+      var path = route_options['path']; // TODO: what to do with this under express.
+      var async = route_options['async'];
+      var autorender = route_options['disable_autorender'];
+
+      // Check for controller and action from regex assignments.
+      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 if (route_options[i] == 'json')
+          json = json || request.params[i];
+        else request.params[route_options[i]] = request.params[i];
+      }
+
+      // Check for controller and action in parameters.
+      request.params._action = action || request.params.action || "index";
+      request.params._controller =
+          controller || request.params.controller || "application";
+      request.params._json = json || !!request.params.json;
+      request.params._async = async == null || async == undefined ?
+          !!this.application.get('nails_config').config.ASYNC : async;
+      // autorender should default to true if it is not defined
+      request.params._autorender = autorender ? !!autorender : true;
+
+      this.route(request, response);
+    };
+  }
+}
+
+export default Router;

package/lib/sequelize_connector.js

@@ -0,0 +1,31 @@
+import DbConnector from './database_connector.js';
+import { Sequelize, Model } from 'sequelize';
+
+export default class SequelizeConnector extends DbConnector {
+  sequelize;
+
+  async connect(options) {
+    this.sequelize = new Sequelize(options.address);
+    try {
+      await this.sequelize.authenticate();
+      console.log('Connection has been established successfully.');
+    } catch (error) {
+      console.error('Unable to connect to the database:', error);
+    }
+  }
+
+  /**
+   * @returns {Model}
+   */
+  generateModelSuperclass(name, options) {
+    if (options.schema) {
+      return this.sequelize.define(name, options.schema, options.options);
+    }
+    return this.sequelize.define(name, options);
+  }
+
+  async afterInitialization() {
+    console.log("SEQUELIZE::Writing changes to SQL Database");
+    await this.sequelize.sync({alter: {drop: false}});
+  }
+}

package/lib/server.js

@@ -0,0 +1 @@
+// TODO refractor the server to this module

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@projectinvicta/nails",
+  "version": "2.0.15",
+  "description": "A node.js webserver scaffold",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "nails-boilerplate": "bin/lib/nails.js"
+  },
+  "scripts": {
+    "copyreadme": "node bin/convertreadmetohtml.js",
+    "test": "mocha --exit spec",
+    "debug": "mocha --exit debug spec"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/stantonwjones/nails-boilerplate.git"
+  },
+  "keywords": [
+    "nails",
+    "framework",
+    "server",
+    "mvc",
+    "express",
+    "rails"
+  ],
+  "dependencies": {
+    "@babel/core": "*",
+    "@babel/preset-react": "*",
+    "body-parser": "^2.2.0",
+    "cookie-parser": "^1.4.7",
+    "ejs": "*",
+    "express": "*",
+    "express-ws": "*",
+    "fs-extra": "^11.3.2",
+    "mime": "*",
+    "mongodb": "^4.17.2",
+    "mongodb-memory-server": "^8.16.0",
+    "mongoose": "^6.13.0",
+    "react": "*",
+    "react-dom": "^16.13.1",
+    "sequelize": "^6.37.7",
+    "showdown": "^2.1.0",
+    "sqlite3": "^5.1.7",
+    "ws": "*"
+  },
+  "devDependencies": {
+    "chai": "*",
+    "chai-http": "*",
+    "mocha": "^10.2.0",
+    "sinon": "*"
+  },
+  "config": {
+    "mongodbMemoryServer": {
+      "version": "latest"
+    }
+  },
+  "author": "Stanton W. Jones",
+  "license": "MIT"
+}

package/scripts/install.js

@@ -0,0 +1,57 @@
+/**
+    NOT USING THIS RIGHT NOW
+    save as preinstall script for cross patform compatibility in the future
+**/
+// The install script to add executables
+var execute = require('child_process').exec;
+var fs = require('fs');
+var os = process.platform;
+
+// Compile nails.c
+// get the directories
+var sourceloc = __dirname + "/../bin/lib/nails.c";
+var destloc = __dirname + "/../bin/nails";
+
+if ( os.match(/win32/i) ) {
+    // use a compiler for windows
+} else {
+    // use the GNU compiler g++
+    execute("g++ " + sourceloc + " -o " + destloc, handleCompile);    
+}
+
+function handleCompile( error, stdout, stderr ) {
+    if (error) {
+        console.log("Error compiling nails.c");
+        console.log(error);
+        process.exit(1);
+    }
+    console.log("Successfully compiled Nails binary");
+    process.exit(0);
+}
+
+/* This is now being handled by npm
+execute('npm bin -g', createSymlinks);
+
+function createSymlinks(error, stdout, stderr){
+    var symloc = stdout.replace(/\s/g, '');
+
+    if ( os.match(/win32/i) ) {
+        var command = 'mklink ' + symloc + '\\nails.bat ' +
+            __dirname +"\\..\\bin\\nails.bat";
+        console.log(command);
+        execute(command, handleSymlink);
+    } else {
+        execute('ln -s ' + __dirname +"/../bin/nails.sh" +
+            symloc + '/nails', handleSymlink);
+    }
+
+}
+
+function handleSymlink(error, stdout, stderr) {
+    if (error) {
+        console.log('error adding symbolic link');
+        console.log(error);
+    }
+    else console.log('successfully add symbolic link');
+}
+*/

package/scripts/uninstall.js

@@ -0,0 +1,23 @@
+// The uninstall script for removing executables// The install script to add executables
+var execute = require('child_process').exec;
+var os = process.platform;
+
+execute('npm bin -g', deleteSymlinks);
+
+function deleteSymlinks(error, stdout, stderr){
+    var symloc = stdout.replace(/\s/g, '');
+
+    if ( os.match(/win32/i) ) {
+        command = 'del ' + symloc + '\\nails.bat';
+        console.log(command);
+        execute(command, handleDeletion);
+    } else {
+        execute('rm ' + symloc + '/nails', handleDeletion);
+    }
+
+}
+
+function handleDeletion(error, stdout, stderr) {
+    if (error) console.log('error removing symbolic link');
+    else console.log('successfully removed symbolic link');
+}

package/spec/controller.spec.js

@@ -0,0 +1,105 @@
+import Controller from '../lib/controller.js';
+import assert from 'assert';
+import sinon from 'sinon';
+import {EventEmitter} from 'node:events';
+
+function TestController() {
+    this.testAction = function () {};
+};
+
+class TestEs6Controller extends Controller {
+  testEs6Action() {
+
+  }
+
+}
+
+describe('Controller', function() {
+  describe('Controller.setRouter', function() {
+    it('should set Controller.router to the router', function() {
+      var router = {};
+      Controller.setRouter(router);
+      assert(Controller.router === router);
+    });
+  });
+  describe('Controller.constructor', function() {
+    it('should set the appropriate listener on the router',
+        function() {
+      let mockRouter = new EventEmitter();
+      let mockParams = {_controller: "test"};
+      let mockRequest = {};
+      let mockResponse = {headersSent: true};
+      Controller.setRouter(mockRouter);
+      let testController = new TestEs6Controller();
+      sinon.spy(testController, "testEs6Action");
+
+      mockRouter.emit(
+        'dispatchTo:testes6', 'testEs6Action', mockParams, mockRequest, mockResponse);
+
+      assert(testController.testEs6Action.calledWith(
+          mockParams, mockRequest, mockResponse));
+    });
+  });
+  describe('Controller.extend', function() {
+    it('should error if an anonymous function is passed', function() {
+      try {
+        let testController = Controller.extend(function(){});
+        assert(false); // Fail if we get here.
+      } catch(e) {
+      }
+    });
+
+    it('should set the appropriate listener on the router',
+        function() {
+      let mockRouter = new EventEmitter();
+      let mockParams = {_controller: "test"};
+      let mockRequest = {};
+      let mockResponse = {headersSent: true};
+      Controller.setRouter(mockRouter);
+      let testController = Controller.extend(TestController);
+      sinon.spy(testController, "testAction");
+
+      mockRouter.emit(
+        'dispatchTo:test', 'testAction', mockParams, mockRequest, mockResponse);
+
+      assert(testController.testAction.calledWith(
+          mockParams, mockRequest, mockResponse));
+    });
+    it('should set itself as the prototype of the passed constructor method',
+      function() {
+        let mockRouter = new EventEmitter();
+        Controller.setRouter(mockRouter);
+        let testController = Controller.extend(TestController);
+        assert(testController instanceof Controller);
+      }
+    );
+    it('should return an initialized instance of the constructor', function() {
+      let mockRouter = new EventEmitter();
+      Controller.setRouter(mockRouter);
+      let testController = Controller.extend(TestController);
+      assert(testController instanceof TestController);
+    });
+    it('should raise an error if no router has been set', function() {
+      try {
+        let testController = Controller.extend(TestController);
+        assert(false); // Fail if we get here.
+      } catch (expectedError) {
+      }
+    });
+  });
+  describe('#_do', function() {
+    it('should call the function on the controller matching the given action');
+    it('should call 404 if the action does not exist on the controller instance');
+    it('should call 500 if the action throws an error');
+    it('should attempt to render a view');
+    it('should not render a view if data has already been sent to the client');
+    it('should not render a view if _async is true');
+    it('should not render a view if async is true on the action');
+  });
+  describe('#404', function() {
+  });
+  describe('#500', function() {
+  });
+  describe('#public', function() {
+  });
+});

package/spec/model_v2.spec.js

@@ -0,0 +1,75 @@
+import assert from 'assert';
+import Model from '../lib/model_v2.js';
+import MongooseConnectorUtil from './mongoose_connector.util.js';
+
+const testSchema = {
+  name: String,
+  isTrue: Boolean,
+  index: Number
+}
+let TestModel = null;
+
+
+describe('ModelV2', function() {
+  var util;
+  beforeEach(async function() {
+    util = new MongooseConnectorUtil();
+    let connector = await util.getTestConnector();
+    Model.setConnector(connector);
+    TestModel =
+        class Test extends new Model(
+            "" + Math.random(), {schema: testSchema}) {
+              whatsMyName() {return this.name};
+            };
+  });
+  afterEach(async function() {
+    await util.cleanup();
+  });
+  describe('Mongoose Model Inheritance', function() {
+    const testAttr = {
+      name: "testname",
+      isTrue: false,
+      index: 7
+    };
+    it("should be able to create a model", async function() {
+      const testModel = new TestModel(testAttr);
+      assert(testModel.name == testAttr.name);
+      assert(testModel.isTrue == testAttr.isTrue);
+      assert(testModel.index == testAttr.index);
+      await testModel.save();
+      console.log("The ID is:", testModel._id);
+    })
+    it("should be able to update a model", function() {
+      const testModel = new TestModel(testAttr);
+      const newName = "newName";
+      return testModel.save().then(savedModel => {
+        savedModel.name = newName;
+        return savedModel.save();
+      }).then(secondSavedModel => {
+        assert(secondSavedModel.name == newName);
+        assert(secondSavedModel._id == testModel._id);
+      });
+    });
+    it("should be able to delete a model", async function() {
+      const testModel = new TestModel(testAttr);
+      await testModel.save();
+      await TestModel.deleteOne({_id: testModel._id});
+      assert.equal(await TestModel.findById(testModel._id), null);
+    })
+    it("should be able to find a model by id", async function() {
+      const testModel = new TestModel(testAttr);
+      await testModel.save();
+      const foundModel = await TestModel.findById(testModel._id);
+      assert(testModel._id.toString() == foundModel._id.toString());
+      assert.equal(testModel.name, foundModel.name);
+      assert.equal(testModel.isTrue, foundModel.isTrue);
+      assert.equal(testModel.index, foundModel.index);
+    });
+    it("should preserve instance methods", async function() {
+      const testModel = new TestModel(testAttr);
+      await testModel.save();
+      const foundModel = await TestModel.findById(testModel._id);
+      assert.equal(foundModel.whatsMyName(), testModel.name);
+    });
+  });
+})

package/spec/mongodb_connector.util.js

@@ -0,0 +1,30 @@
+import MongooseConnector from '../lib/mongoose_connector.js';
+import {MongoMemoryServer} from 'mongodb-memory-server';
+
+let singularInstanceCreated = false;
+let promisedMongod = null;
+
+class MongoDBConnectorUtil {
+  constructor() {
+    promisedMongod = MongoMemoryServer.create();
+    singularInstanceCreated = true;
+  }
+
+  async getTestConnector() {
+    this.mongod = await promisedMongod;
+    const uri = this.mongod.getUri();
+    const port = this.mongod.instanceInfo.port;
+    const dbPath = this.mongod.instanceInfo.dbPath;
+    const dbName = this.mongod.instanceInfo.dbName;
+    const dbConfig =
+        {uri: uri, port: port, database: dbName, dbPath: dbPath};
+    //console.log(JSON.stringify(dbConfig));
+    return new MongooseConnector(dbConfig);
+  }
+
+  async cleanup() {
+    await this.mongod.stop();
+  }
+}
+
+export default MongoDBConnectorUtil;

package/spec/mongoose_connector.util.js

@@ -0,0 +1,20 @@
+import MongooseMemoryConnector from '../lib/mongoose_mem_connector.js';
+import mongoose from 'mongoose';
+
+class MongooseConnectorUtil {
+  constructor() {
+    this.mongoose = mongoose;
+  }
+
+  async getTestConnector() {
+    const dbConnector = new MongooseMemoryConnector();
+    this.connection = await dbConnector.connect();
+    debugger;
+    return dbConnector;
+  }
+  async cleanup() {
+    debugger;
+  }
+}
+
+export default MongooseConnectorUtil;