mythix 3.0.0 → 4.0.2

package/lib/controllers/controller-module.mjs

@@ -0,0 +1,70 @@
+import Nife             from 'nife';
+import { ModuleBase }   from '../modules/module-base.mjs';
+
+export class ControllerModule extends ModuleBase {
+  static getOptionsScopeName() {
+    return 'controllers';
+  }
+
+  static shouldUse(application, options) {
+    if (options.httpServer === false)
+      return false;
+
+    return true;
+  }
+
+  constructor(application, opts) {
+    super(application, opts);
+
+    let _controllers;
+
+    Object.defineProperties(this, {
+      'controllers': {
+        enumerable:   false,
+        configurable: true,
+        get:          () => {
+          if (!_controllers)
+            _controllers = application.getAppControllerClasses();
+
+          return _controllers;
+        },
+        set:          () => {},
+      },
+    });
+
+    // Inject methods into the application
+    Object.defineProperties(application, {
+      'getController': {
+        writable:     true,
+        enumerable:   false,
+        configurable: true,
+        value:        this.getController.bind(this),
+      },
+    });
+  }
+
+  getController(name) {
+    let controllers     = this.controllers;
+    let controllerName  = name.replace(/(.*?)\b\w+$/, '$1');
+    let methodName      = name.substring(controllerName.length);
+    if (!methodName)
+      methodName = undefined;
+
+    controllerName = controllerName.replace(/\W+$/g, '');
+
+    return {
+      controller:       Nife.get(controllers, controllerName),
+      controllerMethod: methodName,
+    };
+  }
+
+  async start() {
+    let application = this.getApplication();
+    let httpServer  = (typeof application.getHTTPServer === 'function') ? application.getHTTPServer() : null;
+
+    httpServer.setRoutes(application._getRoutes());
+  }
+
+  async stop() {
+  }
+}

package/lib/controllers/generate-client-api-interface-spec.mjs

@@ -0,0 +1,44 @@
+import { generateClientAPIInterface } from './generate-client-api-interface.mjs';
+import { newTestApplication }         from '../../spec/support/application.mjs';
+import { matchesSnapshot }            from '../../spec/support/snapshots.mjs';
+
+function getRoutes() {
+}
+
+describe('generateClientAPIInterface', () => {
+  let app;
+
+  beforeAll(async () => {
+    try {
+      app = await newTestApplication();
+      app.getRoutes = getRoutes.bind(app);
+    } catch (error) {
+      console.error('Error in beforeAll: ', error);
+    }
+  });
+
+  it('should be able to generate an interface using route definitions', () => {
+    let result = generateClientAPIInterface(app);
+    expect(matchesSnapshot(result)).toBe(true);
+  });
+
+  it('should be able to generate an interface for node', () => {
+    let result = generateClientAPIInterface(app, { environment: 'node' });
+    expect(matchesSnapshot(result)).toBe(true);
+  });
+
+  it('should be able to generate an interface for the browser', () => {
+    let result = generateClientAPIInterface(app, { environment: 'browser' });
+    expect(matchesSnapshot(result)).toBe(true);
+  });
+
+  it('should be able to export a global', () => {
+    let result = generateClientAPIInterface(app, { globalName: 'API' });
+    expect(matchesSnapshot(result)).toBe(true);
+  });
+
+  it('should be able to specify a domain', () => {
+    let result = generateClientAPIInterface(app, { domain: 'http://localhost:8080' });
+    expect(matchesSnapshot(result)).toBe(true);
+  });
+});

package/{src → lib}/controllers/generate-client-api-interface.d.ts

@@ -8,6 +8,7 @@ export declare interface GenerateClientInterfaceOptions {
   mode?: string;
   domain?: string;
   routeFilter?: ((value: any, index?: number) => boolean) | RegExp | string;
+  type?: 'module' | 'commonjs';
 }
 
 export declare function generateClientAPIInterface(application: Application, options?: GenerateClientInterfaceOptions): string;

package/{src/controllers/generate-client-api-interface.js → lib/controllers/generate-client-api-interface.mjs}

@@ -1,9 +1,8 @@
-'use strict';
+/* eslint-disable no-magic-numbers */
+/* global Utils, globalScope, HTTP */
 
