mythix 2.4.14 → 2.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mythix",
-  "version": "2.4.14",
+  "version": "2.5.2",
   "description": "Mythix is a NodeJS web-app framework",
   "main": "src/index",
   "scripts": {
@@ -20,19 +20,21 @@
   "homepage": "https://github.com/th317erd/mythix#readme",
   "devDependencies": {
     "@spothero/eslint-plugin-spothero": "github:spothero/eslint-plugin-spothero",
+    "@types/node": "^18.7.17",
     "colors": "^1.4.0",
     "diff": "^5.1.0",
-    "eslint": "^8.13.0",
-    "jasmine": "^4.0.2"
+    "eslint": "^8.23.1",
+    "jasmine": "^4.4.0"
   },
   "dependencies": {
+    "@types/events": "^3.0.0",
     "chokidar": "^3.5.3",
-    "cmded": "^1.2.1",
-    "express": "^4.17.3",
+    "cmded": "^1.2.3",
+    "express": "^4.18.1",
     "express-busboy": "github:th317erd/express-busboy#0754a570d7979097b31e48655b80d3fcd628d4e4",
     "form-data": "^4.0.0",
-    "mythix-orm": "^1.5.6",
-    "nife": "^1.11.3",
+    "mythix-orm": "^1.6.2",
+    "nife": "^1.12.1",
     "prompts": "^2.4.2"
   }
 }

package/src/application.d.ts

@@ -0,0 +1,88 @@
+import { ConnectionBase, ModelClass, Models } from 'mythix-orm';
+import { ControllerClass } from './controllers/controller-base';
+import { HTTPServer } from './http-server/http-server';
+import { GenericObject } from './interfaces/common';
+import { Logger, LoggerClass, LoggerOptions } from './logger';
+import { Modules, ModuleClasses, BaseModuleClass } from './modules/base-module';
+
+export declare type ApplicationClass = typeof Application;
+
+export declare interface ApplicationOptions {
+  environment: string;
+  appName: string;
+  rootPath: string;
+  configPath: string;
+  migrationsPath: string;
+  modelsPath: string;
+  seedersPath: string;
+  controllersPath: string;
+  templatesPath: string;
+  commandsPath: string;
+  tasksPath: string;
+  modules: ModuleClasses;
+  autoReload: boolean;
+  exitOnShutdown: number | null;
+  runTasks: boolean;
+  testMode: boolean;
+  noInternalMigrationTable: boolean;
+  logger: LoggerOptions;
+  database: boolean | GenericObject;
+  httpServer: boolean | GenericObject;
+  tempPath: string;
+  routeParserTypes: { [ key: string ]: (value: string, param: GenericObject, index?: number) => any };
+}
+
+export declare class Application {
+  declare public static APP_NAME: string;
+
+  public static getDefaultModules(): ModuleClasses;
+  public static findModuleIndex(modules: ModuleClasses, moduleKlass: BaseModuleClass): number;
+  public static replaceModule(modules: ModuleClasses, moduleKlass: BaseModuleClass, replacementModuleKlass: BaseModuleClass): ModuleClasses;
+
+  public constructor(options?: ApplicationOptions);
+  public getTempPath(): string | null;
+  public getModules(): Modules;
+  public initializeModules(modules: ModuleClasses): Promise<void>;
+  public startAllModules(options: ApplicationOptions): Promise<void>;
+  public stopAllModules(options: ApplicationOptions): Promise<Array<Error>>;
+  public bindToProcessSignals(): void;
+  public getOptions(): ApplicationOptions;
+  public setOptions(options: ApplicationOptions): Application;
+  public loadConfig(configPath: string): GenericObject;
+  public getConfigValue(key: string, defaultValue?: any, type?: string): any;
+  public getConfig(): GenericObject;
+  public setConfig(options: GenericObject): Application;
+  public getApplicationName(): string;
+  public getRoutes(): GenericObject;
+  public getCustomRouteParserTypes(): { [ key: string ]: (value: string, param: GenericObject, index?: number) => any };
+  public createLogger(loggerOptions: LoggerOptions, LoggerClass: LoggerClass): Logger;
+  public getLogger(): Logger;
+  public start(): Promise<void>;
+  public stop(exitCode?: number): Promise<void>;
+
+  // From DatabaseModule
+  public getDBConfig(): GenericObject;
+  public getDBTablePrefix(): string | null;
+  public getDBConnection(): ConnectionBase;
+
+  // From FileWatcherModule
+  public autoReload(enable?: boolean, shuttingDown?: boolean): Promise<void>;
+
+  // From ModelModule
+  public getModel(modelName?: string): ModelClass | undefined;
+  public getModels(): Models;
+
+  // From ControllerModule
+  public getController(name: string): { controller: ControllerClass, controllerMethod: string | undefined };
+
+  // From HTTPServerModule
+  public getHTTPServer(): HTTPServer | null;
+  public getHTTPServerConfig(): GenericObject;
+
+  declare public isStarted: boolean;
+  declare public isStopping: boolean;
+  declare public options: ApplicationOptions;
+  declare public moduleInstances: Modules;
+  declare public config: GenericObject;
+  declare public logger: Logger;
+}

