@projectinvicta/nails 2.0.15

package/spec/services.integration.spec.js

@@ -0,0 +1,296 @@
+// Import the dependencies for testing
+import * as chai from 'chai';
+import { default as chaiHttp, request } from "chai-http";
+// import chaiHttp from 'chai-http';
+import { assert } from 'chai';
+// import { WebSocket } from 'ws';
+import WebSocket from 'ws';
+// const WebSocket = require('ws');
+
+var express_app;
+// const {MongoMemoryServer} = require('mongodb-memory-server');
+let mongod = null;
+
+// Configure chai
+chai.use(chaiHttp);
+chai.should();
+
+describe("Integration: Sequelize", 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;
+  });
+  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();
+        });
+    });
+  });
+  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();
+        });
+    });
+  });
+  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('/classbased/arbi00/trary00/testLocalRoutes')
+        .end((err, res) => {
+          res.should.have.status(200);
+          assert(res.text == JSON.stringify({ testLocalRoutes: true }));
+          done();
+        });
+    });
+    it("Should not rewrite local route prefix and return the expected JSON", function (done) {
+      request.execute(express_app)
+        .get('/cl4ssb4sed/arbi/trary/testLocalRoutes')
+        .end((err, res) => {
+          res.should.have.status(200);
+          assert(res.text == JSON.stringify({ testLocalRoutes: true }));
+          done();
+        });
+    });
+    it("Should rewrite local route prefix, './' and return the expected JSON", function (done) {
+      request.execute(express_app)
+        .get('/classbased/arbi/trary/testLocalRoutes')
+        .end((err, res) => {
+          res.should.have.status(200);
+          assert(res.text == JSON.stringify({ testLocalRoutes: true }));
+          done();
+        });
+    });
+  });
+  describe("Get /defaultjson/arbi/trary", function () {
+    it("Should default to json if not present in route options", function(done) {
+      request.execute(express_app)
+        .get('/defaultjson/arbi/trary/testautojson')
+        .end((err, res) => {
+          res.should.have.status(200);
+          assert(res.text == JSON.stringify({ json_testautojson: true }));
+          done();
+        });
+    });
+    it("Should autoassign the action if not present in route options", function(done) {
+      request.execute(express_app)
+        .get('/defaultjson/arbi/trary/testautoaction')
+        .end((err, res) => {
+          res.should.have.status(200);
+          assert(res.text == JSON.stringify({ json_testautoaction: true }));
+          done();
+        });
+    });
+    it("Should not render json if route options explicitly say not to", function(done) {
+      request.execute(express_app)
+        .get('/defaultjson/arbi/trary/testjsonoverridden')
+        .end((err, res) => {
+          res.should.have.status(200);
+          assert(res.text == 'I am some arbitrary text');
+          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) {
+      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();
+        })
+    });
+    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();
+        })
+    });
+  });
+
+  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/");
+
+      wsClient.on('close', () => done());
+      wsClient.on('message', (message) => {
+        assert(message == "It worked");
+      });
+    });
+    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");
+      });
+      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 = request.execute(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) {
+        request.execute(express_app)
+          // Route to index action.
+          .get('/json/testparams?testkey=testvalue')
+          .end((err, res) => {
+            res.should.have.status(200);
+            assert(JSON.parse(res.text).testkey == "testvalue");
+            done();
+          });
+      }
+    );
+    it('should render the returned object as json', function (done) {
+      request.execute(express_app)
+        .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_testpromise: true }));
+            done();
+          });
+      }
+    );
+  });
+  describe("Get /ManualRenderAsync", function () {
+    it("./testmanualrenderasync Should not throw an exception after manually"
+      + " 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();
+          });
+      });
+
+    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 () {
+      // Used to initialize mongod here
+    });
+    afterEach(async function () {
+      //await mongod.stop();
+    });
+    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();
+            });
+        });
+    });
+
+  });
+});

package/spec/services.integration_sequelize.spec.js

