mythix 1.0.1 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mythix",
-  "version": "1.0.1",
+  "version": "1.0.4",
   "description": "Mythix is a NodeJS web-app framework",
   "main": "src/index.js",
   "scripts": {
@@ -23,12 +23,15 @@
   "dependencies": {
     "chokidar": "^3.5.3",
     "deep-diff": "^1.0.2",
-    "express": "^4.17.2",
-    "express-busboy": "^8.0.0",
-    "inflection": "^1.13.1",
+    "express": "^4.17.3",
+    "express-busboy": "^8.0.2",
+    "inflection": "^1.13.2",
     "lodash": "^4.17.21",
-    "nife": "^1.2.2",
-    "object-hash": "^2.2.0",
-    "sequelize": "^6.13.0"
+    "nife": "^1.6.0",
+    "object-hash": "^3.0.0",
+    "sequelize": "^6.18.0",
+    "sqlite3": "^4.2.0",
+    "pg": "^8.7.3",
+    "pg-hstore": "^2.3.4"
   }
 }

package/spec/controller-utils-spec.js

@@ -135,7 +135,7 @@ describe('controller-utils', function() {
         },
       });
 
-      console.log('ALL ROUTES: ', allRoutes);
+      // console.log('ALL ROUTES: ', allRoutes);
     });
   });
 });

package/src/application.js

@@ -14,7 +14,7 @@ const {
 } = require('./utils');
 
 function nowInSeconds() {
-  return Math.floor(Date.now() / 1000);
+  return Date.now() / 1000;
 }
 
 // Trace what is requesting the application exit