package/src/application.js

@@ -232,7 +232,10 @@ class Application extends EventEmitter {
     try {
       let appOptions = this.getOptions();
 
-      const config = require(configPath);
+      let config = require(configPath);
+      if (config.__esModule)
+        config = config['default'];
+
       return wrapConfig(Object.assign({}, config || {}, { environment: (appOptions.environment || config.environment || 'development')}));
     } catch (error) {
       this.getLogger().error(`Error while trying to load application configuration ${configPath}: `, error);
@@ -351,6 +354,4 @@ class Application extends EventEmitter {
   }
 }
 
-module.exports = {
-  Application,
-};
+module.exports = { Application };

package/src/cli/cli-utils.d.ts

@@ -0,0 +1,63 @@
+import { HelpInterface, Runner } from 'cmded';
+import { ConnectionBase } from 'mythix-orm';
+import { Application, ApplicationClass, ApplicationOptions } from '../application';
+import { GenericObject } from '../interfaces/common';
+import { Logger } from '../logger';
+
+export declare type CommandClass = typeof CommandBase;
+
+export declare type CommandClasses = { [ key: string ]: CommandClass };
+
+export declare class CommandBase {
+  declare public static commands: GenericObject;
+  declare public static commandName: string;
+  declare public static applicationConfig?: GenericObject | (() => GenericObject);
+  declare public static commandArguments?: () => { help: HelpInterface, runner: Runner };
+  declare public static runtimeArguments?: { [ key: string ]: Array<string> };
+  public static execute(): Promise<void>;
+
+  declare public application: Application;
+  declare public options: GenericObject;
+
+  constructor(application: Application, options?: GenericObject);
+  getOptions(): GenericObject;
+  getApplication(): Application;
+  getLogger(): Logger;
+  getDBConnection(): ConnectionBase;
+}
+
+export declare interface DefineCommandContext {
+  Parent: CommandClass;
+  commandName: string;
+}
+
+export declare function loadMythixConfig(
+  mythixConfigPath: string,
+  appRootPath: string
+): GenericObject;
+
+export declare function loadCommand(name: string): CommandClass;
+
+export declare function loadCommands(
+  applicationCommandsPath: string,
+  skip: Array<string>
+): CommandClasses;
+
+export declare function defineCommand(
+  commandName: string,
+  definer: (context: DefineCommandContext) => CommandClass,
+  parent?: string | CommandClass,
+): CommandClass;
+
+export declare function createApplication(
+  applicationClass: ApplicationClass,
+  options?: ApplicationOptions
+): Application;
+
+export declare function executeCommand(
+  config: GenericObject,
+  appOptions: ApplicationOptions,
+  commandContext: GenericObject,
+  CommandKlass: CommandClass,
+  argv: Array<string>
+): void;

package/src/cli/cli-utils.js

@@ -5,7 +5,7 @@
 const Path        = require('path');
 const FileSystem  = require('fs');
 const Nife        = require('nife');
-const { Logger }  = require('../logger');
+const Logger      = require('../logger');
 
 const {
   walkDir,
@@ -204,8 +204,8 @@ function defineCommand(_commandName, definer, _parent) {
   return Klass;
 }
 
-async function createApplication(Application, opts) {
-  let application = new Application(Object.assign({ cli: true }, opts || {}));
+async function createApplication(ApplicationClass, opts) {
+  let application = new ApplicationClass(Object.assign({ cli: true }, opts || {}));
 
   if (Nife.isNotEmpty(opts))
     application.setOptions(Object.assign(opts || {}));
@@ -217,6 +217,9 @@ function loadCommand(name) {
   let fullPath      = require.resolve(name);
   let CommandKlass  = require(fullPath);
 
+  if (CommandKlass && typeof CommandKlass !== 'function' && typeof CommandKlass.default === 'function')
+    CommandKlass = CommandKlass.default;
+
   CommandKlass.path = fullPath;
 
   return CommandKlass;

package/src/cli/index.d.ts

@@ -0,0 +1 @@
+export * from './cli-utils';

package/src/cli/routes-command.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { defineCommand } = require('./cli-utils');
-const { Logger }        = require('../logger');
+const Logger            = require('../logger');
 const { buildRoutes }   = require('../controllers/controller-utils');
 
 const TAB_SIZE = 8;

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

@@ -0,0 +1,59 @@
+import { Application } from '../application';
+import { Logger } from '../logger';
+import { Request, Response } from 'express';
+import { GenericObject } from '../interfaces/common';
+import { ConnectionBase, ModelClass, Models } from 'mythix-orm';
+import { HTTPBaseError } from '../http-server/http-errors';
+
+export declare type ControllerClass = typeof ControllerBase;
+
+export declare type ControllerClasses = { [ key: string ]: ControllerClass };
+
+export declare interface ControllerContext {
+  params: GenericObject;
+  query: GenericObject;
+  route: GenericObject;
+  controller: ControllerClass;
+  controllerMethod: string;
+  controllerInstance: ControllerBase;
+  startTime: number;
+  body?: any;
+}
+
+export declare class ControllerBase {
+  public static getControllerName(): string;
+
+  declare public application: Application;
+  declare public logger: Logger;
+  declare public request: Request;
+  declare public response: Response;
+  declare public route: GenericObject;
+  declare public method: string;
+  declare public contentType: string | null;
+  declare public responseStatusCode: number;
+
+  public constructor(application: Application, logger: Logger, request: Request, response: Response);
+  public getApplication(): Application;
+  public getLogger(): Logger;
+  public getModel(name?: string): ModelClass | undefined;
+  public getModels(): Models;
+  public getDBConnection(): ConnectionBase;
+  public prepareToThrowError(ErrorClass: Function, args: Array<any>): HTTPBaseError;
+  public throwNotFoundError(...args: Array<any>): void;
+  public throwBadRequestError(...args: Array<any>): void;
+  public throwUnauthorizedError(...args: Array<any>): void;
+  public throwForbiddenError(...args: Array<any>): void;
+  public throwInternalServerError(...args: Array<any>): void;
+  public isHTTPError(error: any): boolean;
+  public redirectTo(url: string, status?: number);
+  public getCookie(name: string);
+  public setCookie(name: string, value: any, options?: GenericObject);
+  public getHeader(name: string): string;
+  public getHeaders(names: Array<string>): GenericObject;
+  public setHeader(name: string, value: any): void;
+  public setHeaders(headers: GenericObject): void;
+  public setContentType(contentType: string): void;
+  public setStatusCode(code: number): void;
+  public handleIncomingRequest(request: Request, response: Response, context: ControllerContext): Promise<any>;
+  public handleOutgoingResponse(controllerResult: any, request: Request, response: Response, context: ControllerContext): Promise<void>;
+}

package/src/controllers/controller-base.js

@@ -183,16 +183,17 @@ class ControllerBase {
     this.responseStatusCode = parseInt(code, 10);
   }
 
-  async handleIncomingRequest(request, response, args) {
-    this.route = args.route;
+  async handleIncomingRequest(request, response, context) {
+    this.route = context.route;
 
-    if (typeof this[args.controllerMethod] !== 'function')
-      this.throwInternalServerError(`Specified route handler named "${this.constructor.name}::${args.controllerMethod}" not found.`);
+    if (typeof this[context.controllerMethod] !== 'function')
+      this.throwInternalServerError(`Specified route handler named "${this.constructor.name}::${context.controllerMethod}" not found.`);
 
-    return await this[args.controllerMethod].call(this, { body: request.body, request, response, ...args }, this.getModels());
+    return await this[context.controllerMethod].call(this, { body: request.body, request, response, ...context }, this.getModels());
   }
 
-  async handleOutgoingResponse(_controllerResult, request, response /*, { route, controller, controllerMethod, controllerInstance, startTime, params } */) {
+  // eslint-disable-next-line no-unused-vars
+  async handleOutgoingResponse(_controllerResult, request, response, context) {
     // Has a response already been sent?
     if (response.statusMessage)
       return;

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

@@ -0,0 +1,11 @@
+import { HTTPServer } from '../http-server';
+import { GenericObject } from '../interfaces/common';
+import { BaseModule } from '../modules/base-module';
+import { ControllerClass, ControllerClasses } from './controller-base';
+
+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

@@ -80,7 +80,7 @@ class ControllerModule extends BaseModule {
 
       try {
         let controllerGenerator = require(controllerFile);
-        if (controllerGenerator['default'] && typeof controllerGenerator['default'] === 'function')
+        if (controllerGenerator.__esModule)
           controllerGenerator = controllerGenerator['default'];
 
         Object.assign(controllers, controllerGenerator(args));

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

@@ -0,0 +1,51 @@
+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;
+  server: HTTPServer;
+  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,
+  parent?: T
+): (context: {
+  application: Application,
+  server: HTTPServer,
+}) => ControllerClass;

package/src/controllers/controller-utils.js

@@ -14,6 +14,8 @@ function defineController(controllerName, definer, _parent) {
       controllerName,
     });
 
+    Klass.getControllerName = () => controllerName;
+
     return { [controllerName]: Klass };
   };
 }
@@ -62,7 +64,7 @@ function buildPatternMatcher(_patterns, _opts) {
         writable:     false,
         enumerable:   false,
         configurable: false,
-        value:        undefined,
+        value:        [],
       },
     });
 
@@ -273,21 +275,6 @@ function buildPathMatcher(routeName, customParserTypes) {
   return matchFunc;
 }
 
-function getRouteProperties(route) {
-  let props = {};
-
-  for (let i = 0, il = ROUTE_PROPERTIES.length; i < il; i++) {
-    let propName  = ROUTE_PROPERTIES[i];
-    let value     = route[propName];
-    if (value === undefined)
-      continue;
-
-    props[propName] = value;
-  }
-
-  return props;
-}
-
 function compileRoutes(routes, customParserTypes, _context) {
   const addRoute = (theseRoutes, route, path, priority) => {
     let newRoute = Object.assign(

package/src/controllers/generate-client-api-interface.d.ts

@@ -0,0 +1,13 @@
+import { Application } from '../application';
+import { GenericObject } from '../interfaces/common';
+
+export declare interface GenerateClientInterfaceOptions {
+  globalName?: string;
+  environment?: string;
+  defaultRouteOptions?: GenericObject;
+  mode?: string;
+  domain?: string;
+  routeFilter?: ((value: any, index?: number) => boolean) | RegExp | string;
+}
+
+export declare function generateClientAPIInterface(application: Application, options?: GenerateClientInterfaceOptions): string;

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

@@ -374,7 +374,7 @@ function generateRoutes(_routes, _options) {
     if (clientOptions == null) {
       var contentType = route.accept;
       if (Nife.isEmpty(contentType))
-        contentType = 'application/json; charset=UTF-8';
+        contentType = 'application/json';
       else if (Array.isArray(contentType))
         contentType = contentType[0];
 

package/src/controllers/index.d.ts

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

package/src/http-server/http-errors.d.ts

@@ -0,0 +1,17 @@
+import { GenericObject } from '../interfaces/common';
+
+export declare class HTTPBaseError extends Error {
+  declare public route: GenericObject;
+  declare public statusCode: number;
+  declare public headers: GenericObject;
+
+  constructor(route?: GenericObject | null | undefined, message?: string, statusCode?: number);
+  getMessage(): string;
+}
+
+export declare class HTTPNotFoundError extends HTTPBaseError { }
+export declare class HTTPBadRequestError extends HTTPBaseError { }
+export declare class HTTPBadContentTypeError extends HTTPBaseError { }
+export declare class HTTPUnauthorizedError extends HTTPBaseError { }
+export declare class HTTPForbiddenError extends HTTPBaseError { }
+export declare class HTTPInternalServerError extends HTTPBaseError { }

package/src/http-server/http-server-module.d.ts

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

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

@@ -103,6 +103,4 @@ class HTTPServerModule extends BaseModule {
   }
 }
 
-module.exports = {
-  HTTPServerModule,
-};
+module.exports = { HTTPServerModule };

package/src/http-server/http-server.d.ts

@@ -0,0 +1,33 @@
+import { GenericObject } from '../interfaces/common';
+import { Application } from '../application';
+import { Application as ExpressApplication, Request, Response } from 'express';
+import { Logger } from '../logger';
+import { ControllerClass, ControllerContext } from '../controllers/controller-base';
+
+export declare class HTTPServer {
+  declare public application: Application;
+  declare public server: ExpressApplication | null;
+  declare public options: GenericObject;
+  declare public routes: Array<GenericObject>;
+  declare public middleware: Array<Function> | null;
+
+  public constructor(application: Application, options?: GenericObject);
+  public getApplication(): Application;
+  public getLogger(): Logger;
+  public getOptions(): GenericObject;
+  public getHTTPSCredentials(options): { key: string; cert: string; }
+  public setRoutes(routes): void;
+  public executeMiddleware(middleware: Array<Function>, request: Request, response: Response): Promise<void>;
+  public baseMiddleware(request: Request, response: Response, rootNext: Function): void;
+  public findFirstMatchingRoute(request: Request, routes: Array<GenericObject>): GenericObject;
+  public getRouteController(controller: string | Function, route, params, request): { controller: ControllerClass | undefined } | undefined;
+  public createRequestLogger(application: Application, request: Request): Logger;
+  public validateQueryParam(route: GenericObject, query: GenericObject, paramName: string, queryValue: any, queryParams: GenericObject): boolean;
+  public compileQueryParams(route: GenericObject, query: GenericObject, queryParams: GenericObject): GenericObject;
+  public sendRequestToController(request: Request, response: Response, context: ControllerContext): Promise<any>;
+  public baseRouter(request: Request, response: Response, next: Function): void;
+  public errorHandler(error: Error | any, message: string | null | undefined, statusCode: number | null | undefined, response: Response, request: Request): void;
+  public createExpressApplication(options?: GenericObject): ExpressApplication;
+  public start(): Promise<ExpressApplication>;
+  public stop(): Promise<void>;
+}

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

@@ -434,7 +434,13 @@ class HTTPServer {
     app.use((request, response, next) => {
       if ((/application\/json/i).test(request.headers['content-type']) && Buffer.isBuffer(request.body)) {
         let bodyStr = request.body.toString('utf8');
-        request._rawBody = request.body = bodyStr;
+        request._rawBody = bodyStr;
+
+        try {
+          request.body = JSON.parse(bodyStr);
+        } catch (error) {
+          request.body = bodyStr;
+        }
       }
 
       next();

package/src/http-server/index.d.ts

@@ -0,0 +1,3 @@
+export * from './http-server';
+export * as HTTPErrors from './http-errors';
+export { statusCodeToMessage } from '../utils/http-utils';

package/src/http-server/index.js

@@ -1,21 +1,16 @@
 'use strict';
 
-const {
-  HTTPServer,
-} = require('./http-server');
-
 const {
   statusCodeToMessage,
 } = require('../utils/http-utils');
 
+const { HTTPServer }        = require('./http-server');
 const HTTPErrors            = require('./http-errors');
-const Middleware            = require('./middleware');
 const { HTTPServerModule }  = require('./http-server-module');
 
 module.exports = {
   HTTPErrors,
   HTTPServer,
   HTTPServerModule,
-  Middleware,
   statusCodeToMessage,
 };

package/src/index.d.ts

@@ -0,0 +1,49 @@
+// Application
+export * from './interfaces/common';
+export * from './application';
+export * from './logger';
+
+// CLI Utils
+export * as CLI from './cli';
+export { defineCommand } from './cli';
+
+// Utils
+export * as Utils from './utils';
+export {
+  HTTPUtils,
+  CryptoUtils,
+  TestUtils,
+  MimeUtils,
+} from './utils';
+
+// Models
+export * as Models from './models';
+export * from './models';
+
+// Controllers
+export * as Controllers from './controllers';
+export * from './controllers';
+
+// HTTPServer
+export * as HTTP from './http-server';
+export * from './http-server';
+
+// Tasks
+export * as Tasks from './tasks';
+export * from './tasks';
+
+import * as _Modules from './modules';
+import * as _ModelModule from './models/model-module';
+import * as _ControllerModule from './controllers/controller-module';
+import * as _HTTPServerModule from './http-server/http-server-module';
+import * as _TaskModule from './tasks/task-module';
+
+export declare namespace Modules {
+  export import ModelModule = _ModelModule.ModelModule;
+  export import ControllerModule = _ControllerModule.ControllerModule;
+  export import BaseModule = _Modules.BaseModule;
+  export import DatabaseModule = _Modules.DatabaseModule;
+  export import FileWatcherModule = _Modules.FileWatcherModule;
+  export import HTTPServerModule = _HTTPServerModule.HTTPServerModule;
+  export import TaskModule = _TaskModule.TaskModule;
+}