@@ -0,0 +1,60 @@
+import * as chai from 'chai';
+import { default as chaiHttp, request } from "chai-http";
+// import chaiHttp from 'chai-http';
+import { assert } from 'chai';
+// import { WebSocket } from 'ws';
+import WebSocket from 'ws';
+// const WebSocket = require('ws');
+
+var express_app;
+
+// Configure chai
+chai.use(chaiHttp);
+chai.should();
+
+describe("Integration", function () {
+  before(async function () {
+    try {
+      var nails = (await import('./services/integration_sequelize/server.js')).default;
+    } catch (e) {
+      console.log("could not import server");
+      console.log(e);
+    }
+    console.log("got here");
+    express_app = nails.application;
+  });
+  describe("GET /", function () {
+    it('should return the expected JSON from index', function (done) {
+      request.execute(express_app)
+        .get('/')
+        .end((err, res) => {
+          if (err) console.error(err);
+          res.should.have.status(200);
+          assert(res.text == JSON.stringify({ home_index: true }));
+          done();
+        });
+    });
+  });
+  describe("/listowners", function() {
+    it('should return an empty array if no owners', function(done) {
+      request.execute(express_app)
+        .get('/listowners')
+        .end((err, res) => {
+          res.should.have.status(200);
+          assert(JSON.parse(res.text).length == 0);
+          done();
+        });
+    })
+  })
+  describe("/listowneddogs", function() {
+    it('should return an empty array if no owned dogs', function(done) {
+      request.execute(express_app)
+        .get('/listowneddogs')
+        .end((err, res) => {
+          res.should.have.status(200);
+          assert(JSON.parse(res.text).length == 0);
+          done();
+        });
+    })
+  })
+});

package/templates/bin/promote.sh

@@ -0,0 +1,20 @@
+version=$1
+if [ "$version" == "" ]; then
+  version="live"
+fi
+
+if [ "$version" != "live" ] &&
+    [ "$version" != "development" ] &&
+    [ "$version" != "staging_qa" ] &&
+    [ "$version" != "staging_prod" ] &&
+    [ "$version" != "production" ]; then
+  echo "$version is not a valid version"
+  exit 1
+fi
+
+# TODO: make sure we're on the master branch
+git pull origin master
+git tag -d $version
+git push origin --delete $version
+git tag $version
+git push origin $version

package/templates/bin/rollout.sh

@@ -0,0 +1,74 @@
+# make sure no one can run the script on their local machine
+stage=$1
+if [ "$stage" = "" ]; then
+  stage="live"
+fi
+
+if [ "$stage" != "live" ] &&
+    [ "$stage" != "development" ] &&
+    [ "$stage" != "staging_qa" ] &&
+    [ "$stage" != "staging_prod" ] &&
+    [ "$stage" != "production" ]; then
+  echo "$stage is not a valid release stage"
+  exit 1
+fi
+
+current_hostname=$(hostname)
+
+# TODO: find a better way to do this rather than listing them all out. Maybe some kind of dynamic list checking.
+com_suffix=".com"
+dev_suffix=".dev"
+app_suffix=".app"
+net_suffix=".net"
+org_suffix=".org"
+
+
+if [[ $current_hostname != *$com_suffix &&
+      $current_hostname != *$dev_suffix &&
+      $current_hostname != *$app_suffix &&
+      $current_hostname != *$net_suffix &&
+      $current_hostname != *$org_suffix ]]; then
+    echo "This script cannot be run on your local machine and must be run on a server"
+    exit 1
+fi
+
+echo "Running checkout_live.sh version $stage on `date`"
+
+# check if the repo is up to date by comparing hashes for the live tag
+remote_hash=$(git ls-remote --tags origin "$stage" | awk '{ print $1 }')
+local_hash=$(git rev-list -n 1 $stage)
+
+# get the latest updates from the repo if out of date
+if [ $remote_hash != $local_hash ]; then
+    date=`date`
+    echo "Checkout $NAME running at: $date"
+    echo "Checkout $NAME running at: $date" 1>&2 # write date to stderr as well
+    echo "`dirname $0`"
+    echo "`dirname $0`" 1>&2
+    git fetch --all --tags --force
+    git checkout tags/$stage
+    npm install
+else
+    echo "Repository is not out of date. Exiting..."
+    exit 0
+fi
+
+# TODO: add conditional when real test added
+
+# test
+npm test # currently an echo noop
+
+# restart parkway
+/usr/sbin/service $NAME-$stage restart
+
+changelog=`git log $local_hash..$remote_hash --oneline`
+
+# send email
+user=$(whoami)
+message="The latest $NAME changes have been deployed to $stage at $date by $user\n$changelog"
+recipient="eng@projectinvicta.com"
+subject="Automated deploy of $NAME: $stage"
+echo $message | mail -s "$subject" $recipient
+echo "Mail sent"
+
+exit 0

package/templates/bin/server.js

@@ -0,0 +1,6 @@
+import nails from 'nails-boilerplate';
+
+// See self-documented config files
+import service_config from '../config/service.js';
+
+(await nails( service_config )).startServer();

package/templates/bin/start.sh

@@ -0,0 +1,16 @@
+SCRIPT_DIR=$(dirname "$0")
+echo "Script directory (relative): $SCRIPT_DIR"
+
+COMMAND=$1
+if [[ -z "${COMMAND}" ]]; then
+  COMMAND=start
+else
+  echo "COMMAND is NOT empty."
+fi
+
+
+SCRIPT_PATH=$(readlink -f "$0")
+SCRIPT_DIR=$(dirname "$SCRIPT_PATH")
+echo "Script directory (absolute, resolved): $SCRIPT_DIR"
+
+npm --prefix=$SCRIPT_DIR/.. run $COMMAND -- $2 $3 $4 $5 $6 $7 $8 $9

