nails-boilerplate 0.10.2 → 0.11.1

package/lib/mongodb_connector.js

@@ -58,7 +58,7 @@ MongoDBConnector.prototype._put_one = function(collection_name, doc) {
   // TODO: replacing document completely is sow
   // will want to only send changed attr
   // TODO: write concerns?
-  return this._db.collection(collection_name).update({_id: doc._id}, doc);
+  return this._db.collection(collection_name).replaceOne({_id: doc._id}, doc);
 }
 /**
 * _put_many will call _update on each individual object in collection

package/lib/mongoose_connector.js

@@ -1,13 +1,37 @@
 const mongoose = require('mongoose');
-const mongooseOptions = {useNewUrlParser: true};
 
-module.exports.connect = async function(options) {
-  if (options.uri) return mongoose.connect(options.uri, mongooseOptions);
+class MongooseDbConnector {
+  async connect(options) {
+    if (options.uri) {
+      this.connection = await mongoose.createConnection(options.uri/*, mongooseOptions*/).asPromise();
+      debugger;
+    } else {
+      var url = options.url || 'mongodb://127.0.0.1';
+      var port = options.port || '27017';
+      var database = options.database || options.dbName || 'nails';
+      this.connection = await mongoose.createConnection(`${url}:${port}/${database}`).asPromise();
+    }
+  }
+
+  generateModelSuperclass(name, options) {
+    let schema = options.schema instanceof mongoose.Schema
+      ? options.schema
+      : new mongoose.Schema(options.schema);
+    if (options.indexes) {
+      options.indexes.forEach(index => schema.index(index));
+    }
+    return this.connection.model(name, options.schema);
+  }
+}
+module.exports = MongooseDbConnector;
+/*
+module.exports.connect = function(options) {
+  if (options.uri) return mongoose.createConnection(options.uri, mongooseOptions);
   else {
     var url = options.url || 'mongodb://localhost';
     var port = options.port || '27017';
     var database = options.database || 'nails';
-    return mongoose.connect(`${url}:${port}/${database}`, mongooseOptions);
+    return mongoose.createConnection(`${url}:${port}/${database}`, mongooseOptions);
   }
 }
 
@@ -20,3 +44,4 @@ module.exports.generateModelSuperclass = function(name, options) {
   }
   return mongoose.model(name, options.schema);
 }
+*/

package/lib/nails.js

@@ -4,6 +4,7 @@ const URL = require('url');
 const path = require('path');
 const fs = require('fs');
 const domain = require('domain');
+const EventEmitter = require('events').EventEmitter;
 
 const Controller = require('./controller.js');
 const Model = require('./model.js');
@@ -32,6 +33,7 @@ nails.application = express_app;
 nails.Controller = Controller;
 nails.Model = ModelV2;
 nails.ModelDeprecated = Model;
+nails.events = new EventEmitter();
 
 async function configure( app_config ) {
   express_app.set('nails_config', application);
@@ -67,28 +69,36 @@ async function configure( app_config ) {
   // TODO: make this Model style mandatory
   if (DBConnector.connect && DBConnector.generateModelSuperclass) {
     await DBConnector.connect(app_config.db);
-    await ModelV2.setConnector(DBConnector);
+    ModelV2.setConnector(DBConnector);
+  } else {
+    // Try to instantiate DBConnector
+    let dbConnector = new DBConnector();
+    await dbConnector.connect(app_config.db);
+    ModelV2.setConnector(dbConnector);
   }
 
   // init Controllers
   Controller.setRouter(application.router);
   application.controller = Controller.extend(ApplicationController);
-  console.warn('initializing controllers: ', app_config.config.CONTROLLERS_ROOT);
+  console.log('initializing controllers: ', app_config.config.CONTROLLERS_ROOT);
   init_controllers(app_config.config.CONTROLLERS_ROOT);
 };
 
 function startServer(config) {
     // Log the config.
     console.log(config);
+    //await application._onceConfigured;
+    console.log("CONFIGURATION COMPLETE");
+    // TODO: Use logging middleware.
     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);
+      express_app.listen(port, ip, () => {
+        nails.events.emit("ready", null);
+      });
     });
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nails-boilerplate",
-  "version": "0.10.2",
+  "version": "0.11.1",
   "description": "A node.js webserver scaffold",
   "main": "index.js",
   "bin": {
@@ -31,7 +31,7 @@
     "express-ws": "*",
     "mime": "*",
     "mongodb": "^4.3.1",
-    "mongoose": "*",
+    "mongoose": "^6.1.8",
     "react": "*",
     "react-dom": "^16.13.1",
     "wrench": "*"
@@ -40,7 +40,7 @@
     "chai": "*",
     "chai-http": "*",
     "mocha": "^7.1.2",
-    "mongodb-memory-server": "*",
+    "mongodb-memory-server": "^8.2.0",
     "sinon": "*",
     "ws": "*"
   },

