mythix 2.5.4 → 2.5.6

package/src/cli/generators/generate-command.js

@@ -0,0 +1,149 @@
+'use strict';
+
+const Path        = require('path');
+const Nife        = require('nife');
+const { Logger }  = require('../../logger');
+
+const {
+  defineCommand,
+  getCommandFiles,
+  getInternalCommandsPath,
+} = require('../cli-utils');
+
+function loadGeneratorCommands(application, operationName) {
+  const generatorFilterFunc = (fullFileName, fileName, stats) => {
+    if (stats.isDirectory())
+      return true;
+
+    if ((/[^_][\w-]+-generator\.\w+$/).test(fileName))
+      return true;
+
+    return false;
+  };
+
+  let applicationOptions = application.getOptions();
+  let generatorFiles = [].concat(
+    getCommandFiles(
+      getInternalCommandsPath(),
+      generatorFilterFunc,
+    ),
+    (Nife.isEmpty(applicationOptions.commandsPath)) ? getCommandFiles(
+      getInternalCommandsPath(),
+      generatorFilterFunc,
+    ) : null,
+  ).filter(Boolean);
+
+  generatorFiles = Nife.uniq(generatorFiles);
+
+  let commands = {};
+
+  for (let i = 0, il = generatorFiles.length; i < il; i++) {
+    let fullFileName  = generatorFiles[i];
+    let fileName      = Path.basename(fullFileName);
+    let commandName   = fileName.replace(/^([\w-]+)-generator\.\w+$/, '$1');
+    let commandArgs   = {};
+    let Klass;
+
+    try {
+      Klass = require(fullFileName);
+      if (Klass.__esModule)
+        Klass = Klass['default'];
+
+      if (typeof Klass.commandArguments === 'function') {
+        commandArgs = Klass.commandArguments(application, operationName);
+
+        if (commandArgs && commandArgs.help)
+          commandArgs.help['@see'] = `See: 'mythix-cli generate ${commandName} --help' for more help`;
+      }
+    } catch (error) {
+      if (operationName === 'help')
+        console.error(`Error while attempting to load generator "${fullFileName}": `, error);
+
+      continue;
+    }
+
+    commands[commandName.toLocaleLowerCase()] = {
+      CommandKlass: Klass,
+      ...commandArgs,
+    };
+  }
+
+  return commands;
+}
+
+module.exports = defineCommand('generate', ({ Parent }) => {
+  return class GenerateCommand extends Parent {
+    static applicationConfig = () => {
+      return {
+        httpServer: false,
+        autoReload: false,
+        runTasks:   false,
+        logger:     {
+          level: Logger.LEVEL_ERROR,
+        },
+      };
+    };
+
+    static commandArguments(application, operationName) {
+      let generatorCommands = loadGeneratorCommands(application, operationName);
+
+      let help = {
+        '@usage': 'mythix-cli generate {generator}',
+        '@title': 'Generate new content using the specified generator',
+      };
+
+      Nife.iterate(generatorCommands, ({ value, key }) => {
+        if (value.help)
+          help[key] = value.help;
+      });
+
+      return {
+        help:   help,
+        runner: ({ $, fetch, showHelp, scope, store }) => {
+          let subCommandResult = $(
+            /[\w-]+/,
+            ({ store }, parsedResult) => {
+              store({ generateSubCommand: parsedResult.value.toLowerCase() });
+              return true;
+            },
+            { formatParsedResult: (result) => ({ value: result[0] }) },
+          );
+
+          if (!subCommandResult)
+            return false;
+
+          let subCommandName  = fetch('generateSubCommand');
+          let command         = generatorCommands[subCommandName];
+
+          if (!command) {
+            console.error(`Error: unknown generator "${subCommandName}"\n`);
+            return false;
+          }
+
+          let subCommandRunnerResult = true;
+          if (command.runner)
+            subCommandRunnerResult = scope(subCommandName, command.runner);
+
+          if (!subCommandRunnerResult || fetch('help', false)) {
+            showHelp(null, help[subCommandName] || help);
+            return false;
+          }
+
+          store('generatorCommands', generatorCommands);
+
+          return true;
+        },
+      };
+    }
+
+    async execute(args, fullArgs) {
+      let application       = this.getApplication();
+      let subCommandName    = args.generateSubCommand;
+      let generatorCommands = args.generatorCommands;
+      let command           = generatorCommands[subCommandName];
+
+      let commandInstance = new command.CommandKlass(application, this.getOptions());
+      return await commandInstance.execute.call(commandInstance, args[subCommandName], fullArgs);
+    }
+  };
+});

package/src/cli/generators/migration-generator.js

