mythix 2.11.0 → 2.11.2

package/package.json

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

package/src/cli/routes-command.js

@@ -1,6 +1,5 @@
 'use strict';
 
-const Nife              = require('nife');
 const { defineCommand } = require('./cli-utils');
 const { Logger }        = require('../logger');
 
@@ -26,9 +25,14 @@ module.exports = defineCommand('routes', ({ Parent }) => {
 
       routes.walkRoutes(({ endpoint }) => {
         let methods = endpoint.methods;
+        let flags   = [
+          (endpoint.isDynamic) ? 'dynamic' : '',
+          (endpoint.cors) ? 'COR' : '',
+        ].filter(Boolean).join(', ');
+
         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)' : ''}`);
+          console.log(`  ${method}${whitespace.substring(0, whitespace.length - method.length)}/${endpoint.path} -> [${endpoint.controller}]${(flags) ? ` (${flags})` : ''}`);
         }
       });
     }

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

@@ -3,6 +3,13 @@ import { RouteScopeBase } from './route-scope-base';
 
 export declare type EndpointMethods = 'GET' | 'PUT' | 'POST' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS' | '*';
 
+export declare interface EndpointCORsOptions {
+  allowOrigin: string;
+  allowMethods?: string | Array<string>;
+  allowHeaders?: string | Array<string>;
+  maxAge?: number;
+}
+
 export declare interface EndpointOptions {
   name?: string;
   methods?: Array<EndpointMethods> | EndpointMethods;
@@ -12,6 +19,7 @@ export declare interface EndpointOptions {
   help?: GenericObject;
   queryParams?: GenericObject;
   middleware?: Array<Function>;
+  cors?: boolean | EndpointCORsOptions;
   [key: string | symbol]: any;
 }
 

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

@@ -4,6 +4,15 @@ const Nife = require('nife');
 
 class RouteEndpoint {
   constructor(parentScope, attributes) {
+    const mapMethods = (methods) => {
+      return Nife.arrayFlatten(Nife.toArray(methods || []).filter(Boolean).map((method) => {
+        if (method === '*')
+          return [ 'GET', 'PUT', 'POST', 'PATCH', 'DELETE', 'HEAD' ];
+
+        return ('' + method).toUpperCase();
+      }));
+    };
+
     Object.defineProperties(this, {
       '_parentScope': {
         writable:     false,
@@ -28,12 +37,8 @@ class RouteEndpoint {
       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.methods = mapMethods(this.methods);
+    this.methods = Nife.uniq(this.methods.concat('OPTIONS'));
 
     this.contentType = Nife.arrayFlatten(Nife.toArray(this.contentType || []).filter(Boolean).map((contentType) => {
       if (contentType === '*')
@@ -47,6 +52,38 @@ class RouteEndpoint {
 
     if (Nife.isEmpty(this.contentType))
       this.contentType = null;
+
+    let cors = this.cors;
+    if (cors) {
+      if (cors === true)
+        cors = this.cors = {};
+
+      if (cors.allowOrigin == null)
+        cors.allowOrigin = '*';
+
+      if (cors.allowMethods == null)
+        cors.allowMethods = this.methods;
+
+      if (cors.allowHeaders == null) {
+        cors.allowHeaders = [
+          'DNT',
+          'User-Agent',
+          'X-Requested-With',
+          'If-Modified-Since',
+          'Cache-Control',
+          'Content-Type',
+          'Range',
+        ];
+      }
+
+      if (cors.maxAge == null)
+        cors.maxAge = 86400;
+
+      cors.allowMethods = mapMethods(cors.allowMethods).join(',');
+
+      if (Array.isArray(cors.allowHeaders))
+        cors.allowHeaders = cors.allowHeaders.filter(Boolean).join(',');
+    }
   }
 
   getParentScope = () => {

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

@@ -5,7 +5,7 @@ const { RouteCapture }  = require('./route-capture');
 const { RouteEndpoint } = require('./route-endpoint');
 
 class RouteScopeBase {
-  constructor(parentScope, pathParts) {
+  constructor(parentScope, pathParts, options) {
     Object.defineProperties(this, {
       '_parentScope': {
         writable:     false,
@@ -19,6 +19,12 @@ class RouteScopeBase {
         configurable: false,
         value:        pathParts || [],
       },
+      '_options': {
+        writable:     true,
+        enumerable:   false,
+        configurable: true,
+        value:        Nife.extend(true, {}, ((parentScope && parentScope.getOptions()) || {}), (options || {})),
+      },
       '_routes': {
         writable:     true,
         enumerable:   false,
@@ -44,6 +50,15 @@ class RouteScopeBase {
     return this._parentScope;
   };
 
+  getOptions = () => {
+    return this._options;
+  };
+
+  updateOptions = (newOptions) => {
+    let options = this.getOptions();
+    this._options = Nife.extend(true, {}, (newOptions || {}));
+  };
+
   addRoute(pathPart, route) {
     let set = this._routes.get(pathPart);
     if (!set) {
@@ -60,8 +75,10 @@ class RouteScopeBase {
       return;
 
     let firstRoute = Array.from(set.values()).find((route) => {
-      if (route instanceof RouteScopeBase)
-        return true;
+      if (route instanceof RouteScopeBase) {
+        if (route._pathParts && route._pathParts[route._pathParts.length - 1] === pathPart)
+          return true;
+      }
 
       return false;
     });

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

@@ -4,7 +4,7 @@ import { EndpointOptions } from './route-endpoint';
 import { PathPart, RouteScopeBase } from './route-scope-base';
 
 export declare class RouteScope extends RouteScopeBase {
-  public path(pathPart: PathPart, callback: (context: RouteScope) => void): void;
+  public path(pathPart: PathPart, callback: (context: RouteScope) => void, options?: GenericObject): void;
   public endpoint(pathPart: PathPart, options: EndpointOptions | string): void;
   public capture(paramName: string, _helperOrOptions?: RouteCaptureHelper | GenericObject, _options?: RouteCaptureOptions): RouteCapture;
 }

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

@@ -6,7 +6,7 @@ const { RouteScopeBase }  = require('./route-scope-base');
 const { RouteEndpoint }   = require('./route-endpoint');
 
 class RouteScope extends RouteScopeBase {
-  path = (_pathPart, callback) => {
+  path = (_pathPart, callback, options) => {
     let pathPart = _pathPart;
     if (!Nife.instanceOf(pathPart, 'string') && !(pathPart instanceof RouteCapture))
       throw new TypeError('RouteScope::path: First argument must be a string or a capture.');
@@ -16,9 +16,11 @@ class RouteScope extends RouteScopeBase {
 
     let routeScope = this.getPathRoute(pathPart);
     if (!routeScope) {
-      routeScope = new RouteScope(this, this._pathParts.concat(pathPart));
+      routeScope = new RouteScope(this, this._pathParts.concat(pathPart), options);
       routeScope.isDynamic = this.isDynamic || this.isDynamicPathPart(pathPart);
       this.addRoute(pathPart, routeScope);
+    } else if (options) {
+      routeScope.updateOptions(options);
     }
 
     callback(routeScope);
@@ -32,6 +34,7 @@ class RouteScope extends RouteScopeBase {
       throw new TypeError('RouteScope::endpoint: Endpoint "options" required.');
 
     let options = (Nife.instanceOf(_options, 'string')) ? { controller: ('' + _options) } : { ..._options };
+    options = Nife.extend(true, {}, (this.getOptions() || {}).endpointDefaults || {}, options);
     options.path = this._pathParts.concat(pathPart).join('/');
 
     let endpoint  = new RouteEndpoint(this, options);

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

@@ -317,17 +317,40 @@ class HTTPServer {
   }
 
   async baseRouter(request, response, next) {
-    let startTime   = Nife.now();
-    let application = this.getApplication();
+    let startTime     = Nife.now();
+    let application   = this.getApplication();
+    let requestMethod = ('' + request.method).toUpperCase();
     let controllerInstance;
     let logger;
 
     try {
       logger = this.createRequestLogger(application, request);
-      logger.info('Starting request');
+      logger.info(`Starting request: ${requestMethod} ${decodeURIComponent(request.path)}`);
 
       let { endpoint, params } = (this.findFirstMatchingRoute(request, this.routes) || {});
 
+      // CORS
+      let cors = endpoint.cors;
+      if (!cors && requestMethod === 'OPTIONS') {
+        response.header('Content-Type', 'text/plain; charset=UTF-8');
+        response.status(403);
+        response.end();
+
+        let requestTime = Nife.now() - startTime;
+        logger.log(`Completed request in ${requestTime.toFixed(REQUEST_TIME_RESOLUTION)}ms: 403 Forbidden`);
+
+        return;
+      }
+
+      if (cors) {
+        response.header('Access-Control-Allow-Origin', cors.allowOrigin);
+        response.header('Access-Control-Allow-Methods', cors.allowMethods);
+        response.header('Access-Control-Allow-Headers', cors.allowHeaders);
+
+        if (cors.maxAge != null)
+          response.header('Access-Control-Max-Age', cors.maxAge);
+      }
+
       request.params = params || {};
 
       let _controller = this.getRouteController(endpoint.controller, endpoint, params, request);