mythix 2.4.13 → 2.5.1

package/README.md

@@ -314,11 +314,9 @@ module.exports = defineModel('Product', ({ Parent, Type, Relation }) => {
 
 The `mythix-cli` can load commands from `mythix`, as well as custom commands you define. For example, if you create a command named `deploy`, then that command can be ran like so: `mythix-cli deploy`. Commands can inherit from other commands in `mythix`, including commands built directly into `mythix`.
 
-Your command class needs to have a `static definition` string specified, or your command will not show up in `mythix-cli --help`.
+A `static commandArguments` method is used to define the `help` for your command, and to define a `Runner` to gather arguments for your command. This `Runner` is a [CMDed](https://www.npmjs.com/package/cmded) `Runner`, so please refer to the [CMDed](https://www.npmjs.com/package/cmded) documentation for how to properly create a `Runner` for your command.
 
-`mythix` handles all the command line arguments for you. All you need to do is define a `static commandArguments` string on your command class to list your command arguments. Command arguments use the [simple-yargs](https://www.npmjs.com/package/simple-yargs) module to parse command line arguments.
-
-You can optionally define a `static nodeArguments` array of strings, which define the arguments for node that will be used when spawning this command via the CLI.
+You can optionally define a `static runtimeArguments` object, defining an array of strings arguments for each `runtime`. A `runtime` would be something like `node`, `ts-node`, or `babel-node`.
 
 There is also the static property `static applicationConfig` which can be an object specifying the options for your `Application` class, or, if this is a method, should return the options for your `Application` class. If this is a method, then the options it returns are the *only* options that will be passed to your `Application` class upon instantiation. If this is an object, then the `mythix-cli` will deliberately merge other options in (such as `{ httpServer: false, runTasks: false, autoReload: false }`), as most commands don't want an HTTP server, tasks, or auto-reloading running.
 
@@ -331,8 +329,28 @@ const { defineCommand } = require('mythix');
 
 module.exports = defineCommand('deploy', ({ Parent }) => {
   return class DeployCommand extends Parent {
-    static definition = 'Deploy application to servers';
-    static commandArguments = '<-target:string(Target server to deploy to)';
+    static runtimeArguments = {
+      'node': [ '--inspect' ],
+    };
+
+    static commandArguments() {
+      return {
+        // CMDed help
+        help: {
+          '@usage': 'mythix-cli deploy [options]',
+          '@title': 'Deploy the application to the specified target servers',
+          '-t={target} | -t {target} | --target={target} | --target {target}': 'Target server to deploy to',
+        },
+        // CMDed runner
+        runner: ({ $, store, Types }) => {
+          $('--target', Types.STRING(), { name: 'target' })
+            || $('-t', Types.STRING(), { name: 'target' })
+            || store({ target: 'production' }); // Default value
+
+          return true;
+        },
+      };
+    }
 
     async execute(args) {
       // args contains all your command line arguments parsed
@@ -474,12 +492,12 @@ When the `mythix-cli` is invoked, it will always pass a `{ cli: true }` option t
 
 A little bit should be mentioned about how the `mythix-cli` command works. When it is invoked, the first thing it does is search for your `Application` class. When it finds it, it will then create an instance of your application to fetch all your application defined paths. Once it has the paths you specified for your application, it will then load all commands it finds (both internal 'mythix' commands, and any custom commands you have defined).
 
-When a command is invoked, the `mythix-cli` will deliberately launch a new `node` process to execute the command specified. This is so that each command can specify its own custom `nodeArguments` (if desired).
+When a command is invoked, the `mythix-cli` will deliberately launch a new process using the specified `runtime` (default is `node`) to execute the command specified. This is so that each command can specify its own custom `runtimeArguments` (if desired).
 
 Because of the way this works, your application will be instantiated twice:
 
 * Once, and first, to load your application configuration (specifically your defined paths). This part of the process will *not* start your application, but simply instantiate it.
-* Second, your application will be instantiated again in the new spawned `node` process, and this time your application will also be started. Once your application has been successfully instantiated and started, then the command will run.
+* Second, your application will be instantiated again in the new spawned `runtime` (default `node`) process, and this time your application will also be started. Once your application has been successfully instantiated and started, then the command will run.
 
 Most commands by default will start your application with the options `{ httpServer: false, autoReload: false, runTasks: false }`. This informs your application NOT to start the web-server, NOT to start the task worker, and to NOT auto-reload files on change (which often isn't desired for many commands).
 
@@ -620,7 +638,7 @@ Create a new command class, giving your command the name specified by the `comma
 #### Static Class Properties
 
 * static **description** *`<string>`* - The description to give to this command. If this is not provided, then your command's "help" will not be shown when you run `mythix-cli --help`.
-* static **nodeArguments** *`<Array[<string>]>`* - An array of string arguments to use as command line arguments when invoking your command with `node`. These are NOT your command's arguments, but rather the arguments to give to `node`.
+* static **runtimeArguments** *`{ [key: string]: <Array[<string>]> }`* - An object containing runtime name keys, where each key value is an array of string arguments to use as command line arguments when invoking your command with the specified runtime. These are NOT your command's arguments, but rather the arguments to give to the specified runtime. For example, for the default `node` runtime, this might look something like `{ node: [ '--inspect' ] }`.
 * static **commandArguments** *`<string>`* - A string containing your command arguments, their descriptions, their types, and their default values. [simple-yargs](https://www.npmjs.com/package/simple-yargs) is used to parse these command argument strings, so refer to its documentation for how to define your command arguments.
 * static **applicationConfig** *`<object> | <function>`* - Define the options passed to your `Application.constructor`. If this is a simple object, then the `mythix-cli` will inject some default options that make sense for most commands. If this is a function, then it should return an options object. When this is a function, the `mythix-cli` will not inject any arguments, but instead will pass your options directly to `Application.constructor` without modification.
 

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "mythix",
-  "version": "2.4.13",
+  "version": "2.5.1",
   "description": "Mythix is a NodeJS web-app framework",
-  "main": "src/index.js",
+  "main": "src/index",
   "scripts": {
     "test": "node ./node_modules/.bin/jasmine",
     "test-watch": "watch 'clear ; node --trace-warnings ./node_modules/.bin/jasmine' . --wait=3 --interval=1"
@@ -20,18 +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",
-    "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

@@ -13,7 +13,7 @@ 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.js');
+const { FileWatcherModule } = require('./modules/file-watcher-module');
 const { wrapConfig }        = require('./utils');
 
 // Trace what is requesting the application exit
@@ -351,6 +351,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,31 +5,37 @@
 const Path        = require('path');
 const FileSystem  = require('fs');
 const Nife        = require('nife');
-const { Logger }  = require('../logger');
+const Logger      = require('../logger');
 
 const {
   walkDir,
   fileNameWithoutExtension,
 } = require('../utils/file-utils');
 
+const { CMDed } = require('cmded');
+
 class CommandBase {
-  constructor(application, argv) {
+  constructor(application, options) {
     Object.defineProperties(this, {
       'application': {
         writable:     false,
-        enumberable:  false,
+        enumerable:   false,
         configurable: true,
         value:        application,
       },
-      'argv': {
+      'options': {
         writable:     false,
-        enumberable:  false,
+        enumerable:   false,
         configurable: true,
-        value:        argv,
+        value:        options,
       },
     });
   }
 
+  getOptions() {
+    return this.options;
+  }
+
   getApplication() {
     return this.application;
   }
@@ -47,17 +53,12 @@ class CommandBase {
 
 let loadingAllCommandsInProgress = false;
 
-CommandBase.defaultArguments = `
-[-e,-env:string(Environment to use)=$NODE_ENV|development(Default "development")]
-[--mythixConfig:string(Path to .mythix-config.js)=$MYTHIX_CONFIG_PATH]
-`.trim();
-
 function defineCommand(_commandName, definer, _parent) {
   if (!CommandBase.commands) {
     Object.defineProperties(CommandBase, {
       'commands': {
         writable:     false,
-        enumberable:  false,
+        enumerable:   false,
         configurable: true,
         value:        {},
       },
@@ -81,7 +82,6 @@ function defineCommand(_commandName, definer, _parent) {
     let mythixApplicationCommandsPath = process.env['MYTHIX_APPLICATION_COMMANDS'];
     if (mythixCommandPath && mythixApplicationCommandsPath)
       loadCommands(mythixApplicationCommandsPath, [ mythixCommandPath ]);
-
   }
 
   if (Nife.instanceOf(parent, 'string')) {
@@ -102,20 +102,6 @@ function defineCommand(_commandName, definer, _parent) {
     throw new Error(`Error while defining command ${commandName}: "execute" method is required`);
 
   Klass.commandName = commandName;
-  if (!Klass.commandArguments)
-    Klass.commandArguments = '';
-
-  if (!Klass.description)
-    Klass.description = '';
-
-  if (Klass.commandArguments.indexOf(CommandBase.defaultArguments) < 0)
-    Klass.commandArguments = `${Klass.commandArguments} ${CommandBase.defaultArguments}`.trim();
-  else
-    Klass.commandArguments = Klass.commandArguments.trim();
-
-  Klass.commandString = `${commandName}(${Klass.description}) ${(Klass.commandArguments) ? Klass.commandArguments : ''}`.trim();
-
-  //console.log('COMMAND STRING: ', name, Klass.commandString.replace(/\n/gm, ' '));
 
   // Executor method. This gets invoked in a separate node process
   // The command script is executed directly via node when the
@@ -123,74 +109,86 @@ function defineCommand(_commandName, definer, _parent) {
   // "executeCommand" below, which spawns a node process that
   // targets this command script.
   Klass.execute = async function() {
-    let yargsPath = process.env['MYTHIX_YARGS_PATH'];
-    if (!yargsPath)
-      yargsPath = Path.dirname(require.resolve('yargs'));
+    // eslint-disable-next-line new-cap
+    let commandContext = CMDed((context) => {
+      let { $, Types, store, scope } = context;
 
-    let simpleYargsPath = process.env['MYTHIX_SIMPLE_YARGS_PATH'];
-    if (!simpleYargsPath)
-      simpleYargsPath = Path.dirname(require.resolve('simple-yargs', '..'));
+      // Parse these even though they are no longer needed
+      // so that we ensure they are "consumed".
+      $('--config', Types.STRING({
+        format: Path.resolve,
+      })) || store({ config: (Nife.isNotEmpty(process.env.MYTHIX_CONFIG_PATH)) ? Path.resolve(process.env.MYTHIX_CONFIG_PATH) : Path.join(process.env.PWD, '.mythix-config.js') });
 
-    let yargs             = require(Path.resolve(yargsPath, 'yargs'));
-    let { hideBin }       = require(Path.resolve(yargsPath, 'helpers'));
-    const SimpleYargs     = require(simpleYargsPath);
-    let argv              = hideBin(process.argv).concat('');
-    let rootCommand       = yargs(argv);
+      $('--runtime', Types.STRING());
 
-    rootCommand = SimpleYargs.buildCommands(rootCommand, async function(command, args) {
-      let application;
+      $('-e', Types.STRING(), { name: 'environment' });
+      $('--env', Types.STRING(), { name: 'environment' });
 
-      try {
-        let PWD               = process.env['PWD'];
-        let mythixConfigPath  = args.mythixConfig;
+      let runner = null;
 
-        if (Nife.isEmpty(mythixConfigPath))
-          mythixConfigPath = process.env['MYTHIX_CONFIG_PATH'];
+      if (typeof Klass.commandArguments === 'function') {
+        let result = (Klass.commandArguments() || {});
+        runner = result.runner;
+      }
 
-        if (Nife.isEmpty(mythixConfigPath))
-          mythixConfigPath = PWD;
+      return scope(commandName, (context) => {
+        if (typeof runner === 'function')
+          return runner(context);
 
-        let config            = loadMythixConfig(mythixConfigPath);
-        let Application       = config.getApplicationClass(config);
-        let applicationConfig = Klass.applicationConfig;
+        return true;
+      });
+    });
 
-        if (typeof applicationConfig === 'function')
-          applicationConfig = applicationConfig(config, Application);
-        else if (applicationConfig)
-          applicationConfig = Nife.extend(true, { httpServer: false, autoReload: false, logger: { level: Logger.LEVEL_WARN }, runTasks: false }, applicationConfig);
+    if (!commandContext)
+      return;
 
+    let application;
 
-        if (!applicationConfig)
-          applicationConfig = { httpServer: false, autoReload: false, logger: { level: Logger.LEVEL_WARN }, runTasks: false };
+    try {
+      let PWD               = process.env['PWD'];
+      let mythixConfigPath  = commandContext.config || process.env['MYTHIX_CONFIG_PATH'];
 
-        let doStartApplication = (applicationConfig.autoStart !== false);
+      if (Nife.isEmpty(mythixConfigPath))
+        mythixConfigPath = PWD;
 
-        delete applicationConfig.autoStart;
+      let config            = loadMythixConfig(mythixConfigPath);
+      let Application       = config.getApplicationClass(config);
+      let applicationConfig = Klass.applicationConfig;
 
-        application = await createApplication(Application, Object.assign({ exitOnShutdown: 1 }, applicationConfig), false);
+      if (typeof applicationConfig === 'function')
+        applicationConfig = applicationConfig(config, Application);
+      else if (applicationConfig)
+        applicationConfig = Nife.extend(true, { httpServer: false, autoReload: false, logger: { level: Logger.LEVEL_WARN }, runTasks: false }, applicationConfig);
 
-        let environment = args.env;
-        if (Nife.isEmpty(environment))
-          environment = application.getConfigValue('environment', 'development');
+      if (!applicationConfig)
+        applicationConfig = { httpServer: false, autoReload: false, logger: { level: Logger.LEVEL_WARN }, runTasks: false };
 
-        application.setConfig({ environment: environment });
+      let doStartApplication = (applicationConfig.autoStart !== false);
 
-        if (doStartApplication)
-          await application.start();
+      delete applicationConfig.autoStart;
 
-        let commandInstance = new Klass(application, args);
-        let result          = await commandInstance.execute.call(commandInstance, args);
+      application = await createApplication(Application, Object.assign({ exitOnShutdown: 1 }, applicationConfig), false);
 
-        await application.stop(result || 0);
-      } catch (error) {
-        console.log(`Error while executing command "${command}"`, error);
+      let environment = commandContext.environment;
+      if (Nife.isEmpty(environment))
+        environment = application.getConfigValue('environment', 'development');
 
-        if (application)
-          await application.stop(1);
-      }
-    }, [ Klass.commandString ]);
+      application.setConfig({ environment: environment });
+
+      if (doStartApplication)
+        await application.start();
+
+      let commandOptions  = commandContext[commandName] || {};
+      let commandInstance = new Klass(application, commandOptions);
+      let result          = await commandInstance.execute.call(commandInstance, commandOptions);
+
+      await application.stop(result || 0);
+    } catch (error) {
+      console.log(`Error while executing command "${commandName}"`, error);
 
-    rootCommand.parse();
+      if (application)
+        await application.stop(1);
+    }
   };
 
   CommandBase.commands[commandName] = Klass;
@@ -203,12 +201,11 @@ 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 || {}));
@@ -220,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;
@@ -292,7 +292,7 @@ function loadMythixConfig(_mythixConfigPath, _appRootPath) {
   try {
     let stats = FileSystem.statSync(mythixConfigPath);
     if (stats.isDirectory())
-      configPath = Path.resolve(mythixConfigPath, '.mythix-config.js');
+      configPath = Path.resolve(mythixConfigPath, '.mythix-config');
     else if (stats.isFile(mythixConfigPath))
       mythixConfigPath = Path.dirname(mythixConfigPath);
   } catch (error) {
@@ -309,7 +309,7 @@ function loadMythixConfig(_mythixConfigPath, _appRootPath) {
   let defaultConfig = {
     runtime:              process.env.MYTHIX_RUNTIME || 'node',
     runtimeArgs:          (process.env.MYTHIX_RUNTIME_ARGS || '').split(/\s+/g).filter(Boolean),
-    applicationPath:      (config) => Path.resolve(config.appRootPath, 'application.js'),
+    applicationPath:      (config) => Path.resolve(config.appRootPath, 'application'),
     getApplicationClass:  (config) => {
       let Application = require(config.applicationPath);
       if (Application && typeof Application !== 'function' && typeof Application.Application === 'function')
@@ -367,27 +367,34 @@ function spawnCommand(args, options, _config) {
   });
 }
 
-async function executeCommand(configPath, applicationCommandsPath, yargsPath, simpleYargsPath, argv, commandPath, command, _config) {
+async function executeCommand(_config, appOptions, commandContext, CommandKlass, argv) {
+  let command = commandContext.command;
+
   try {
-    let config        = _config || {};
-    let Klass         = CommandBase.commands[command];
-    let nodeArguments = ((config.runtime || 'node') === 'node') ? (Klass.nodeArguments || []) : [];
-    let args          = nodeArguments.concat([ commandPath ], argv);
+    let config            = _config || {};
+    let configPath        = commandContext.config;
+    let commandPath       = CommandKlass.path;
+    let commandsPath      = appOptions.commandsPath;
+    let runtime           = commandContext.runtime || config.runtime || process.env.MYTHIX_RUNTIME || 'node';
+    let runtimeArguments  = ((CommandKlass.runtimeArguments || {})[runtime]) || [];
+    let args              = runtimeArguments.concat([ commandPath ], argv);
 
     let code = await spawnCommand(
       args,
       {
         env: {
-          MYTHIX_RUNTIME:               config.runtime || process.env.MYTHIX_RUNTIME || 'node',
+          NODE_ENV:                     commandContext.environment || '',
+          MYTHIX_RUNTIME:               runtime,
           MYTHIX_CONFIG_PATH:           configPath,
           MYTHIX_COMMAND_PATH:          commandPath,
-          MYTHIX_APPLICATION_COMMANDS:  applicationCommandsPath,
-          MYTHIX_YARGS_PATH:            yargsPath,
-          MYTHIX_SIMPLE_YARGS_PATH:     simpleYargsPath,
+          MYTHIX_APPLICATION_COMMANDS:  commandsPath,
           MYTHIX_EXECUTE_COMMAND:       command,
         },
       },
-      config,
+      {
+        ...config,
+        ...commandContext,
+      },
     );
 
     process.exit(code);

package/src/cli/index.d.ts

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

package/src/cli/migrations/makemigrations-command.js

@@ -37,15 +37,16 @@ ${postCode}
 
 module.exports = defineCommand('makemigrations', ({ Parent }) => {
   return class MakeMigrationsCommand extends Parent {
-    static description      = 'Create migration for current model schema';
-
-    // static nodeArguments    = [ '--inspect-brk' ];
-
-    static commandArguments = `
-      [-p,-preview:boolean(Preview what the generated migration would look like without migrating anything)]
-      [-n,-name:string(Specify a name for your migration)]
-      [-c,-comment:string(Specify a comment for your migration)]
-    `;
+    static commandArguments() {
+      return {
+        help: {
+          // eslint-disable-next-line key-spacing
+          '@usage': 'mythix-cli makemigrations [options]',
+          '@title': 'Generate a migration file',
+          '-n={name} | -n {name} | --name={name} | --name {name}': 'Specify the name of the generated migration file',
+        },
+      };
+    }
 
     getRevisionNumber() {
       let date = new Date();
@@ -1120,8 +1121,6 @@ module.exports = defineCommand('makemigrations', ({ Parent }) => {
       let models          = dbSchema.models;
       let dbTableSchema   = dbSchema.dbTableSchema;
 
-      debugger;
-
       // Now create migration
       for (let i = 0, il = schemaDiff.length; i < il; i++) {
         let thisDiff  = schemaDiff[i];