package/templates/common/readme_fetcher.js

@@ -0,0 +1,4 @@
+export async function fetchReadme() {
+  return fetch('/public/README.xml')
+      .then(response => response.text());
+}

package/templates/config/db.js

@@ -0,0 +1,19 @@
+let DB_ADDRESS = process.env.NAILS_SQLITE_DB_FILE;
+if (!DB_ADDRESS) DB_ADDRESS = 'sqlite://' + import.meta.dirname + '/development.db';
+
+export default {
+  /** Mongoose Connector */
+  // connector: 'mongoose_connector.js',
+  // url: 'mongodb://localhost',
+  // port: '27017',
+
+  /** Mongoose Memory Server Connector */
+  // connector: 'mongoose_mem_connector.js',
+  // database: 'development',
+
+  /** Sequelize Connector */
+  connector: 'sequelize_connector.js',
+  address: process.env.NAILS_RELEASE_STAGE == 'test'
+    ? 'sqlite::memory:'
+    : DB_ADDRESS,
+}

package/templates/config/mimes.js

@@ -0,0 +1,59 @@
+/**
+ *  This file uses file extensions in the request to determine
+ *  the type of an asset and, therefore, where it can be found
+ *  in the file system.
+ *
+ *  Currently, the supported types are: 'js', 'css', 'html',
+ *  'img'
+ *  TODO: Add supported types pdf ( or document ), and video
+ *  TODO: move this file into nails.  Too annoying for the dev
+ *  to see and they shouldn't need to have to change it
+ */
+ /*
+    var mimes = {
+    // <ext>: '<type>'
+        js: 'js',
+        jpg: 'image',
+        css: 'css',
+        html: 'html'
+    };
+    */
+
+export default {
+    html: {
+        type: 'page',
+        contentType: 'text/html'
+    },
+    js: {
+        type: 'script', // the type of the script,
+        contentType: 'application/javascript' // Header info
+    },
+    css: {
+        type: 'style',
+        contentType: 'text/css'
+    },
+    ico: {
+        type: 'image',
+        contentType: 'image/x-icon'
+    },
+    jpg: {
+        type: 'image',
+        contentType: 'image/jpeg'
+    },
+    png: {
+        type: 'image',
+        contentType: 'image/png'
+    },
+    pdf: {
+        type: 'document',
+        contentType: 'application/pdf'
+    },
+    xml: {
+        type: 'data',
+        contentType: 'text/xml'
+    },
+    json: {
+        type: 'data',
+        contentType: 'application/json'
+    }
+}

package/templates/config/routes.js

@@ -0,0 +1,38 @@
+/**
+ *	Routes specifies the array of route definitions to be passed to the router
+ *
+ *	Routes are checked in series, and the first matching route is applied.
+ *	A route definition is as follows:
+ *		['METHOD', 'MATCHER', 'OPTIONS']
+ *
+ *		METHOD => crud methods (GET, PUT, POST, DELETE)
+ *		MATCHER  => to be matched against the path.  Captured elements will be passed to options. Delegates to express application routing.
+ *		OPTIONS => an object with parametes deciding how the route will be handled in order of execution:
+ *			path: => the path to a static file ( index.html f/e)
+ *			controller: => controller to route the request to. TODO: May implement a resource definition for automatically routing cruds
+ *			action: => the method to run in the controller. If not specified, the index method will be called.
+ *			[1..n]: => each numerical definition defines a parameter in which to store the value of the captured elements in the regex.
+ *						controller, and action are protected names and will apply the cature to controller name and method respectively.
+ *						f/e: ['get', /\/(home)/, {0: 'controller'}] => routes to home controller
+ *							 ['get, '/\/home\/(5)/, {controller: 'home', 0: 'id'}] => routes to home controller and adds {id: 5} to the params hash.
+ */
+
+export default [
+	// Routes the root request to index.html, as well as all other requests to static
+  ['get', "/", {controller: 'home'}],
+  // Routes all requests starting with /public as static requests to the public folder.
+  ['get', '/public', {public: true}],
+
+	// 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"],
+
+  // For all other GET requests, render HomeController#index
+  ['get', '/:catchall', {controller: 'home'}],
+
+  // Defines a WebSocket handler
+  // ['ws', "/:controller/:action/:id"]
+];
+

package/templates/config/service.js

