mythix 3.0.0 → 4.0.2

package/lib/cli/commands/generators/generate-command.mjs

@@ -0,0 +1,117 @@
+import Nife             from 'nife';
+import { CommandBase }  from '../../command-base.mjs';
+import { Logger }       from '../../../logger.mjs';
+
+import { GenerateMigrationCommand } from './migration-generator.mjs';
+
+function prepareGeneratorCommands(commands, application, operationName) {
+  return Nife.iterate(commands, ({ index, key, value, context }) => {
+    const Klass = value;
+
+    let commandName = key;
+    if (index === key) {
+      if (typeof Klass.getGeneratorName === 'function')
+        commandName = Klass.getGeneratorName();
+      else
+        commandName = Klass.name;
+    }
+
+    let commandArgs = {};
+    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`;
+    }
+
+    context[commandName.toLocaleLowerCase()] = {
+      CommandKlass: Klass,
+      ...commandArgs,
+    };
+  }, {});
+}
+
+export class GenerateCommand extends CommandBase {
+  static getCommandName() {
+    return 'generate';
+  }
+
+  static getGeneratorCommands() {
+    return {
+      migration: GenerateMigrationCommand,
+    };
+  }
+
+  static applicationConfig = () => {
+    return {
+      httpServer: false,
+      autoReload: false,
+      runTasks:   false,
+      logger:     {
+        level: Logger.LEVEL_ERROR,
+      },
+    };
+  };
+
+  static commandArguments(application, operationName) {
+    let generatorCommands = prepareGeneratorCommands(this.getGeneratorCommands(), 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/lib/cli/commands/generators/index.mjs

@@ -0,0 +1,2 @@
+export * from './generate-command.mjs';
+export * from './migration-generator.mjs';

package/{src/cli/generators/migration-generator.js → lib/cli/commands/generators/migration-generator.mjs}

@@ -1,23 +1,19 @@
 /* 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');
+import Path             from 'node:path';
+import FileSystem       from 'node:fs';
+import Nife             from 'nife';
+import { Utils }        from 'mythix-orm';
+import { CommandBase }  from '../../command-base.mjs';
 
 class ValidationError extends Error {}
 
 function generateMigration(migrationID, upCode, downCode) {
   let template =
 `
-'use strict';
-
 const MIGRATION_ID = '${migrationID}';
 
-module.exports = {
+export default {
   MIGRATION_ID,
   up: async function(connection, application) {
 ${upCode || ''}
@@ -31,7 +27,11 @@ ${downCode || ''}
   return template;
 }
 
-class GenerateMigrationCommand extends CommandBase {
+export class GenerateMigrationCommand extends CommandBase {
+  static getGeneratorName() {
+    return 'migration';
+  }
+
   static commandArguments() {
     return {
       help:   {
@@ -306,5 +306,3 @@ class GenerateMigrationCommand extends CommandBase {
     return this.addOrDropFields(args, true);
   }
 }
-
-module.exports = GenerateMigrationCommand;

package/lib/cli/commands/index.mjs

@@ -0,0 +1,22 @@
+export * from './generators/index.mjs';
+export * from './deploy-command.mjs';
+export * from './migrate-command.mjs';
+export * from './routes-command.mjs';
+export * from './serve-command.mjs';
+export * from './shell-command.mjs';
+
+import { GenerateCommand } from './generators/generate-command.mjs';
+import { DeployCommand  } from './deploy-command.mjs';
+import { MigrateCommand } from './migrate-command.mjs';
+import { RoutesCommand } from './routes-command.mjs';
+import { ServeCommand } from './serve-command.mjs';
+import { ShellCommand } from './shell-command.mjs';
+
+export const COMMANDS = {
+  'generate': GenerateCommand,
+  'deploy':   DeployCommand,
+  'migrate':  MigrateCommand,
+  'routes':   RoutesCommand,
+  'serve':    ServeCommand,
+  'shell':    ShellCommand,
+};

package/lib/cli/commands/migrate-command.mjs

@@ -0,0 +1,184 @@
+import Path               from 'node:path';
+import Nife               from 'nife';
+import { CommandBase }    from '../command-base.mjs';
+import { walkDir }        from '../../utils/file-utils.mjs';
+
+const TIMESTAMP_LENGTH        = 14;
+const MILLISECONDS_PER_SECOND = 1000.0;
+
+export class MigrateCommand extends CommandBase {
+  static getCommandName() {
+    return 'migrate';
+  }
+
+  static commandArguments() {
+    return {
+      help: {
+        /* eslint-disable key-spacing */
+        '@usage': 'mythix-cli migrate [options]',
+        '@title': 'Run or rollback migrations',
+        '-r={revision number} | -r {revision number} | --revision={revision number} | --revision {revision number}': 'Start operation at revision specified. For rollbacks, this specifies the revision to stop at (inclusive).',
+        '--rollback': 'Rollback migrations to the revision number specified, or rollback the last migration if no revision number is specified.',
+      },
+      runner: ({ $, Types }) => {
+        $('-r', Types.STRING(), { name: 'revision' });
+        $('--revision', Types.STRING(), { name: 'revision' });
+
+        $('--rollback', Types.STRING());
+
+        return true;
+      },
+    };
+  }
+
+  getMigrationFiles(migrationsPath) {
+    try {
+      let files = walkDir(migrationsPath, {
+        filter: (fullFileName, fileName, stats) => {
+          if (fileName.match(/^_/) && stats.isDirectory())
+            return false;
+
+          if (stats.isFile() && !fileName.match(/^\d{14}.*\.[mc]?js$/))
+            return false;
+
+          return true;
+        },
+      });
+
+      return files.sort();
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        console.log(`No migrations found at ${migrationsPath}. Aborting...`);
+        return [];
+      }
+
+      throw error;
+    }
+  }
+
+  getMigrationFilesFromRevision(migrationFiles, _revision, isRollback) {
+    let revision = BigInt('' + _revision);
+
+    let index = migrationFiles.findIndex((fullFileName) => {
+      let fileName        = Path.basename(fullFileName);
+      let migrationFileTS = fileName.substring(0, TIMESTAMP_LENGTH);
+
+      if (BigInt(migrationFileTS) > revision)
+        return true;
+
+      return false;
+    });
+
+    if (index < 0)
+      return [];
+
+    return migrationFiles.slice((isRollback) ? index - 1 : index);
+  }
+
+  async executeMigration(application, dbConnection, migrationFileName, useTransaction, rollback) {
+    let migration = await import(migrationFileName);
+    if (migration && migration.default)
+      migration = migration.default;
+
+    let startTime = Nife.now();
+
+    if (rollback) {
+      await migration.down(dbConnection, application);
+      await this.removeMigrationFromDB(migration.MIGRATION_ID);
+
+      let seconds = ((Nife.now() - startTime) / MILLISECONDS_PER_SECOND).toFixed(2);
+      console.log(`Rolled back migration ${migrationFileName} successfully in ${seconds} seconds`);
+    } else {
+      await migration.up(dbConnection, application);
+      await this.storeSuccessfulMigrationToDB(migration.MIGRATION_ID);
+
+      let seconds = ((Nife.now() - startTime) / MILLISECONDS_PER_SECOND).toFixed(2);
+      console.log(`Migration ${migrationFileName} completed successfully in ${seconds} seconds`);
+    }
+  }
+
+  async storeSuccessfulMigrationToDB(migrationID) {
+    let MigrationModel = this.getApplication().getModel('Migration');
+
+    await MigrationModel.create({ id: ('' + migrationID) });
+  }
+
+  async removeMigrationFromDB(migrationID) {
+    try {
+      let MigrationModel = this.getApplication().getModel('Migration');
+
+      await MigrationModel.where.id.EQ(('' + migrationID)).LIMIT(1).destroy();
+    } catch (error) {
+      return;
+    }
+  }
+
+  async fetchLastMigrationIDFromDB() {
+    try {
+      let MigrationModel = this.getApplication().getModel('Migration');
+
+      let lastMigrationModel = await MigrationModel.where.id.NEQ(null).ORDER.DESC('Migration:id').first();
+      if (lastMigrationModel == null)
+        return null;
+
+      return lastMigrationModel.id;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  async execute(args) {
+    const nextMigration = (doneCallback, _index) => {
+      let index = _index || 0;
+      if (index >= migrationFiles.length)
+        return doneCallback();
+
+      let migrationFileName = migrationFiles[index];
+
+      if (rollback)
+        console.log(`Undoing migration ${migrationFileName}...`);
+      else
+        console.log(`Running migration ${migrationFileName}...`);
+
+      this.executeMigration(application, dbConnection, migrationFileName, useTransaction, rollback).then(
+        () => nextMigration(doneCallback, index + 1),
+        (error) => {
+          console.error(`Error while running migration ${migrationFileName}: `, error);
+          doneCallback(error);
+        },
+      );
+    };
+
+    let cliConfig       = this.getCLIConfig();
+    let application     = this.getApplication();
+    let dbConnection    = application.getConnection();
+    let migrationsPath  = cliConfig.migrationRoot || Path.resolve(cliConfig.appRootPath, 'migrations');
+    let migrationFiles  = this.getMigrationFiles(migrationsPath);
+    let useTransaction  = args.transaction;
+    let rollback        = args.rollback;
+    let migrationID     = args.revision;
+
+    if (!migrationID)
+      migrationID = await this.fetchLastMigrationIDFromDB(dbConnection);
+
+    if (migrationID)
+      migrationFiles = this.getMigrationFilesFromRevision(migrationFiles, migrationID, rollback);
+
+    if (args.rollback)
+      migrationFiles = migrationFiles.reverse();
+
+    if (migrationFiles.length === 0) {
+      console.log('Nothing to migrate');
+      return;
+    }
+
+    return new Promise((resolve, reject) => {
+      nextMigration((error) => {
+        if (error)
+          return reject(error);
+
+        resolve();
+      });
+    });
+  }
+}

package/lib/cli/commands/routes-command.mjs

@@ -0,0 +1,40 @@
+import { Logger }       from '../../logger.mjs';
+import { CommandBase }  from '../command-base.mjs';
+
+export class RoutesCommand extends CommandBase {
+  static getCommandName() {
+    return 'routes';
+  }
+
+  static applicationConfig = { database: false, logger: { level: Logger.LEVEL_ERROR } };
+
+  static commandArguments() {
+    return {
+      help: {
+        '@usage': 'mythix-cli routes',
+        '@title': 'List application routes',
+      },
+    };
+  }
+
+  execute() {
+    let application = this.getApplication();
+    let routes      = application._getRoutes();
+    let whitespace  = '        ';
+
+    console.log(`${application.getApplicationName()} routes:`);
+
+    routes.walkRoutes(({ endpoint }) => {
+      let methods = endpoint.methods || [];
+      let flags   = [
+        (endpoint.isDynamic) ? 'dynamic' : '',
+        (endpoint.cors) ? 'COR' : '',
+      ].filter(Boolean).join(', ');
+
+      for (let i = 0, il = methods.length; i < il; i++) {
+        let method = methods[i];
+        console.log(`  ${method}${whitespace.substring(0, whitespace.length - method.length)}/${endpoint.path} -> [${endpoint.controller}]${(flags) ? ` (${flags})` : ''}`);
+      }
+    });
+  }
+}

package/lib/cli/commands/serve-command.mjs

@@ -0,0 +1,63 @@
+import Nife             from 'nife';
+import { CommandBase }  from '../command-base.mjs';
+
+export class ServeCommand extends CommandBase {
+  static getCommandName() {
+    return 'serve';
+  }
+
+  static applicationConfig = () => ({ autoStart: false, exitOnShutdown: 0 });
+
+  static commandArguments() {
+    return {
+      help: {
+        /* eslint-disable key-spacing */
+        '@usage': 'mythix-cli serve [options]',
+        '@title': 'Start application and HTTP server',
+        '--host={hostname or IP} | --host {hostname or IP}': 'Specify hostname or IP to listen on.',
+        '--port={port number} | --port {port number}': 'Specify port to listen on.',
+      },
+      runner: ({ $, Types }) => {
+        $('--host', Types.STRING());
+        $('--port', Types.INTEGER({
+          validate: (value) => {
+            // eslint-disable-next-line no-magic-numbers
+            if (value < 0 || value > 65535) {
+              console.error('Invalid "--port" specified... must be in the range 0-65535');
+              return false;
+            }
+
+            return true;
+          },
+        }));
+
+        return true;
+      },
+    };
+  }
+
+  execute(args) {
+    // eslint-disable-next-line no-async-promise-executor
+    return new Promise(async (resolve, reject) => {
+      try {
+        let application = this.getApplication();
+        let config = {};
+
+        if (Nife.isNotEmpty(args.host))
+          config.host = args.host;
+
+        if (Nife.isNotEmpty(args.port))
+          config.port = args.port;
+
+        if (Nife.isNotEmpty(config))
+          application.setConfig({ httpServer: config });
+
+        application.on('exit', resolve);
+
+        await application.start();
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+}

package/lib/cli/commands/shell-command.mjs

@@ -0,0 +1,95 @@
+import OS                 from 'node:os';
+import Path               from 'node:path';
+import REPL               from 'node:repl';
+import Nife               from 'nife';
+import * as UUID          from 'uuid';
+import { CommandBase }    from '../command-base.mjs';
+import { HTTPInterface }  from '../../http/http-interface.mjs';
+import * as Utils         from '../../utils/index.mjs';
+
+export class ShellCommand extends CommandBase {
+  static getCommandName() {
+    return 'shell';
+  }
+
+  static runtimeArguments = {
+    'node': [ '--experimental-repl-await', '--experimental-top-level-await' ],
+  };
+
+  static commandArguments() {
+    return {
+      help: {
+        '@usage': 'mythix-cli shell',
+        '@title': 'Drop into an server shell to execute commands directly',
+      },
+    };
+  }
+
+  constructor(...args) {
+    super(...args);
+
+    Object.defineProperties(this, {
+      'defaultHeaders': {
+        writable:     true,
+        enumerable:   false,
+        configurable: true,
+        value:        {},
+      },
+      'defaultURL': {
+        writable:     true,
+        enumerable:   false,
+        configurable: true,
+        value:        null,
+      },
+    });
+  }
+
+  execute() {
+    return new Promise((resolve) => {
+      let application   = this.getApplication();
+      let environment   = application.getConfigValue('environment', 'development');
+      let appName       = application.getApplicationName();
+      let httpInterface = new HTTPInterface();
+
+      const interactiveShell = REPL.start({
+        prompt: `${appName} (${environment}) > `,
+      });
+
+      interactiveShell.on('exit', () => {
+        resolve(0);
+      });
+
+      interactiveShell.setupHistory(Path.join(OS.homedir(), `.${appName}-${environment}-history`), () => {});
+
+      interactiveShell.context.UUIDV4 = UUID.v4;
+      interactiveShell.context.connection = (typeof application.getConnection === 'function') ? application.getConnection() : null;
+      interactiveShell.context.application = application;
+      interactiveShell.context.Nife = Nife;
+      interactiveShell.context.Utils = Utils;
+
+      interactiveShell.context.HTTP = {
+        'getDefaultURL':      httpInterface.getDefaultURL.bind(httpInterface),
+        'setDefaultURL':      httpInterface.setDefaultURL.bind(httpInterface),
+        'getDefaultHeader':   httpInterface.getDefaultHeader.bind(httpInterface),
+        'getDefaultHeaders':  httpInterface.getDefaultHeaders.bind(httpInterface),
+        'setDefaultHeader':   httpInterface.setDefaultHeader.bind(httpInterface),
+        'setDefaultHeaders':  httpInterface.setDefaultHeaders.bind(httpInterface),
+        'request':            httpInterface.request.bind(httpInterface),
+        'get':                httpInterface.getRequest.bind(httpInterface),
+        'post':               httpInterface.postRequest.bind(httpInterface),
+        'put':                httpInterface.putRequest.bind(httpInterface),
+        'delete':             httpInterface.deleteRequest.bind(httpInterface),
+        'head':               httpInterface.headRequest.bind(httpInterface),
+        'options':            httpInterface.optionsRequest.bind(httpInterface),
+        'dataToQueryString':  Utils.HTTPUtils.dataToQueryString,
+      };
+
+      if (typeof application.getModels === 'function')
+        Object.assign(interactiveShell.context, application.getModels());
+
+      this.onStart(interactiveShell);
+    });
+  }
+
+  onStart() {}
+}

package/lib/cli/index.mjs

@@ -0,0 +1,3 @@
+export * from './command-base.mjs';
+export * as Commands from './commands/index.mjs';
+export * from './cli-utils.mjs';

package/{src → lib}/controllers/controller-base.d.ts

@@ -3,7 +3,7 @@ import { Logger } from '../logger';
 import { Request, Response } from 'express';
 import { GenericObject } from '../interfaces/common';
 import { ConnectionBase, ModelClass, Models } from 'mythix-orm';
-import { HTTPBaseError } from '../http-server/http-errors';
+import { HTTPBaseError } from '../http/http-errors';
 
 export declare type ControllerClass = typeof ControllerBase;
 

package/{src/controllers/controller-base.js → lib/controllers/controller-base.mjs}

@@ -1,9 +1,7 @@
-'use strict';
+import Nife             from 'nife';
+import * as HTTPErrors  from '../http/http-errors.mjs';
 
-const Nife        = require('nife');
-const HTTPErrors  = require('../http-server/http-errors');
-
-class ControllerBase {
+export class ControllerBase {
   constructor(application, logger, request, response) {
     Object.defineProperties(this, {
       'application': {
@@ -220,7 +218,3 @@ class ControllerBase {
     }
   }
 }
-
-module.exports = {
-  ControllerBase,
-};

package/{src → lib}/controllers/controller-module.d.ts

@@ -1,9 +1,9 @@
-import { HTTPServer } from '../http-server';
+import { HTTPServer } from '../http';
 import { GenericObject } from '../interfaces/common';
-import { BaseModule } from '../modules/base-module';
+import { ModuleBase } from '../modules/module-base';
 import { ControllerClass, ControllerClasses } from './controller-base';
 
-export class ControllerModule extends BaseModule {
+export class ControllerModule extends ModuleBase {
   public getControllerFilePaths(controllersPath: string): Array<string>;
   public loadControllers(controllersPath: string): ControllerClasses;
   public getController(name: string): { controller: ControllerClass, controllerMethod: string | undefined };