mythix 2.9.0 → 2.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mythix",
-  "version": "2.9.0",
+  "version": "2.10.0",
   "description": "Mythix is a NodeJS web-app framework",
   "main": "src/index",
   "scripts": {

package/src/application.d.ts

@@ -1,5 +1,6 @@
 import { ConnectionBase, ModelClass, Models } from 'mythix-orm';
 import { ControllerClass } from './controllers/controller-base';
+import { RouteScope } from './controllers/routes/route-scope';
 import { HTTPServer } from './http-server/http-server';
 import { GenericObject } from './interfaces/common';
 import { Logger, LoggerClass, LoggerOptions } from './logger';
@@ -54,7 +55,8 @@ export declare class Application {
   public getConfig(): GenericObject;
   public setConfig(options: GenericObject): Application;
   public getApplicationName(): string;
-  public getRoutes(): GenericObject;
+  public _getRoutes(): RouteScope;
+  public getRoutes(context: RouteScope): void;
   public getCustomRouteParserTypes(): { [key: string]: (value: string, param: GenericObject, index?: number) => any };
   public createLogger(loggerOptions: LoggerOptions, LoggerClass: LoggerClass): Logger;
   public getLogger(): Logger;

package/src/application.js

@@ -15,6 +15,7 @@ const { ControllerModule }  = require('./controllers/controller-module');
 const { TaskModule }        = require('./tasks/task-module');
 const { FileWatcherModule } = require('./modules/file-watcher-module');
 const { wrapConfig }        = require('./utils');
+const ControllerRoutes      = require('./controllers/routes');
 
 // Trace what is requesting the application exit
 
@@ -272,6 +273,12 @@ class Application extends EventEmitter {
     return this;
   }
 
+  _getRoutes() {
+    let routeScope = new ControllerRoutes.RouteScope();
+    this.getRoutes(routeScope);
+    return routeScope;
+  }
+
   getRoutes() {
     throw new Error('Error: child application expected to implement "getRoutes" method');
   }

package/src/cli/cli-utils.js

@@ -78,6 +78,17 @@ class CommandBase {
         });
 
         childProcess.on('error', (error) => {
+          if (options && options.ignoreExitCode) {
+            resolve({
+              stdout: Buffer.concat(output).toString('utf8'),
+              stderr: Buffer.concat(errors).toString('utf8'),
+              code:   0,
+              error,
+            });
+
+            return;
+          }
+
           reject({
             stdout: Buffer.concat(output).toString('utf8'),
             stderr: Buffer.concat(errors).toString('utf8'),

package/src/cli/deploy-command.js

@@ -68,6 +68,10 @@ module.exports = defineCommand('deploy', ({ Parent }) => {
       try {
         return await super.spawnCommand(command, args, options);
       } catch (error) {
+        console.error('Error with command: ', { dryRun, command, args, options }, error);
+        if (error.stderr)
+          console.error(error.stderr);
+
         if (error instanceof Error)
           throw error;
 

package/src/cli/routes-command.js

@@ -1,10 +1,8 @@
 'use strict';
 
+const Nife              = require('nife');
 const { defineCommand } = require('./cli-utils');
 const { Logger }        = require('../logger');
-const { buildRoutes }   = require('../controllers/controller-utils');
-
-const TAB_SIZE = 8;
 
 module.exports = defineCommand('routes', ({ Parent }) => {
   return class RoutesCommand extends Parent {
@@ -19,40 +17,19 @@ module.exports = defineCommand('routes', ({ Parent }) => {
       };
     }
 
-    buildRoutes(httpServer, routes) {
-      let application       = this.getApplication();
-      let customParserTypes = application.getCustomRouteParserTypes(httpServer, routes);
-
-      return buildRoutes(routes, customParserTypes);
-    }
-
     execute() {
-      const whitespaceOfLength = (len) => {
-        if (len < 0)
-          return '';
-
-        let parts = new Array(len);
-        for (let i = 0, il = parts.length; i < il; i++)
-          parts[i] = ' ';
-
-        return parts.join('');
-      };
-
-      const stringToLength = (str, len) => {
-        return `${str}${whitespaceOfLength(len - str.length)}`;
-      };
-
       let application = this.getApplication();
-      let routes      = this.buildRoutes(null, application.getRoutes());
+      let routes      = application._getRoutes();
+      let whitespace  = '        ';
 
-      routes.forEach((route) => {
-        let methods = route.methods;
-        if (!methods === '*')
-          methods = [ '{ANY}' ];
+      console.log(`${application.getApplicationName()} routes:`);
 
-        methods.forEach((method) => {
-          console.log(`${stringToLength(method, TAB_SIZE)}${route.path} -> ${route.controller}`);
-        });
+      routes.walkRoutes(({ endpoint }) => {
+        let methods = endpoint.methods;
+        for (let i = 0, il = methods.length; i < il; i++) {
+          let method = methods[i];
+          console.log(`  ${method}${whitespace.substring(0, whitespace.length - method.length)}/${endpoint.path} -> [${endpoint.controller}]${(endpoint.isDynamic) ? ' (dynamic)' : ''}`);
+        }
       });
     }
   };

package/src/controllers/controller-module.d.ts

@@ -7,5 +7,4 @@ export class ControllerModule extends BaseModule {
   public getControllerFilePaths(controllersPath: string): Array<string>;
   public loadControllers(controllersPath: string): ControllerClasses;
   public getController(name: string): { controller: ControllerClass, controllerMethod: string | undefined };
-  public buildRoutes(httpServer: HTTPServer, routes: Array<GenericObject>): Array<GenericObject>;
 }

package/src/controllers/controller-module.js

@@ -2,7 +2,6 @@
 
 const Nife            = require('nife');
 const { BaseModule }  = require('../modules/base-module');
-const { buildRoutes } = require('./controller-utils');
 const {
   fileNameWithoutExtension,
   walkDir,
@@ -108,22 +107,14 @@ class ControllerModule extends BaseModule {
     };
   }
 
-  buildRoutes(httpServer, routes) {
-    let application       = this.getApplication();
-    let customParserTypes = application.getCustomRouteParserTypes(httpServer, routes);
-
-    return buildRoutes(routes, customParserTypes);
-  }
-
   async start(options) {
-    let application       = this.getApplication();
-    let httpServer        = (typeof application.getHTTPServer === 'function') ? application.getHTTPServer() : null;
-    let controllers       = await this.loadControllers(options.controllersPath);
+    let application = this.getApplication();
+    let httpServer  = (typeof application.getHTTPServer === 'function') ? application.getHTTPServer() : null;
+    let controllers = await this.loadControllers(options.controllersPath);
 
     this.controllers = controllers;
 
-    let routes = await this.buildRoutes(httpServer, application.getRoutes());
-    httpServer.setRoutes(routes);
+    httpServer.setRoutes(application._getRoutes());
   }
 
   async stop() {

package/src/controllers/controller-utils.d.ts

@@ -1,34 +1,7 @@
 import { Application } from '../application';
 import { HTTPServer } from '../http-server';
-import { GenericObject } from '../interfaces/common';
 import { ControllerClass } from './controller-base';
 
-export declare interface BuildPatternMatcherOptions {
-  strict?: boolean;
-  sanitize?: (value: string) => string;
-  flags?: string;
-}
-
-export declare interface PatternMatcherMethod {
-  (value: string): boolean;
-  regexp: RegExp;
-  directPatterns: Array<RegExp>;
-}
-
-export declare interface PathMatcherMethod {
-  (pathPart: string): GenericObject | undefined;
-  regexp: RegExp;
-  params: Array<string>;
-  sanitizedPath: string;
-}
-
-export declare type RoutePatterns = string | RegExp | Array<string | RegExp>;
-
-export declare function buildPatternMatcher(
-  patterns: RoutePatterns,
-  options?: BuildPatternMatcherOptions
-): PatternMatcherMethod;
-
 export declare interface DefineControllerContext<T = ControllerClass> {
   Parent: T;
   application: Application;
@@ -36,11 +9,6 @@ export declare interface DefineControllerContext<T = ControllerClass> {
   controllerName: string;
 }
 
-export declare function buildMethodMatcher(patterns: RoutePatterns): PatternMatcherMethod;
-export declare function buildContentTypeMatcher(patterns: RoutePatterns): PatternMatcherMethod;
-export declare function buildPathMatcher(routeName: string, customParserTypes: GenericObject): PathMatcherMethod;
-export declare function buildRoutes(routes: GenericObject | Array<GenericObject>, customParserTypes?: GenericObject): Array<GenericObject>;
-
 export declare function defineController<T = ControllerClass>(
   controllerName: string,
   definer: (context: DefineControllerContext<T>) => ControllerClass,

package/src/controllers/controller-utils.js

@@ -1,7 +1,6 @@
 'use strict';
 
-const Nife                = require('nife');
-const { ControllerBase }  = require('./controller-base');
+const { ControllerBase } = require('./controller-base');
 
 function defineController(controllerName, definer, _parent) {
   let parentKlass = _parent || ControllerBase;
@@ -20,411 +19,6 @@ function defineController(controllerName, definer, _parent) {
   };
 }
 
-const ROUTE_PROPERTIES = [
-  'name',
-  'accept',
-  'controller',
-  'methods',
-  'middleware',
-  'priority',
-  'queryParams',
-  'clientOptions',
-];
-
-function buildPatternMatcher(_patterns, _opts) {
-  let opts          = _opts || {};
-  let patterns      = _patterns;
-  let sanitizeFunc  = opts.sanitize;
-  let strict        = opts.strict;
-  let flags         = (Nife.instanceOf(opts.flags, 'string') && Nife.isNotEmpty(opts.flags)) ? opts.flags : 'i';
-  let matchRE;
-  let matchFunc;
-
-  if (Nife.instanceOf(patterns, 'array'))
-    patterns = Nife.uniq(patterns);
-
-  if (patterns === '*' || (Nife.instanceOf(patterns, 'array') && patterns.indexOf('*') >= 0) || patterns instanceof RegExp) {
-    matchRE = (patterns instanceof RegExp) ? patterns : /.*/i;
-
-    matchFunc = function patternMatcher(value) {
-      if (!value || !Nife.instanceOf(value, 'string'))
-        return true;
-
-      return !!value.match(matchRE);
-    };
-
-    Object.defineProperties(matchFunc, {
-      'regexp': {
-        writable:     false,
-        enumerable:   false,
-        configurable: false,
-        value:        matchRE,
-      },
-      'directPatterns': {
-        writable:     false,
-        enumerable:   false,
-        configurable: false,
-        value:        [],
-      },
-    });
-
-    return matchFunc;
-  }
-
-  if (!Nife.instanceOf(patterns, 'array'))
-    patterns = [ patterns ];
-
-  let parts           = [];
-  let directPatterns  = [];
-
-  for (let i = 0, il = patterns.length; i < il; i++) {
-    let part = patterns[i];
-
-    if (part instanceof RegExp) {
-      directPatterns.push(part);
-      continue;
-    }
-
-    if (typeof sanitizeFunc === 'function') {
-      part = sanitizeFunc(part);
-    } else {
-      part = part.replace(/\*/g, '@@@WILD_MATCH@@@');
-      part = Nife.regexpEscape(part);
-      part = part.replace(/@@@WILD_MATCH@@@/g, '.*?');
-    }
-
-    parts.push(part);
-  }
-
-  if (parts && parts.length)
-    matchRE = new RegExp((strict) ? `^(${parts.join('|')})$` : `(${parts.join('|')})`, flags);
-
-  matchFunc = function patternMatcher(value) {
-    if (!value || !Nife.instanceOf(value, 'string'))
-      return false;
-
-    if (directPatterns && directPatterns.length) {
-      for (let j = 0, jl = directPatterns.length; j < jl; j++) {
-        let pattern = directPatterns[j];
-        if (value.match(pattern))
-          return true;
-      }
-    }
-
-    if (!matchRE)
-      return false;
-
-    return !!value.match(matchRE);
-  };
-
-  Object.defineProperties(matchFunc, {
-    'regexp': {
-      writable:     false,
-      enumerable:   false,
-      configurable: false,
-      value:        matchRE,
-    },
-    'directPatterns': {
-      writable:     false,
-      enumerable:   false,
-      configurable: false,
-      value:        directPatterns,
-    },
-  });
-
-  return matchFunc;
-}
-
-function buildMethodMatcher(methods) {
-  return buildPatternMatcher(methods, { strict: true });
-}
-
-function buildContentTypeMatcher(contentTypePatterns) {
-  return buildPatternMatcher(contentTypePatterns);
-}
-
-function buildPathMatcher(routeName, customParserTypes) {
-  let params      = [];
-  let parts       = [];
-  let lastOffset  = 0;
-
-  let sanitizedPath = routeName.replace(/<\s*([^\s:]+?\??)\s*(:\w+?)?\s*(=\s*[^>]+)?>/g, function(m, _name, _type, _defaultValue, offset, str) {
-    if (offset > lastOffset) {
-      parts.push(str.substring(lastOffset, offset));
-      lastOffset = offset + m.length;
-    }
-
-    let defaultValue  = _defaultValue;
-    let type          = _type;
-    let optional      = false;
-    let name          = _name;
-
-    if (name.match(/\?$/)) {
-      optional = true;
-      name = name.substring(0, name.length - 1);
-    }
-
-    if (type)
-      type = type.replace(/\W/g, '');
-
-    if (defaultValue) {
-      defaultValue = defaultValue.trim().replace(/^=\s*/, '');
-      defaultValue = Nife.coerceValue(defaultValue, type);
-    }
-
-    let matcher;
-
-    if (type === 'number' || type === 'int' || type === 'integer' || type === 'bigint')
-      matcher = '([\\d.e-]+)';
-    else if (type === 'boolean' || type === 'bool')
-      matcher = '(true|True|TRUE|false|False|FALSE)';
-    else
-      matcher = (optional) ? '(.*?)' : '(.+?)';
-
-    if (optional)
-      matcher = matcher + '?';
-
-    let param = {
-      startOffset:  offset,
-      endOffset:    offset + m.length,
-      name,
-      type,
-      defaultValue,
-      matcher,
-      optional,
-    };
-
-    params.push(param);
-    parts.push(param);
-
-    return `<<${name}${(optional) ? '?' : ''}>>`;
-  });
-
-  if (lastOffset < routeName.length)
-    parts.push(routeName.substring(lastOffset));
-
-  let finalRegExpStr = parts.reduce((items, _item, index) => {
-    let item = _item;
-
-    if (typeof item === 'string') {
-      item = item.replace(/\?/g, '@@@CHAR_MATCH@@@').replace(/\*/g, '@@@WILD_MATCH@@@').replace(/\/+/g, '@@@FORWARD_SLASH@@@');
-      item = Nife.regexpEscape(item);
-      item = item.replace(/@@@CHAR_MATCH@@@/g, '.').replace(/@@@WILD_MATCH@@@/g, '.*?').replace(/@@@FORWARD_SLASH@@@/g, '/');
-
-      if (item.match(/\/$/)) {
-        let nextItem = parts[index + 1];
-        if (nextItem && typeof nextItem !== 'string' && nextItem.optional)
-          item = item + '?';
-      }
-
-      items.push(item);
-    } else {
-      items.push(item.matcher);
-    }
-
-    return items;
-  }, []).join('');
-
-  let matcherRE = new RegExp(`^${finalRegExpStr}$`);
-  let matchFunc = function routeMatcher(pathPart) {
-    let match = pathPart.match(matcherRE);
-    if (!match)
-      return;
-
-    let result = {};
-    for (let i = 1, il = match.length; i < il; i++) {
-      let part = match[i];
-      if (!part)
-        continue;
-
-      let paramIndex  = i - 1;
-      let param       = params[paramIndex];
-      if (!param)
-        continue;
-
-      if (customParserTypes && Object.prototype.hasOwnProperty.call(customParserTypes, param.type))
-        result[param.name] = customParserTypes[param.type](part, param, paramIndex);
-      else
-        result[param.name] = Nife.coerceValue(part, param.type);
-    }
-
-    return result;
-  };
-
-  Object.defineProperties(matchFunc, {
-    'regexp': {
-      writable:     false,
-      enumerable:   false,
-      configurable: false,
-      value:        matcherRE,
-    },
-    'params': {
-      writable:     false,
-      enumerable:   false,
-      configurable: false,
-      value:        params,
-    },
-    'sanitizedPath': {
-      writable:     false,
-      enumerable:   false,
-      configurable: false,
-      value:        sanitizedPath,
-    },
-  });
-
-  return matchFunc;
-}
-
-function compileRoutes(routes, customParserTypes, _context) {
-  const addRoute = (theseRoutes, route, path, priority) => {
-    let newRoute = Object.assign(
-      {
-        methods:  'GET',
-        accept:   '*',
-        priority,
-      },
-      route || {},
-      {
-        path: path.replace(/\/{2,}/g, '/'),
-      },
-    );
-
-    if (Nife.instanceOf(newRoute.methods, 'array')) {
-      newRoute.methods = Nife
-        .uniq(newRoute.methods)
-        .filter((method) => ((typeof method === 'string' || method instanceof String) && Nife.isNotEmpty(method)))
-        .map((method) => method.toUpperCase());
-
-      if (newRoute.methods.indexOf('*') >= 0)
-        newRoute.methods = '*';
-    } else {
-      if (Nife.instanceOf(newRoute.methods, 'string') || Nife.isEmpty(newRoute.methods))
-        newRoute.methods = 'GET';
-
-      newRoute.methods = newRoute.methods.toUpperCase();
-    }
-
-    theseRoutes.push(newRoute);
-  };
-
-  let context     = _context || {};
-  let theseRoutes = [];
-  let isArray     = (routes instanceof Array);
-  let {
-    routeName,
-    path,
-    alreadyVisited,
-    depth,
-  } = context;
-
-  if (!alreadyVisited)
-    alreadyVisited = new Map();
-
-  if (alreadyVisited.get(routes))
-    return [];
-
-  alreadyVisited.set(routes, true);
-
-  if (!depth)
-    depth = 0;
-
-  if (Nife.isEmpty(routeName))
-    routeName = '/';
-
-  if (!path)
-    path = '/';
-
-  path = path.replace(/\/{2,}/g, '/');
-
-  // eslint-disable-next-line no-magic-numbers
-  let basePriority = 1000000 - (depth * 1000);
-  let keys = Object.keys(routes);
-
-  for (let i = 0, il = keys.length; i < il; i++) {
-    let key   = keys[i];
-    let route = routes[key];
-
-    if (route && Nife.isNotEmpty(route.controller)) {
-      let newPath = (isArray) ? path : `${path}/${key}`;
-      addRoute(theseRoutes, route, newPath, basePriority + i);
-    }
-
-    if (ROUTE_PROPERTIES.indexOf(key) >= 0 || Nife.instanceOf(route, 'boolean', 'string', 'number', 'bigint'))
-      continue;
-
-    let thisRouteName = (isArray) ? routeName : key;
-    let newPath       = (isArray) ? path : `${path}/${key}`;
-
-    if (Nife.instanceOf(route, 'object', 'array')) {
-      let subRoutes = compileRoutes(route, customParserTypes, {
-        routeName:  thisRouteName,
-        path:       newPath,
-        priority:   i,
-        depth:      depth + 1,
-        alreadyVisited,
-      });
-
-      if (!subRoutes || !subRoutes.length)
-        continue;
-
-      theseRoutes = [].concat(subRoutes, theseRoutes);
-    }
-  }
-
-  return theseRoutes;
-}
-
-function buildRoutes(_routes, customParserTypes) {
-  const sortRoutes = (routesToSort) => {
-    return routesToSort.sort((a, b) => {
-      // We convert "<" to "{" and ">" to "}"
-      // to get the desired sort order...
-      // This is so that capture parameters
-      // always come last.
-      const mangle = (str) => {
-        return str.replace(/</g, '{').replace(/>/g, '}');
-      };
-
-      // We pad the priority number so as not to get:
-      // 100
-      // 10
-      // 1
-      // sort order funkiness
-
-      // eslint-disable-next-line no-magic-numbers
-      let pathA = mangle(`${a.path}${('' + a.priority).padStart(12, '0')}`);
-      // eslint-disable-next-line no-magic-numbers
-      let pathB = mangle(`${b.path}${('' + b.priority).padStart(12, '0')}`);
-
-      if (pathA === pathB)
-        return 0;
-
-      return (pathA < pathB) ? -1 : 1;
-    });
-  };
-
-  let routes = compileRoutes(_routes, customParserTypes);
-
-  routes = sortRoutes(routes);
-
-  return routes.map((route) => {
-    // Filter out priority key
-    let thisRoute = Nife.extend(Nife.extend.FILTER, (key) => !key.match(/^(priority)$/), {}, route);
-
-    // Inject route matchers
-    thisRoute.methodMatcher       = buildMethodMatcher(thisRoute.methods || '*');
-    thisRoute.contentTypeMatcher  = buildContentTypeMatcher(thisRoute.accept || '*');
-    thisRoute.pathMatcher         = buildPathMatcher(thisRoute.path, customParserTypes);
-
-    return thisRoute;
-  });
-}
-
 module.exports = {
-  buildPatternMatcher,
-  buildMethodMatcher,
-  buildContentTypeMatcher,
-  buildPathMatcher,
-  buildRoutes,
   defineController,
 };