mythix 2.9.0 → 2.10.0

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

@@ -2,9 +2,8 @@
 
 /* global Buffer, Utils, globalScope */
 
-const Nife            = require('nife');
-const ControllerUtils = require('./controller-utils');
-const HTTPUtils       = require('../utils/http-utils');
+const Nife      = require('nife');
+const HTTPUtils = require('../utils/http-utils');
 
 function tabIn(str, amount) {
   var padding = ''.padStart((amount || 1) * 2, ' ');
@@ -20,11 +19,6 @@ function tabIn(str, amount) {
   });
 }
 
-function buildRoutes(httpServer, routes) {
-  var customParserTypes = this.getCustomRouteParserTypes(httpServer, routes);
-  return ControllerUtils.buildRoutes(routes, customParserTypes);
-}
-
 function nodeRequestHandler(routeName, requestOptions) {
   return new Promise((function(resolve, reject) {
     if (!requestOptions || Utils.isEmpty(requestOptions.url)) {
@@ -163,15 +157,22 @@ function browserRequestHandler(routeName, requestOptions) {
     var data        = requestOptions.data;
     var extraConfig = {};
     var headers     = Object.assign(Utils.keysToLowerCase(this.defaultHeaders || {}), Utils.keysToLowerCase(requestOptions.headers || {}));
+    var isFormData  = (data && (data instanceof FormData || data.constructor.name === 'FormData'));
 
     if (data) {
       if (!method.match(/^(GET|HEAD)$/i)) {
-        if ((headers['content-type'] || '').match(/application\/json/i))
-          data = JSON.stringify(data);
+        if (isFormData) {
+          extraConfig = {
+            body: data,
+          };
+        } else {
+          if ((headers['content-type'] || '').match(/application\/json/i))
+            data = JSON.stringify(data);
 
-        extraConfig = {
-          body: data,
-        };
+          extraConfig = {
+            body: data,
+          };
+        }
       } else {
         var queryString = Utils.dataToQueryString(data);
         if (queryString)
@@ -193,6 +194,8 @@ function browserRequestHandler(routeName, requestOptions) {
     );
 
     delete options.data;
+    if (isFormData && options.headers)
+      delete options.headers['content-type'];
 
     globalScope.fetch(url, Utils.cleanObjectProperties(options)).then(
       async function(response) {
@@ -298,45 +301,31 @@ function generateUtils() {
 `;
 }
 
-function generateRoutes(_routes, _options) {
-  var options         = _options || {};
-  var methods         = {};
-  var domain          = options.domain;
-  var routes          = _routes;
-
-  if (options.routeFilter) {
-    var routeFilter = options.routeFilter;
-
-    if (typeof routeFilter === 'function') {
-      routes = routes.filter(routeFilter);
-    } else if (routeFilter instanceof RegExp) {
-      routes = routes.filter((route) => {
-        return routeFilter.test(route.path);
-      });
-    } else if (Nife.instanceOf(routeFilter, 'string')) {
-      routes = routes.filter((route) => {
-        return (route.path.indexOf(routeFilter) >= 0);
-      });
-    }
-  }
+function generateRoutes(applicationRoutes, _options) {
+  let options     = _options || {};
+  let methods     = {};
+  let domain      = options.domain;
+  let routeFilter = options.routeFilter;
 
   if (Nife.isEmpty(domain))
     domain = '';
   else
     domain = ('' + domain).replace(/\/+$/, '');
 
-  for (var i = 0, il = routes.length; i < il; i++) {
-    var route       = routes[i];
-    var methodName  = route.name;
-    if (Nife.isEmpty(methodName))
-      continue;
+  applicationRoutes.walkRoutes((context) => {
+    if (typeof routeFilter === 'function') {
+      if (!routeFilter(context))
+        return;
+    }
 
-    var pathMatcher   = route.pathMatcher;
-    var clientOptions = route.clientOptions;
-    var sanitizedPath = pathMatcher.sanitizedPath;
+    let { endpoint }  = context;
+    let methodName    = endpoint.name;
+    if (Nife.isEmpty(methodName))
+      return;
 
+    let clientOptions = endpoint.clientOptions;
     if (clientOptions == null) {
-      var contentType = route.accept;
+      let contentType = endpoint.contentType;
       if (Nife.isEmpty(contentType))
         contentType = 'application/json';
       else if (Array.isArray(contentType))
@@ -361,15 +350,13 @@ function generateRoutes(_routes, _options) {
       return value;
     });
 
-    var defaultMethod = Nife.toArray(route.methods).filter(Boolean);
-    if (Nife.isEmpty(defaultMethod))
-      defaultMethod = 'GET';
-    else if (Array.isArray(defaultMethod))
-      defaultMethod = defaultMethod[0];
-
-    var url = `${domain}${sanitizedPath}`;
-    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 };
-  }
+    let defaultMethod = endpoint.methods[0];
+    let url = `${domain}/${endpoint.path.replace(/^\/+/, '')}`;
+    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); }`,
+      endpoint,
+    };
+  });
 
   return methods;
 }
@@ -498,10 +485,10 @@ function generateAPIInterface(routes, _options) {
   var routeMethods      = generateRoutes(routes, options);
   var routeMethodNames  = Object.keys(routeMethods).sort();
   var injectMethodsStr  = routeMethodNames.map((methodName) => {
-    var info    = routeMethods[methodName];
-    var method  = info.method;
-    var route   = info.route;
-    var help    = route.help;
+    var info      = routeMethods[methodName];
+    var method    = info.method;
+    var endpoint  = info.endpoint;
+    var help      = endpoint.help;
 
     if (!help || options.mode !== 'development')
       help = '{}';
@@ -647,8 +634,7 @@ function generateAPIInterface(routes, _options) {
 
 function generateClientAPIInterface(application, _options) {
   var options     = _options || {};
-  var httpServer  = application.getHTTPServer() || null;
-  var routes      = buildRoutes.call(application, httpServer, application.getRoutes());
+  var routes      = application._getRoutes();
   var globalName  = (Object.prototype.hasOwnProperty.call(options, 'globalName')) ? options.globalName : '';
 
   if (Nife.isNotEmpty(globalName))

package/src/controllers/index.d.ts

@@ -1,4 +1,5 @@
 export * from './controller-base';
+export * as Routes from './routes';
 export * as ControllerUtils from './controller-utils';
 export { defineController } from './controller-utils';
 export * from './generate-client-api-interface';

package/src/controllers/index.js

@@ -5,22 +5,15 @@ const { ControllerModule }            = require('./controller-module');
 const { generateClientAPIInterface }  = require('./generate-client-api-interface');
 
 const {
-  buildPatternMatcher,
-  buildMethodMatcher,
-  buildContentTypeMatcher,
-  buildPathMatcher,
-  buildRoutes,
   defineController,
 } = require('./controller-utils');
 
+const Routes = require('./routes');
+
 module.exports = {
   ControllerBase,
   ControllerModule,
-  buildPatternMatcher,
-  buildMethodMatcher,
-  buildContentTypeMatcher,
-  buildPathMatcher,
-  buildRoutes,
+  Routes,
   defineController,
   generateClientAPIInterface,
 };

package/src/controllers/routes/index.d.ts

@@ -0,0 +1,4 @@
+export * from './route-capture';
+export * from './route-endpoint';
+export * from './route-scope-base';
+export * from './route-scope';

package/src/controllers/routes/index.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const {
+  RouteScopeBase,
+} = require('./route-scope-base');
+
+const {
+  RouteScope,
+} = require('./route-scope');
+
+const {
+  RouteCapture,
+} = require('./route-capture');
+
+const {
+  RouteEndpoint,
+} = require('./route-endpoint');
+
+module.exports = {
+  // Route scope base
+  RouteScopeBase,
+
+  // Route scope
+  RouteScope,
+
+  // Route capture
+  RouteCapture,
+
+  // Route endpoint
+  RouteEndpoint,
+};

package/src/controllers/routes/route-capture.d.ts

@@ -0,0 +1,32 @@
+import { GenericObject } from '../../interfaces/common';
+import { RouteScopeBase } from './route-scope-base';
+
+export declare interface RouteCaptureOptions {
+  type?: string;
+  optional?: boolean;
+}
+
+export declare interface RouteCaptureHelperContext {
+  value: string;
+  request: Request;
+  method: string;
+  path: string;
+  contentType: string | undefined;
+  params: GenericObject;
+}
+
+export declare type RouteCaptureHelper = ((context: RouteCaptureHelperContext) => any) | RegExp;
+
+export declare class RouteCapture {
+  declare _parentScope: RouteScopeBase;
+  declare _paramName: string;
+  declare _helper: RouteCaptureHelper | null;
+  declare _options: RouteCaptureOptions;
+
+  public constructor(parentScope: RouteScopeBase, paramName: string, _helperOrOptions?: RouteCaptureHelper | GenericObject, _options?: RouteCaptureOptions);
+  public getParentScope(): RouteScopeBase;
+  public getName(): string;
+  public isOptional(): boolean;
+  public clone(newOptions?: RouteCaptureOptions): RouteCapture;
+  public matches(context: RouteCaptureHelperContext): any;
+}

package/src/controllers/routes/route-capture.js

@@ -0,0 +1,99 @@
+'use strict';
+
+const Nife = require('nife');
+
+class RouteCapture {
+  constructor(parentScope, paramName, _helperOrOptions, _options) {
+    let helper;
+    let options;
+
+    if (!Nife.instanceOf(paramName, 'string'))
+      throw new TypeError('RouteCapture::constructor: "paramName" is required to be a string.');
+
+    if (typeof _helperOrOptions === 'function' || _helperOrOptions instanceof RegExp) {
+      helper = _helperOrOptions;
+      options = _options || {};
+    } else {
+      options = _helperOrOptions || {};
+    }
+
+    Object.defineProperties(this, {
+      '_parentScope': {
+        writable:     false,
+        enumerable:   false,
+        configurable: false,
+        value:        parentScope || null,
+      },
+      '_paramName': {
+        writable:     false,
+        enumerable:   false,
+        configurable: false,
+        value:        paramName,
+      },
+      '_helper': {
+        writable:     false,
+        enumerable:   false,
+        configurable: false,
+        value:        helper || null,
+      },
+      '_options': {
+        writable:     false,
+        enumerable:   false,
+        configurable: false,
+        value:        options,
+      },
+    });
+  }
+
+  getParentScope = () => {
+    return this._parentScope;
+  };
+
+  getName() {
+    return this._paramName;
+  }
+
+  isOptional() {
+    return !!this._options.optional;
+  }
+
+  clone(newOptions) {
+    let options = Object.assign({}, this._options, newOptions || {});
+
+    if (this._helper)
+      return new this.constructor(this._parentScope, this._paramName, this._helper, options);
+    else
+      return new this.constructor(this._parentScope, this._paramName, options);
+  }
+
+  matches(context) {
+    let helper = this._helper;
+    if (typeof helper === 'function') {
+      return helper(context);
+    } else if (helper instanceof RegExp) {
+      let result = context.value.match(helper);
+      if (!result)
+        return;
+
+      return (result && result.groups) ? result.groups : result[0];
+    } else {
+      if (!this.isOptional() && Nife.isEmpty(context.value))
+        return;
+
+      let options = this._options || {};
+      let type    = options.type || 'string';
+      return Nife.coerceValue(context.value, type);
+    }
+  }
+
+  toString() {
+    let paramName = this.getName();
+    let optional  = this.isOptional();
+
+    return `<<${paramName}${(optional) ? '?' : ''}>>`;
+  }
+}
+
+module.exports = {
+  RouteCapture,
+};

package/src/controllers/routes/route-endpoint.d.ts

@@ -0,0 +1,26 @@
+import { GenericObject } from '../../interfaces/common';
+import { RouteScopeBase } from './route-scope-base';
+
+export declare type EndpointMethods = 'GET' | 'PUT' | 'POST' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS' | '*';
+
+export declare interface EndpointOptions {
+  name?: string;
+  methods?: Array<EndpointMethods> | EndpointMethods;
+  contentType?: Array<string | RegExp> | string | RegExp;
+  controller: string;
+  path?: string;
+  help?: GenericObject;
+  queryParams?: GenericObject;
+  middleware?: Array<Function>;
+  [key: string | symbol]: any;
+}
+
+export declare class RouteEndpoint implements EndpointOptions {
+  declare _parentScope: RouteScopeBase;
+  declare isDynamic: boolean;
+  declare controller: string;
+  declare methods: Array<EndpointMethods>;
+
+  public constructor(parentScope: RouteScopeBase, attributes: EndpointOptions);
+  public getParentScope(): RouteScopeBase;
+}

package/src/controllers/routes/route-endpoint.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const Nife = require('nife');
+
+class RouteEndpoint {
+  constructor(parentScope, attributes) {
+    Object.defineProperties(this, {
+      '_parentScope': {
+        writable:     false,
+        enumerable:   false,
+        configurable: false,
+        value:        parentScope || null,
+      },
+      'isDynamic': {
+        writable:     true,
+        enumerable:   false,
+        configurable: true,
+        value:        false,
+      },
+    });
+
+    Object.assign(
+      this,
+      {
+        methods:      [ 'GET' ],
+        contentType:  [ 'application/json', 'multipart/form-data' ],
+      },
+      attributes,
+    );
+
+    this.methods = Nife.arrayFlatten(Nife.toArray(this.methods || []).filter(Boolean).map((method) => {
+      if (method === '*')
+        return [ 'GET', 'PUT', 'POST', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS' ];
+
+      return ('' + method).toUpperCase();
+    }));
+
+    this.contentType = Nife.arrayFlatten(Nife.toArray(this.contentType || []).filter(Boolean).map((contentType) => {
+      if (contentType === '*')
+        return [];
+
+      if (contentType instanceof RegExp)
+        return contentType;
+
+      return ('' + contentType).split(';')[0].trim().toLowerCase();
+    }));
+
+    if (Nife.isEmpty(this.contentType))
+      this.contentType = null;
+  }
+
+  getParentScope = () => {
+    return this._parentScope;
+  };
+}
+
+module.exports = {
+  RouteEndpoint,
+};

package/src/controllers/routes/route-scope-base.d.ts

@@ -0,0 +1,29 @@
+import { GenericObject } from '../../interfaces/common';
+import { RouteCapture } from './route-capture';
+import { RouteEndpoint } from './route-endpoint';
+
+export declare type PathPart = string | RouteCapture;
+export declare type RoutePart = RouteScopeBase | RouteEndpoint;
+
+export declare interface RouteCallbackContext {
+  endpoint: RouteEndpoint;
+  pathParts: Array<PathPart>;
+  stop: (result: any) => void;
+  scope: RouteScopeBase;
+}
+
+export declare type RouteCallback = (context: RouteCallbackContext) => void;
+
+export declare class RouteScopeBase {
+  declare _parentScope: RouteScopeBase | null;
+  declare _pathParts: Array<PathPart>;
+  declare _routes: Map<PathPart, RoutePart>;
+  declare isDynamic: boolean;
+
+  public constructor(parentScope?: RouteScopeBase | null, pathParts?: Array<PathPart> | null);
+  public getParentScope(): RouteScopeBase | null;
+  public addRoute(pathPart: PathPart, scope: RoutePart): void;
+  public isDynamicPathPart(pathPart: PathPart): boolean;
+  public walkRoutes(callback: RouteCallback): any;
+  public findFirstMatchingRoute(request: Request): { endpoint?: RouteEndpoint, params?: GenericObject, error?: string };
+}

package/src/controllers/routes/route-scope-base.js

@@ -0,0 +1,196 @@
+'use strict';
+
+const Nife              = require('nife');
+const { RouteCapture }  = require('./route-capture');
+const { RouteEndpoint } = require('./route-endpoint');
+
+class RouteScopeBase {
+  constructor(parentScope, pathParts) {
+    Object.defineProperties(this, {
+      '_parentScope': {
+        writable:     false,
+        enumerable:   false,
+        configurable: false,
+        value:        parentScope || null,
+      },
+      '_pathParts': {
+        writable:     false,
+        enumerable:   false,
+        configurable: false,
+        value:        pathParts || [],
+      },
+      '_routes': {
+        writable:     true,
+        enumerable:   false,
+        configurable: true,
+        value:        new Map(),
+      },
+      '_routeMatchCache': {
+        writable:     true,
+        enumerable:   false,
+        configurable: true,
+        value:        new Map(),
+      },
+      'isDynamic': {
+        writable:     true,
+        enumerable:   false,
+        configurable: true,
+        value:        false,
+      },
+    });
+  }
+
+  getParentScope = () => {
+    return this._parentScope;
+  };
+
+  addRoute(pathPart, scope) {
+    let set = this._routes.get(pathPart);
+    if (!set) {
+      set = new Set();
+      this._routes.set(pathPart, set);
+    }
+
+    set.add(scope);
+  }
+
+  isDynamicPathPart(pathPart) {
+    if (pathPart instanceof RouteCapture)
+      return true;
+
+    return false;
+  }
+
+  walkRoutes(callback) {
+    const walk = (routeScope, pathParts) => {
+      for (let [ pathPart, children ] of routeScope._routes) {
+        if (isStopped)
+          break;
+
+        let newPathParts = pathParts.concat(pathPart);
+        for (let child of children) {
+          if (child instanceof RouteEndpoint)
+            callback({ endpoint: child, pathParts: newPathParts, stop, scope: routeScope });
+          else
+            walk(child, newPathParts);
+        }
+      }
+    };
+
+    let finalResult;
+    let isStopped = false;
+    let stop      = (result) => {
+      isStopped = true;
+      finalResult = result;
+    };
+
+    walk(this, []);
+
+    return finalResult;
+  }
+
+  findFirstMatchingRoute(request) {
+    let method      = request.method.toUpperCase();
+    let contentType = Nife.get(request, 'headers.content-type');
+    let path        = decodeURIComponent(request.path);
+
+    if (contentType) {
+      contentType = contentType.split(';')[0];
+      if (contentType)
+        contentType = contentType.trim().toLowerCase();
+    }
+
+    let cacheKey    = `${method}:${contentType}:${path}`;
+    let routeMatch  = this._routeMatchCache.get(cacheKey);
+    if (routeMatch)
+      return routeMatch;
+
+    const matchesPathParts = (pathParts) => {
+      let params = {};
+
+      for (let i = 0, il = pathParts.length; i < il; i++) {
+        let pathPart          = pathParts[i];
+        let incomingPathPart  = incomingPathParts[i] || '';
+
+        if (pathPart instanceof RouteCapture) {
+          let result = pathPart.matches({ value: incomingPathPart, request, method, path, contentType, params });
+          if (result == null) {
+            if (pathPart.isOptional())
+              continue;
+
+            return;
+          }
+
+          params[pathPart.getName()] = result;
+        } else {
+          if (pathPart !== incomingPathPart)
+            return;
+        }
+      }
+
+      return params;
+    };
+
+    const contentTypeMatches = (endpointContentTypes) => {
+      if (!endpointContentTypes || !contentType)
+        return true;
+
+      for (let i = 0, il = endpointContentTypes.length; i < il; i++) {
+        let thisContentType = endpointContentTypes[i];
+        if ((thisContentType instanceof RegExp) && thisContentType.test(contentType))
+          return true;
+        else if (thisContentType === contentType)
+          return true;
+      }
+
+      return false;
+    };
+
+    let incomingPathParts = path.trim().replace(/^\/+/, '').split('/');
+    let possibleMatch;
+
+    let result = this.walkRoutes(({ endpoint, pathParts, stop }) => {
+      // Does method match route?
+      if (endpoint.methods.indexOf(method) < 0)
+        return;
+
+      // Because of optional capture groups, it is possible
+      // that the length could deviate by one.
+      if (pathParts.length !== incomingPathParts.length) {
+        if (Math.abs(pathParts.length - incomingPathParts.length) > 1)
+          return;
+
+        let lastPathPart = pathParts[pathParts.length - 1];
+        if (!((lastPathPart instanceof RouteCapture) && lastPathPart.isOptional()))
+          return;
+      }
+
+      let params = matchesPathParts(pathParts);
+      if (params) {
+        // Does the contentType match?
+        if ((method !== 'GET' && method !== 'HEAD') && !contentTypeMatches(endpoint.contentType)) {
+          possibleMatch = endpoint;
+          return;
+        }
+
+        return stop({ endpoint, params });
+      }
+    });
+
+    if (!result) {
+      if (possibleMatch)
+        return { endpoint: possibleMatch, error: 'BadContentType' };
+
+      return {};
+    }
+
+    if (!result.endpoint.isDynamic)
+      this._routeMatchCache.set(cacheKey, result);
+
+    return result;
+  }
+}
+
+module.exports = {
+  RouteScopeBase,
+};