@projectinvicta/nails 2.0.15 → 3.0.0

package/lib/Nails.ts

@@ -0,0 +1,210 @@
+
+import fs from 'node:fs';
+import path from 'node:path';
+import https, {type Server as HttpsServer} from 'node:https';
+import {type Server as HttpServer} from 'node:http';
+
+import { type Application } from 'express-ws';
+import { type InitOptions, Model, Sequelize, type ModelAttributes, type ModelStatic } from 'sequelize';
+import expressApp from './application.ts';
+import Router from './Router.ts';
+
+import { type Config } from './config.ts';
+import Controller from './Controller.ts';
+
+export default class Nails {
+  static Controller = Controller;
+  private static instance: Nails;
+
+  static get sequelize() {
+    return this.instance.sequelize;
+  }
+
+  static get initialized() {
+    return this.instance.initialized;
+  }
+
+  static get config() {
+    return this.instance.config;
+  }
+
+  static get application() {
+    return this.instance.application;
+  }
+
+  static get httpServer() {
+    return this.instance.httpServer;
+  }
+
+  static get httpsServer() {
+    return this.instance.httpsServer;
+  }
+
+  // static initModel<T extends Model>(modelClass: ModelStatic<T>, attributes: ModelAttributes, options?: InitOptions) {
+  //   const actualOptions = {...options, sequelize: this.sequelize}
+  //   modelClass.init(attributes, actualOptions);
+  // }
+
+  declare ready: Promise<boolean>;
+  declare config: Config;
+  declare application: Application;
+  declare Controller: typeof Controller;
+  declare sequelize: Sequelize;
+  declare initialized: Promise<void>;
+  declare router: Router;
+  declare Model: Model;
+  declare httpServer: HttpServer;
+  declare httpsServer: HttpsServer;
+
+  private modelFinalizations: (() => Promise<void>)[] = [];
+  private modelMigrations: (() => Promise<void>)[] = [];
+
+  constructor(appConfig: Config) {
+    Nails.instance = this;
+    this.config = appConfig;
+    this.application = expressApp;
+    this.Controller = Controller;
+    this.sequelize = this.config.db.options
+      ? new Sequelize(
+        this.config.db.address,
+        this.config.db.options)
+      : new Sequelize(this.config.db.address);
+    this.router = new Router([]);
+    this.initialized = this.configure();
+  }
+
+  async configure() {
+    expressApp.set('nails_config', { config: this.config });
+    expressApp.set('view engine', 'ejs');
+    expressApp.set('views', this.config.service.VIEWS_ROOT);
+    expressApp.set("public_root", this.config.service.PUBLIC_ROOT);
+    console.log("Initializing Router...");
+    // this.router = new Router( app_config.routes || [] );
+    console.log("Application Router initialized");
+    // init models
+    try {
+      await this.sequelize.authenticate();
+      console.log('Connection has been established successfully.');
+    } catch (error) {
+      console.error('Unable to connect to the database:', error);
+    }
+    await this.initializeModels();
+
+    Controller.setRouter(this.router);
+    await this.initializeControllers();
+    this.router.addRoutes(this.config.routes);
+  }
+
+  async initializeModels() {
+    await this.loadModels(this.config.service.MODELS_ROOT);
+    await this.sequelize.sync();
+  }
+
+  async startServer() {
+    await this.initialized;
+    console.log("CONFIGURATION COMPLETE");
+    // TODO: Use logging middleware.
+    // Use the router middleware.
+    expressApp.use(this.router.expressRouter);
+    var host = this.config.service.HOST || 'localhost';
+    var port = this.config.service.PORT || 3000;
+
+    let startHttp = 'ENABLE_HTTP' in this.config.service && !!this.config.service.ENABLE_HTTP;
+    let startHttps = !!this.config.service.ENABLE_HTTPS;
+
+    if (!startHttp && !startHttps) {
+      console.error("Either ENABLE_HTTPS or ENABLE_HTTP must be set for nails to start");
+    }
+
+    let atLeastOneServerStarted = false;
+    return new Promise<void>((resolve, reject) => {
+      if (atLeastOneServerStarted) return resolve();
+      let serverStartedCallback = () => {
+        console.log("Started");
+        atLeastOneServerStarted = true;
+        resolve();
+      }
+
+      if (startHttp) {
+        console.log("starting nails HTTP server. listening to ", host + ':' + port);
+        if (this.httpServer) {
+          console.warn("Attempted to recreate http server");
+        } else {
+          this.httpServer = expressApp.listen(port, host, serverStartedCallback);
+          console.log("Done starting HTTP server");
+        }
+      }
+      if (startHttps) {
+        if (this.httpsServer) {
+          console.warn("Attempted to recreate HTTPS server");
+        } else {
+          console.log(`starting nails HTTPS server. Listening to ${host}:${this.config.service.SSL_PORT}`);
+          this.httpsServer = https.createServer({
+            key: this.config.service.PRIVATE_KEY,
+            cert: this.config.service.CERTIFICATE
+          }, expressApp).listen(this.config.service.SSL_PORT, serverStartedCallback);
+        }
+      }
+      // TODO: Set a startup timeout and reject the promise so it does not hang forever;
+    });
+  }
+
+  async loadModels(absolutePath: string) {
+    if (!fs.existsSync(absolutePath))
+      return console.log('Cannot initialize. Path not found.', absolutePath);
+    if (!fs.statSync(absolutePath).isFile()) {
+      const directory_contents = fs.readdirSync(absolutePath);
+      for (const rel_path of directory_contents) {
+        await this.loadModels(path.join(absolutePath, rel_path));
+      };
+      return;
+    }
+    console.log('attempting to import Model:', absolutePath);
+    // We just need to import each model once so the generateSuperclass
+    // method is called at least once for each model.
+    const modelModule = await import(absolutePath);
+    // TODO: make sure the name isn't constantly "model"
+    const modelClass = modelModule.default;
+    if (!(modelClass.prototype instanceof Model)) {
+      const errorMessage = `Default export is not a sequelize Model: ${absolutePath}`;
+      console.error(errorMessage);
+      throw errorMessage;
+    }
+    const schema = modelModule.schema;
+    const options = modelModule.options;
+    const defer = modelModule.defer as (() => Promise<void>) | undefined;
+    this.modelFinalizations.push(modelModule.finalize as () => Promise<void>);
+    this.modelMigrations.push(modelModule.migrate as () => Promise<void>);
+
+    modelClass.init(schema, { sequelize: this.sequelize, ...options });
+    if (modelClass && modelClass.name) {
+      console.log('imported model:', modelClass.name);
+      if (defer) {
+        await defer();
+      }
+      await modelClass.sync();
+    }
+    else console.warn("No model found at:", absolutePath);
+  }
+
+  private async initializeControllers(directory?: string) {
+    if (!directory) directory = this.config.service.CONTROLLERS_ROOT;
+    console.log('attempting to import:', directory);
+    if (!fs.existsSync(directory))
+      return console.error('Cannot initialize. Path not found.', directory);
+    if (fs.statSync(directory).isFile()) {
+      let subclass = (await import(directory)).default;
+      if (!(Controller.isPrototypeOf(subclass)))
+        return console.error(`Non-Controller export "${subclass.name}: ${typeof subclass}" found: ${directory}`);
+      const controller = new subclass();
+      controller._registerControllerRoutes();
+      return controller;
+    }
+    for (const rel_path of fs.readdirSync(directory)) {
+      await this.initializeControllers(path.join(directory, rel_path));
+    }
+  }
+
+}
+
+// const sequelize = new Sequelize();