@@ -58,6 +58,7 @@ class Application extends EventEmitter {
       autoReload:         (process.env.NODE_ENV || 'development') === 'development',
       exitOnShutdown:     null,
       runTasks:           true,
+      testMode:           false,
     }, _opts || {});
 
     Object.defineProperties(this, {
@@ -138,7 +139,7 @@ class Application extends EventEmitter {
         enumerable:   false,
         configurable: true,
         value:        this.createLogger(
-          Object.assign({}, opts.logger || {}, this.getConfigValue('logger', {})),
+          Object.assign({}, this.getConfigValue('logger', {}), opts.logger || {}),
           Logger,
         ),
       },
@@ -777,17 +778,22 @@ class Application extends EventEmitter {
     }
 
     var sequelize = new Sequelize(databaseConfig);
+    var dbConnectionString;
+
+    if (Nife.instanceOf(databaseConfig, 'string'))
+      dbConnectionString = databaseConfig;
+    else
+      dbConnectionString = `${databaseConfig.dialect}://${databaseConfig.host}:${databaseConfig.port || '<default port>'}/${databaseConfig.database}`;
 
-    var dbConnectionString = `${databaseConfig.dialect}://${databaseConfig.host}:${databaseConfig.port || '<default port>'}/${databaseConfig.database}`;
     try {
       await sequelize.authenticate();
 
-      this.getLogger().log(`Connection to ${dbConnectionString} has been established successfully!`);
+      this.getLogger().info(`Connection to ${dbConnectionString} has been established successfully!`);
 
       return sequelize;
     } catch (error) {
       this.getLogger().error(`Unable to connect to database ${dbConnectionString}:`, error);
-      await this.stop();
+      throw error;
     }
   }
 
@@ -803,6 +809,13 @@ class Application extends EventEmitter {
     return server;
   }
 
+  getDBTablePrefix(userSpecifiedPrefix) {
+    if (Nife.isNotEmpty(userSpecifiedPrefix))
+      return userSpecifiedPrefix;
+
+    return `${this.getApplicationName()}_`;
+  }
+
   async start() {
     var options = this.getOptions();
 
@@ -818,10 +831,13 @@ class Application extends EventEmitter {
         return;
       }
 
-      databaseConfig.logging = this.getLogger().isDebugLevel();
+      if (options.testMode) {
+        databaseConfig.logging = false;
+      } else {
+        databaseConfig.logging = (this.getLogger().isDebugLevel()) ? this.getLogger().log.bind(this.getLogger()) : false;
+      }
 
-      if (Nife.isEmpty(databaseConfig.tablePrefix))
-        databaseConfig.tablePrefix = `${this.getApplicationName()}_`;
+      databaseConfig.tablePrefix = this.getDBTablePrefix(databaseConfig.tablePrefix);
 
       this.dbConnection = await this.connectToDatabase(databaseConfig);
 

package/src/cli/cli-utils.js

@@ -34,6 +34,11 @@ class CommandBase {
     var app = this.getApplication();
     return app.getLogger();
   }
+
+  getDBConnection() {
+    var application = this.getApplication();
+    return application.getDBConnection();
+  }
 }
 
 var loadingAllCommandsInProgress = false;

package/src/cli/migrations/migrate-command.js

@@ -63,7 +63,11 @@ module.exports = defineCommand('migrate', ({ Parent }) => {
           return doneCallback();
 
         var migrationFileName = migrationFiles[index];
-        console.log(`Running migration ${migrationFileName}...`);
+
+        if (rollback)
+          console.log(`Undoing migration ${migrationFileName}...`);
+        else
+          console.log(`Running migration ${migrationFileName}...`);
 
         MigrationUtils.executeMigration(queryInterface, migrationFileName, useTransaction, 0, rollback).then(
           () => nextMigration(doneCallback, index + 1),
@@ -78,10 +82,10 @@ module.exports = defineCommand('migrate', ({ Parent }) => {
       var applicationOptions  = application.getOptions();
       var migrationsPath      = applicationOptions.migrationsPath;
       var migrationFiles      = this.getMigrationFiles(migrationsPath);
-      var useTransaction      = (args['transaction']) ? true : false;
+      var useTransaction      = args.transaction;
       var rollback            = args.rollback;
 
-      console.log('USING TRANSACTION: ', useTransaction, args['no-transaction']);
+      console.log('USING TRANSACTION: ', useTransaction, args['transaction'], rollback, typeof rollback);
 
       if (args.revision)
         migrationFiles = this.getMigrationFilesFromRevision(migrationFiles, args.revision);

package/src/cli/routes-command.js

@@ -0,0 +1,39 @@
+const { defineCommand } = require('./cli-utils');
+const { Logger }        = require('../logger');
+
+module.exports = defineCommand('routes', ({ Parent }) => {
+  return class RoutesCommand extends Parent {
+    static description        = 'List application routes';
+    static applicationConfig  = { logger: { level: Logger.ERROR } };
+
+    execute(args) {
+      const whitespaceOfLength = (len) => {
+        if (len < 0)
+          return '';
+
+        var parts = new Array(len);
+        for (var i = 0, il = parts.length; i < il; i++)
+          parts[i] = ' ';
+
+        return parts.join('');
+      };
+
+      const stringToLength = (str, len) => {
+        return `${str}${whitespaceOfLength(len - str.length)}`
+      };
+
+      var application = this.getApplication();
+      var routes      = application.buildRoutes(null, application.getRoutes());
+
+      routes.forEach((route) => {
+        var methods = route.methods;
+        if (!methods === '*')
+          methods = [ '{ANY}' ];
+
+        methods.forEach((method) => {
+          console.log(`${stringToLength(method, 8)}${route.path} -> ${route.controller}`);
+        });
+      });
+    }
+  };
+});

package/src/controllers/controller-base.js

@@ -1,4 +1,5 @@
-const Nife = require('nife');
+const Nife        = require('nife');
+const HTTPErrors  = require('../http-server/http-errors');
 
 class ControllerBase {
   constructor(application, logger, request, response) {
@@ -27,6 +28,12 @@ class ControllerBase {
         configurable: true,
         value:        logger,
       },
+      'route': {
+        writable:     true,
+        enumberable:  false,
+        configurable: true,
+        value:        null,
+      },
     });
   }
 
@@ -54,8 +61,31 @@ class ControllerBase {
     return application.getModels();
   }
 
-  async handleIncomingRequest(request, response, { route, controller, controllerMethod, controllerInstance, startTime, params }) {
-    return await this[controllerMethod].call(this, params, request.query || {}, request.body, this.getModels());
+  getDBConnection() {
+    var application = this.getApplication();
+    return application.getDBConnection();
+  }
+
+  throwNotFoundError(message) {
+    throw new HTTPErrors.HTTPNotFoundError(this.route, message);
+  }
+
+  throwBadRequestError(message) {
+    throw new HTTPErrors.HTTPBadRequestError(this.route, message);
+  }
+
+  throwUnauthorizedError(message) {
+    throw new HTTPErrors.HTTPUnauthorizedError(this.route, message);
+  }
+
+  throwInternalServerError(message) {
+    throw new HTTPErrors.HTTPInternalServerError(this.route, message);
+  }
+
+  async handleIncomingRequest(request, response, { route, controller, controllerMethod, controllerInstance, startTime, params, query }) {
+    this.route = route;
+
+    return await this[controllerMethod].call(this, { params, query, body: request.body, request, response, startTime }, this.getModels());
   }
 
   async handleOutgoingResponse(_controllerResult, request, response, { route, controller, controllerMethod, controllerInstance, startTime, params }) {
@@ -74,6 +104,7 @@ class ControllerBase {
     if (controllerResult == null)
       controllerResult = {};
 
+    response.header('Content-Type', 'application/json; charset=UTF-8');
     response.status(200).send(JSON.stringify(controllerResult));
   }
 }

package/src/controllers/controller-utils.js

@@ -20,8 +20,9 @@ const ROUTE_PROPERTIES = [
   'accept',
   'controller',
   'methods',
-  'middleWare',
+  'middleware',
   'priority',
+  'queryParams',
 ];
 
 function buildPatternMatcher(_patterns, _opts) {
@@ -281,6 +282,26 @@ function getRouteProperties(route) {
 function compileRoutes(routes, customParserTypes, _context) {
   const sortRoutes = (routes) => {
     return routes.sort((a, b) => {
+      var pathA = a.path;
+      var pathB = b.path;
+
+      if (Nife.arrayUnion(a.methods, b.methods).length > 0) {
+        // If the routes are at the same level
+        // but one of them has a capture parameter
+        // then the one without a capture parameter comes first.
+        // If we don't do this, then the capture parameter wild-card
+        // might match the route name of the non-parameter route
+        var lastForwardSlashIndexA = pathA.lastIndexOf('/');
+        var lastForwardSlashIndexB = pathB.lastIndexOf('/');
+
+        if (lastForwardSlashIndexA >= 0 && lastForwardSlashIndexB >= 0 && pathA.substring(0, lastForwardSlashIndexA) === pathB.substring(0, lastForwardSlashIndexB)) {
+          if (pathA.indexOf('<', lastForwardSlashIndexA) >= 0 && pathB.indexOf('<', lastForwardSlashIndexB) < 0)
+            return 1;
+          else if (pathA.indexOf('<', lastForwardSlashIndexA) < 0 && pathB.indexOf('<', lastForwardSlashIndexB) >= 0)
+            return -1;
+        }
+      }
+
       var x = a.priority;
       var y = b.priority;
 
@@ -349,9 +370,6 @@ function compileRoutes(routes, customParserTypes, _context) {
   if (!path)
     path = '/';
 
-  if (routeName !== '/')
-    path = `${(path)}/${routeName}`;
-
   path = path.replace(/\/{2,}/g, '/');
 
   var keys = Object.keys(routes);
@@ -370,10 +388,12 @@ function compileRoutes(routes, customParserTypes, _context) {
       continue;
 
     var thisRouteName = (isArray) ? routeName : key;
+    var newPath       = (isArray) ? path : `${path}/${key}`;
+
     if (Nife.instanceOf(route, 'object', 'array')) {
       var subRoutes = compileRoutes(route, customParserTypes, {
         routeName:  thisRouteName,
-        path:       path,
+        path:       newPath,
         priority:   i,
         depth:      depth + 1,
         alreadyVisited,

package/src/http-server/http-errors.js

@@ -25,10 +25,19 @@ class HTTPBadRequestError extends HTTPBaseError {
   constructor(route, message) {
     super(route, message, 400);
   }
+}
+
+class HTTPBadContentTypeError extends HTTPBaseError {
+  constructor(route, message) {
+    super(route, message, 400);
+  }
 
   getMessage() {
-    var route   = this.route;
-    var accept  = route.accept;
+    var route = this.route;
+    if (!route)
+      return this.message;
+
+    var accept = route.accept;
     if (!(accept instanceof Array))
       accept = [ accept ];
 
@@ -43,7 +52,10 @@ class HTTPBadRequestError extends HTTPBaseError {
                 return `'${part}'`;
               });
 
-    return `${this.message}: Accepted Content-Types are [ ${accept.join(', ')} ]`;
+    if (this.message)
+      return `${this.message}: Accepted Content-Types are [ ${accept.join(', ')} ]`;
+    else
+      return `Accepted Content-Types are [ ${accept.join(', ')} ]`;
   }
 }
 
@@ -63,6 +75,7 @@ module.exports = {
   HTTPBaseError,
   HTTPNotFoundError,
   HTTPBadRequestError,
+  HTTPBadContentTypeError,
   HTTPUnauthorizedError,
   HTTPInternalServerError,
 };

package/src/http-server/http-server.js

@@ -12,6 +12,7 @@ const {
   HTTPBaseError,
   HTTPNotFoundError,
   HTTPBadRequestError,
+  HTTPBadContentTypeError,
   HTTPInternalServerError,
 } = require('./http-errors');
 
@@ -23,7 +24,7 @@ class HTTPServer {
   constructor(application, _opts) {
     var appName = application.getApplicationName();
 
-    var uploadPath = Path.resolve(OS.tmpdir(), 'appName', ('' + process.pid));
+    var uploadPath = Path.resolve(OS.tmpdir(), appName.replace(/[^\w-]/g, ''), ('' + process.pid));
 
     var opts = Nife.extend(true, {
       host:   'localhost',
@@ -102,46 +103,67 @@ class HTTPServer {
     this.routes = routes;
   }
 
-  baseMiddleware(request, response, rootNext) {
-    var middleware = this.middleware;
-    if (!middleware || !middleware.length)
-      return rootNext.call(this);
+  executeMiddleware(middleware, request, response) {
+    return new Promise((resolve, reject) => {
+      if (Nife.isEmpty(middleware))
+        return resolve();
 
-    var application = this.getApplication();
-    request.mythixApplication = application;
+      var application = this.getApplication();
+      if (!request.mythixApplication)
+        request.mythixApplication = application;
 
-    var logger = request.mythixLogger = this.createRequestLogger(application, request);
+      var logger = request.mythixLogger;
+      if (!logger)
+        logger = request.mythixLogger = this.createRequestLogger(application, request);
 
-    request.Sequelize = Sequelize;
+      if (!request.Sequelize)
+        request.Sequelize = Sequelize;
 
-    var middlewareIndex = 0;
-    const next = async () => {
-      if (middlewareIndex >= middleware.length)
-        return rootNext();
+      var middlewareIndex = 0;
+      const next = async () => {
+        if (middlewareIndex >= middleware.length)
+          return resolve();
 
-      var middlewareFunc = middleware[middlewareIndex++];
+        var middlewareFunc = middleware[middlewareIndex++];
 
-      try {
-        await middlewareFunc.call(this, request, response, next);
-      } catch (error) {
-        var statusCode  = error.statusCode || error.status_code || 500;
+        try {
+          await middlewareFunc.call(this, request, response, next);
+        } catch (error) {
+          var statusCode  = error.statusCode || error.status_code || 500;
 
-        if (error instanceof HTTPBaseError) {
-          logger.log(`Error: ${statusCode} ${statusCodeToMessage(statusCode)}`);
-          this.errorHandler(error.getMessage(), statusCode, response, request);
-        } else {
-          if (statusCode) {
+          if (error instanceof HTTPBaseError) {
             logger.log(`Error: ${statusCode} ${statusCodeToMessage(statusCode)}`);
-            this.errorHandler(error.message, statusCode, response, request);
+            this.errorHandler(error.getMessage(), statusCode, response, request);
           } else {
-            logger.log(`Error: ${error.message}`, error);
-            this.errorHandler(error.message, 500, response, request);
+            if (statusCode) {
+              logger.log(`Error: ${statusCode} ${statusCodeToMessage(statusCode)}`);
+              this.errorHandler(error.message, statusCode, response, request);
+            } else {
+              logger.log(`Error: ${error.message}`, error);
+              this.errorHandler(error.message, 500, response, request);
+            }
           }
+
+          reject(error);
         }
-      }
-    };
+      };
 
-    next();
+      next().catch(reject);
+    });
+  }
+
+  baseMiddleware(request, response, rootNext) {
+    var middleware = this.middleware;
+    if (Nife.isEmpty(middleware))
+      return rootNext();
+
+    this.executeMiddleware(middleware, request, response).then(
+      () => rootNext(),
+      (error) => {
+        if (!(error instanceof HTTPBaseError))
+          this.getApplication().error('Error in middleware: ', error);
+      }
+    );
   }
 
   findFirstMatchingRoute(request, _routes) {
@@ -160,7 +182,7 @@ class HTTPServer {
         return;
 
       if (typeof contentTypeMatcher === 'function' && !contentTypeMatcher(contentType))
-        throw new HTTPBadRequestError(route);
+        throw new HTTPBadContentTypeError(route);
 
       return result;
     };
@@ -168,7 +190,7 @@ class HTTPServer {
     var routes      = _routes || [];
     var method      = request.method;
     var contentType = Nife.get(request, 'headers.content-type');
-    var path        = request.url;
+    var path        = request.path;
 
     for (var i = 0, il = routes.length; i < il; i++) {
       var route   = routes[i];
@@ -207,26 +229,81 @@ class HTTPServer {
 
     var logger        = application.getLogger();
     var loggerMethod  = ('' + request.method).toUpperCase();
-    var loggerURL     = ('' + request.url);
+    var loggerURL     = ('' + request.path);
     var requestID     = (Date.now() + Math.random()).toFixed(4);
     var ipAddress     = Nife.get(request, 'client.remoteAddress', '<unknown IP address>');
 
     return logger.clone({ formatter: (output) => `{${ipAddress}} - [#${requestID} ${loggerMethod} ${loggerURL}]: ${output}`});
   }
 
-  sendRequestToController(...args) {
+  validateQueryParam(route, query, paramName, queryValue, queryParams) {
+    var { validate } = queryParams;
+    if (!validate)
+      return true;
+
+    if (validate instanceof RegExp)
+      return !!('' + queryValue).match(validate);
+    else if (typeof validate === 'function')
+      return !!validate.call(route, queryValue, paramName, query, queryParams);
+
+    return true;
+  }
+
+  compileQueryParams(route, query, queryParams) {
+    var finalQuery = Object.assign({}, query || {});
+
+    var paramNames = Object.keys(queryParams || {});
+    for (var i = 0, il = paramNames.length; i < il; i++) {
+      var paramName   = paramNames[i];
+      var queryParam  = queryParams[paramName];
+      if (!queryParam)
+        continue;
+
+      var queryValue = finalQuery[paramName];
+      if (queryValue == null) {
+        if (queryParam.required)
+          throw new HTTPBadRequestError(route, `Query param "${paramName}" is required`);
+
+        if (queryParam.hasOwnProperty('defaultValue'))
+          finalQuery[paramName] = queryParam['defaultValue'];
+      } else {
+        if (!this.validateQueryParam(route, finalQuery, paramName, queryValue, queryParam))
+          throw new HTTPBadRequestError(route, `Query param "${paramName}" is invalid`);
+
+        if (queryParam.hasOwnProperty('type'))
+          finalQuery[paramName] = Nife.coerceValue(queryValue, queryParam['type']);
+      }
+    }
+
+    return finalQuery;
+  }
+
+  async sendRequestToController(...args) {
     var context             = args[2];
     var controllerInstance  = context.controllerInstance;
 
-    return controllerInstance.handleIncomingRequest.apply(controllerInstance, args);
+    // Compile query params
+    context.query = this.compileQueryParams(context.route, context.query, (context.route && context.route.queryParams));
+
+    var route = context.route;
+
+    // Execute middleware if any exists
+    var middleware = (typeof controllerInstance.getMiddleware === 'function') ? controllerInstance.getMiddleware.call(controllerInstance, context) : [];
+    if (route && Nife.instanceOf(route.middleware, 'array') && Nife.isNotEmpty(route.middleware))
+      middleware = route.middleware.concat((middleware) ? middleware : []);
+
+    if (Nife.isNotEmpty(middleware))
+      await this.executeMiddleware(middleware, request, response);
+
+    return await controllerInstance.handleIncomingRequest.apply(controllerInstance, args);
   }
 
   async baseRouter(request, response, next) {
-    var startTime = Nife.now();
+    var startTime   = Nife.now();
+    var application = this.getApplication();
 
     try {
-      var application = this.getApplication();
-      var logger      = this.createRequestLogger(application, request, { controller, controllerMethod });
+      var logger = this.createRequestLogger(application, request, { controller, controllerMethod });
 
       logger.log(`Starting request`);
 
@@ -250,6 +327,7 @@ class HTTPServer {
 
       var context = {
         params: request.params,
+        query:  request.query,
         route,
         controller,
         controllerMethod,
@@ -259,13 +337,18 @@ class HTTPServer {
 
       var controllerResult = await this.sendRequestToController(request, response, context);
 
-      if (!response.finished)
+      if (!(response.finished || response.statusMessage))
         await controllerInstance.handleOutgoingResponse(controllerResult, request, response, context);
+      else if (!response.finished)
+        response.end();
 
       var statusCode  = response.statusCode || 200;
       var requestTime = Nife.now() - startTime;
       logger.log(`Completed request in ${requestTime.toFixed(3)}ms: ${statusCode} ${response.statusMessage || statusCodeToMessage(statusCode)}`);
     } catch (error) {
+      if ((error instanceof HTTPInternalServerError || !(error instanceof HTTPBaseError)) && application.getOptions().testMode)
+        console.error(error);
+
       try {
         var statusCode  = error.statusCode || error.status_code || 500;
         var requestTime = Nife.now() - startTime;
@@ -305,14 +388,15 @@ class HTTPServer {
   }
 
   async start() {
-    var options = this.getOptions();
-    var app     = this.createExpressApplication(options);
+    var options     = this.getOptions();
+    var app         = this.createExpressApplication(options);
+    var portString  = (options.port) ? `:${options.port}` : '';
     var server;
 
     app.use(this.baseMiddleware.bind(this));
     app.all('*', this.baseRouter.bind(this));
 
-    this.getLogger().log(`Starting ${(options.https) ? 'HTTPS' : 'HTTP'} server ${(options.https) ? 'https' : 'http'}://${options.host}:${options.port}...`);
+    this.getLogger().log(`Starting ${(options.https) ? 'HTTPS' : 'HTTP'} server ${(options.https) ? 'https' : 'http'}://${options.host}${portString}...`);
 
     if (options.https) {
       var credentials = await this.getHTTPSCredentials(options.https);
@@ -325,7 +409,8 @@ class HTTPServer {
 
     this.server = server;
 
-    this.getLogger().log(`Web server listening at ${(options.https) ? 'https' : 'http'}://${options.host}:${options.port}`);
+    var listeningPort = server.address().port;
+    this.getLogger().log(`Web server listening at ${(options.https) ? 'https' : 'http'}://${options.host}:${listeningPort}`);
 
     return server;
   }