mythix 3.0.0 → 4.0.2

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022 Wyatt Greenway
+Copyright (c) 2023 Wyatt Greenway
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -45,17 +45,18 @@ To create your own `mythix` application, you simply need to inherit from the `My
 Example:
 
 ```javascript
-const Path                = require('path');
-const Mythix              = require('mythix');
-const getRoutes           = require('./routes');
-const { authMiddleware }  = require('./middleware');
-
-class Application extends Mythix.Application {
-  static APP_NAME = 'my_app_name';
+import Path                 from 'node:path';
+import Mythix               from 'mythix';
+import getRoutes            from './routes/index.mjs';
+import { authMiddleware }   from './middleware.mjs';
+
+export class Application extends Mythix.Application {
+  static getName() {
+    return 'my_app_name';
+  }
 
   constructor(_opts) {
     var opts = Object.assign({
-      rootPath: Path.resolve(__dirname),
       httpServer: {
         middleware: [
           authMiddleware,
@@ -70,10 +71,6 @@ class Application extends Mythix.Application {
     return getRoutes.apply(this, args);
   }
 }
-
-module.exports = {
-  Application,
-};
 ```
 
 ## Starting your server
@@ -120,9 +117,9 @@ Once you have your new controller file created, you simply need to define your c
 For example, a simple demo controller can be created by creating a new controller file named `./app/controllers/hello-world-controller.js` and placing the following contents in this file:
 
 ```javascript
-const { defineController } = require('mythix');
+import { defineController }  from 'mythix';
 
-module.exports = defineController('HelloWorld', ({ Parent }) => {
+export const HelloWorld = defineController('HelloWorld', ({ Parent }) => {
   return class HelloWorldController extends Parent {
     async greet(params, query, body, models) {
       return 'Hello World!';
@@ -136,7 +133,7 @@ Now, all you need to do is add your new controller to the routes:
 Simply modify `./app/routes.js` to have the following content:
 
 ```
-module.exports = function getRoutes({ path }) {
+export function getRoutes({ path }) {
   path('api', ({ path }) => {
     path('v1', ({ endpoint }) => {
       endpoint('greet', {
@@ -183,7 +180,7 @@ Routes are defined using methods. The method `getRoutes` is called on your appli
 Example:
 
 ```javascript
-module.exports = function({ path }) {
+export function getRoutes({ path }) {
   path('api', ({ path }) => {
     path('v1', ({ endpoint, capture }) => {
       path('user', ({ endpoint, capture }) => {
@@ -246,9 +243,9 @@ Model definition files need to be placed in `./app/models`, and need to have a `
 Example:
 
 ```javascript
-const { defineModel } = require('mythix');
+import { defineModel }  from 'mythix';
 
-module.exports = defineModel('Product', ({ Parent, Types }) => {
+export const Product = defineModel('Product', ({ Parent, Types }) => {
   return class Product extends Parent {
     // Define the model fields, using mythix-orm
     static fields = {
@@ -311,9 +308,9 @@ Any file placed in `./app/commands/` with a `-command.js` suffix will be loaded
 Example:
 
 ```javascript
-const { defineCommand } = require('mythix');
+import { defineCommand }  from 'mythix';
 
-module.exports = defineCommand('deploy', ({ Parent }) => {
+export const Deploy = defineCommand('deploy', ({ Parent }) => {
   return class DeployCommand extends Parent {
     static runtimeArguments = {
       'node': [ '--inspect' ],
@@ -411,7 +408,7 @@ const {
   TaskBase,
 } = require('mythix');
 
-module.exports = defineTask('CustomTask', ({ application, Parent, time }) => {
+export const CustomTask = defineTask('CustomTask', ({ application, Parent, time }) => {
   const workerCount = application.getConfigValue('tasks.CustomTask.workers', 1, 'integer');
 
   return class CustomTask extends Parent {
@@ -519,9 +516,9 @@ The return value will be a controller class, inherited from `Mythix.ControllerBa
 #### Example
 
 ```javascript
-const { defineController } = require('mythix');
+import { defineController }  from 'mythix';
 
-module.exports = defineController(
+export const HelloWorld = defineController(
   'HelloWorld',
   ({ Parent, application }) => {
 
@@ -575,9 +572,9 @@ The return value will be a model class, inherited from `Mythix.ModelBase`.
 #### Example
 
 ```javascript
-const { defineModel } = require('mythix');
+import { defineModel }  from 'mythix';
 
-module.exports = defineModel('Product', ({ Parent, Types }) => {
+export const Product = defineModel('Product', ({ Parent, Types }) => {
   return class Product extends Parent {
     // Define the model fields, using mythix-orm
     static fields = {
@@ -629,7 +626,7 @@ module.exports = defineModel('Product', ({ Parent, Types }) => {
 
 #### Description
 
-**Note: This section is outdated... command arguments have been changed to use the [cmded](https://www.npmjs.com/package/cmded) module. Refer to `mythix` [built-in commands](https://github.com/th317erd/mythix/blob/main/src/cli/deploy-command.js) for examples on the new command line argument interface.**
+**Note: This section is outdated... command arguments have been changed to use the [cmded](https://www.npmjs.com/package/cmded) module. Refer to `mythix` [built-in commands](https://github.com/th317erd/mythix/blob/main/lib/cli/deploy-command.js) for examples on the new command line argument interface.**
 
 Create a new command class, giving your command the name specified by the `commandName` argument (all lower-case). The `definer` method will be invoked immediately upon the call to `Mythix.defineCommand`, and is expected to return a new controller class that inherits from `context.Parent`. `context.Parent` by default (if no `ParentCommandClassNameToInheritFrom` argument is specified) will be `Mythix.CommandBase`.
 
@@ -656,9 +653,9 @@ The return value will be a command class, inherited from `Mythix.CommandBase`.
 #### Example
 
 ```javascript
-const { defineCommand } = require('mythix');
+import { defineCommand }  from 'mythix';
 
-module.exports = defineCommand('deploy', ({ Parent }) => {
+export const Deploy = defineCommand('deploy', ({ Parent }) => {
   return class DeployCommand extends Parent {
     static definition = 'Deploy application to servers';
     static commandArguments = '<-target:string(Target server to deploy to)';
@@ -708,9 +705,9 @@ The return value will be a task class, inherited from `Mythix.TaskBase`.
 #### Example
 
 ```javascript
-const { defineTask } = require('mythix');
+import { defineTask }  from 'mythix';
 
-module.exports = defineTask('CustomTask', ({ Parent, time }) => {
+export const CustomTask = defineTask('CustomTask', ({ Parent, time }) => {
   return class CustomTask extends Parent {
     static workers    = 4;
     static frequency  = time.days(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>;