mythix 1.1.2 → 1.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mythix",
-  "version": "1.1.2",
+  "version": "1.1.5",
   "description": "Mythix is a NodeJS web-app framework",
   "main": "src/index.js",
   "scripts": {
@@ -39,6 +39,6 @@
     "pg-hstore": "^2.3.4",
     "prompts": "^2.4.2",
     "sequelize": "^6.18.0",
-    "sqlite3": "^4.2.0"
+    "sqlite3": "^5.0.9"
   }
 }

package/src/application.js

@@ -299,7 +299,10 @@ class Application extends EventEmitter {
   }
 
   async stop(exitCode) {
-    if (this.isStopping || !this.isStarted)
+    if (this.isStopping)
+      process.exit(1);
+
+    if (!this.isStarted)
       return;
 
     try {

package/src/controllers/controller-base.js

@@ -83,11 +83,17 @@ class ControllerBase {
 
   getModel(name) {
     let application = this.getApplication();
+    if (typeof application.getModel !== 'function')
+      return;
+
     return application.getModel(name);
   }
 
   getModels() {
     let application = this.getApplication();
+    if (typeof application.getModels !== 'function')
+      return {};
+
     return application.getModels();
   }
 
@@ -164,6 +170,9 @@ class ControllerBase {
   async handleIncomingRequest(request, response, { route, controllerMethod, startTime, params, query /* , controller, controllerInstance, */ }) {
     this.route = route;
 
+    if (typeof this[controllerMethod] !== 'function')
+      this.throwInternalServerError(`Specified route handler named "${this.constructor.name}::${controllerMethod}" not found.`);
+
     return await this[controllerMethod].call(this, { params, query, body: request.body, request, response, startTime }, this.getModels());
   }
 

package/src/controllers/controller-utils.js

@@ -296,7 +296,7 @@ function compileRoutes(routes, customParserTypes, _context) {
         accept:   '*',
         priority,
       },
-      getRouteProperties(route),
+      route || {},
       {
         path: path.replace(/\/{2,}/g, '/'),
       },
@@ -362,7 +362,7 @@ function compileRoutes(routes, customParserTypes, _context) {
       addRoute(theseRoutes, route, newPath, basePriority + i);
     }
 
-    if (ROUTE_PROPERTIES.indexOf(key) >= 0)
+    if (ROUTE_PROPERTIES.indexOf(key) >= 0 || Nife.instanceOf(route, 'boolean', 'string', 'number', 'bigint'))
       continue;
 
     let thisRouteName = (isArray) ? routeName : key;

package/src/controllers/generate-client-api-interface.js

@@ -371,20 +371,146 @@ function generateRoutes(_routes, _options) {
       defaultMethod = defaultMethod[0];
 
     var url = `${domain}${sanitizedPath}`;
-    methods[methodName] = `function ${methodName}(_options) { var clientOptions = ${clientOptions}; var options = Object.assign({ url: '${url}', method: '${defaultMethod}' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('${methodName}', options); delete options.params; return makeRequest.call(this, '${methodName}', options); }`;
+    methods[methodName] = { method: `function ${methodName}(_options) { var clientOptions = ${clientOptions}; var options = Object.assign({ url: '${url}', method: '${defaultMethod}' }, defaultRouteOptions, clientOptions, Object.assign({}, _options || {}, { headers: Object.assign({}, defaultRouteOptions.headers || {}, clientOptions.headers || {}, ((_options || {}).headers) || {}) })); options.url = Utils.injectURLParams('${methodName}', options); delete options.params; return makeRequest.call(this, '${methodName}', options); }`, route };
   }
 
   return methods;
 }
 
+const PRINT_TABLE = `
+    function printTable(columns, rows, title, prefix) {
+      function print(message) {
+        lines.push((prefix || '') + message);
+      }
+
+      const findLongestValue = (column) => {
+        var maxSize = column.length;
+
+        for (var i = 0, il = rows.length; i < il; i++) {
+          var row = rows[i];
+          if (!row)
+            continue;
+
+          var value = ('' + row[column]);
+          if (value.length > maxSize)
+            maxSize = value.length;
+        }
+
+        return maxSize;
+      };
+
+      const generateSequence = (size, char) => {
+        var array = new Array(size);
+        for (var i = 0, il = array.length; i < il; i++)
+          array[i] = char;
+
+        return array.join('');
+      };
+
+      const padColumnValue = (value, columnSize) => {
+        var prefixSize = Math.floor((columnSize - value.length) / 2.0);
+        var prefix = generateSequence(prefixSize, ' ');
+        var postfix = generateSequence(columnSize - value.length - prefixSize, ' ');
+
+        return [ prefix, value, postfix ].join('');
+      };
+
+      const bold = (value) => {
+        return '\u001b[1m' + value + '\u001b[0m';
+      };
+
+      const capitalize = (value) => {
+        return value.replace(/^./, (m) => {
+          return m.toUpperCase();
+        });
+      };
+
+      var lines = [];
+      var columnSizes = {};
+      var columnPadding = 4;
+      var totalWidth = columns.length + 1;
+
+      var lineChar = '~';
+      var sepChar = bold('|');
+
+      for (var i = 0, il = columns.length; i < il; i++) {
+        var column = columns[i];
+        var columnWidth = findLongestValue(column) + (columnPadding * 2);
+
+        totalWidth += columnWidth;
+
+        columnSizes[column] = columnWidth;
+      }
+
+      var hrLine = bold(sepChar + generateSequence(totalWidth - 2, lineChar) + sepChar);
+      var hrLine2 = columns.map((column) => generateSequence(columnSizes[column], lineChar));
+
+      hrLine2 = bold(sepChar + hrLine2.join(sepChar) + sepChar);
+
+      if (title) {
+        print(hrLine);
+        print(sepChar + bold(padColumnValue(capitalize(title), totalWidth - 2)) + sepChar);
+      }
+
+      print(hrLine);
+
+      var line = [ sepChar ];
+      for (var j = 0, jl = columns.length; j < jl; j++) {
+        var column = columns[j];
+        var columnSize = columnSizes[column];
+
+        line.push(bold(padColumnValue(capitalize(column), columnSize)));
+
+        line.push(sepChar);
+      }
+
+      print(line.join(''));
+      print(hrLine);
+
+      for (var i = 0, il = rows.length; i < il; i++) {
+        var row = rows[i];
+
+        if (i > 0)
+          print(hrLine2);
+
+        var line = [ sepChar ];
+
+        for (var j = 0, jl = columns.length; j < jl; j++) {
+          var column = columns[j];
+          var columnSize = columnSizes[column];
+          var value = ('' + row[column]);
+
+          line.push(padColumnValue(value, columnSize));
+
+          line.push(sepChar);
+        }
+
+        print(line.join(''));
+      }
+
+      print(hrLine);
+
+      console.info(lines.join('\\n'));
+    }
+`;
+
 function generateAPIInterface(routes, _options) {
   var options           = _options || {};
   var environment       = options.environment;
   var routeMethods      = generateRoutes(routes, options);
   var routeMethodNames  = Object.keys(routeMethods).sort();
   var injectMethodsStr  = routeMethodNames.map((methodName) => {
-    var method = routeMethods[methodName];
-    return `    apiInterface['${methodName}'] = (${method}).bind(apiInterface);`;
+    var info    = routeMethods[methodName];
+    var method  = info.method;
+    var route   = info.route;
+    var help    = route.help;
+
+    if (!help || options.mode !== 'development')
+      help = '{}';
+    else
+      help = JSON.stringify(help);
+
+    return `    apiInterface['${methodName}'] = assignHelp((${method}).bind(apiInterface), '${methodName}', ${help});`;
   }).join('\n\n');
 
   var defaultRouteOptions = options.defaultRouteOptions;
@@ -400,6 +526,43 @@ function generateAPIInterface(routes, _options) {
   }
 
   return `function generateAPIInterface(globalScope, environmentType) {
+    var helpStyles = {
+      'error': 'font-weight: 800; color: red;',
+      'normal': 'font-weight: 200;',
+      'bold': 'font-weight: 800;',
+      'boldYellow': 'font-weight: 800; color: yellow;',
+    };
+
+    ${(options.mode === 'development') ? PRINT_TABLE : ''}
+
+    function assignHelp(func, methodName, help) {
+      Object.defineProperty(func, 'help', {
+        enumberable:  false,
+        configurable: false,
+        get: () => {
+          if (!help || !help.description) {
+            console.log('%cNo help found for route "' + methodName + '"', helpStyles.error);
+            return;
+          }
+
+          console.info('%cHelp for %c' + methodName + '%c route:', helpStyles.bold, helpStyles.boldYellow, helpStyles.bold);
+          console.info('  %cDescription:%c ' + help.description, helpStyles.bold, helpStyles.normal);
+
+          if (!Utils.isEmpty(help.data))
+            printTable([ 'property', 'type', 'description' ], help.data, 'Data: { data: { ... } }', '  ');
+
+          if (!Utils.isEmpty(help.params))
+            printTable([ 'property', 'type', 'description' ], help.params, 'Parameters: { params: { ... } }', '  ');
+
+          if (help.example)
+            console.info('  %cExample:%c ' + help.example, helpStyles.bold, helpStyles.normal);
+        },
+        set: () => {},
+      });
+
+      return func;
+    }
+
     function getDefaultHeader(headerName) {
       return apiInterface.defaultHeaders[headerName];
     }

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

@@ -116,6 +116,8 @@ class HTTPServer {
   }
 
   executeMiddleware(middleware, request, response) {
+    let { route, params } = (this.findFirstMatchingRoute(request, this.routes) || {});
+
     return new Promise((resolve, reject) => {
       if (Nife.isEmpty(middleware)) {
         resolve();
@@ -133,6 +135,9 @@ class HTTPServer {
       if (!request.Sequelize)
         request.Sequelize = Sequelize;
 
+      request.route = route;
+      request.params = params;
+
       let middlewareIndex = 0;
       const next = async () => {
         if (middlewareIndex >= middleware.length)

package/src/modules/file-watcher-module.js

@@ -69,10 +69,14 @@ class FileWatcherModule extends BaseModule {
     return this.watchedPathsCache;
   }
 
-  isWatchedFile(options, filePath) {
-    let monitoredPaths = this.getMonitoredPaths(options);
+  isWatchedFile(_monitoredPaths, filePath) {
+    let monitoredPaths = Nife.toArray(_monitoredPaths);
+
     for (let i = 0, il = monitoredPaths.length; i < il; i++) {
       let monitoredPath = monitoredPaths[i];
+      if (!monitoredPath)
+        continue;
+
       if (filePath.substring(0, monitoredPath.length) === monitoredPath)
         return true;
     }
@@ -90,7 +94,8 @@ class FileWatcherModule extends BaseModule {
       if (!queueName)
         continue;
 
-      if (this.isWatchedFile(options, filePath))
+      let paths = moduleInstance.fileWatcherGetMonitorPaths(options);
+      if (this.isWatchedFile(paths, filePath))
         return queueName;
     }