@@ -0,0 +1,209 @@
+/* eslint-disable key-spacing */
+
+'use strict';
+
+const Path              = require('path');
+const FileSystem        = require('fs');
+const Nife              = require('nife');
+const { Utils }         = require('mythix-orm');
+const { CommandBase }   = require('../cli-utils');
+
+class ValidationError extends Error {}
+
+function generateMigration(migrationID, upCode, downCode) {
+  let template =
+`
+const MIGRATION_ID = '${migrationID}';
+
+module.exports = {
+  MIGRATION_ID,
+  up: async function(connection) {
+${upCode}
+  },
+  down: async function(connection) {
+${downCode}
+  },
+};
+`;
+
+  return template;
+}
+
+class GenerateMigrationCommand extends CommandBase {
+  static commandArguments() {
+    return {
+      help:   {
+        '@usage': 'mythix-cli generate migration {operation} {operation args} [options]',
+        '@title': 'Generate a migration file',
+        '@examples':  [
+          'mythix-cli generate migration add model User',
+          'mythix-cli generate migration rename model User AdminUser',
+          'mythix-cli generate migration remove model User',
+          'mythix-cli generate migration add field User:age',
+          'mythix-cli generate migration rename field User:age yearsLived',
+          'mythix-cli generate migration remove field User:age',
+        ],
+        '-n={name} | -n {name} | --name={name} | --name {name}': 'Specify the name of the generated migration file',
+        '-o={path} | -o {path} | --output={path} | --output {path}': 'Specify the name of the generated migration file',
+      },
+      runner: ({ $, Types, fetch, store }) => {
+        const pathFormatter = (value) => Path.resolve(value);
+
+        let application         = fetch('mythixApplication');
+        let applicationOptions  = application.getOptions();
+
+        $('--name', Types.STRING(), { name: 'name' })
+          || $('-n', Types.STRING(), { name: 'name' });
+
+        $('--output', Types.STRING(), { name: 'outputPath', format: pathFormatter })
+          || $('-o', Types.STRING(), { name: 'outputPath', format: pathFormatter })
+          || store('outputPath', Path.resolve(applicationOptions.migrationsPath));
+
+        let result = $(
+          /[\w-]+/,
+          ({ store }, parsedResult) => {
+            store({ operation: parsedResult.value });
+            return true;
+          },
+          { formatParsedResult: (result) => ({ value: result[0] }) },
+        );
+
+        if (!result)
+          return false;
+
+        result = $(
+          /[\w-]+/,
+          ({ store }, parsedResult) => {
+            store({ entity: parsedResult.value });
+            return true;
+          },
+          { formatParsedResult: (result) => ({ value: result[0] }) },
+        );
+
+        if (!result && fetch('operation') !== 'blank')
+          return false;
+
+        if (fetch('operation') === 'blank' && Nife.isEmpty(fetch('name'))) {
+          console.log('Error: Blank templates require a name. Use the "--name {name}" argument to specify a name.\n');
+          return false;
+        }
+
+        return true;
+      },
+    };
+  }
+
+  getRevisionNumber() {
+    let date = new Date();
+    return date.toISOString().replace(/\.[^.]+$/, '').replace(/\D/g, '');
+  }
+
+  formatMigrationName(name) {
+    return name
+      .replace(/\.\w+$/, '')
+      .replace(/[^a-zA-Z0-9-]+/g, '-')
+      .replace(/^[^a-zA-Z0-9]+/, '')
+      .replace(/[^a-zA-Z0-9]+$/, '')
+      .toLowerCase();
+  }
+
+  getOrGenerateMigrationName(args) {
+    if (Nife.isNotEmpty(args.name))
+      return `${args.version}-${this.formatMigrationName(args.name)}.js`;
+
+    let name = [
+      args.operation,
+      args.entity,
+      ...args.remaining,
+    ];
+
+    return `${args.version}-${this.formatMigrationName(name.join('-'))}.js`;
+  }
+
+  async execute(args, fullArgs) {
+    args.version = this.getRevisionNumber();
+    args.remaining = fullArgs._remaining;
+
+    // Ensure the output path exists
+    try {
+      let stats = FileSystem.statSync(args.outputPath);
+      if (!stats.isDirectory())
+        throw new Error(`The path specified is a file, not a directory: "${args.outputPath}"`);
+    } catch (error) {
+      if (error.code === 'ENOENT')
+        FileSystem.mkdirSync(args.outputPath, { recursive: true });
+      else
+        throw error;
+    }
+
+    // Generate the migration name
+    let migrationName = this.getOrGenerateMigrationName(args);
+    let methodName    = `operation${Nife.capitalize(args.operation)}${(args.entity) ? Nife.capitalize(args.entity) : ''}`;
+    if (typeof this[methodName] !== 'function') {
+      console.error(`Error: unknown operation or entity specified: "${args.operation}${(args.entity) ? `:${args.entity}` : ''}"`);
+      return 1;
+    }
+
+    try {
+      let content   = await this[methodName](args);
+      let finalPath = Path.join(args.outputPath, migrationName);
+
+      console.log(`Would write content:\n${content}`);
+
+      // FileSystem.writeFileSync(migrationWritePath, migrationSource, 'utf8');
+
+      console.log(`New migration to revision ${args.version} has been written to file "${finalPath}"`);
+    } catch (error) {
+      if (error instanceof ValidationError) {
+        console.error(error.message + '\n');
+        return 1;
+      }
+
+      throw error;
+    }
+  }
+
+  tabIn(str, amount = 1) {
+    let parts = new Array(amount);
+    for (let i = 0; i < amount; i++)
+      parts.push('  ');
+
+    let ws = parts.join('');
+    return str.trim().replace(/^/gm, ws);
+  }
+
+  operationAddModels(args) {
+    if (Nife.isEmpty(args.remaining))
+      throw new ValidationError('No model name(s) provided. Try this instead: \n\nmythix-cli generate migration add models \'{model name}\' ...');
+
+    let application       = this.getApplication();
+    let connection        = application.getDBConnection();
+    let queryGenerator    = connection.getQueryGenerator();
+    let statements        = [];
+    let reverseStatements = [];
+
+    let modelNames = Utils.sortModelNamesByCreationOrder(connection, Nife.uniq(args.remaining));
+    for (let i = 0, il = modelNames.length; i < il; i++) {
+      let modelName = modelNames[i];
+      let Model     = connection.getModel(modelName);
+
+      let createTable = queryGenerator.generateCreateTableStatement(Model);
+      statements.push(`    // Create ${modelName} table\n    await connection.query(\`\n${this.tabIn(createTable, 3)}\`,\n      { logger: console },\n    );`);
+
+      let dropTable = queryGenerator.generateDropTableStatement(Model, { cascade: true });
+      reverseStatements.push(`    // Drop ${modelName} table\n    await connection.query(\n      \`${dropTable.trim()}\`,\n      { logger: console },\n    );`);
+    }
+
+    return generateMigration(
+      args.version,
+      statements.join('\n\n'),
+      reverseStatements.reverse().join('\n\n'),
+    );
+  }
+
+  operationAddModel(args) {
+    return this.operationAddModels(args);
+  }
+}
+
+module.exports = GenerateMigrationCommand;

