@projectinvicta/nails 2.0.15

package/lib/controller.js

@@ -0,0 +1,182 @@
+// const fs = require('fs');
+import fs from 'node:fs';
+import events from 'node:events';
+// const events = require('events');
+import application from './application.js';
+// const application = require('./application');
+
+var router;
+var controller_proto;
+var models;
+
+// TODO: refractor error generation
+var NAME_REQUIRED_ERROR = function () {
+  return new Error(
+      'FATAL ERROR::: Named function required for Controller constructor method');
+}
+
+const DISABLE_AUTORENDER = new (class DisableAutorender {});
+
+// The base controller definition
+class Controller {
+  constructor() {
+    var subclassName = this.constructor.name;
+    var controllerName = this._getControllerName();
+        // subclassName.toLowerCase().replace(/controller$/, '');
+    router.removeAllListeners('dispatchTo:' + controllerName);
+    router.on('dispatchTo:' + controllerName, this._do.bind(this));
+  }
+
+  static get DISABLE_AUTORENDER() {
+    return DISABLE_AUTORENDER;
+  }
+
+  static setRouter (router_singleton) {
+    Controller.router = router = router_singleton;
+  }
+
+  static setModels (models) {
+    Controller.prototype.models = models;
+  }
+
+  static extend (constructor) {
+    console.log('extending', constructor.name);
+    if (!constructor.name) throw NAME_REQUIRED_ERROR();
+    controller_proto = controller_proto || new Controller();
+    constructor.prototype.__proto__ = controller_proto;
+    var constructed = new constructor();
+
+    // configure event listeners on router.
+    var controller_name =
+        constructor.name.toLowerCase().replace(/controller$/, '');
+    router.removeAllListeners('dispatchTo:' + controller_name);
+    router.on('dispatchTo:' + controller_name, constructed._do.bind(constructed));
+
+    return constructed;
+  }
+
+  _getControllerName() {
+    return this.constructor.name.toLowerCase().replace(/controller$/, '');
+  }
+
+  /** Initializes local and global routes defined on the Controller subclass */
+  _registerControllerRoutes() {
+    const defaultToJson = !!this.json;
+    const controllerName = this._getControllerName();
+    if (this.routes && this.routes.length) {
+      const localizedRoutes = this.routes.map(route => {
+        // TODO: throw an error if :controller is present in local routes
+        // TODO: also account for other malformed local routes
+        const routePrefix = `/${controllerName}/`;
+        const modifiedDestination = route[1][0] == '/'
+            ? route[1]
+            : route[1].startsWith('./') ? route[1].replace('./', routePrefix) : routePrefix + route[1];
+        const modifiedOptions = {...route[2]};
+        // TODO: introduce a shorthand so action doesn't have to be redefined everywhere
+        if (!('json' in modifiedOptions)) modifiedOptions.json = defaultToJson;
+        if (!('action' in modifiedOptions)
+            && !modifiedDestination.includes(":action")
+            && !Object.values(modifiedOptions).includes('action')) {
+          const destinationParts = modifiedDestination.split("/");
+          modifiedOptions.action = destinationParts[destinationParts.length - 1];
+        }
+        modifiedOptions.controller = controllerName;
+        return [route[0], modifiedDestination, modifiedOptions];
+      });
+      router.addRoutes(localizedRoutes);
+    }
+  }
+
+  /****  Network Methods  *****/
+  /**
+   *  The main entry function of the controller.
+   *
+   *  @param {string} action      The action called for this 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, ws) {
+    request.handled_by_controller = true;
+    var doAction = this[action];
+    console.log(this.constructor.name, 'doing', action);
+    // TODO: let express handle errors
+    if (typeof doAction != 'function') {
+      //return this['404'](params, request, response);
+      var error = new Error('Action Not Available: #' + action);
+      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;
+    let actionResponse = doAction.call(this, params, request, response);
+    let controller = params._controller.toString();
+    //let viewAction = params._action ? params._action.toString() : "index";
+    let viewPath = `${controller}/${action}`;
+    function renderView(templateVars) {
+      if (response.headersSent) {
+        return;
+      }
+      if (!!params._json) {
+        response.json(templateVars == undefined ? params : templateVars);
+        return;
+      }
+      response.render(
+        viewPath,
+        templateVars == undefined ? params : templateVars,
+        function(err, html) {
+          if (err && err.message.match(/Failed to lookup view/)) {
+            response.render(viewPath + ".ejs", params);
+          } else if (err) {
+            console.error(err);
+            response.sendStatus(400, err);
+          } else {
+            response.send(html);
+          }
+        });
+    }
+    // Default to the jsx engine. If that doesn't work, try the configured view engine.
+    if (!response.headersSent
+        && !params._async
+        && actionResponse != DISABLE_AUTORENDER) {
+      if (actionResponse instanceof Promise) {
+        // TODO: add a timeout so an unresolved promise doesn't preserve the
+        // connection indefinitely.
+        actionResponse
+          .then(renderView)
+          .catch(error => {
+            // TODO: only do one of these
+            console.error(error);
+            console.log(error);
+            response.sendStatus(500, error);
+          });
+      } else renderView(actionResponse);
+    }
+  }
+}
+
+const error_codes = [404, 500];
+error_codes.forEach((ec) => {
+  Controller.prototype[ec] = function (params, request, response) {
+    //this._render('404');
+    console.error(ec.toString() + ' error with params', params);
+    var error = params['error'] || {};
+    var message = error.message || 'Error';
+    var stack_trace = error.stack || error || '';
+    response.setHeader('content-type', 'text/plain');
+    response.statusCode = ec;
+    response.end(message + '\n\n' + stack_trace);
+  };
+  Controller.prototype[ec.toString()] = Controller.prototype[ec];
+
+});
+
+export default Controller;

package/lib/database_connector.js

@@ -0,0 +1,12 @@
+export default class DbConnector {
+  async connect() {
+    throw 'DbConnector#connect not implemented'
+  }
+  generateModelSuperclass() {
+    throw 'GenerateModelSuperclass not implemented'
+  }
+  
+  async afterInitialization() {
+    console.warn("DbConnector#afterInitialization not implemented");
+  }
+}

package/lib/firebase_connector.js

@@ -0,0 +1,94 @@
+// 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;
+import { MongoClient } from 'mongodb';
+// const MongoClient = require('mongodb').MongoClient;
+// const test = require('assert');
+import test from 'assert';
+
+module.exports = 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';
+    this.exec_once_connected = [];
+    MongoClient.connect(url + ':' + port)
+        .then((err, client) => {
+          this._client = client;
+          this._db = client.db(database);
+        }).catch({
+          // TODO: handle a failed mongodb connection
+        });
+}
+
+/**
+ * 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) 
+        this._post_one(model_or_collection._collection_name(), 
+            model_or_collection.attributes);
+}
+MongoDBConnector.prototype._post_one = function(collection_name, doc_attributes, callback) {
+    this._db.collection(collection_name).insert(doc_attributes);
+}
+MongoDBConnector.prototype._post_many = function(collection) {
+    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)
+        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?
+    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
+ */
+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)
+        this._get_one(model_or_collection._collection_name(), model_or_collection.id, null,
+                this._on_doc_response.bind(model_or_collection));
+}
+MongoDBConnector.prototype._get_one = function(collection_name, id, options, callback) {
+    options = options || {};
+    this._db.collection(collection_name).findOne(id, options, callback);
+}
+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(err, doc) {
+    if (err) return console.log('error retrieving from', collection_name, '\n', err);
+    delete doc._id;
+    this._merge_attributes(doc);
+}

