mythix 2.12.2 → 4.0.1

package/{src → lib}/application.d.ts

@@ -1,50 +1,39 @@
 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 { HTTPServer } from './http/http-server';
 import { GenericObject } from './interfaces/common';
 import { Logger, LoggerClass, LoggerOptions } from './logger';
-import { Modules, ModuleClasses, BaseModuleClass } from './modules/base-module';
+import { ModuleBase } from './modules/module-base';
+import { TaskBase } from './tasks/task-base';
+import { CommandClasses } from './cli/command-base';
 
 export declare type ApplicationClass = typeof Application;
 
+export declare interface ModuleDictionary {
+  [key: string]: typeof ModuleBase;
+}
+
 export declare interface ApplicationOptions {
-  cli: boolean;
-  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 };
+  bindToProcessSignals?: boolean;
+  cli?: boolean;
+  database?: boolean | GenericObject;
+  environment?: string;
+  exitOnShutdown?: number | null;
+  httpServer?: boolean | GenericObject;
+  logger?: LoggerOptions;
+  tasks?: boolean | { [key: string]: TaskBase } | Array<TaskBase>;
+  tempPath?: string;
 }
 
 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 static getName(): string;
+  public static getCommandList(): CommandClasses;
+  public static getModules(): ModuleDictionary;
 
   public constructor(options?: ApplicationOptions);
   public getTempPath(): string | null;
-  public getModules(): Modules;
-  public initializeModules(modules: ModuleClasses): Promise<void>;
+  public initializeModules(modules: ModuleDictionary): Promise<void>;
   public startAllModules(options: ApplicationOptions): Promise<void>;
   public stopAllModules(options: ApplicationOptions): Promise<Array<Error>>;
   public bindToProcessSignals(): void;
