mythix 2.5.4 → 2.5.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mythix",
-  "version": "2.5.4",
+  "version": "2.5.6",
   "description": "Mythix is a NodeJS web-app framework",
   "main": "src/index",
   "scripts": {
@@ -29,10 +29,11 @@
   "dependencies": {
     "@types/events": "^3.0.0",
     "chokidar": "^3.5.3",
-    "cmded": "^1.2.3",
+    "cmded": "^1.2.5",
     "express": "^4.18.1",
     "express-busboy": "github:th317erd/express-busboy#0754a570d7979097b31e48655b80d3fcd628d4e4",
     "form-data": "^4.0.0",
+    "micromatch": "^4.0.5",
     "mythix-orm": "^1.6.3",
     "nife": "^1.12.1",
     "prompts": "^2.4.2"

package/src/application.js

@@ -151,6 +151,11 @@ class Application extends EventEmitter {
       opts.tempPath = Path.resolve(OS.tmpdir(), this.getApplicationName().replace(/[^\w-]/g, ''), ('' + process.pid));
   }
 
+  getApplicationName() {
+    let options = this.getOptions();
+    return options.appName || this.constructor.APP_NAME;
+  }
+
   getTempPath() {
     let options = this.getOptions();
     return options.tempPath;
@@ -262,11 +267,6 @@ class Application extends EventEmitter {
     return this;
   }
 
-  getApplicationName() {
-    let options = this.getOptions();
-    return options.appName;
-  }
-
   getRoutes() {
     throw new Error('Error: child application expected to implement "getRoutes" method');
   }

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

@@ -1,4 +1,5 @@
 import { HelpInterface, Runner } from 'cmded';
+import { Stats } from 'fs';
 import { ConnectionBase } from 'mythix-orm';
 import { Application, ApplicationClass, ApplicationOptions } from '../application';
 import { GenericObject } from '../interfaces/common';
@@ -8,6 +9,8 @@ export declare type CommandClass = typeof CommandBase;
 
 export declare type CommandClasses = { [ key: string ]: CommandClass };
 
+export declare type FileFilterCallback = (fullFileName: string, fileName: string, stats?: Stats) => boolean;
+
 export declare class CommandBase {
   declare public static commands: GenericObject;
   declare public static commandName: string;
@@ -24,6 +27,14 @@ export declare class CommandBase {
   getApplication(): Application;
   getLogger(): Logger;
   getDBConnection(): ConnectionBase;
+
+  spawnCommand(
+    command: string,
+    args: Array<string>,
+    options?: GenericObject
+  ): Promise<{ stdout: string, stderr: string, error: any, code: number }>;
+
+  getCommandFiles(filterFunc?: FileFilterCallback): Array<string>;
 }
 
 export declare interface DefineCommandContext {
@@ -61,3 +72,6 @@ export declare function executeCommand(
   CommandKlass: CommandClass,
   argv: Array<string>
 ): void;
+
+export declare function getInternalCommandsPath(): string;
+export declare function getCommandFiles(commandsPath: string, filterFunc?: FileFilterCallback): Array<string>;

package/src/cli/cli-utils.js

@@ -1,6 +1,6 @@
 'use strict';
 
-/* global process, __dirname */
+/* global process, __dirname, Buffer */
 
 const Path        = require('path');
 const FileSystem  = require('fs');
@@ -12,7 +12,10 @@ const {
   fileNameWithoutExtension,
 } = require('../utils/file-utils');
 
-const { CMDed } = require('cmded');
+const {
+  CMDed,
+  showHelp,
+} = require('cmded');
 
 class CommandBase {
   constructor(application, options) {
@@ -49,6 +52,81 @@ class CommandBase {
     let application = this.getApplication();
     return application.getDBConnection();
   }
+
+  spawnCommand(command, args, options) {
+    const { spawn } = require('child_process');
+
+    return new Promise((resolve, reject) => {
+      try {
+        let childProcess = spawn(
+          command,
+          args,
+          Object.assign({ shell: true }, options || {}, {
+            env: Object.assign({}, process.env, (options || {}).env || {}),
+          }),
+        );
+
+        let output = [];
+        let errors = [];
+
+        childProcess.stdout.on('data', (data) => {
+          output.push(data);
+        });
+
+        childProcess.stderr.on('data', (data) => {
+          errors.push(data);
+        });
+
+        childProcess.on('error', (error) => {
+          reject({
+            stdout: Buffer.concat(output).toString('utf8'),
+            stderr: Buffer.concat(errors).toString('utf8'),
+            code:   1,
+            error,
+          });
+        });
+
+        childProcess.on('close', (code) => {
+          if (code !== 0) {
+            let error = Buffer.concat(errors).toString('utf8');
+
+            reject({
+              stdout: Buffer.concat(output).toString('utf8'),
+              stderr: error,
+              error:  error,
+              code,
+            });
+          } else {
+            resolve({
+              stdout: Buffer.concat(output).toString('utf8'),
+              stderr: Buffer.concat(errors).toString('utf8'),
+              error:  null,
+              code,
+            });
+          }
+        });
+      } catch (error) {
+        reject({
+          stdout: '',
+          stderr: '',
+          code:   1,
+          error,
+        });
+      }
+    });
+  }
+
+  getCommandFiles(filterFunc) {
+    let application         = this.getApplication();
+    let applicationOptions  = application.getOptions();
+    let internalCommands    = getCommandFiles(getInternalCommandsPath(), filterFunc);
+    let externalCommands    = [];
+
+    if (Nife.isNotEmpty(applicationOptions.commandsPath))
+      externalCommands = getCommandFiles(applicationOptions.commandsPath, filterFunc);
+
+    return [].concat(internalCommands, externalCommands);
+  }
 }
 
 let loadingAllCommandsInProgress = false;
@@ -68,22 +146,6 @@ function defineCommand(_commandName, definer, _parent) {
   let commandName = _commandName.toLowerCase();
   let parent      = _parent;
 
-  let doExecuteCommand    = process.env['MYTHIX_EXECUTE_COMMAND'];
-  let executeImmediately  = false;
-
-  // Is this command script being executed directly?
-  // If so, make certain to load all commands.
-  // This is required, so that commands that inherit
-  // from other commands will continue to work.
-  if (doExecuteCommand === commandName && !loadingAllCommandsInProgress) {
-    executeImmediately = true;
-
-    let mythixCommandPath             = process.env['MYTHIX_COMMAND_PATH'];
-    let mythixApplicationCommandsPath = process.env['MYTHIX_APPLICATION_COMMANDS'];
-    if (mythixCommandPath && mythixApplicationCommandsPath)
-      loadCommands(mythixApplicationCommandsPath, [ mythixCommandPath ]);
-  }
-
   if (Nife.instanceOf(parent, 'string')) {
     if (!CommandBase.commands[parent])
       throw new Error(`Can not find parent class for command "${commandName}": No such parent class "${parent}" found`);
@@ -109,36 +171,66 @@ function defineCommand(_commandName, definer, _parent) {
   // "executeCommand" below, which spawns a node process that
   // targets this command script.
   Klass.execute = async function() {
-    // eslint-disable-next-line new-cap
-    let commandContext = CMDed((context) => {
-      let { $, Types, store, scope } = context;
+    let helpShown = false;
 
-      // 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') });
+    const customShowHelp = (subHelp) => {
+      if (helpShown)
+        return;
 
-      $('--runtime', Types.STRING());
+      helpShown = true;
 
-      $('-e', Types.STRING(), { name: 'environment' });
-      $('--env', Types.STRING(), { name: 'environment' });
+      showHelp(subHelp);
+    };
 
-      let runner = null;
+    const getArgumentsContext = async (application) => {
+      // eslint-disable-next-line new-cap
+      return await CMDed(async (context) => {
+        let { $, Types, store, scope } = context;
 
-      if (typeof Klass.commandArguments === 'function') {
-        let result = (Klass.commandArguments() || {});
-        runner = result.runner;
-      }
+        // 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') });
 
-      return scope(commandName, (context) => {
-        if (typeof runner === 'function')
-          return runner(context);
+        $('--runtime', Types.STRING());
 
-        return true;
+        $('-e', Types.STRING(), { name: 'environment' });
+        $('--env', Types.STRING(), { name: 'environment' });
+
+        if (!application)
+          return true;
+
+        store('executing', true);
+        store('mythixApplication', application);
+
+        // Consume the command name
+        $(commandName, ({ fetch, showHelp }) => {
+          if (fetch('help', false))
+            showHelp(commandName);
+
+          return true;
+        });
+
+        let runner = null;
+        if (typeof Klass.commandArguments === 'function') {
+          let result = ((await Klass.commandArguments(application, 'runner')) || {});
+          runner = result.runner;
+        }
+
+        return await scope(commandName, async (context) => {
+          if (typeof runner === 'function')
+            return await runner(context);
+
+          return true;
+        });
+      }, {
+        helpArgPattern: null,
+        showHelp:       customShowHelp,
       });
-    });
+    };
 
+    let commandContext = await getArgumentsContext();
     if (!commandContext)
       return;
 
@@ -178,9 +270,11 @@ function defineCommand(_commandName, definer, _parent) {
       if (doStartApplication)
         await application.start();
 
+      commandContext = await getArgumentsContext(application);
+
       let commandOptions  = commandContext[commandName] || {};
       let commandInstance = new Klass(application, commandOptions);
-      let result          = await commandInstance.execute.call(commandInstance, commandOptions);
+      let result          = await commandInstance.execute.call(commandInstance, commandOptions, commandContext);
 
       await application.stop(result || 0);
     } catch (error) {
@@ -193,14 +287,6 @@ function defineCommand(_commandName, definer, _parent) {
 
   CommandBase.commands[commandName] = Klass;
 
-  // If this command file was loaded directly, and it was requested
-  // that we execute it, then do so right now
-  if (executeImmediately) {
-    Klass.execute().then(() => {}, (error) => {
-      console.log(error);
-    });
-  }
-
   return Klass;
 }
 
@@ -225,35 +311,42 @@ function loadCommand(name) {
   return CommandKlass;
 }
 
-function loadCommands(applicationCommandsPath, skip) {
-  const getCommandFiles = (commandsPath) => {
-    try {
-      return walkDir(commandsPath, {
-        filter: (fullFileName, fileName, stats) => {
-          if (fileName.match(/^_/))
-            return false;
+function getCommandFiles(commandsPath, filterFunc) {
+  try {
+    return walkDir(commandsPath, {
+      filter: (fullFileName, fileName, stats) => {
+        if (typeof filterFunc === 'function')
+          return filterFunc(fullFileName, fileName, stats);
 
-          if (stats.isFile() && !fileNameWithoutExtension(fileName).match(/-command$/))
-            return false;
+        if (fileName.match(/^_/))
+          return false;
 
-          return true;
-        },
-      });
-    } catch (error) {
-      if (error.code === 'ENOENT')
-        return [];
+        if (stats.isFile() && !fileNameWithoutExtension(fileName).match(/-command$/))
+          return false;
 
-      console.error(error);
-      throw error;
-    }
-  };
+        return true;
+      },
+    });
+  } catch (error) {
+    if (error.code === 'ENOENT')
+      return [];
 
+    console.error(error);
+    throw error;
+  }
+}
+
+function getInternalCommandsPath() {
+  return Path.resolve(__dirname);
+}
+
+function loadCommands(applicationCommandsPath, skip) {
   if (loadingAllCommandsInProgress)
     return;
 
   loadingAllCommandsInProgress = true;
 
-  let mythixCommandFiles      = getCommandFiles(Path.resolve(__dirname));
+  let mythixCommandFiles      = getCommandFiles(getInternalCommandsPath());
   let applicationCommandFiles = getCommandFiles(applicationCommandsPath);
   let allCommandFiles         = [].concat(mythixCommandFiles, applicationCommandFiles);
 
@@ -261,7 +354,6 @@ function loadCommands(applicationCommandsPath, skip) {
     if (skip && skip.indexOf(commandPath) >= 0)
       return;
 
-
     loadCommand(commandPath);
   });
 
@@ -324,6 +416,9 @@ function loadMythixConfig(_mythixConfigPath, _appRootPath) {
   try {
     if (FileSystem.existsSync(configPath)) {
       let mythixConfig = require(configPath);
+      if (mythixConfig.__esModule)
+        mythixConfig = mythixConfig['default'];
+
       if (!mythixConfig.appRootPath)
         mythixConfig.appRootPath = appRootPath;
 
@@ -377,7 +472,7 @@ async function executeCommand(_config, appOptions, commandContext, CommandKlass,
     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 args              = runtimeArguments.concat([ Path.resolve(__dirname, 'command-executor.js') ], argv);
 
     let code = await spawnCommand(
       args,
@@ -407,6 +502,8 @@ async function executeCommand(_config, appOptions, commandContext, CommandKlass,
 module.exports = {
   CommandBase,
   loadMythixConfig,
+  getInternalCommandsPath,
+  getCommandFiles,
   loadCommand,
   loadCommands,
   defineCommand,

package/src/cli/command-executor.js

@@ -0,0 +1,31 @@
+'use strict';
+
+/* global process */
+
+const Nife = require('nife');
+const {
+  CommandBase,
+  loadCommands,
+} = require('./cli-utils');
+
+(async function() {
+  let commandName = process.env['MYTHIX_EXECUTE_COMMAND'];
+  if (Nife.isEmpty(commandName))
+    return;
+
+  // First load all commands
+  let mythixCommandPath             = process.env['MYTHIX_COMMAND_PATH'];
+  let mythixApplicationCommandsPath = process.env['MYTHIX_APPLICATION_COMMANDS'];
+  if (mythixCommandPath && mythixApplicationCommandsPath)
+    loadCommands(mythixApplicationCommandsPath);
+
+  let Klass = CommandBase.commands[commandName];
+  if (!Klass || typeof Klass.execute !== 'function')
+    return;
+
+  try {
+    await Klass.execute();
+  } catch (error) {
+    console.error(error);
+  }
+})();