package/src/cli/{migrations/migrate-command.js → migrate-command.js}

@@ -2,8 +2,8 @@
 
 const Path              = require('path');
 const Nife              = require('nife');
-const { defineCommand } = require('../cli-utils');
-const { walkDir }       = require('../../utils/file-utils');
+const { defineCommand } = require('./cli-utils');
+const { walkDir }       = require('../utils/file-utils');
 
 const TIMESTAMP_LENGTH        = 14;
 const MILLISECONDS_PER_SECOND = 1000.0;

package/src/models/model-utils.js

@@ -9,7 +9,7 @@ function _setupModel(modelName, _Model, { application, connection }) {
   let tablePrefix = application.getDBTablePrefix();
 
   if (tablePrefix)
-    tableName = (`${tablePrefix}${tableName}`);
+    tableName = `${tablePrefix}${tableName}`.replace(/_+/g, '_');
 
   Model.getTableName  = () => tableName;
   Model.getModelName  = () => modelName;

package/src/modules/database-module.js

@@ -89,7 +89,7 @@ class DatabaseModule extends BaseModule {
     if (userSpecifiedPrefix != null)
       return ('' + userSpecifiedPrefix);
 
-    return `${this.getApplication().getApplicationName()}_`.replace(/[^A-Za-z0-9_]+/g, '');
+    return `${this.getApplication().getApplicationName()}_`.replace(/[^A-Za-z0-9_]+/g, '_').replace(/_+/g, '_');
   }
 
   getConnection() {

package/src/tasks/task-utils.js

@@ -1,7 +1,7 @@
 'use strict';
 
-const Nife      = require('nife');
-const TaskBase  = require('./task-base');
+const Nife          = require('nife');
+const { TaskBase }  = require('./task-base');
 
 const SECONDS_PER_MINUTE      = 60;
 const MINUTES_PER_HOUR        = 60;

package/src/utils/file-utils.js

@@ -14,7 +14,16 @@ function walkDir(rootPath, _options, _callback, _allFiles, _depth) {
   for (let i = 0, il = fileNames.length; i < il; i++) {
     let fileName      = fileNames[i];
     let fullFileName  = Path.join(rootPath, fileName);
-    let stats         = FileSystem.statSync(fullFileName);
+    let stats;
+
+    try {
+      stats = FileSystem.statSync(fullFileName);
+    } catch (error) {
+      if (error.code === 'ENOENT')
+        continue;
+
+      throw error;
+    }
 
     if (typeof filterFunc === 'function' && !filterFunc(fullFileName, fileName, stats, rootPath, depth))
       continue;

package/src/utils/test-utils.js

@@ -54,8 +54,6 @@ class TestHTTPServerModule extends HTTPServerModule {
 
 function createTestApplication(ApplicationClass) {
   const Klass = class TestApplication extends ApplicationClass {
-    static APP_NAME = `${(Nife.isNotEmpty(ApplicationClass.APP_NAME)) ? ApplicationClass.APP_NAME : 'mythix'}_test`;
-
     // Swap out modules for test config
     static getDefaultModules() {
       let defaultModules = ApplicationClass.getDefaultModules();
@@ -72,6 +70,7 @@ function createTestApplication(ApplicationClass) {
         autoReload:   false,
         runTasks:     false,
         testMode:     true,
+        appName:      `${(Nife.isNotEmpty(ApplicationClass.APP_NAME)) ? ApplicationClass.APP_NAME : 'mythix'}_test`,
       }, _opts || {});
 
       super(opts);