package/lib/model_v2.js

@@ -0,0 +1,24 @@
+let dbConnector = null;
+
+const FINALIZATIONS = [];
+
+export default class Model {
+  static finalize(extraWork) {
+    FINALIZATIONS.push(extraWork);
+  }
+
+  static async _doFinalize() {
+    await Promise.all(FINALIZATIONS.map(extraWork => extraWork()));
+  }
+
+  static setConnector(connector) {
+    // TODO: enforce environment using variables
+    if (dbConnector)
+      console.warn("WARNING: Model#setConnector should not be called multiple times outside of tests");
+    dbConnector = connector;
+  }
+
+  constructor(modelName, connectorOptions) {
+    return dbConnector.generateModelSuperclass(modelName, connectorOptions);
+  }
+}

package/lib/mongoose_connector.js

@@ -0,0 +1,49 @@
+// const mongoose = require('mongoose');
+import mongoose from 'mongoose';
+import DbConnector from './database_connector.js';
+
+class MongooseDbConnector extends DbConnector{
+  async connect(options) {
+    if (options.uri) {
+      this.connection = await mongoose.createConnection(options.uri/*, mongooseOptions*/).asPromise();
+    } 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) {
+    if (!this.connection) console.error("NO CONNECTION\n", this);
+    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);
+  }
+}
+export default 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.createConnection(`${url}:${port}/${database}`, mongooseOptions);
+  }
+}
+
+module.exports.generateModelSuperclass = function(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 mongoose.model(name, options.schema);
+}
+*/

