mythix 1.0.2 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mythix",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Mythix is a NodeJS web-app framework",
   "main": "src/index.js",
   "scripts": {
@@ -27,8 +27,9 @@
     "express-busboy": "^8.0.0",
     "inflection": "^1.13.1",
     "lodash": "^4.17.21",
-    "nife": "^1.2.2",
+    "nife": "^1.5.0",
     "object-hash": "^2.2.0",
-    "sequelize": "^6.13.0"
+    "sequelize": "^6.13.0",
+    "sqlite3": "^5.0.2"
   }
 }

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,12 +778,17 @@ 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) {
@@ -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()) ? this.getLogger().log.bind(this.getLogger()) : false;
+      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

@@ -81,7 +81,7 @@ module.exports = defineCommand('migrate', ({ Parent }) => {
       var useTransaction      = (args['transaction']) ? true : false;
       var rollback            = args.rollback;
 
-      console.log('USING TRANSACTION: ', useTransaction, args['no-transaction']);
+      console.log('USING TRANSACTION: ', useTransaction, args['transaction']);
 
       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;
   }

package/src/index.js

@@ -8,22 +8,25 @@ const { Logger }        = require('./logger');
 const Utils             = require('./utils');
 
 module.exports = {
-  defineCommand:    CLIUtilsScope.defineCommand,
-  defineController: ControllerScope.defineController,
-  defineModel:      Models.defineModel,
-  defineTask:       TasksScope.defineTask,
+  defineCommand:          CLIUtilsScope.defineCommand,
+  defineController:       ControllerScope.defineController,
+  defineModel:            Models.defineModel,
+  defineTask:             TasksScope.defineTask,
+  createTestApplication:  Utils.TestUtils.createTestApplication,
 
-  CLI:              CLIUtilsScope,
-  ControllerBase:   ControllerScope.ControllerBase,
-  Controllers:      ControllerScope,
-  CryptoUtils:      Utils.CryptoUtils,
-  HTTP:             HTTPServerScope,
-  HTTPErrors:       HTTPServerScope.HTTPErrors,
-  HTTPServer:       HTTPServerScope.HTTPServer,
-  HTTPUtils:        Utils.HTTPUtils,
-  Middleware:       HTTPServerScope.Middleware,
-  TaskBase:         TasksScope.TaskBase,
-  Tasks:            TasksScope,
+  CLI:                    CLIUtilsScope,
+  ControllerBase:         ControllerScope.ControllerBase,
+  Controllers:            ControllerScope,
+  CryptoUtils:            Utils.CryptoUtils,
+  HTTP:                   HTTPServerScope,
+  HTTPErrors:             HTTPServerScope.HTTPErrors,
+  HTTPServer:             HTTPServerScope.HTTPServer,
+  HTTPUtils:              Utils.HTTPUtils,
+  Middleware:             HTTPServerScope.Middleware,
+  TaskBase:               TasksScope.TaskBase,
+  Tasks:                  TasksScope,
+  TestUtils:              Utils.TestUtils,
+  Model:                  Models.Model,
 
   Application,
   Logger,

package/src/logger.js

@@ -2,9 +2,10 @@ const Path        = require('path');
 const FileSystem  = require('fs');
 
 const LEVEL_ERROR   = 1;
-const LEVEL_WARN    = 2;
-const LEVEL_INFO    = 3;
-const LEVEL_DEBUG   = 4;
+const LEVEL_LOG     = 2;
+const LEVEL_WARN    = 3;
+const LEVEL_INFO    = 4;
+const LEVEL_DEBUG   = 5;
 
 function errorStackToString(rootPath, error) {
   return ('\n -> ' + error.stack.split(/\n+/).slice(1).map((part) => `${part.replace(/^\s+at\s+/, '')}\n`).join(' -> ')).trimEnd();
@@ -48,8 +49,11 @@ function logToWriter(type, ..._args) {
 
     try {
       arg = JSON.stringify(arg);
-    } catch (e) {
-      return '<LOGGER_ERROR>';
+    } catch (error) {
+      if (error.message = 'Converting circular structure to JSON')
+        return '<circular>';
+
+      return `<LOGGER_ERROR: ${error.message}>`;
     }
 
     return arg;
@@ -88,7 +92,7 @@ class Logger {
 
     Object.defineProperties(this, {
       '_level': {
-        writable:     false,
+        writable:     true,
         enumerable:   false,
         configurable: false,
         value:        opts.level,
@@ -132,13 +136,18 @@ class Logger {
     });
   }
 
+  setLevel(level) {
+    this._level = level;
+  }
+
   clone(extraOpts) {
     return new this.constructor(Object.assign({
-      level:      this._level,
-      writer:     this._writer,
-      pid:        this._pid,
-      formatter:  this._formatter,
-      rootPath:   this._rootPath,
+      level:                this._level,
+      writer:               this._writer,
+      pid:                  this._pid,
+      formatter:            this._formatter,
+      rootPath:             this._rootPath,
+      errorStackFormatter:  this._errorStackFormatter,
     }, extraOpts || {}));
   }
 
@@ -146,6 +155,10 @@ class Logger {
     return (this._level >= LEVEL_ERROR);
   }
 
+  isLogLevel() {
+    return (this._level >= LEVEL_LOG);
+  }
+
   isWarningLevel() {
     return (this._level >= LEVEL_WARN);
   }
@@ -179,7 +192,7 @@ class Logger {
   }
 
   log(...args) {
-    if (this.isErrorLevel())
+    if (this.isLogLevel())
       logToWriter.call(this, 'log', ...args);
   }
 
@@ -201,6 +214,7 @@ class Logger {
 
 Object.assign(Logger, {
   ERROR:  LEVEL_ERROR,
+  LOG:    LEVEL_LOG,
   WARN:   LEVEL_WARN,
   INFO:   LEVEL_INFO,
   DEBUG:  LEVEL_DEBUG,

package/src/models/model-utils.js

@@ -34,14 +34,28 @@ function relationHelper(type) {
 const RELATION_HELPERS = {
   hasOne:         relationHelper('hasOne'),
   belongsTo:      relationHelper('belongsTo'),
-  hasMany:        relationHelper('belongsToMany'),
+  hasMany:        relationHelper('hasMany'),
   belongsToMany:  relationHelper('belongsToMany'),
 };
 
+function preciseNow() {
+  var janFirst2022      = 1640995200000;
+  var now               = Date.now() - janFirst2022;
+  var highResolutionNow = Nife.now();
+  var diff              = Math.floor(highResolutionNow);
+
+  return Math.floor((now + (highResolutionNow - diff)) * 1000);
+}
+
 function defineModel(modelName, definer, _parent) {
-  function compileModelFields(Klass, DataTypes) {
+  function compileModelFields(Klass, DataTypes, application, connection) {
+    const createAutoIncrementor = () => {
+      return () => preciseNow();
+    };
+
     var fields      = Klass.fields;
     var fieldNames  = Object.keys(fields);
+    var isSQLIte    = !!('' + Nife.get(connection, 'options.dialect')).match(/sqlite/);
 
     for (var i = 0, il = fieldNames.length; i < il; i++) {
       var fieldName = fieldNames[i];
@@ -52,6 +66,14 @@ function defineModel(modelName, definer, _parent) {
         field.field = columnName;
       }
 
+      // If using SQLite, which doesn't support autoincrement
+      // on anything except the primary key, then create our
+      // own auto-incrementor for this field
+      if (field.autoIncrement && isSQLIte && !field.primaryKey) {
+        application.getLogger().warn(`!Warning!: Using an auto-increment field in SQLite on a non-primary-key column "${field.field}"! Be aware that this functionality is now emulated using high resolution timestamps. This won't work unless the column is a BIGINT. You may run into serious problems with this emulation!`)
+        field.defaultValue = createAutoIncrementor();
+      }
+
       if (field.type === DataTypes.BIGINT) {
         if (!field.get) {
           field.get = function(name) {
@@ -80,15 +102,26 @@ function defineModel(modelName, definer, _parent) {
     return fields;
   }
 
-  function cleanModelFields(Klass) {
+  function cleanModelFields(Klass, connection) {
     var finalFields = {};
     var fields      = Klass.fields;
     var fieldNames  = Object.keys(fields);
+    var isSQLIte    = !!('' + Nife.get(connection, 'options.dialect')).match(/sqlite/);
 
     for (var i = 0, il = fieldNames.length; i < il; i++) {
       var fieldName = fieldNames[i];
       var field     = fields[fieldName];
-      var newField  = Nife.extend(Nife.extend.FILTER, (key) => !key.match(/^(index)$/), {}, field);
+      var newField  = Nife.extend(Nife.extend.FILTER, (key) => {
+        if (key.match(/^(index)$/))
+          return false;
+
+        // Strip "autoIncrement" if this is not the primary key
+        // and we are using sqlite for our dialect
+        if (key === 'autoIncrement' && isSQLIte && !field.primaryKey)
+          return false;
+
+        return true;
+      }, {}, field);
 
       finalFields[fieldName] = newField;
     }
@@ -135,7 +168,7 @@ function defineModel(modelName, definer, _parent) {
   }
 
   return function({ application, Sequelize, connection }) {
-    var Klass = definer({
+    var definerArgs = {
       Parent:   (_parent) ? _parent : Model,
       Type:     Sequelize.DataTypes,
       Relation: RELATION_HELPERS,
@@ -143,19 +176,24 @@ function defineModel(modelName, definer, _parent) {
       connection,
       modelName,
       application,
-    });
+    };
+
+    var Klass = definer(definerArgs);
 
     Klass.name = modelName;
 
+    if (typeof Klass.onModelClassCreate === 'function')
+      Klass = Klass.onModelClassCreate(Klass, definerArgs);
+
     var pluralName = (Klass.pluralName) ? Klass.pluralName : Inflection.pluralize(modelName);
     if (Klass.pluralName !== pluralName)
       Klass.pluralName = pluralName;
 
-    Klass.fields = compileModelFields(Klass, Sequelize.DataTypes);
+    Klass.fields = compileModelFields(Klass, Sequelize.DataTypes, application, connection);
 
     var indexes = generateIndexes(Klass);
 
-    Klass.fields = cleanModelFields(Klass);
+    Klass.fields = cleanModelFields(Klass, connection);
 
     var applicationOptions = application.getOptions();
     var tableName;
@@ -177,8 +215,8 @@ function defineModel(modelName, definer, _parent) {
     Klass.getPrimaryKeyField      = getModelPrimaryKeyField.bind(this, Klass);
     Klass.getPrimaryKeyFieldName  = () => (getModelPrimaryKeyField(Klass).field);
 
-    if (typeof Klass.onModelClassCreate === 'function')
-      Klass = Klass.onModelClassCreate(Klass);
+    if (typeof Klass.onModelClassFinalized === 'function')
+      Klass = Klass.onModelClassFinalized(Klass, definerArgs);
 
     return { [modelName]: Klass };
   };

package/src/models/model.js

@@ -11,6 +11,11 @@ class Model extends Sequelize.Model {
     return application.getLogger();
   }
 
+  getDBConnection() {
+    var application = this.getApplication();
+    return application.getDBConnection();
+  }
+
   getPrimaryKeyField() {
     return this.constructor.getPrimaryKeyField();
   }
@@ -20,12 +25,16 @@ class Model extends Sequelize.Model {
   }
 
   static prepareWhereStatement(conditions) {
-    if (Nife.isEmpty(conditions))
+    if (Nife.isEmpty(conditions)) {
       return undefined;
+    }
+
+    if (conditions._mythixQuery)
+      return conditions;
 
     const Ops       = Sequelize.Op;
     var finalQuery  = {};
-    var keys        = Object.keys(conditions);
+    var keys        = Object.keys(conditions).concat(Object.getOwnPropertySymbols(conditions));
 
     for (var i = 0, il = keys.length; i < il; i++) {
       var key   = keys[i];
@@ -34,47 +43,134 @@ class Model extends Sequelize.Model {
       if (value === undefined)
         continue;
 
-      if (value === null) {
-        finalQuery[key] = { [Ops.is]: value };
+      var name    = key;
+      var invert  = false;
+
+      if (typeof name === 'string' && name.charAt(0) === '!') {
+        name    = name.substring(1);
+        invert  = true;
+      }
+
+      if (typeof key === 'symbol') {
+        finalQuery[key] = value;
+      } else if (value === null) {
+        finalQuery[name] = (invert) ? { [Ops.not]: value } : { [Ops.is]: value };
       } else if (Nife.instanceOf(value, 'number', 'string', 'boolean', 'bigint')) {
-        finalQuery[key] = { [Ops.eq]: value };
+        finalQuery[name] = (invert) ? { [Ops.ne]: value } : { [Ops.eq]: value };
       } else if (Nife.instanceOf(value, 'array') && Nife.isNotEmpty(value)) {
-        finalQuery[key] = { [Ops.in]: value };
+        finalQuery[name] = (invert) ? { [Ops.not]: { [Ops.in]: value } } : { [Ops.in]: value };
       } else if (Nife.isNotEmpty(value)) {
-        finalQuery[key] = value;
+        if (invert)
+          throw new Error(`Model.prepareWhereStatement: Attempted to invert a custom matcher "${name}"`);
+
+        finalQuery[name] = value;
       }
     }
 
+    if (Nife.isEmpty(finalQuery))
+      return;
+
+    Object.defineProperties(finalQuery, {
+      '_mythixQuery': {
+        writable:     false,
+        enumberable:  false,
+        configurable: false,
+        value:        true,
+      },
+    });
+
     return finalQuery;
   }
 
-  static onModelClassCreate(Klass) {
-    Klass.first = Klass.first.bind(this, Klass);
-    Klass.last  = Klass.last.bind(this, Klass);
+  static onModelClassFinalized(Klass) {
+    Klass.getDefaultOrderBy   = Klass.getDefaultOrderBy.bind(this, Klass);
+    Klass.prepareQueryOptions = Klass.prepareQueryOptions.bind(this, Klass);
+    Klass.bulkUpdate           = Klass.bulkUpdate.bind(this, Klass);
+    Klass.all                 = Klass.all.bind(this, Klass);
+    Klass.where               = Klass.where.bind(this, Klass);
+    Klass.rowCount            = Klass.rowCount.bind(this, Klass);
+    Klass.first               = Klass.first.bind(this, Klass);
+    Klass.last                = Klass.last.bind(this, Klass);
 
     return Klass;
   }
 
-  static async first(Model, conditions, _order) {
-    var options = {};
-    var query   = Model.prepareWhereStatement(conditions);
+  static getDefaultOrderBy(Model) {
+    return [ Model.getPrimaryKeyFieldName() ];
+  }
+
+  static prepareQueryOptions(Model, conditions, _order) {
+    const Ops = Sequelize.Op;
+    var options;
+    var query;
+
+    if (conditions && Nife.isNotEmpty(conditions.where)) {
+      query = conditions.where;
+      options = Object.assign({}, conditions);
+    } else if (conditions) {
+      query = Model.prepareWhereStatement(conditions);
+    }
+
+    var order = _order;
+    if (!options && Nife.instanceOf(order, 'object')) {
+      options = Object.assign({}, order);
+      order = undefined;
+    } else if (!options) {
+      options = {};
+    }
 
     if (Nife.isNotEmpty(query))
       options.where = query;
 
-    var order = _order;
-    if (!order)
-      order = [ Model.getPrimaryKeyFieldName() ];
+    if (!order && options.defaultOrder !== false) {
+      if (options.order) {
+        order = options.order;
+      } else {
+        if (typeof Model.getDefaultOrderBy === 'function')
+          order = Model.getDefaultOrderBy();
+        else
+          order = [ Model.getPrimaryKeyFieldName() ];
+      }
+    }
 
     options.order = order;
+    if (!options.hasOwnProperty('distinct'))
+      options.distinct = true;
+
+    // If no "where" clause was specified, then grab everything
+    if (!options.where)
+      options.where = { [Model.getPrimaryKeyFieldName()]: { [Ops.not]: null } };
+
+    if (options.debug)
+      console.log('QUERY OPTIONS: ', options);
+
+    return options;
+  }
+
+  static where(Model, conditions) {
+    return Model.prepareWhereStatement(conditions);
+  }
+
+  static async rowCount(Model, conditions, options) {
+    return await Model.count(Model.prepareQueryOptions(conditions, options));
+  }
+
+  static async bulkUpdate(Model, attrs, conditions) {
+    return await Model.update(attrs, Model.prepareQueryOptions(conditions, { distinct: false }));
+  }
+
+  static async all(Model, conditions, order) {
+    return await Model.findAll(Model.prepareQueryOptions(conditions, order));
+  }
 
-    return await Model.findOne(options);
+  static async first(Model, conditions, order) {
+    return await Model.findOne(Model.prepareQueryOptions(conditions, order));
   }
 
   static async last(Model, conditions, _order) {
     var order = _order;
     if (!order)
-      order = [ Model.getPrimaryKeyFieldName(), 'DESC' ];
+      order = [ 'createdAt', 'DESC' ];
 
     return await Model.first(conditions, order);
   }

package/src/tasks/task-base.js

@@ -94,7 +94,7 @@ class TaskBase {
 
     if (workers > 1) {
       var shift = (frequency / workers);
-      startDelay = Math.round(startDelay + (shift * taskIndex));
+      startDelay = startDelay + (shift * taskIndex);
     }
 
     return startDelay;

package/src/tasks/task-utils.js

@@ -72,7 +72,7 @@ class TimeHelpers {
   }
 
   totalMilliseconds() {
-    return this.totalSeconds() * 1000;
+    return Math.round(this.totalSeconds() * 1000);
   }
 }
 

package/src/utils/http-utils.js

@@ -59,9 +59,12 @@ function makeRequest(requestOptions) {
     var url         = new URL(requestOptions.url);
     var data        = (!method.match(/^(GET|HEAD)$/i) && requestOptions.data) ? requestOptions.data : undefined;
     var extraConfig = {};
+    var headers     = Object.assign({
+      'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/97.0.4692.71 Safari/537.36',
+    }, defaultHeaders || {}, requestOptions.headers || {});
 
     if (data) {
-      if (Nife.get(requestOptions, 'headers.Content-Type').match(/application\/json/))
+      if (Nife.get(headers, 'Content-Type', '').match(/application\/json/))
         data = JSON.stringify(data);
 
       extraConfig = {
@@ -77,9 +80,7 @@ function makeRequest(requestOptions) {
       port:     url.port,
       path:     `${url.pathname}${url.search}`,
       method,
-      headers: Object.assign({
-        'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/97.0.4692.71 Safari/537.36',
-      }, defaultHeaders || {}),
+      headers,
     }, requestOptions, extraConfig);
 
     delete options.data;

package/src/utils/index.js

@@ -7,11 +7,13 @@ const {
 
 const HTTPUtils   = require('./http-utils');
 const CryptoUtils = require('./crypto-utils');
+const TestUtils   = require('./test-utils');
 
 module.exports = {
   CryptoUtils,
   fileNameWithoutExtension,
   HTTPUtils,
+  TestUtils,
   walkDir,
   wrapConfig,
 };

package/src/utils/test-utils.js

@@ -0,0 +1,161 @@
+const Nife        = require('nife');
+const { Logger }  = require('../logger');
+const HTTPUtils   = require('./http-utils');
+
+function createTestApplication(Application) {
+  const Klass = class TestApplication extends Application {
+    static APP_NAME = `${(Nife.isNotEmpty(Application.APP_NAME)) ? Application.APP_NAME : 'mythix'}_test`;
+
+    constructor(_opts) {
+      var opts = Nife.extend(true, {
+        autoReload: false,
+        runTasks:   false,
+        testMode:   true,
+      }, _opts || {});
+
+      super(opts);
+    }
+
+    getDBTablePrefix(userSpecifiedPrefix) {
+      var prefix = super.getDBTablePrefix(userSpecifiedPrefix);
+      return `${prefix.replace(/_test/g, '')}_test_`.replace(/_+/g, '_');
+    }
+
+    getTestingDatabaseConfig() {
+      return { dialect: 'sqlite', logging: false };
+    }
+
+    getTestingHTTPServerConfig(options) {
+      return Object.assign({}, options || {}, {
+        host:   'localhost',
+        port:   0, // Select a random port
+        https:  false,
+      });
+    }
+
+    getTestingLoggerConfig(loggerOpts) {
+      return Object.assign({}, loggerOpts, {
+        level:  Logger.ERROR,
+        writer: null,
+      });
+    }
+
+    createLogger(loggerOpts, Logger) {
+      return super.createLogger(this.getTestingLoggerConfig(loggerOpts), Logger);
+    }
+
+    async connectToDatabase() {
+      var connection = await super.connectToDatabase(this.getTestingDatabaseConfig());
+      return connection;
+    }
+
+    async createHTTPServer(options) {
+      var httpServerConfig  = this.getTestingHTTPServerConfig(options);
+      var server            = await super.createHTTPServer(httpServerConfig);
+
+      Object.defineProperties(this, {
+        'host': {
+          writable:     true,
+          enumberable:  false,
+          configurable: true,
+          value:        {
+            hostname: httpServerConfig.host,
+            port:     server.server.address().port,
+          },
+        },
+      });
+
+      this.setDefaultURL(`http://${this.host.hostname}:${this.host.port}/`);
+
+      return server;
+    }
+
+    async start(...args) {
+      var result = await super.start(...args);
+
+      var dbConnection = this.getDBConnection();
+      await dbConnection.sync({ force: true, logging: false });
+
+      return result;
+    }
+
+    async truncateAllTables(exclude) {
+      var dbConnection  = this.getDBConnection();
+      var models        = this.getModels();
+      var modelNames    = Object.keys(models);
+
+      await dbConnection.query('PRAGMA foreign_keys = OFF');
+
+      try {
+        for (var i = 0, il = modelNames.length; i < il; i++) {
+          var modelName = modelNames[i];
+          if (exclude && exclude.indexOf(modelName) >= 0)
+            continue;
+
+          var model = models[modelName];
+          await dbConnection.query(`DELETE FROM ${model.tableName}`);
+        }
+      } catch (error) {
+        await dbConnection.query('PRAGMA foreign_keys = ON');
+      }
+    }
+
+    getDefaultURL(...args) {
+      return HTTPUtils.getDefaultURL(...args);
+    }
+
+    setDefaultURL(...args) {
+      return HTTPUtils.setDefaultURL(...args);
+    }
+
+    async getDefaultHeader(...args) {
+      return HTTPUtils.getDefaultHeader(...args);
+    }
+
+    async getDefaultHeaders(...args) {
+      return HTTPUtils.getDefaultHeaders(...args);
+    }
+
+    async setDefaultHeader(...args) {
+      return HTTPUtils.setDefaultHeader(...args);
+    }
+
+    async setDefaultHeaders(...args) {
+      return HTTPUtils.setDefaultHeaders(...args);
+    }
+
+    async request(...args) {
+      return HTTPUtils.request(...args);
+    }
+
+    async get(...args) {
+      return HTTPUtils.get(...args);
+    }
+
+    async post(...args) {
+      return HTTPUtils.post(...args);
+    }
+
+    async put(...args) {
+      return HTTPUtils.put(...args);
+    }
+
+    async delete(...args) {
+      return HTTPUtils.delete(...args);
+    }
+
+    async head(...args) {
+      return HTTPUtils.head(...args);
+    }
+
+    async options(...args) {
+      return HTTPUtils.options(...args);
+    }
+  };
+
+  return Klass;
+}
+
+module.exports = {
+  createTestApplication,
+};