-/* global Buffer, Utils, globalScope */
-
-const Nife      = require('nife');
-const HTTPUtils = require('../utils/http-utils');
+import Nife           from 'nife';
+import * as HTTPUtils from '../utils/http-utils.mjs';
 
 function tabIn(str, amount) {
   var padding = ''.padStart((amount || 1) * 2, ' ');
@@ -26,11 +25,11 @@ function nodeRequestHandler(routeName, requestOptions) {
       return;
     }
 
-    var HTTP  = (requestOptions.httpModule) ? requestOptions.httpModule : require('http');
-    var URL   = require('url');
+    var HTTPModule  = (requestOptions.httpModule) ? requestOptions.httpModule : HTTP;
+    var URLModule   = (requestOptions.urlModule) ? requestOptions.urlModule : URL;
 
     var method      = (requestOptions.method || 'GET').toUpperCase();
-    var url         = new URL.URL(requestOptions.url);
+    var url         = new URLModule.URL(requestOptions.url);
     var data        = requestOptions.data;
     var extraConfig = {};
     var headers     = Object.assign({}, Utils.keysToLowerCase(this.defaultHeaders || {}), Utils.keysToLowerCase(requestOptions.headers || {}));
@@ -54,7 +53,7 @@ function nodeRequestHandler(routeName, requestOptions) {
       } else {
         var queryString = Utils.dataToQueryString(data);
         if (queryString) {
-          var newParams = new URL.URLSearchParams(queryString);
+          var newParams = new URLModule.URLSearchParams(queryString);
           var keys      = Array.from(newParams.keys());
 
           for (var i = 0, il = keys.length; i < il; i++) {
@@ -88,7 +87,7 @@ function nodeRequestHandler(routeName, requestOptions) {
 
     delete options.data;
 
-    var thisRequest = HTTP.request(Utils.cleanObjectProperties(options), function(response) {
+    var thisRequest = HTTPModule.request(Utils.cleanObjectProperties(options), function(response) {
       var responseData = Buffer.alloc(0);
 
       response.on('data', function(chunk) {
@@ -616,6 +615,7 @@ function generateAPIInterface(routes, _options) {
     }
 
     var apiInterface = Object.create({
+      ${(environment === 'node') ? 'loaded: () => Promise.all(_loadingPromises).then(() => true)' : 'loaded: () => Promise.resolve(true)'},
       defaultHeaders: {},
       makeRequest,
       getDefaultHeader,
@@ -632,17 +632,44 @@ function generateAPIInterface(routes, _options) {
   }`;
 }
 
-function generateClientAPIInterface(application, _options) {
+export function generateClientAPIInterface(application, _options) {
   var options     = _options || {};
   var routes      = application._getRoutes();
   var globalName  = (Object.prototype.hasOwnProperty.call(options, 'globalName')) ? options.globalName : '';
+  var environment = options.environment;
 
   if (Nife.isNotEmpty(globalName))
     globalName = `globalScope['${globalName}'] = APIInterface`;
   else
     globalName = '';
 
-  return `'use strict';\n
+  var preamble;
+  if (options.type === 'commonjs') {
+    preamble = [ '\'use strict\';\n' ];
+
+    if (environment === 'node') {
+      preamble = preamble.concat([
+        'var HTTP = require(\'node:http\');',
+        'var URL = require(\'node:url\');',
+        'var _loadingPromises = [ Promise.resolve() ];',
+      ]);
+    }
+  } else {
+    if (environment === 'node') {
+      preamble = [
+        'var HTTP;',
+        'var URL;',
+        'var _loadingPromises = [',
+        '  import(\'node:http\').then((M) => (HTTP = M), (error) => { throw error }),',
+        '  import(\'node:url\').then((M) => (URL = M), (error) => { throw error }),',
+        '];',
+      ];
+    } else {
+      preamble = [ '\'use strict\';\n' ];
+    }
+  }
+
+  return `${preamble.join('\n')}
 (function(globalScope, environmentType) {
   ${generateUtils()}\n
   ${tabIn(generateAPIInterface(routes, options), 1)}\n
@@ -655,7 +682,3 @@ function generateClientAPIInterface(application, _options) {
 }).call(this, (typeof window === 'undefined') ? global : window, (typeof window !== 'undefined') ? 'browser' : 'node');
 `;
 }
-
-module.exports = {
-  generateClientAPIInterface,
-};

package/{src → lib}/controllers/index.d.ts

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

package/lib/controllers/index.mjs

@@ -0,0 +1,4 @@
+export * from './controller-base.mjs';
+export * from './controller-module.mjs';
+export * from './generate-client-api-interface.mjs';
+export * as Routes from './routes/index.mjs';

package/lib/controllers/routes/index.mjs

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

package/{src/controllers/routes/route-capture.js → lib/controllers/routes/route-capture.mjs}

@@ -1,8 +1,6 @@
-'use strict';
+import Nife  from 'nife';
 
-const Nife = require('nife');
-
-class RouteCapture {
+export class RouteCapture {
   constructor(parentScope, paramName, _helperOrOptions, _options) {
     let helper;
     let options;
@@ -93,7 +91,3 @@ class RouteCapture {
     return `<<${paramName}${(optional) ? '?' : ''}>>`;
   }
 }
-
-module.exports = {
-  RouteCapture,
-};

package/{src/controllers/routes/route-endpoint.js → lib/controllers/routes/route-endpoint.mjs}

@@ -1,8 +1,6 @@
-'use strict';
+import Nife  from 'nife';
 
-const Nife = require('nife');
-
-class RouteEndpoint {
+export class RouteEndpoint {
   constructor(parentScope, attributes) {
     const mapMethods = (methods) => {
       return Nife.arrayFlatten(Nife.toArray(methods || []).filter(Boolean).map((method) => {
@@ -26,6 +24,12 @@ class RouteEndpoint {
         configurable: true,
         value:        false,
       },
+      'isEndpoint': {
+        writable:     true,
+        enumerable:   false,
+        configurable: true,
+        value:        true,
+      },
     });
 
     Object.assign(
@@ -90,7 +94,3 @@ class RouteEndpoint {
     return this._parentScope;
   };
 }
-
-module.exports = {
-  RouteEndpoint,
-};

package/{src/controllers/routes/route-scope-base.js → lib/controllers/routes/route-scope-base.mjs}

@@ -1,10 +1,7 @@
-'use strict';
+import Nife               from 'nife';
+import { RouteCapture }   from './route-capture.mjs';
 
-const Nife              = require('nife');
-const { RouteCapture }  = require('./route-capture');
-const { RouteEndpoint } = require('./route-endpoint');
-
-class RouteScopeBase {
+export class RouteScopeBase {
   constructor(parentScope, pathParts, options) {
     Object.defineProperties(this, {
       '_parentScope': {
@@ -43,6 +40,12 @@ class RouteScopeBase {
         configurable: true,
         value:        false,
       },
+      'isEndpoint': {
+        writable:     true,
+        enumerable:   false,
+        configurable: true,
+        value:        false,
+      },
     });
   }
 
@@ -56,7 +59,7 @@ class RouteScopeBase {
 
   updateOptions = (newOptions) => {
     let options = this.getOptions();
-    this._options = Nife.extend(true, {}, (newOptions || {}));
+    this._options = Nife.extend(true, {}, options, (newOptions || {}));
   };
 
   addRoute(pathPart, route) {
@@ -101,7 +104,7 @@ class RouteScopeBase {
 
         let newPathParts = pathParts.concat(pathPart);
         for (let child of children) {
-          if (child instanceof RouteEndpoint)
+          if (child.isEndpoint)
             callback({ endpoint: child, pathParts: newPathParts, stop, scope: routeScope });
           else
             walk(child, newPathParts);
@@ -137,7 +140,7 @@ class RouteScopeBase {
     if (routeMatch)
       return routeMatch;
 
-    const matchesPathParts = (pathParts) => {
+    const matchesPathParts = (pathParts, endpoint) => {
       let params = {};
 
       for (let i = 0, il = pathParts.length; i < il; i++) {
@@ -160,6 +163,11 @@ class RouteScopeBase {
         }
       }
 
+      // If this is a wild endpoint, then grab the remaining path
+      // and store it as a param named "_relativePath"
+      if (endpoint.wild && pathParts[pathParts.length - 1] === incomingPathParts[pathParts.length - 1])
+        params['_relativePath'] = incomingPathParts.slice(pathParts.length).join('/');
+
       return params;
     };
 
@@ -188,7 +196,7 @@ class RouteScopeBase {
 
       // Because of optional capture groups, it is possible
       // that the length could deviate by one.
-      if (pathParts.length !== incomingPathParts.length) {
+      if (pathParts.length !== incomingPathParts.length && endpoint.wild !== true) {
         if (Math.abs(pathParts.length - incomingPathParts.length) > 1)
           return;
 
@@ -197,7 +205,7 @@ class RouteScopeBase {
           return;
       }
 
-      let params = matchesPathParts(pathParts);
+      let params = matchesPathParts(pathParts, endpoint);
       if (params) {
         // Does the contentType match?
         if ((method !== 'GET' && method !== 'HEAD') && !contentTypeMatches(endpoint.contentType)) {
@@ -222,7 +230,3 @@ class RouteScopeBase {
     return result;
   }
 }
-
-module.exports = {
-  RouteScopeBase,
-};

package/{src/controllers/routes/route-scope.js → lib/controllers/routes/route-scope.mjs}

@@ -1,12 +1,13 @@
-'use strict';
+import Nife                 from 'nife';
+import { RouteCapture }     from './route-capture.mjs';
+import { RouteScopeBase }   from './route-scope-base.mjs';
+import { RouteEndpoint }    from './route-endpoint.mjs';
 
-const Nife                = require('nife');
-const { RouteCapture }    = require('./route-capture');
-const { RouteScopeBase }  = require('./route-scope-base');
-const { RouteEndpoint }   = require('./route-endpoint');
-
-class RouteScope extends RouteScopeBase {
+export class RouteScope extends RouteScopeBase {
   path = (_pathPart, callback, options) => {
+    if (typeof callback !== 'function')
+      return this.endpoint(_pathPart, { ...(options || {}), wild: true });
+
     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.');
@@ -23,7 +24,8 @@ class RouteScope extends RouteScopeBase {
       routeScope.updateOptions(options);
     }
 
-    callback(routeScope);
+    if (typeof callback === 'function')
+      callback(routeScope);
   };
 
   endpoint = (pathPart, _options) => {
@@ -47,7 +49,3 @@ class RouteScope extends RouteScopeBase {
     return new RouteCapture(this, ...args);
   };
 }
-
-module.exports = {
-  RouteScope,
-};

package/{src/http-server/http-errors.js → lib/http/http-errors.mjs}

@@ -1,10 +1,9 @@
+/* eslint-disable no-magic-numbers */
 /* eslint-disable max-classes-per-file */
 
-'use strict';
+import { statusCodeToMessage }  from '../utils/http-utils.mjs';
 
-const { statusCodeToMessage } = require('../utils/http-utils');
-
-class HTTPBaseError extends Error {
+export class HTTPBaseError extends Error {
   constructor(route, message, _statusCode) {
     let statusCode  = _statusCode || 500;
 
@@ -20,19 +19,19 @@ class HTTPBaseError extends Error {
   }
 }
 
-class HTTPNotFoundError extends HTTPBaseError {
+export class HTTPNotFoundError extends HTTPBaseError {
   constructor(route, message) {
     super(route, message, 404);
   }
 }
 
-class HTTPBadRequestError extends HTTPBaseError {
+export class HTTPBadRequestError extends HTTPBaseError {
   constructor(route, message) {
     super(route, message, 400);
   }
 }
 
-class HTTPBadContentTypeError extends HTTPBaseError {
+export class HTTPBadContentTypeError extends HTTPBaseError {
   constructor(route, message) {
     super(route, message, 400);
   }
@@ -64,30 +63,20 @@ class HTTPBadContentTypeError extends HTTPBaseError {
   }
 }
 
-class HTTPUnauthorizedError extends HTTPBaseError {
+export class HTTPUnauthorizedError extends HTTPBaseError {
   constructor(route, message) {
     super(route, message, 401);
   }
 }
 
-class HTTPForbiddenError extends HTTPBaseError {
+export class HTTPForbiddenError extends HTTPBaseError {
   constructor(route, message) {
     super(route, message, 403);
   }
 }
 
-class HTTPInternalServerError extends HTTPBaseError {
+export class HTTPInternalServerError extends HTTPBaseError {
   constructor(route, message) {
     super(route, message, 500);
   }
 }
-
-module.exports = {
-  HTTPBadContentTypeError,
-  HTTPBadRequestError,
-  HTTPBaseError,
-  HTTPForbiddenError,
-  HTTPInternalServerError,
-  HTTPNotFoundError,
-  HTTPUnauthorizedError,
-};

package/{src/utils/http-interface.js → lib/http/http-interface.mjs}

@@ -1,14 +1,10 @@
-'use strict';
+import http                       from 'node:http';
+import https                      from 'node:https';
+import { URL, URLSearchParams }   from 'node:url';
+import Nife                       from 'nife';
+import { dataToQueryString }      from '../utils/http-utils.mjs';
 
-/* global Buffer */
-
-const Nife                      = require('nife');
-const http                      = require('node:http');
-const https                     = require('node:https');
-const { URL, URLSearchParams }  = require('node:url');
-const { dataToQueryString }     = require('./http-utils');
-
-class HTTPInterface {
+export class HTTPInterface {
   constructor() {
     Object.defineProperties(this, {
       'defaultURL': {
@@ -236,7 +232,3 @@ class HTTPInterface {
     return this.makeRequest(this.getRequestOptions(url, options, 'OPTIONS'));
   }
 }
-
-module.exports = {
-  HTTPInterface,
-};

package/{src/http-server → lib/http}/http-server-module.d.ts

@@ -1,8 +1,8 @@
-import { BaseModule } from '../modules/base-module';
+import { ModuleBase } from '../modules/module-base';
 import { GenericObject } from '../interfaces/common';
 import { HTTPServer } from './http-server';
 
-export declare class HTTPServerModule extends BaseModule {
+export declare class HTTPServerModule extends ModuleBase {
   public getHTTPServer(): HTTPServer | null;
   public getHTTPServerConfig(): GenericObject;
   public createHTTPServer(httpServerConfig: GenericObject): HTTPServer;

package/{src/http-server/http-server-module.js → lib/http/http-server-module.mjs}

@@ -1,10 +1,12 @@
-'use strict';
+import Nife             from 'nife';
+import { ModuleBase }   from '../modules/module-base.mjs';
+import { HTTPServer }   from './http-server.mjs';
 
-const Nife            = require('nife');
-const { BaseModule }  = require('../modules/base-module');
-const { HTTPServer }  = require('./http-server');
+export class HTTPServerModule extends ModuleBase {
+  static getOptionsScopeName() {
+    return 'httpServer';
+  }
 
-class HTTPServerModule extends BaseModule {
   static shouldUse(application, options) {
     if (options.httpServer === false)
       return false;
@@ -12,10 +14,6 @@ class HTTPServerModule extends BaseModule {
     return true;
   }
 
-  static getModuleName() {
-    return 'HTTPServerModule';
-  }
-
   constructor(application) {
     super(application);
 
@@ -102,5 +100,3 @@ class HTTPServerModule extends BaseModule {
     this.getLogger().info('HTTP server stopped successfully!');
   }
 }
-
-module.exports = { HTTPServerModule };

package/{src/http-server/http-server.js → lib/http/http-server.mjs}

@@ -1,34 +1,32 @@
-'use strict';
-
-/* global Buffer */
-
-const Path          = require('path');
-const FileSystem    = require('fs');
-const HTTP          = require('http');
-const HTTPS         = require('https');
-const Nife          = require('nife');
-const Express       = require('express');
-const ExpressBusBoy = require('express-busboy');
-
-const {
+import Path           from 'node:path';
+import FileSystem     from 'node:fs';
+import HTTP           from 'node:http';
+import HTTPS          from 'node:https';
+import Nife           from 'nife';
+import Express        from 'express';
+import ExpressBusBoy  from 'express-busboy';
+
+import {
   HTTPBaseError,
   HTTPNotFoundError,
   HTTPBadRequestError,
   HTTPBadContentTypeError,
   HTTPInternalServerError,
-} = require('./http-errors');
+} from './http-errors.mjs';
 
-const {
+import {
   statusCodeToMessage,
-} = require('../utils/http-utils');
+} from '../utils/http-utils.mjs';
 
 const REQUEST_ID_POSTFIX_LENGTH = 4;
 const REQUEST_TIME_RESOLUTION   = 3;
 
 const DEFAULT_FILE_UPLOAD_BUFFER_SIZE = 2 * (1024 * 1024); // 2mb
+
+// eslint-disable-next-line no-magic-numbers
 const DEFAULT_FILE_UPLOAD_SIZE_LIMIT  = 10 * (1024 * 1024); // 10mb
 
-class HTTPServer {
+export class HTTPServer {
   constructor(application, _opts) {
     let uploadPath = Path.resolve(application.getTempPath(), 'uploads');
 
@@ -333,6 +331,8 @@ class HTTPServer {
       let cors = endpoint.cors;
       if (!cors && requestMethod === 'OPTIONS') {
         response.header('Content-Type', 'text/plain; charset=UTF-8');
+
+        // eslint-disable-next-line no-magic-numbers
         response.status(403);
         response.end();
 
@@ -535,7 +535,3 @@ class HTTPServer {
     }
   }
 }
-
-module.exports = {
-  HTTPServer,
-};

package/lib/http/index.d.ts

@@ -0,0 +1,4 @@
+export * from './http-errors';
+export * from './http-server';
+export * from './http-server-module';
+export * from './http-interface';

package/lib/http/index.mjs

@@ -0,0 +1,5 @@
+export * as HTTPErrors from './http-errors.mjs';
+export * from './http-server.mjs';
+export * from './http-server-module.mjs';
+export * from './http-interface.mjs';
+