@@ -68,17 +57,14 @@ export declare class Application {
   public getDBTablePrefix(): string | null;
   public getConnection(connection?: ConnectionBase): ConnectionBase;
 
-  // Deprecated
-  public getDBConnection(connection?: ConnectionBase): ConnectionBase;
-
-  // From FileWatcherModule
-  public autoReload(enable?: boolean, shuttingDown?: boolean): Promise<void>;
-
   // From ModelModule
   public getModel(modelName?: string): ModelClass | undefined;
   public getModels(): Models;
+  public getAppModelClasses(connection: ConnectionBase): { [key: string]: ModelClass };
+  public bindModels(connection: ConnectionBase, models: { [key: string]: ModelClass }): { [key: string]: ModelClass };
 
   // From ControllerModule
+  public getAppControllerClasses(): { [key: string]: ControllerClass };
   public getController(name: string): { controller: ControllerClass, controllerMethod: string | undefined };
 
   // From HTTPServerModule
@@ -88,7 +74,7 @@ export declare class Application {
   declare public isStarted: boolean;
   declare public isStopping: boolean;
   declare public options: ApplicationOptions;
-  declare public moduleInstances: Modules;
+  declare public moduleInstances: Array<ModuleBase>;
   declare public config: GenericObject;
   declare public logger: Logger;
 }

package/{src/application.js → lib/application.mjs}

@@ -1,100 +1,39 @@
-'use strict';
-
-/* global process, __dirname */
-
-const Nife                  = require('nife');
-const Path                  = require('path');
-const FileSystem            = require('fs');
-const EventEmitter          = require('events');
-const OS                    = require('os');
-const { Logger }            = require('./logger');
-const { DatabaseModule }    = require('./modules/database-module');
-const { ModelModule }       = require('./models/model-module');
-const { HTTPServerModule }  = require('./http-server/http-server-module');
-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
-
-// (function doExit(_exit) {
-//   process.exit = function() {
-//     console.trace('EXIT');
-//     return _exit.apply(process, arguments);
-//   };
-// })(process.exit);
-
-class Application extends EventEmitter {
-  static APP_NAME = 'mythix';
-
-  static getDefaultModules() {
-    return [
-      DatabaseModule,
-      ModelModule,
-      HTTPServerModule,
-      ControllerModule,
-      TaskModule,
-      FileWatcherModule,
-    ];
+import Path                   from 'node:path';
+import FileSystem             from 'node:fs';
+import OS                     from 'node:os';
+import Nife                   from 'nife';
+import { Logger }             from './logger.mjs';
+import { DatabaseModule }     from './modules/database-module.mjs';
+import { HTTPServerModule }   from './http/http-server-module.mjs';
+import { ControllerModule }   from './controllers/controller-module.mjs';
+import { TaskModule }         from './tasks/task-module.mjs';
+import { wrapConfig }         from './utils/config-utils.mjs';
+import * as ControllerRoutes  from './controllers/routes/index.mjs';
+import { COMMANDS }           from './cli/commands/index.mjs';
+import { Migration }          from './models/migration-model.mjs';
+
+export class Application {
+  static getName() {
+    return 'mythix';
   }
 
-  static findModuleIndex(modules, moduleKlass) {
-    let index = -1;
-
-    if (typeof moduleKlass.getModuleName === 'function') {
-      let moduleKlassName = moduleKlass.getModuleName();
-      index = modules.findIndex((thisModuleClass) => {
-        return (thisModuleClass.getModuleName() === moduleKlassName);
-      });
-    } else {
-      index = modules.findIndex((thisModuleClass) => thisModuleClass === moduleKlass);
-    }
-
-    return index;
+  static getCommandList() {
+    return COMMANDS;
   }
 
-  static replaceModule(modules, moduleKlass, replacementModuleKlass) {
-    let index = this.findModuleIndex(modules, moduleKlass);
-    if (index >= 0)
-      modules[index] = replacementModuleKlass;
-    else
-      throw new Error('Application::replaceModule: Unable to find and replace requested module');
-
-    return modules;
+  static getModules() {
+    return {
+      database:    DatabaseModule,
+      httpServer:  HTTPServerModule,
+      controllers: ControllerModule,
+      tasks:       TaskModule,
+    };
   }
 
   constructor(_opts) {
-    super();
-
-    let ROOT_PATH = (_opts && _opts.rootPath) ? _opts.rootPath : Path.resolve(__dirname);
-
     let opts = Nife.extend(true, {
-      environment:              (process.env.NODE_ENV || 'development'),
-      appName:                  this.constructor.APP_NAME,
-      rootPath:                 ROOT_PATH,
-      configPath:               Path.resolve(ROOT_PATH, 'config'),
-      migrationsPath:           Path.resolve(ROOT_PATH, 'migrations'),
-      modelsPath:               Path.resolve(ROOT_PATH, 'models'),
-      seedersPath:              Path.resolve(ROOT_PATH, 'seeders'),
-      controllersPath:          Path.resolve(ROOT_PATH, 'controllers'),
-      templatesPath:            Path.resolve(ROOT_PATH, 'templates'),
-      commandsPath:             Path.resolve(ROOT_PATH, 'commands'),
-      tasksPath:                Path.resolve(ROOT_PATH, 'tasks'),
-      autoReload:               ((_opts && _opts.environment) || process.env.NODE_ENV || 'development') === 'development',
-      exitOnShutdown:           null,
-      runTasks:                 true,
-      testMode:                 false,
-      noInternalMigrationTable: false,
-      logger:                   {
-        rootPath: ROOT_PATH,
-      },
-      database:                 {},
-      httpServer:               {
-        routeParserTypes:       undefined,
-        middleware:             null,
-      },
+      environment:    (process.env.NODE_ENV || 'development'),
+      exitOnShutdown: null,
     }, _opts || {});
 
     Object.defineProperties(this, {
@@ -129,7 +68,7 @@ class Application extends EventEmitter {
         writable:     false,
         enumerable:   false,
         configurable: true,
-        value:        this.loadConfig(opts.configPath),
+        value:        wrapConfig(Object.assign({}, opts.config || {}, { environment: opts.environment })),
       },
     });
 
@@ -145,17 +84,15 @@ class Application extends EventEmitter {
       },
     });
 
-    this.bindToProcessSignals();
+    if (opts.bindToProcessSignals !== false)
+      this.bindToProcessSignals();
 
     if (Nife.isEmpty(opts.tempPath))
       opts.tempPath = Path.resolve(OS.tmpdir(), this.getApplicationName().replace(/[^\w-]/g, ''), ('' + process.pid));
-
-    opts.modules = this.constructor.getDefaultModules(this, opts);
   }
 
   getApplicationName() {
-    let options = this.getOptions();
-    return options.appName || this.constructor.APP_NAME;
+    return this.constructor.getName();
   }
 
   getTempPath() {
@@ -163,21 +100,25 @@ class Application extends EventEmitter {
     return options.tempPath;
   }
 
-  getModules() {
+  getModuleInstances() {
     return this.moduleInstances || [];
   }
 
   async initializeModules(_modules) {
     // Shutdown modules, if any are active
-    let stopPromises = this.getModules().map((moduleInstance) => moduleInstance.stop());
-    await Promise.all(stopPromises);
+    await this.stopAllModules(this.getOptions());
 
-    let modules         = _modules || [];
+    let modules         = _modules || {};
+    let moduleNames     = Object.keys(modules);
     let moduleInstances = [];
     let options         = this.getOptions();
 
-    for (let i = 0, il = modules.length; i < il; i++) {
-      let ModuleClass = modules[i];
+    for (let i = 0, il = moduleNames.length; i < il; i++) {
+      let moduleName  = moduleNames[i];
+      let ModuleClass = modules[moduleName];
+      if (typeof ModuleClass !== 'function')
+        throw new TypeError(`Specified module "${moduleName}" is not a module class`);
+
       if (typeof ModuleClass.shouldUse === 'function' && ModuleClass.shouldUse.call(ModuleClass, this, options) === false)
         continue;
 
@@ -189,7 +130,7 @@ class Application extends EventEmitter {
   }
 
   async startAllModules(options) {
-    let moduleInstances = this.getModules();
+    let moduleInstances = this.getModuleInstances();
 
     for (let i = 0, il = moduleInstances.length; i < il; i++) {
       let moduleInstance = moduleInstances[i];
@@ -198,7 +139,7 @@ class Application extends EventEmitter {
   }
 
   async stopAllModules(options) {
-    let moduleInstances = this.getModules();
+    let moduleInstances = this.getModuleInstances();
     let errors = [];
 
     for (let i = moduleInstances.length - 1; i >= 0; i--) {
@@ -211,8 +152,11 @@ class Application extends EventEmitter {
       }
     }
 
-    if (errors.length > 0)
-      return errors;
+    if (errors.length > 0) {
+      let error = new AggregateError('Errors were encountered while shutting down modules');
+      error.errors = errors;
+      throw error;
+    }
   }
 
   bindToProcessSignals() {
@@ -235,25 +179,6 @@ class Application extends EventEmitter {
     return this;
   }
 
-  loadConfig(configPath) {
-    let appOptions  = this.getOptions();
-    let environment = (appOptions.environment || process.NODE_ENV || 'development');
-
-    if (!configPath)
-      return wrapConfig(Object.assign({}, { environment }));
-
-    try {
-      let config = require(configPath);
-      if (config.__esModule)
-        config = config['default'];
-
-      return wrapConfig(Object.assign({}, config || {}, { environment }));
-    } catch (error) {
-      this.getLogger().error(`Error while trying to load application configuration ${configPath}: `, error);
-      throw error;
-    }
-  }
-
   getConfigValue(key, defaultValue, type) {
     let result = this.config.ENV(key, defaultValue);
 
@@ -273,6 +198,49 @@ class Application extends EventEmitter {
     return this;
   }
 
+  getAppControllerClasses() {
+    return {};
+  }
+
+  getAppModelClasses() {
+    return {
+      Migration,
+    };
+  }
+
+  bindModels(connection, models) {
+    const generateBoundModelClass = (connection, modelName, ModelClass) => {
+      if (typeof ModelClass !== 'function')
+        return;
+
+      const app = this;
+
+      return class BoundModel extends ModelClass {
+        static getApplication() {
+          return app;
+        }
+
+        static getModelName() {
+          return modelName;
+        }
+      };
+    };
+
+    let modelNames  = Object.keys(models);
+    let boundModels = [];
+
+    for (let i = 0, il = modelNames.length; i < il; i++) {
+      let modelName = modelNames[i];
+      let ModelClass  = generateBoundModelClass(connection, modelName, models[modelName]);
+      if (!ModelClass)
+        continue;
+
+      boundModels[modelName] = ModelClass;
+    }
+
+    return boundModels;
+  }
+
   _getRoutes() {
     let routeScope = new ControllerRoutes.RouteScope();
     this.getRoutes(routeScope);
@@ -284,8 +252,7 @@ class Application extends EventEmitter {
   }
 
   getCustomRouteParserTypes() {
-    let options = this.getOptions();
-    return options.routeParserTypes;
+    return [];
   }
 
   createLogger(loggerOpts, LoggerClass) {
@@ -299,21 +266,34 @@ class Application extends EventEmitter {
     return this.logger;
   }
 
+  getModel(name) {
+    if (typeof this.getConnection !== 'function')
+      return;
+
+    let connection = this.getConnection();
+    return connection.getModel(name);
+  }
+
+  getModels() {
+    if (typeof this.getConnection !== 'function')
+      return {};
+
+    let connection = this.getConnection();
+    return connection.getModels();
+  }
+
   async start() {
     let options = this.getOptions();
-
     let tempDir = this.getTempPath();
     if (Nife.isNotEmpty(tempDir)) {
       if (!FileSystem.existsSync(tempDir))
         FileSystem.mkdirSync(tempDir, { recursive: true });
     }
 
-    await this.initializeModules(options.modules);
+    await this.initializeModules(this.constructor.getModules());
     await this.startAllModules(options);
 
     this.isStarted = true;
-
-    this.emit('start');
   }
 
   async stop(exitCode) {
@@ -352,11 +332,8 @@ class Application extends EventEmitter {
 
       this.getLogger().info('Shut down complete!');
 
-      this.emit('stop');
-
       if (options.exitOnShutdown != null || exitCode != null) {
         let code = (exitCode != null) ? exitCode : options.exitOnShutdown;
-        this.emit('exit', code);
         process.exit(code);
       }
     } catch (error) {
@@ -365,5 +342,3 @@ class Application extends EventEmitter {
     }
   }
 }
-
-module.exports = { Application };

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

@@ -0,0 +1,21 @@
+import { Application, ApplicationClass, ApplicationOptions } from '../application';
+import { GenericObject } from '../interfaces/common';
+import { CommandClass } from './command-base';
+
+export declare function loadMythixConfig(
+  mythixConfigPath: string,
+  appRootPath: string
+): Promise<GenericObject>;
+
+export declare function createApplication(
+  applicationClass: ApplicationClass,
+  options?: ApplicationOptions
+): Application;
+
+export declare function executeCommand(
+  config: GenericObject,
+  appOptions: ApplicationOptions,
+  commandContext: GenericObject,
+  CommandKlass: CommandClass,
+  argv: Array<string>
+): Promise<undefined>;