package/lib/mongoose_mem_connector.js

@@ -0,0 +1,21 @@
+// const mongoose = require('mongoose');
+// const {MongoMemoryServer} = require('mongodb-memory-server');
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import MongooseDbConnector from './mongoose_connector.js';
+// const MongooseDbConnector = require('./mongoose_connector');
+
+export default class MongooseMemoryConnector extends MongooseDbConnector {
+
+  async connect() {
+    try {
+      const mongod = await MongoMemoryServer.create();
+      const uri = mongod.getUri();
+      console.error("The URI", uri);
+      const dbConfig = {uri: uri};
+      return super.connect(dbConfig);
+    } catch (e) {
+      console.error("Could not connect to MongoMemoryServer");
+      console.error(e);
+    }
+  }
+}

package/lib/nails.js

@@ -0,0 +1,244 @@
+// The file which configures the nails application
+// import http from 'node:http';
+import https from 'node:https';
+// import URL from 'node:url';
+import path from 'node:path';
+import fs from 'node:fs';
+import { EventEmitter } from 'node:events';
+
+import Controller from './controller.js';
+import ModelV2 from './model_v2.js';
+import Router from './router.js';
+
+import express_app from './application.js';
+import { Model } from 'mongoose';
+
+// TODO: add key value pairs to express app singleton.
+var application = {};
+application.config = {};
+
+// TODO: this should return a function (the configure function).
+// Calling the function should return { startServer: startServer }.
+// export defulat nails;
+
+export default async function nails(app_config) {
+  nails.config = app_config.config;
+  application._onceConfigured = configure(app_config);
+  await application._onceConfigured;
+  return {startServer: startServer};
+}
+
+nails.application = express_app;
+nails.Controller = Controller;
+nails.Model = ModelV2;
+nails.events = new EventEmitter();
+nails._dbConnector = null;
+nails.MODELS = {init: initializeModels};
+
+async function configure( app_config ) {
+  express_app.set('nails_config', application);
+  application.config = app_config.config;
+  // TODO: may not need mimes any more.
+  application.mimes = app_config.mimes;
+
+  // Init view engine. Defaults to ejs.
+  express_app.set('view engine', 'ejs');
+  if (app_config.config.VIEW_ENGINE) {
+    if (typeof app_config.config.VIEW_ENGINE == "string") {
+      console.log("using consolidate for some reason");
+    }
+    express_app.engine(
+        app_config.config.VIEW_ENGINE_EXT,
+        app_config.config.VIEW_ENGINE);
+    express_app.set('view engine', app_config.config.VIEW_ENGINE_EXT);
+  }
+  express_app.set('views', app_config.config.VIEWS_ROOT);
+
+  // set up router and controllers
+  express_app.set("public_root", app_config.config.PUBLIC_ROOT);
+  console.log("Initializing Router...");
+  // application.router = new Router( app_config.routes || [] );
+  application.router = new Router( [] );
+  console.log("Application Router initialized");
+
+  // init models
+  await initializeModels(app_config);
+
+  // init Controllers
+  Controller.setRouter(application.router);
+  application.controller = Controller.extend(ApplicationController);
+  console.log('initializing controllers: ', app_config.config.CONTROLLERS_ROOT);
+  await init_controllers(app_config.config.CONTROLLERS_ROOT);
+  application.router.addRoutes(app_config.routes);
+};
+
+export async function initializeModels( app_config ) {
+  // init models
+  console.log("Initializing DB connection...");
+  var DBConnector = await get_dbconnector(app_config.db.connector);
+
+  console.log("Instantiating DBConnector and Connecting to DB...");
+  // Try to instantiate DBConnector
+  const dbConnector = new DBConnector();
+  nails._dbConnector = dbConnector;
+  await dbConnector.connect(app_config.db);
+  console.log("Generating model superclass...");
+  ModelV2.setConnector(dbConnector);
+  await init_models_v2(app_config.config.MODELS_ROOT);
+  console.log("Done importing models");
+  await dbConnector.afterInitialization();
+  await ModelV2._doFinalize();
+  console.log("DB Connection complete");
+}
+
+function startServer(config) {
+    // Log the config.
+    console.log(config);
+    // await application._onceConfigured;
+    console.log("CONFIGURATION COMPLETE");
+    // TODO: Use logging middleware.
+    application._onceConfigured.then(() => {
+      // Use the router middleware.
+      express_app.use(application.router.express_router);
+      var ip = application.config.IP || 'localhost';
+      var port = application.config.PORT || 3000;
+
+      let startHttp = 'ENABLE_HTTP' in application.config && !!application.config.ENABLE_HTTP;
+      let startHttps = !!application.config.ENABLE_HTTPS;
+
+      if (!startHttp && !startHttps) {
+        console.error("Either ENABLE_HTTPS or ENABLE_HTTP must be set for nails to start");
+      }
+
+      let atLeastOneServerStarted = false;
+      let serverStartedCallback = () => {
+        console.log("Started");
+        if (atLeastOneServerStarted) return;
+        nails.events.emit("ready", null);
+        atLeastOneServerStarted = true;
+      }
+      
+      if (startHttp) {
+          console.log("starting nails HTTP server. listening to ", ip + ':' + port);
+          express_app.listen(port, ip, serverStartedCallback);
+
+      }
+      if (startHttps) {
+        console.log(`starting nails HTTPS server. Listening to ${ip}:${application.config.SSL_PORT}`);
+        https.createServer({
+            key: application.config.PRIVATE_KEY,
+            cert: application.config.CERTIFICATE
+        }, express_app).listen(application.config.SSL_PORT, serverStartedCallback);
+      }
+    });
+}
+
+// TODO: create an initializer lib file.
+async function init_controllers(controller_lib) {
+  await init_app_lib(Controller, controller_lib);
+}
+
+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 = (await import(abs_path)).default;
+      // Constructor function was provided
+      if (!superclass.isPrototypeOf(subclass))
+          return superclass.extend(subclass);
+      // ES6 Class was provided
+      const subInstance = new subclass();
+      if (superclass == Controller) {
+        subInstance._registerControllerRoutes();
+      }
+      return subInstance;
+    }
+    for (const rel_path of fs.readdirSync(abs_path)) {
+      await init_app_lib(superclass, path.join(abs_path, rel_path));
+    }
+}
+
+async function init_models_v2(abs_path) {
+  if (!fs.existsSync(abs_path))
+    return console.log('Cannot initialize. Path not found.', abs_path);
+  if (fs.statSync(abs_path).isFile()) {
+    console.log('attempting to import:', abs_path);
+    // We just need to import each model once so the generateSuperclass
+    // method is called at least once for each model.
+    const modelModule = await import(abs_path);
+    let modelClass = modelModule.default;
+    if (modelClass && modelClass.name) {
+      console.log('imported model:', modelClass.name);
+      nails.MODELS[modelClass.name] = modelClass;
+      if (modelModule.defer) {
+        await modelModule.defer();
+      }
+    }
+    else console.warn("No model found at:", abs_path);
+    return;
+  }
+  const directory_contents = fs.readdirSync(abs_path);
+  for (const rel_path of directory_contents) {
+      await init_models_v2(path.join(abs_path, rel_path));
+  };
+}
+
+// retrieves the connector object. If cannot
+// require the module with the same name,
+// try grabbing connector from lib
+// (default connectors)
+async function get_dbconnector(connector_name) {
+  console.log("Getting DBConnector:", connector_name);
+    var DBConnector;
+    //TODO: put mongodbconnector in its own module
+    try {
+        DBConnector = (await import(connector_name)).default;
+    } catch(e) {
+        DBConnector = (await import('./'+connector_name)).default;
+    }
+    console.log("Got DBConnector:", DBConnector.name);
+    return DBConnector;
+}
+
+// Define default views and controllers
+// TODO: clean this up... all this logic shouldnt be here
+function ApplicationController(){};
+
+/**
+ * Application Views
+ */
+function JSONView(){};
+// TODO: add error template for error view
+function ErrorView() {}
+ErrorView.prototype.render = function(params, response) {
+    response.statusCode = params.code || 500;
+    // TODO: change this to use the error jade template
+    response.setHeader('content-type', 'text/plain');
+    var content = params.error ?
+        params.error.message + '\n' + params.error.stack :
+        params.message;
+    response.end(content);
+}
+// TODO: consider changing public to static...
+function PublicView(){};
+PublicView.prototype.get_full_path = function(filepath) {
+    var pubroot = application.config.PUBLIC_ROOT;
+    var partial_path = filepath;
+    if (filepath.substr(0, pubroot.length) != pubroot)
+        partial_path = path.join(pubroot, filepath);
+    return path.join(application.config.SERVER_ROOT, partial_path);
+};
+PublicView.prototype.render = function(params, response) {
+    var file_path = this.get_full_path(params.path);
+
+    var content = '';
+    try {
+        content = fs.readFileSync(file_path);
+    } catch(e) {
+        console.log(e.message, "\n",  e.stack);
+        response.statusCode = 404;
+    } finally {
+        response.end(content);
+    }
+};