@@ -0,0 +1,45 @@
+// Initializes application before server starts
+// Each of these is REQUIRED
+import routes from './routes.js';
+import mimes from './mimes.js';
+import db from './db.js';
+
+import path from 'node:path';
+var SERVER_ROOT = path.resolve(import.meta.dirname, '..');
+var APP_ROOT = path.resolve(SERVER_ROOT, 'server');
+
+// Only for reading the certificates for SSL
+import fs from 'node:fs';
+const PRIVATE_KEY_FILE = fs.readFileSync(`${import.meta.dirname}/ssl/key.pem`);
+const CERTIFICATE_FILE = fs.readFileSync(`${import.meta.dirname}/ssl/certificate.pem`);
+
+var config = {
+  APP_ROOT: APP_ROOT,
+  // root directory for delivering static assets
+  PUBLIC_ROOT: SERVER_ROOT + '/public',
+  CONTROLLERS_ROOT: APP_ROOT + '/controllers',
+  VIEWS_ROOT: APP_ROOT + '/views',
+  MODELS_ROOT: APP_ROOT + '/models',
+  SERVER_ROOT: SERVER_ROOT,
+
+  ENABLE_HTTP: true,
+  //IP: "0.0.0.0",
+  PORT: 3333,
+
+  // Uncomment these to use serverside react view engine.
+  //VIEW_ENGINE: require('express-react-views').createEngine(),
+  //VIEW_ENGINE_EXT: 'jsx',
+
+  // For HTTPS
+  ENABLE_HTTPS: true,
+  SSL_PORT: 3334,
+  PRIVATE_KEY: PRIVATE_KEY_FILE,
+  CERTIFICATE: CERTIFICATE_FILE,
+};
+
+export default {
+  config,
+  routes,
+  mimes,
+  db
+}

package/templates/config/ssl/certificate.pem

@@ -0,0 +1,22 @@
+-----BEGIN CERTIFICATE-----
+MIIDrzCCApegAwIBAgIUR04h3qlfhW5SYQrnm0VjDSLQrwUwDQYJKoZIhvcNAQEL
+BQAwZzELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQ4wDAYDVQQKDAVOYWlsczES
+MBAGA1UEAwwJbG9jYWxob3N0MScwJQYJKoZIhvcNAQkBFhhhZG1pbkBwcm9qZWN0
+aW52aWN0YS5jb20wHhcNMjMwODMwMDE1MzUzWhcNMjQwODI5MDE1MzUzWjBnMQsw
+CQYDVQQGEwJVUzELMAkGA1UECAwCQ0ExDjAMBgNVBAoMBU5haWxzMRIwEAYDVQQD
+DAlsb2NhbGhvc3QxJzAlBgkqhkiG9w0BCQEWGGFkbWluQHByb2plY3RpbnZpY3Rh
+LmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALP54rGDg1Lo7FSs
+q4xvvOeisWLJzbTZN+hsxL3ytcxvk3oidVoZDDfkDJ1QBoPFjIyHlJZCvC6mJMeY
+3Nibn1zZAtsST84DCYS8c0bQAbEUc+OwSmNpVLQElnTAKyoY/7izj579p5uR7WLD
+mSk2c4igeqjOAQn/rrC3Lr+Dr6HA3lcEQD7g87OQz7JCRY6p5E980HO81gknnxod
+veQogbreiQ+MOwC9qPOwfJjAX/qkTWc1SXIiV2SskoIANTbGujMHZZZIaY5a5oWZ
+9pAKR0basSAjECMmr1/UCKGZeot0AZRKMBSHp6mlHlE5LLFIH56PaRTguSBhsrle
+BWcuUcUCAwEAAaNTMFEwHQYDVR0OBBYEFCigQMRd+cKymXdHgew3JMEcokv0MB8G
+A1UdIwQYMBaAFCigQMRd+cKymXdHgew3JMEcokv0MA8GA1UdEwEB/wQFMAMBAf8w
+DQYJKoZIhvcNAQELBQADggEBAD5ZtQ3XLBzOiJoICcRA0evC/59gt2kKw1owOLJy
+Ji4rtoWCis8nr3R1U62KUENZ//WRy09uNPHfjsaFwuvgO+GWn53Q3breCEO1r2lH
+z5qWUAdb7WpoZWZJdj6wZoJQeKQoK8fVCVNNPNHwhZRK2P2SWhn5v/7Qco5JMP8+
+qpIbAzjKOoHiz1238JYXJ5G1tMVMfVvQpC1E+KM9p9Bohtuc51pYMssT31WPBoOv
+TBcIarZ8ri6VBAh/+aUpce0BqOEtZ1oa6Mnd2w5GeqgtV+G7ir5g0uXZjOFrh5A7
+c6J3QmpeF3kfs+Ggsxh/fRrnK1VDDtWQ/mF/3Jrq43JoP0E=
+-----END CERTIFICATE-----