@projectinvicta/nails 2.0.15 → 3.0.0

package/lib/firebase_connector.js

@@ -1,94 +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;
-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

@@ -1,24 +0,0 @@
-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

@@ -1,49 +0,0 @@
-// 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

@@ -1,21 +0,0 @@
-// 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

@@ -1,244 +0,0 @@
-// 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);
-    }
-};

package/lib/router.js

@@ -1,202 +0,0 @@
-// 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

@@ -1,31 +0,0 @@
-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

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