package/spec/model_v2.spec.js

@@ -1,6 +1,7 @@
 const assert = require('assert');
 const Model = require('../lib/model_v2.js');
 const MongooseConnectorUtil = require("./mongoose_connector.util.js");
+const mongoose = require('mongoose');
 
 const testSchema = {
   name: String,
@@ -14,17 +15,16 @@ describe('ModelV2', function() {
   var util;
   beforeEach(async function() {
     util = new MongooseConnectorUtil();
-    await util.getTestConnector().then(connector => {
-      Model.setConnector(connector);
-      TestModel =
-          class Test extends new Model(
-              "" + Math.random(), {schema: testSchema}) {
-                whatsMyName() {return this.name};
-              };
-    });
+    let connector = await util.getTestConnector();
+    Model.setConnector(connector);
+    TestModel =
+        class Test extends new Model(
+            "" + Math.random(), {schema: testSchema}) {
+              whatsMyName() {return this.name};
+            };
   });
-  afterEach(function(done) {
-    util.cleanup().then(() => done());
+  afterEach(async function() {
+    await util.cleanup();
   });
   describe('Mongoose Model Inheritance', function() {
     const testAttr = {
@@ -32,15 +32,13 @@ describe('ModelV2', function() {
       isTrue: false,
       index: 7
     };
-    it("should be able to create a model", function(done) {
+    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);
-      testModel.save().then(() => {
-        console.log("The ID is:", testModel._id);
-        done();
-      });
+      await testModel.save();
+      console.log("The ID is:", testModel._id);
     })
     it("should be able to update a model", function() {
       const testModel = new TestModel(testAttr);

package/spec/mongodb_connector.spec.js

@@ -44,10 +44,13 @@ describe('MongoDBConnector', function() {
   });
   describe('Document Creation', function(){
     describe('#_post_one', function() {
-      it('should set an _id attribute on the given attributes hash', function() {
+      it('should set an _id attribute on the given attributes hash', function(done) {
         var test_model = get_test_model();
-        mdbc._post_one(test_model.collection_name(), test_model.attributes);
-        assert.ok(test_model.attributes._id);
+        mdbc._post_one(test_model.collection_name(), test_model.attributes)
+          .then(() => {
+            assert.ok(test_model.attributes._id);
+            done();
+          });
       });
     });
   });

package/spec/mongodb_connector.util.js

@@ -1,22 +1,29 @@
 const MongoDBConnector = require('../lib/mongodb_connector.js');
 const {MongoMemoryServer} = require('mongodb-memory-server');
 
+let singularInstanceCreated = false;
+let promisedMongod = null;
+
 class MongoDBConnectorUtil {
   constructor() {
-    this.mongod = new MongoMemoryServer();
+    promisedMongod = MongoMemoryServer.create();
+    singularInstanceCreated = true;
   }
+
   async getTestConnector() {
-    const uri = await this.mongod.getConnectionString();
-    const port = await this.mongod.getPort();
-    const dbPath = await this.mongod.getDbPath();
-    const dbName = await this.mongod.getDbName();
+    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 MongoDBConnector(dbConfig);
   }
-  cleanup() {
-    return this.mongod.stop();
+
+  async cleanup() {
+    await this.mongod.stop();
   }
 }
 

package/spec/mongoose_connector.util.js

@@ -1,23 +1,32 @@
 const MongooseConnector = require('../lib/mongoose_connector.js');
 const {MongoMemoryServer} = require('mongodb-memory-server');
+const mongoose = require('mongoose');
+
+let promisedMongod = null;
 
 class MongooseConnectorUtil {
   constructor() {
-    this.mongod = new MongoMemoryServer();
+    this.mongoose = mongoose;
+    promisedMongod = MongoMemoryServer.create();
   }
 
   async getTestConnector() {
-    const uri = await this.mongod.getConnectionString();
-    const port = await this.mongod.getPort();
-    const dbPath = await this.mongod.getDbPath();
-    const dbName = await this.mongod.getDbName();
-    const dbConfig =
-        {uri: uri, port: port, database: dbName, dbPath: dbPath};
-    MongooseConnector.connect(dbConfig);
-    return MongooseConnector;
+    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};
+        //{uri: uri, port: port, database: dbName, dbPath: dbPath};
+    const dbConnector = new MongooseConnector();
+    this.connection = await dbConnector.connect(dbConfig);
+    debugger;
+    return dbConnector;
   }
-  cleanup() {
-    return this.mongod.stop();
+  async cleanup() {
+    //await this.mongod.stop();
+    //await this.connection.close();
+    debugger;
   }
 }
 

package/spec/router.spec.js

@@ -1,5 +1,7 @@
 var Router = require('../lib/router.js');
 var assert = require('assert');
+var express_app = require('../lib/application.js');
+express_app.set("public_root", __dirname + "/services/integration/public");
 var testRoutes = [
     ['GET', '^/$', {controller: 'testController', action: 'testAction'}],
     ['GET', /^\/public\/*/, {public: true}]

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

@@ -1,5 +1,6 @@
 module.exports = function HomeController() {
   this.index = function(params, request, response) {
+    console.log("HOME::INDEX");
     response.json({
       home_index: true
     });

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

@@ -2,9 +2,9 @@ module.exports = {
   //connector: 'sqlite3_connector.js',
   connector: 'mongoose_connector.js',
   //url: 'mongodb://localhost',
-  port: 55555,
+  port: 5555,
 
-  database: 'development',
+  dbName: 'development',
 
   // For the sqlite3 connector. Unless a filename is defined, an in-memory
   // database is used. In-memory databases are not persisted, and will be lost

package/spec/services/integration/server.js

@@ -2,5 +2,6 @@ var nails = require('../../../index.js');
 
 // See self-documented config files
 var service_config = require('./config/service.js');
+console.log("starting server")
 nails( service_config ).startServer();
 module.exports = nails; // export nails for testing

package/spec/services.integration.spec.js

@@ -3,16 +3,28 @@ 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;
+var express_app;
 const assert = require('assert');
 const {MongoMemoryServer} = require('mongodb-memory-server');
+let mongod = null;
+var service_config = require('./services/integration/config/service.js');
 
 // Configure chai
 chai.use(chaiHttp);
 chai.should();
 
 describe("Integration", function() {
+  before(function(done) {
+    MongoMemoryServer.create({instance: service_config.db}).then((mongodb) => {
+      mongod = mongodb;
+      var nails = require('./services/integration/server.js');
+      express_app = nails.application;
+      nails.events.on("ready", () => {
+        console.log("ready was emitted!");
+        done();
+      });
+    });
+  });
   describe("GET /", function() {
     it('should return the expected JSON from index', function(done) {
       chai.request(express_app)
@@ -168,13 +180,11 @@ describe("Integration", function() {
 
   });
   describe("Mongoose Model", function() {
-    let mongod = null;
     beforeEach(async function() {
-      mongod = new MongoMemoryServer({port: 55555, dbName: "development"});
-      await mongod.getConnectionString();
+      // Used to initialize mongod here
     });
     afterEach(async function() {
-      await mongod.stop();
+      //await mongod.stop();
     });
     it('should save to the correct database', async function() {
       let dogName = "Penny";
@@ -187,7 +197,7 @@ describe("Integration", function() {
             chai.request(express_app)
                 .get(`modeltest/getdogbyid?id=${dogId}`)
                 .end((err, res) => {
-                  asset.equals(
+                  assert.equals(
                     res.text, JSON.stringify({name: dogName, good: true}));
                   done();
                 });