package/lib/Router.ts

@@ -0,0 +1,180 @@
+import { EventEmitter } from 'node:events';
+import {type WebSocket} from "ws";
+import express, {type NextFunction, type Request, type Response} from 'express';
+import expressWs, {type Router as WsRouter, type Application as WsApplication, type WebsocketRequestHandler} from 'express-ws';
+import app, {expressRouter, ExpressRouter, expressStatic} from './application.ts';
+import { type RouteDefinition, type RouteOptions } from './config.ts';
+
+interface ExpressWsType {
+    app: any;
+    getWss: () => any;
+    applyTo: (router: any) => void;
+}
+
+class NailsRouter extends EventEmitter {
+  private static _webSocketsEnabled: boolean = true;
+  private static _expressWs: ExpressWsType;
+
+  static get webSocketsEnabled(): boolean {
+    return this._webSocketsEnabled;
+  }
+
+  static set webSocketsEnabled(enabled: boolean) {
+    this._webSocketsEnabled = enabled;
+  }
+
+  static set expressWs(ews: ExpressWsType) {
+    this._expressWs = ews;
+  }
+
+  static get expressWs(): ExpressWsType {
+    return this._expressWs;
+  }
+
+  private application: WsApplication = app; // TODO: Type this more specifically if application.js is also converted to TS
+  public expressRouter: WsRouter = expressRouter; // express-ws adds a ws method
+  public routes: any[]; // TODO: Type this more specifically
+
+  constructor(routes: RouteDefinition[]) { // TODO: Type routes more specifically
+    super();
+    this.addRoutes(routes);
+  }
+
+  addRoutes(routes: RouteDefinition[]): void { // TODO: Type routes more specifically
+    this.routes = routes;
+    routes.forEach(this.addRoute.bind(this));
+  }
+
+  addRoute(route: RouteDefinition): void { // TODO: Type route more specifically
+    const method = route[0].toLowerCase();
+    const path_matcher = route[1];
+    const consequences = route[2];
+
+    console.log("setting route for", method, path_matcher, consequences);
+
+    if (method.match(/ws/i)) {
+      this.expressRouter.ws(
+        path_matcher,
+        this.get_websocket_handler(consequences)
+      );
+    } else if (consequences && consequences.public) {
+      this.expressRouter.use(
+        path_matcher,
+        expressStatic(this.application.get('public_root'))
+      );
+    } else {
+      this.expressRouter[method](
+        path_matcher,
+        this.get_express_route_handler(consequences)
+      );
+    }
+  }
+
+  routeWs(ws: WebSocket, request: Request): void { // TODO: Define a proper WebSocket type
+    console.log(
+      '\nSERVER_LOG:: WebSocket Router received request for: ',
+      request.method,
+      request.url,
+      '\n'
+    );
+
+    const params: any = {...request.params, ...request.query};
+
+    const controller: string = params._controller;
+    const action: string = 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 as any).handled_by_controller) {
+      params.error = { message: 'controller ' + controller + ' does not exist' };
+      console.log('closing websocket');
+      return ws.close(1003, "Action Not available: #" + action);
+    }
+  }
+
+  route(request: Request, response: Response, next: NextFunction): void {
+    console.log(
+      '\nSERVER_LOG:: Router recieved request for: ',
+      request.method,
+      request.url,
+      '\n'
+    );
+
+    const params: any = { ...request.params, ...request.query};
+
+    const controller: string = params._controller;
+    const action: string = 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, next});
+
+    params.error = { message: 'controller ' + controller + ' does not exist' };
+    if (!(request as any).handled_by_controller) {
+      this.emit('dispatchTo:application', {action: 404, params, request, response});
+    }
+  }
+
+  get_websocket_handler(routeOptions: RouteOptions | undefined): WebsocketRequestHandler {
+    const route_options = routeOptions || {};
+    return (ws: WebSocket, request: express.Request) => { // TODO: Define a proper WebSocket type
+      console.log("handling a websocket request");
+      let controller = route_options.controller;
+      let action = route_options.action;
+
+      for (let i = 0; route_options[i]; i++) {
+        if (route_options[i] === 'action') {
+          action = action || (request.params as any)[i];
+        } else if (route_options[i] === 'controller') {
+          controller = controller || (request.params as any)[i];
+        } else {
+          (request.params as any)[route_options[i]] = (request.params as any)[i];
+        }
+      }
+      (request.params as any)._action = action || (request.params as any).action || "index";
+      (request.params as any)._controller =
+        controller || (request.params as any).controller || "application";
+
+      this.routeWs(ws, request);
+    };
+  }
+
+  get_express_route_handler(route_options: RouteOptions | undefined) {
+    route_options = route_options || {};
+    return async (request: Request, response: Response, next: NextFunction) => {
+      let controller: string | undefined = route_options['controller'];
+      let action = route_options['action'];
+      let json: boolean = !!route_options['json'];
+      let path: string | undefined = route_options['path'];
+      let async: boolean | undefined = route_options['async'];
+      let autorender: boolean | undefined = route_options['disable_autorender'];
+
+      for (let i = 0; route_options[i]; i++) {
+        if (route_options[i] === 'action') {
+          action = action || (request.params as any)[i];
+        } else if (route_options[i] === 'controller') {
+          controller = controller || (request.params as any)[i];
+        } else if (route_options[i] === 'json') {
+          json = json || (request.params as any)[i];
+        } else {
+          (request.params as any)[route_options[i]] = (request.params as any)[i];
+        }
+      }
+
+      (request.params as any)._action = action || (request.params as any).action || "index";
+      (request.params as any)._controller =
+        controller || (request.params as any).controller || "application";
+      (request.params as any)._json = json || !!(request.params as any).json;
+      (request.params as any)._async = async == null || async == undefined ?
+        !!this.application.get('nails_config').config.ASYNC : async;
+      (request.params as any)._autorender = autorender ? !!autorender : true;
+
+      this.route(request, response, next);
+    };
+  }
+}
+
+export default NailsRouter;

