nails-boilerplate 1.3.1 → 2.0.1

package/lib/nails.js

@@ -15,14 +15,10 @@ import { EventEmitter } from 'node:events';
 
 
 import Controller from './controller.js';
-import Model from './model.js';
 import ModelV2 from './model_v2.js';
 import Router from './router.js';
 
 import express_app from './application.js';
-import DbConnector from './database_connector.js';
-
-const models = {};
 
 // TODO: add key value pairs to express app singleton.
 var application = {};
@@ -42,7 +38,6 @@ export default async function nails(app_config) {
 nails.application = express_app;
 nails.Controller = Controller;
 nails.Model = ModelV2;
-nails.ModelDeprecated = Model;
 nails.events = new EventEmitter();
 
 async function configure( app_config ) {
@@ -75,26 +70,14 @@ async function configure( app_config ) {
   console.log("Initializing DB connection...");
   var DBConnector = await get_dbconnector(app_config.db.connector);
 
-  // TODO: deprecate the old Model style
-  if (app_config.config.MODELS_ROOT) {
-    Model.set_connector(DBConnector, app_config.db);
-    await init_models(app_config.config.MODELS_ROOT);
-  }
-  // TODO: make this Model style mandatory
-  console.log("Connecting to DB...");
-  if (DBConnector instanceof DbConnector) {
-    console.log("Generating model superclass...");
-    await DBConnector.connect(app_config.db);
-    ModelV2.setConnector(DBConnector);
-    await init_models_v2(app_config.config.MODELS_ROOT);
-    DBConnector.afterInitialization();
-  } else {
-    console.log("Instantiating DBConnector...");
-    // Try to instantiate DBConnector
-    let dbConnector = new DBConnector();
-    await dbConnector.connect(app_config.db);
-    ModelV2.setConnector(dbConnector);
-  }
+  console.log("Instantiating DBConnector and Connecting to DB...");
+  // Try to instantiate DBConnector
+  let dbConnector = new DBConnector();
+  await dbConnector.connect(app_config.db);
+  console.log("Generating model superclass...");
+  ModelV2.setConnector(dbConnector);
+  await init_models_v2(app_config.config.MODELS_ROOT);
+  await dbConnector.afterInitialization();
   console.log("DB Connection complete");
 
   // init Controllers
@@ -151,9 +134,9 @@ function startServer(config) {
 async function init_controllers(controller_lib) {
   await init_app_lib(Controller, controller_lib);
 }
-async function init_models(model_lib) {
-  await 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);
     if (!fs.existsSync(abs_path))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nails-boilerplate",
-  "version": "1.3.1",
+  "version": "2.0.1",
   "description": "A node.js webserver scaffold",
   "type": "module",
   "main": "index.js",

package/spec/mongodb_connector.util.js

@@ -1,4 +1,4 @@
-import MongoDBConnector from '../lib/mongodb_connector.js';
+import MongooseConnector from '../lib/mongoose_connector.js';
 import {MongoMemoryServer} from 'mongodb-memory-server';
 
 let singularInstanceCreated = false;
@@ -19,7 +19,7 @@ class MongoDBConnectorUtil {
     const dbConfig =
         {uri: uri, port: port, database: dbName, dbPath: dbPath};
     //console.log(JSON.stringify(dbConfig));
-    return new MongoDBConnector(dbConfig);
+    return new MongooseConnector(dbConfig);
   }
 
   async cleanup() {

package/lib/model.js

@@ -1,167 +0,0 @@
-// This is the base definition for a model / collection
-// ideally used as a wrapper for database integration
-// should use promise objects to allow for method chaining
-// eventful.  emits ready event passing itself
-// start with mongodb
-import util from 'util';
-import controller_base from './controller.js';
-// var controller_base = require('./controller.js');
-// var util = require('util');
-
-/** TODO: what persistence methods does a model need?
- *  save/post => saves record to db
- *  fetch/get => updates model from database
- *  patch/put(?) => only changes specific methods and saves to database...
- *  destroy/delete => remove model from db
- *
- ** On Constructor:
- *
- *  get => get a single model by id
- *  find => get a collection of models by parameters
- */
-/** TODO: define a collection
- *
- *  will likely want to put collection constructor as attribute on Model
- *  f/e Model.Collection
- *
- ** Persistence methods:
- *
- *  save/post => save collection in database by batch command
- *      will want to minimize number of db requests, but can probably
- *      start with saving each individually for now
- *  fetch/get => updates collection from database
- *      a collection should have a saved query attribute which
- *      was used to get the collection.  Will make updating easy.
- */
-
-// init references to model base objects for use by controllers
-// and models
-controller_base.prototype.models = {};
-Model.prototype.models = {};
-
-var model_prot = Model.prototype;
-var db;
-
-var NAME_REQUIRED_ERROR = function() {
-    return new Error(
-        'FATAL ERROR::: Named function required for Model constructor method'
-    );
-}
-
-export default function Model(){
-};
-
-Model.extend = function(constructor) {
-    //console.log('extending', constructor.name);
-    if ( !constructor.name ) throw NAME_REQUIRED_ERROR();
-    //model_proto = model_proto || new Model();
-    constructor.prototype.__proto__ = model_prot;
-
-    // TODO: bind collection-specific methods to the constructor
-    //Model.set_db_access_methods(contructor);
-
-    // make models available to controller and other models
-    Model.prototype.models[constructor.name] = constructor;
-    controller_base.prototype.models[constructor.name] = constructor;
-
-};
-Model.set_connector = function(DBConnector, config) {
-  if (!config) {
-    this.prototype.connector = DBConnector;
-  } else {
-    this.prototype.connector = new DBConnector(config);
-  }
-};
-Model.set_db_access_methods = function(constructor) {
-    constructor.find = Model.find;
-};
-Model.find = function() {
-    var args = Array.prototype.slice.call(arguments, 0);
-    return this.connector.find.apply(connector, args);
-};
-
-Object.defineProperty(Model.prototype, 'id', {
-    get: function() {
-        return this.attributes[this.id_attribute];
-    },
-    set: function(new_val) {
-        this.set(this.id_attribute, new_val);
-        return new_val;
-    }
-});
-Object.defineProperty(Model.prototype, 'attributes', {
-    get: function() {
-        if (!this._attributes) this._attributes = {};
-        return this._attributes;
-    },
-    set: function(new_val) {
-        if (typeof new_val != 'object' && util.isArray(new_val))
-            throw 'Model#attributes cannot be set to non-object or array value';
-        this._extend_deeply(this.attributes, new_val, true);
-        return this.attributes;
-    }
-});
-Model.prototype.id_attribute = '_id';
-Model.prototype.is_model = true;
-/**
- * returns the name of the collection or table in the db.
- * override this by setting collection attribute on the model.
- */
-Model.prototype._collection_name = function() {
-    return this.collection || this.constructor.name;
-};
-/**
- * pointer to the database connector
- */
-Model.prototype.connector = {};
-
-Model.prototype.save = function() {
-    // this should create the model if it does not exist
-    // (uses an id to check existence)
-    // or it should update the model
-    if (this.id) return this.connector.put(this);
-    return this.connector.post(this);
-};
-Model.prototype.fetch = function() {
-    if (!this.id) throw 'cannot fetch model with id: ' + this.id.toString();
-    return this.connector.get(this);
-    // TODO: give model backbone-like sync event
-};
-/*
-Model.prototype.patch = function() {
-    // should try to update the model's changed attributes if no
-    // arguments given. Otherwise should attempt to set attributes
-    // on model and then update
-    Model.connector.update(this);
-};
-*/
-Model.prototype.destroy = function() {
-    // should delete the model from the database if it has been
-    // persisted
-    if (this.id) return false;
-    this.connector.delete(this);
-};
-Model.prototype.set = function(attr, val) {
-    this.attributes[attr] = val;
-};
-/**
- * merge a hash of attributes into the current set
- */
-Model.prototype._merge_attributes = function(attr) {
-    this._extend_deeply(this.attributes, attr);
-};
-Model.prototype._extend_deeply = function(obj0, obj1, should_prune) {
-    if (typeof obj0 != 'object' || typeof obj1 != 'object' ||
-            util.isArray(obj0) || util.isArray(obj1))
-        throw 'Attempting to extend a non-object entity';
-    for(var key in obj1) {
-        if (typeof obj0[key] == 'object' && typeof obj1[key] == 'object' && !util.isArray(obj0[key]))
-            this._extend_deeply(obj0[key], obj1[key], should_prune);
-        else obj0[key] = obj1[key];
-    }
-    if (!should_prune) return;
-    for (key in obj0) {
-        if (key in obj1) continue;
-        delete obj0[key];
-    }
-};

package/lib/mongodb_connector.js

@@ -1,100 +0,0 @@
-// TODO: multiple async requests here... need to
-// consider how this will be used by the models
-import {EventEmitter} from 'node:events';
-// var EventEmitter = require('events').EventEmitter;
-// const MongoClient = require('mongodb').MongoClient;
-import { MongoClient } from 'mongodb';
-
-export default MongoDBConnector;
-
-// TODO: need to deal with clustered databases...
-
-MongoDBConnector.prototype.__proto__ = EventEmitter.prototype;
-function MongoDBConnector(config) {
-  EventEmitter.call(this);
-  var url = config.url || 'mongodb://localhost';
-  var port = config.port || '27017';
-  var database = config.database || 'nails';
-  var uri =
-      config.uri ? config.uri : `${url}:${port}/${database}`;
-  this.exec_once_connected = [];
-  var that = this;
-  MongoClient.connect(uri)
-      .then(client => {
-        this._client = client;
-        this._db = client.db(database);
-        this.emit("connected");
-      }).catch(error => {
-        // TODO: better handling of the failed connection
-        console.error(error);
-        throw error;
-      });
-}
-
-/**
-* Need to implement these methods for a connector to work
-*/
-// maybe use rest methods as names for any database connector used...
-MongoDBConnector.prototype.post = function(model_or_collection) {
-  if (model_or_collection.is_model)
-      return this._post_one(model_or_collection._collection_name(),
-          model_or_collection.attributes);
-}
-MongoDBConnector.prototype._post_one = function(collection_name, doc_attributes, callback) {
-  return this._db.collection(collection_name).insert(doc_attributes);
-}
-MongoDBConnector.prototype._post_many = function(collection) {
-  return this._db.collection(collection.name())
-      .save(collection.model_attributes());
-}
-
-// update a record in the collection
-MongoDBConnector.prototype.put = function(model_or_collection) {
-  if (model_or_collection.is_model)
-      return this._put_one(
-        model_or_collection._collection_name(),
-        model_or_collection.attributes);
-}
-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).replaceOne({_id: doc._id}, doc);
-}
-/**
-* _put_many will call _update on each individual object in collection
-* if that object has changed
-*/
-MongoDBConnector.prototype._put_many = function(collection) {
-}
-
-// return a single record from a collection
-// or a collection of records if requested...
-// if a model or collection is passed,
-MongoDBConnector.prototype.get = function(model_or_collection) {
-  if (model_or_collection.is_model)
-      return this._get_one(model_or_collection._collection_name(), model_or_collection.id, null)
-          .then(doc => this._on_doc_response(model_or_collection, doc));
-}
-MongoDBConnector.prototype._get_one = function(collection_name, id, options) {
-  options = options || {};
-  return this._db.collection(collection_name).findOne(id, options);
-}
-MongoDBConnector.prototype._get_many = function(collection) {
-  return this._db.collection(collection.name()).find({
-      _id: collection.collect('_id')});
-}
-
-// delete a record from a collection
-MongoDBConnector.prototype.delete = function(model) {
-  return this._db.collection(model.collection_name())
-      .remove(model.attributes._id);
-}
-// MongoDBConnector.prototype._delete_one
-// MongoDBConnector.prototype._delete_many
-
-MongoDBConnector.prototype._on_doc_response = function(model_or_collection, doc) {
-  // move this to the promise catch block: if (err) return console.log('error retrieving from', collection_name, '\n', err);
-  delete doc._id;
-  model_or_collection._merge_attributes(doc);
-}

package/lib/sqlite3_connector.js

@@ -1,88 +0,0 @@
-// TODO: multiple async requests here... need to
-// consider how this will be used by the models
-import { EventEmitter } from 'events';
-import DBClient from 'node:sqlite';
-// var EventEmitter = require('events').EventEmitter;
-// const DBClient = require('sqlite3');
-import test from 'node:assert';
-// const test = require('assert');
-
-module.exports = SQLite3Connector;
-
-// TODO: need to deal with clustered databases...
-
-SQLite3Connector.prototype.__proto__ = EventEmitter.prototype;
-function SQLite3Connector(config) {
-  EventEmitter.call(this);
-  var url = config.url || 'mongodb://localhost';
-  var port = config.port || '27017';
-  var database = config.database || 'nails';
-  this.exec_once_connected = [];
-  this._db = new DBClient.Database(config.filename);
-}
-
-/**
- * Need to implement these methods for a connector to work
- */
-// maybe use rest methods as names for any database connector used...
-SQLite3Connector.prototype.post = function(model_or_collection) {
-    if (model_or_collection.is_model) 
-        this._post_one(model_or_collection._collection_name(), 
-            model_or_collection.attributes);
-}
-SQLite3Connector.prototype._post_one = function(collection_name, doc_attributes, callback) {
-    this._db.collection(collection_name).insert(doc_attributes);
-}
-SQLite3Connector.prototype._post_many = function(collection) {
-    this._db.collection(collection.name())
-        .save(collection.model_attributes());
-}
-
-// update a record in the collection
-SQLite3Connector.prototype.put = function(model_or_collection) {
-    if (model_or_collection.is_model)
-        this._put_one(model_or_collection._collection_name(), model_or_collection.attributes);
-}
-SQLite3Connector.prototype._put_one = function(collection_name, doc) {
-    // TODO: replacing document completely is sow
-    // will want to only send changed attr
-    // TODO: write concerns?
-    this._db.collection(collection_name).update({_id: doc._id}, doc);
-}
-/**
- * _put_many will call _update on each individual object in collection
- * if that object has changed
- */
-SQLite3Connector.prototype._put_many = function(collection) {
-}
-
-// return a single record from a collection
-// or a collection of records if requested...
-// if a model or collection is passed, 
-SQLite3Connector.prototype.get = function(model_or_collection) {
-    if (model_or_collection.is_model)
-        this._get_one(model_or_collection._collection_name(), model_or_collection.id, null,
-                this._on_doc_response.bind(model_or_collection));
-}
-SQLite3Connector.prototype._get_one = function(collection_name, id, options, callback) {
-    options = options || {};
-    this._db.collection(collection_name).findOne(id, options, callback);
-}
-SQLite3Connector.prototype._get_many = function(collection) {
-    return this._db.collection(collection.name()).find({
-        _id: collection.collect('_id')});
-}
-
-// delete a record from a collection
-SQLite3Connector.prototype.delete = function(model) {
-    return this._db.collection(model.collection_name())
-        .remove(model.attributes._id);
-}
-// SQLite3Connector.prototype._delete_one
-// SQLite3Connector.prototype._delete_many
-
-SQLite3Connector.prototype._on_doc_response = function(err, doc) {
-    if (err) return console.log('error retrieving from', collection_name, '\n', err);
-    delete doc._id;
-    this._merge_attributes(doc);
-}

package/spec/model.spec.js

@@ -1,95 +0,0 @@
-import assert from 'assert';
-import Model from '../lib/model.js';
-import MongoDBConnectorUtil from './mongodb_connector.util.js';
-
-var test_model = new Model();
-var model_prot = Model.prototype;
-describe('Model', function() {
-  var util;
-  beforeEach(function(done) {
-    util = new MongoDBConnectorUtil();
-    util.getTestConnector().then(connector => {
-      Model.set_connector(connector);
-      connector.on("connected", done);
-    });
-  });
-  afterEach(function(done) {
-    util.cleanup().then(() => done());
-  });
-  describe('#_merge_attributes', function() {
-  });
-  describe('#_extend_deeply', function() {
-    var attr0;
-    var attr1;
-    beforeEach(function() {
-      attr0 = {a:7, b:'test', c:null, o: {}};
-      attr1 = {a:8, c:'test0', o: {a:0}};
-    });
-    it('should rewrite non object attributes', function() {
-      model_prot._extend_deeply(attr0, attr1);
-      // these should change
-      assert(attr0.a == attr1.a);
-      assert(attr0.c == attr1.c);
-      // these should not
-      assert(attr0.b == attr0.b);
-      assert(attr0.o == attr0.o);
-    });
-    it('should merge two attributes if they are both non-array objects',
-      function() {
-        model_prot._extend_deeply(attr0, attr1);
-        assert(attr0.o.a == attr1.o.a);
-      });
-    it('should delete attributes not present in obj1 if prune is true',
-      function() {
-        model_prot._extend_deeply(attr0, attr1, true);
-        assert(!('b' in attr0));
-      });
-    it('should not delete attributes absent present in obj1 if prune is falsey', function() {
-      model_prot._extend_deeply(attr0, attr1);
-      assert(attr0.o.a == attr1.o.a);
-    });
-  });
-  describe('#save', function() {
-    it('should save a new model to the database and update id',
-      async function() {
-        var model0 = new Model();
-        var model_name = 'testname0';
-        model0.attributes = {
-          name: model_name
-        };
-        await model0.save();
-        assert.ok(model0.attributes._id);
-        assert.ok(model_name == model0.attributes.name);
-      });
-    it('should save changes to an existing model to the database',
-      async function() {
-        var model0 = new Model();
-        model0.attributes = {
-          name: 'testname1'
-        };
-        await model0.save();
-        model0.set('x', 5);
-        await model0.save();
-        var model1 = new Model();
-        model1.id = model0.id;
-        await model1.fetch();
-        assert.ok(model1.attributes.x == 5);
-      });
-  });
-  describe('#fetch', function() {
-    it('should retrieve attributes for this model id from the database',
-      async function() {
-        var model0 = new Model();
-        model0.set('x', 7);
-        await model0.save();
-        var model1 = new Model();
-        model1.id = model0.id;
-        await model1.fetch();
-        assert.ok(model1.attributes.x == 7);
-      });
-  });
-  describe('#attributes', function() {
-    it('should be a plain object');
-    it('should not change by reference if set to a different attributes hash');
-  });
-});

package/spec/mongodb_connector.spec.js

@@ -1,66 +0,0 @@
-import assert from 'assert';
-import MongoDBConnectorUtil from './mongodb_connector.util.js';
-
-describe('MongoDBConnector', function() {
-  var util;
-  var mdbc;
-  beforeEach(function(done) {
-    util = new MongoDBConnectorUtil();
-    util.getTestConnector().then(connector => {
-      mdbc = connector;
-      connector.on("connected", done);
-    });
-  });
-  afterEach(function(done) {
-    util.cleanup().then(() => done());
-  });
-  it('should create a new connection to mongodb', function(done) {
-    assert.notEqual(mdbc._db, null);
-    done();
-  });
-  describe('#put', function() {
-    it('should be ok, updating the record in the database');
-  });
-  describe('Document retrieval', function() {
-    describe('#get', function() {
-      it('should return a single document when model is passed');
-      it('should return an array of docments when collection is passed');
-    });
-    describe('#_get_one', function() {
-      it('should return a single document with the matching _id', async function() {
-        var test_model = get_test_model('custom0');
-        var test_attr = test_model.attributes;
-        await mdbc._post_one(test_model.collection_name(), test_attr);
-        let doc = await mdbc._get_one(test_model.collection_name(),
-        test_model.attributes._id, null);
-        assert.ok(doc.custom_attr == test_attr.custom_attr);
-        assert.ok(doc._id.equals(test_attr._id));
-        return null;
-      });
-    });
-    describe('#_get_many', function() {
-      it('should return all documents matching the collection._query field');
-    });
-  });
-  describe('Document Creation', function(){
-    describe('#_post_one', 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)
-          .then(() => {
-            assert.ok(test_model.attributes._id);
-            done();
-          });
-      });
-    });
-  });
-});
-function get_test_model(custom_attr) {
-  return {
-    collection_name: function() {return 'test_model'},
-    attributes: {
-      x: 'x',
-      custom_attr: custom_attr
-    }
-  }
-}