package/lib/{application.js → application.ts}

@@ -9,7 +9,7 @@ import cookieParser from 'cookie-parser';
  * Singleton express application.
  */
 // var express = require('express');
-var app = express();
+const {app, applyTo} = expressWs(express());
 app.use(cookieParser());
 // TODO: this has to be done before routes in order to work. Can consider allowing the config to turn this off
 // expressWs(app);
@@ -18,7 +18,12 @@ app.use(urlencoded({ limit: '2mb', extended: false }));
 // Parse application/json
 app.use(json({limit: '2mb'}));
 
-app.Router = express.Router;
-app.static = express.static;
+export const ExpressRouter = express.Router;
+export const expressRouter = express.Router();
+applyTo(expressRouter);
+export const expressStatic = express.static;
+
+// export ExpressRouter;
+// export expressStatic;
 
 export default app;

package/lib/config.ts

@@ -0,0 +1,74 @@
+import {type Options } from "sequelize";
+import { type NextFunction, type Request, type Response } from "express";
+
+export interface ControllerDoRouteParams {
+  action: string,
+  params: Record<string, any>,
+  request: Request,
+  response: Response,
+  ws?: WebSocket,
+  next: NextFunction,
+}
+
+interface ActionParams<T> {
+  params: T;
+  request: Request;
+  response: Response;
+}
+
+export interface RouteOptions {
+  controller?: string;
+  action?: string | (<T>(actionParams: ActionParams<T>) => any);
+  public?: boolean;
+  json?: boolean;
+  path?: string;
+  async?: boolean;
+  disable_autorender?: boolean;
+  [key: number]: string; // For dynamic route parameters
+}
+
+type RouteMatcher = string;
+
+type HttpMethod = 'get' | 'post' | 'put' | 'delete' | 'ws';
+
+export type RouteDefinition = [HttpMethod, RouteMatcher, RouteOptions?];
+
+export interface RoutesConfig extends Array<RouteDefinition> {}
+
+interface MimesConfig {
+  [key: string]: any;
+}
+
+export interface DbConfig {
+  address: string;
+  username?: string;
+  password?: string;
+  options?: Options;
+}
+
+interface AppConfig {
+  APP_ROOT: string;
+  PUBLIC_ROOT: string;
+  CONTROLLERS_ROOT: string;
+  VIEWS_ROOT: string;
+  MODELS_ROOT: string;
+  SERVER_ROOT: string;
+  ENABLE_HTTP: boolean;
+  HOST: string;
+  PORT: number;
+  ENABLE_HTTPS: boolean;
+  SSL_PORT: number;
+  PRIVATE_KEY: Buffer;
+  CERTIFICATE: Buffer;
+  // Optional properties from the original config, if they were uncommented
+  // VIEW_ENGINE?: (path: string, options: object, callback: (err: any, html?: string) => void) => void;
+  // VIEW_ENGINE_EXT?: string;
+  // IP?: string;
+}
+
+export interface Config {
+  service: AppConfig;
+  routes: RoutesConfig;
+  mimes: MimesConfig;
+  db: DbConfig;
+}

package/package.json

@@ -1,20 +1,24 @@
 {
   "name": "@projectinvicta/nails",
-  "version": "2.0.15",
+  "version": "3.0.0",
   "description": "A node.js webserver scaffold",
   "type": "module",
-  "main": "index.js",
+  "main": "index.ts",
+  "engines": {
+    "node": ">=24.0.0"
+  },
   "bin": {
-    "nails-boilerplate": "bin/lib/nails.js"
+    "nails": "bin/lib/nails.js"
   },
   "scripts": {
     "copyreadme": "node bin/convertreadmetohtml.js",
     "test": "mocha --exit spec",
-    "debug": "mocha --exit debug spec"
+    "debug": "mocha --exit debug spec",
+    "test_init": "bash bin/test/test_init.sh"
   },
   "repository": {
     "type": "git",
-    "url": "git+ssh://git@github.com/stantonwjones/nails-boilerplate.git"
+    "url": "git+ssh://git@github.com/projectinvicta/nails.git"
   },
   "keywords": [
     "nails",
@@ -25,8 +29,6 @@
     "rails"
   ],
   "dependencies": {
-    "@babel/core": "*",
-    "@babel/preset-react": "*",
     "body-parser": "^2.2.0",
     "cookie-parser": "^1.4.7",
     "ejs": "*",
@@ -34,17 +36,18 @@
     "express-ws": "*",
     "fs-extra": "^11.3.2",
     "mime": "*",
-    "mongodb": "^4.17.2",
-    "mongodb-memory-server": "^8.16.0",
-    "mongoose": "^6.13.0",
     "react": "*",
     "react-dom": "^16.13.1",
     "sequelize": "^6.37.7",
     "showdown": "^2.1.0",
-    "sqlite3": "^5.1.7",
+    "sqlite3": "^5.0.2",
     "ws": "*"
   },
   "devDependencies": {
+    "@types/cookie-parser": "*",
+    "@types/express": "*",
+    "@types/express-ws": "*",
+    "@types/node": "*",
     "chai": "*",
     "chai-http": "*",
     "mocha": "^10.2.0",

package/spec/controller.spec.js

@@ -1,10 +1,10 @@
-import Controller from '../lib/controller.js';
+import Controller from '../lib/Controller.ts';
 import assert from 'assert';
 import sinon from 'sinon';
 import {EventEmitter} from 'node:events';
 
-function TestController() {
-    this.testAction = function () {};
+class TestController extends Controller {
+    testAction() {};
 };
 
 class TestEs6Controller extends Controller {
@@ -34,59 +34,13 @@ describe('Controller', function() {
       sinon.spy(testController, "testEs6Action");
 
       mockRouter.emit(
-        'dispatchTo:testes6', 'testEs6Action', mockParams, mockRequest, mockResponse);
+        'dispatchTo:testes6',
+        {action: 'testEs6Action', params: mockParams, request: mockRequest, response: mockResponse});
 
       assert(testController.testEs6Action.calledWith(
           mockParams, mockRequest, mockResponse));
     });
   });
-  describe('Controller.extend', function() {
-    it('should error if an anonymous function is passed', function() {
-      try {
-        let testController = Controller.extend(function(){});
-        assert(false); // Fail if we get here.
-      } catch(e) {
-      }
-    });
-
-    it('should set the appropriate listener on the router',
-        function() {
-      let mockRouter = new EventEmitter();
-      let mockParams = {_controller: "test"};
-      let mockRequest = {};
-      let mockResponse = {headersSent: true};
-      Controller.setRouter(mockRouter);
-      let testController = Controller.extend(TestController);
-      sinon.spy(testController, "testAction");
-
-      mockRouter.emit(
-        'dispatchTo:test', 'testAction', mockParams, mockRequest, mockResponse);
-
-      assert(testController.testAction.calledWith(
-          mockParams, mockRequest, mockResponse));
-    });
-    it('should set itself as the prototype of the passed constructor method',
-      function() {
-        let mockRouter = new EventEmitter();
-        Controller.setRouter(mockRouter);
-        let testController = Controller.extend(TestController);
-        assert(testController instanceof Controller);
-      }
-    );
-    it('should return an initialized instance of the constructor', function() {
-      let mockRouter = new EventEmitter();
-      Controller.setRouter(mockRouter);
-      let testController = Controller.extend(TestController);
-      assert(testController instanceof TestController);
-    });
-    it('should raise an error if no router has been set', function() {
-      try {
-        let testController = Controller.extend(TestController);
-        assert(false); // Fail if we get here.
-      } catch (expectedError) {
-      }
-    });
-  });
   describe('#_do', function() {
     it('should call the function on the controller matching the given action');
     it('should call 404 if the action does not exist on the controller instance');

package/spec/nails.spec.js

@@ -0,0 +1 @@
+// TODO test all initialization here

package/spec/router.spec.js

@@ -1,7 +1,7 @@
 // var express_app = require('../lib/application.js');
-import Router from '../lib/router.js';
+import Router from '../lib/Router.ts';
 import assert from 'assert';
-import express_app from '../lib/application.js';
+import express_app from '../lib/application.ts';
 
 express_app.set("public_root", import.meta.dirname + "/services/integration/public");
 var testRoutes = [
@@ -28,7 +28,7 @@ describe('Router', function() {
             var testFunctionCalled;
             router.on('dispatchTo:application', test);
 
-            function test(action, params, request, response) {
+            function test({action, params, request, response}) {
                 testFunctionCalled = true;
                 assert.equal(action, expectedAction);
                 assert.equal(typeof(params), 'object');
@@ -56,7 +56,7 @@ describe('Router', function() {
             var testFunctionCalled;
             router.on('dispatchTo:test', test);
 
-            function test(action, params, request, response) {
+            function test({action, params, request, response}) {
                 testFunctionCalled = true;
                 assert.equal(action, expectedAction);
                 assert.equal(params._controller, mockParams._controller);
@@ -84,7 +84,7 @@ describe('Router', function() {
             var testFunctionCalled;
             router.on('dispatchTo:test', test);
 
-            function test(action, params, request, response) {
+            function test({action, params, request, response}) {
                 testFunctionCalled = true;
                 assert.equal(action, expectedAction);
                 assert.equal(params._controller, mockQuery._controller);

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

@@ -0,0 +1,7 @@
+import {type DbConfig} from '../../../../index.ts';
+
+const config: DbConfig = {
+  address: 'sqlite::memory:',
+};
+
+export default config;