mythix 3.0.0 → 4.0.2

package/lib/index.d.ts

@@ -0,0 +1,30 @@
+export * from './application.mjs';
+export * from './logger.mjs';
+
+export * as Utils from './utils/index.mjs';
+export {
+  CryptoUtils,
+  FileUtils,
+  HTTPUtils,
+  MimeUtils,
+  TestUtils,
+} from './utils/index.mjs';
+
+export * as Modules from './modules/index.mjs';
+export { ModuleBase } from './modules/index.mjs';
+
+export * as Tasks from './tasks/index.mjs';
+export { TaskBase } from './tasks/index.mjs';
+
+export * as Models from './models/index.mjs';
+export { Model } from './models/index.mjs';
+
+export * as HTTP from './http/index.mjs';
+
+export * as Controllers from './controllers/index.mjs';
+export { ControllerBase } from './controllers/index.mjs';
+
+export * as CLI from './cli/index.mjs';
+export { CommandBase, Commands } from './cli/index.mjs';
+
+export { Types, Utils as MythixORMUtils } from 'mythix-orm';

package/lib/index.mjs

@@ -0,0 +1,31 @@
+export * from './application.mjs';
+export * from './logger.mjs';
+
+export * as Utils from './utils/index.mjs';
+export {
+  CryptoUtils,
+  FileUtils,
+  HTTPUtils,
+  MimeUtils,
+  TestUtils,
+} from './utils/index.mjs';
+
+export * as Modules from './modules/index.mjs';
+export { ModuleBase } from './modules/index.mjs';
+
+export * as Tasks from './tasks/index.mjs';
+export { TaskBase } from './tasks/index.mjs';
+
+export * as Models from './models/index.mjs';
+export { Model } from './models/index.mjs';
+
+export * as HTTP from './http/index.mjs';
+export { HTTPErrors } from './http/index.mjs';
+
+export * as Controllers from './controllers/index.mjs';
+export { ControllerBase } from './controllers/index.mjs';
+
+export * as CLI from './cli/index.mjs';
+export { CommandBase, Commands } from './cli/index.mjs';
+
+export { Types, Utils as MythixORMUtils } from 'mythix-orm';

package/lib/logger-spec.mjs

@@ -0,0 +1,121 @@
+/* eslint-disable no-magic-numbers */
+/* global jasmine */
+
+import { Logger } from './logger.mjs';
+
+describe('Logger', () => {
+  let fakeConsole;
+  let consoleOutput;
+  let logger;
+
+  beforeAll(() => {
+    jasmine.clock().install();
+    jasmine.clock().mockDate(new Date(2000, 0, 1, 12, 0, 0, 0));
+  });
+
+  beforeEach(() => {
+    const createConsoleMethod = (name) => {
+      return function(...args) {
+        if (!consoleOutput[name])
+          consoleOutput[name] = [];
+
+        consoleOutput[name].push(args);
+      };
+    };
+
+    consoleOutput = {};
+
+    fakeConsole = {
+      debug:  createConsoleMethod('debug'),
+      error:  createConsoleMethod('error'),
+      info:   createConsoleMethod('info'),
+      log:    createConsoleMethod('log'),
+      warn:   createConsoleMethod('warn'),
+    };
+
+    logger = new Logger({ writer: fakeConsole, pid: 777 });
+  });
+
+  it('works', () => {
+    logger.error('Testing 123', true, 3.14, 'Hello World!', { test: 'stuff' }, [ 'wow', 1, 2, 3 ]);
+    expect(consoleOutput.error[0]).toEqual([ 'E, [2000-01-01T19:00:00.000Z #777] -- : Testing 123 true 3.14 Hello World! {"test":"stuff"} ["wow",1,2,3]' ]);
+
+    logger.log('Testing 123', true, 3.14, 'Hello World!', { test: 'stuff' }, [ 'wow', 1, 2, 3 ]);
+    expect(consoleOutput.log[0]).toEqual([ 'L, [2000-01-01T19:00:00.000Z #777] -- : Testing 123 true 3.14 Hello World! {"test":"stuff"} ["wow",1,2,3]' ]);
+
+    logger.warn('Testing 123', true, 3.14, 'Hello World!', { test: 'stuff' }, [ 'wow', 1, 2, 3 ]);
+    expect(consoleOutput.warn[0]).toEqual([ 'W, [2000-01-01T19:00:00.000Z #777] -- : Testing 123 true 3.14 Hello World! {"test":"stuff"} ["wow",1,2,3]' ]);
+
+    logger.info('Testing 123', true, 3.14, 'Hello World!', { test: 'stuff' }, [ 'wow', 1, 2, 3 ]);
+    expect(consoleOutput.info[0]).toEqual([ 'I, [2000-01-01T19:00:00.000Z #777] -- : Testing 123 true 3.14 Hello World! {"test":"stuff"} ["wow",1,2,3]' ]);
+
+    logger.debug('Testing 123', true, 3.14, 'Hello World!', { test: 'stuff' }, [ 'wow', 1, 2, 3 ]);
+    expect(consoleOutput.debug[0]).toEqual([ 'D, [2000-01-01T19:00:00.000Z #777] -- : Testing 123 true 3.14 Hello World! {"test":"stuff"} ["wow",1,2,3]' ]);
+  });
+
+  it('can set a log level', () => {
+    const writeAll = () => {
+      consoleOutput = {};
+
+      logger.error('test');
+      logger.log('test');
+      logger.warn('test');
+      logger.info('test');
+      logger.debug('test');
+    };
+
+    // Level 0 (no messages)
+    logger.setLevel(0);
+    writeAll();
+    expect(consoleOutput.error).toBe(undefined);
+    expect(consoleOutput.log).toBe(undefined);
+    expect(consoleOutput.warn).toBe(undefined);
+    expect(consoleOutput.info).toBe(undefined);
+    expect(consoleOutput.debug).toBe(undefined);
+
+    // Level 1 (only errors)
+    logger.setLevel(Logger.LEVEL_ERROR);
+    writeAll();
+    expect(consoleOutput.error).toEqual([ [ 'E, [2000-01-01T19:00:00.000Z #777] -- : test' ] ]);
+    expect(consoleOutput.log).toBe(undefined);
+    expect(consoleOutput.warn).toBe(undefined);
+    expect(consoleOutput.info).toBe(undefined);
+    expect(consoleOutput.debug).toBe(undefined);
+
+    // Level 2 (error, and log)
+    logger.setLevel(Logger.LEVEL_LOG);
+    writeAll();
+    expect(consoleOutput.error).toEqual([ [ 'E, [2000-01-01T19:00:00.000Z #777] -- : test' ] ]);
+    expect(consoleOutput.log).toEqual([ [ 'L, [2000-01-01T19:00:00.000Z #777] -- : test' ] ]);
+    expect(consoleOutput.warn).toBe(undefined);
+    expect(consoleOutput.info).toBe(undefined);
+    expect(consoleOutput.debug).toBe(undefined);
+
+    // Level 3 (error, log, and warn)
+    logger.setLevel(Logger.LEVEL_WARN);
+    writeAll();
+    expect(consoleOutput.error).toEqual([ [ 'E, [2000-01-01T19:00:00.000Z #777] -- : test' ] ]);
+    expect(consoleOutput.log).toEqual([ [ 'L, [2000-01-01T19:00:00.000Z #777] -- : test' ] ]);
+    expect(consoleOutput.warn).toEqual([ [ 'W, [2000-01-01T19:00:00.000Z #777] -- : test' ] ]);
+    expect(consoleOutput.info).toBe(undefined);
+    expect(consoleOutput.debug).toBe(undefined);
+
+    // Level 3 (error, log, warn, and info)
+    logger.setLevel(Logger.LEVEL_INFO);
+    writeAll();
+    expect(consoleOutput.error).toEqual([ [ 'E, [2000-01-01T19:00:00.000Z #777] -- : test' ] ]);
+    expect(consoleOutput.log).toEqual([ [ 'L, [2000-01-01T19:00:00.000Z #777] -- : test' ] ]);
+    expect(consoleOutput.warn).toEqual([ [ 'W, [2000-01-01T19:00:00.000Z #777] -- : test' ] ]);
+    expect(consoleOutput.info).toEqual([ [ 'I, [2000-01-01T19:00:00.000Z #777] -- : test' ] ]);
+    expect(consoleOutput.debug).toBe(undefined);
+
+    // Level 4 (error, log, warn, info, and debug)
+    logger.setLevel(Logger.LEVEL_DEBUG);
+    writeAll();
+    expect(consoleOutput.error).toEqual([ [ 'E, [2000-01-01T19:00:00.000Z #777] -- : test' ] ]);
+    expect(consoleOutput.log).toEqual([ [ 'L, [2000-01-01T19:00:00.000Z #777] -- : test' ] ]);
+    expect(consoleOutput.warn).toEqual([ [ 'W, [2000-01-01T19:00:00.000Z #777] -- : test' ] ]);
+    expect(consoleOutput.info).toEqual([ [ 'I, [2000-01-01T19:00:00.000Z #777] -- : test' ] ]);
+    expect(consoleOutput.debug).toEqual([ [ 'D, [2000-01-01T19:00:00.000Z #777] -- : test' ] ]);
+  });
+});

package/{src → lib}/logger.d.ts

@@ -6,14 +6,13 @@ export declare interface LoggerWriter {
   log: (...args: Array<any>) => void;
 }
 
-export declare type ErrorStackFormatterMethod = (rootPath: string, error: Error) => void;
+export declare type ErrorStackFormatterMethod = (error: Error) => void;
 
 export declare type LoggerClass = typeof Logger;
 
 export declare interface LoggerOptions {
   level?: number;
   writer?: string | LoggerWriter | null;
-  rootPath?: string;
   errorStackFormatter?: ErrorStackFormatterMethod;
 }
 
@@ -29,7 +28,6 @@ export declare class Logger {
   declare protected _customWriter: string;
   declare protected _pid: string;
   declare protected _formatter: string;
-  declare protected _rootPath: string;
   declare protected _errorStackFormatter: string;
 
   constructor(options?: LoggerOptions);

package/{src/logger.js → lib/logger.mjs}

@@ -1,9 +1,6 @@
 /* eslint-disable lines-between-class-members */
-'use strict';
 
-/* global process */
-
-const FileSystem = require('fs');
+import FileSystem from 'node:fs';
 
 const LEVEL_ERROR   = 1;
 const LEVEL_LOG     = 2;
@@ -11,7 +8,7 @@ const LEVEL_WARN    = 3;
 const LEVEL_INFO    = 4;
 const LEVEL_DEBUG   = 5;
 
-function errorStackToString(rootPath, error) {
+function errorStackToString(error) {
   return ('\n -> ' + error.stack.split(/\n+/).slice(1).map((part) => `${part.replace(/^\s+at\s+/, '')}\n`).join(' -> ')).trimEnd();
 }
 
@@ -34,8 +31,8 @@ function logToWriter(type, ..._args) {
 
     if (arg instanceof Error) {
       let formattedStack = (typeof this._errorStackFormatter === 'function')
-        ? this._errorStackFormatter.call(this, this._rootPath, arg)
-        : errorStackToString.call(this, this._rootPath, arg);
+        ? this._errorStackFormatter.call(this, arg)
+        : errorStackToString.call(this, arg);
 
       arg = `${arg.name}: ${arg.message}: ${formattedStack}`;
     } else if (arg && typeof arg.valueOf() === 'function') {
@@ -68,10 +65,10 @@ function logToWriter(type, ..._args) {
   let content   = args.join(' ');
   let output    = `${type.charAt(0).toUpperCase()}, [${(new Date()).toISOString()} #${this._pid}] -- : ${(typeof formatter === 'function') ? formatter(content) : content}`;
 
-  writeToWriterObject.call(this, (!writer) ? console : writer, type, output);
+  writeToWriterObject.call(this, writer, type, output);
 }
 
-class Logger {
+export class Logger {
   static LEVEL_ERROR  = LEVEL_ERROR;
   static LEVEL_LOG    = LEVEL_LOG;
   static LEVEL_WARN   = LEVEL_WARN;
@@ -80,13 +77,11 @@ class Logger {
 
   constructor(_opts) {
     let opts = Object.assign({
-      level:                LEVEL_INFO,
+      level:                LEVEL_DEBUG,
       writer:               null,
-      rootPath:             process.cwd(),
       errorStackFormatter:  null,
-    }, _opts || {}, {
-      pid:      process.pid,
-    });
+      pid:                  process.pid,
+    }, _opts || {});
 
     // If string, assume file path
     let customWriter = false;
@@ -111,7 +106,7 @@ class Logger {
         writable:     false,
         enumerable:   false,
         configurable: false,
-        value:        opts.writer,
+        value:        opts.writer || console,
       },
       '_customWriter': {
         writable:     false,
@@ -131,12 +126,6 @@ class Logger {
         configurable: false,
         value:        opts.formatter,
       },
-      '_rootPath': {
-        writable:     false,
-        enumerable:   false,
-        configurable: false,
-        value:        opts.rootPath,
-      },
       '_errorStackFormatter': {
         writable:     false,
         enumerable:   false,
@@ -160,7 +149,6 @@ class Logger {
       writer:               this._writer,
       pid:                  this._pid,
       formatter:            this._formatter,
-      rootPath:             this._rootPath,
       errorStackFormatter:  this._errorStackFormatter,
     }, extraOpts || {}));
   }
@@ -225,5 +213,3 @@ class Logger {
     });
   }
 }
-
-module.exports = { Logger };

package/lib/models/index.d.ts

@@ -0,0 +1,2 @@
+export * from './model';
+export * from './migration-model';

package/lib/models/index.mjs

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

package/{src/models/migration-model.js → lib/models/migration-model.mjs}

@@ -1,12 +1,9 @@
-'use strict';
-
-const { Types }         = require('mythix-orm');
-const { registerModel } = require('./model-utils');
-const { Model }         = require('./model');
+import { Types } from 'mythix-orm';
+import { Model } from './model.mjs';
 
 const ID_STRING_MAX_SIZE = 15;
 
-class Migration extends Model {
+export class Migration extends Model {
   static fields = {
     id: {
       type:         Types.STRING(ID_STRING_MAX_SIZE),
@@ -28,8 +25,3 @@ class Migration extends Model {
     },
   };
 }
-
-const modelRegisterFactory = registerModel(Migration);
-modelRegisterFactory.MigrationModel = Migration;
-
-module.exports = modelRegisterFactory;

package/lib/models/model.d.ts

@@ -0,0 +1,10 @@
+import { Application } from '../application';
+import { Logger } from '../logger';
+import { ConnectionBase, Model as _Model } from 'mythix-orm';
+
+export declare class Model extends _Model {
+  declare public static _getConnection: (connection?: ConnectionBase) => ConnectionBase;
+
+  public getApplication(): Application;
+  public getLogger(): Logger;
+}

package/lib/models/model.mjs

@@ -0,0 +1,28 @@
+import MythixORM from 'mythix-orm';
+
+export class Model extends MythixORM.Model {
+  getApplication() {
+    return this.constructor.getApplication();
+  }
+
+  getLogger() {
+    let application = this.getApplication();
+    return application.getLogger();
+  }
+
+  static _getConnection(_connection) {
+    let connection = super._getConnection(_connection);
+    if (connection)
+      return connection;
+
+    return this.getApplication().getConnection();
+  }
+
+  static getModels() {
+    let connection = this._getConnection();
+    if (!connection)
+      return {};
+
+    return connection.getModels();
+  }
+}

package/{src → lib}/modules/database-module.d.ts

@@ -1,8 +1,8 @@
 import { ConnectionBase } from 'mythix-orm';
 import { GenericObject } from '../interfaces/common';
-import { BaseModule } from './base-module';
+import { ModuleBase } from './module-base';
 
-export declare class DatabaseModule extends BaseModule {
+export declare class DatabaseModule extends ModuleBase {
   public getDatabaseConfig(): GenericObject;
   public getConfig(): GenericObject;
   public getTablePrefix(): string | null;

package/{src/modules/database-module.js → lib/modules/database-module.mjs}

@@ -1,12 +1,10 @@
-'use strict';
+import Nife                 from 'nife';
+import { ConnectionBase }   from 'mythix-orm';
+import { ModuleBase }       from './module-base.mjs';
 
-const Nife                = require('nife');
-const { BaseModule }      = require('../modules/base-module');
-const { ConnectionBase }  = require('mythix-orm');
-
-class DatabaseModule extends BaseModule {
-  static getModuleName() {
-    return 'DatabaseModule';
+export class DatabaseModule extends ModuleBase {
+  static getOptionsScopeName() {
+    return 'database';
   }
 
   static shouldUse(application, options) {
@@ -107,6 +105,17 @@ class DatabaseModule extends BaseModule {
       dbConnectionString = `${databaseConfig.dialect}://${databaseConfig.host}:${databaseConfig.port || '<default port>'}/${databaseConfig.database}`;
 
     try {
+      const registerModelsAndStartConnection = (connection) => {
+        let models = app.getAppModelClasses(connection);
+        if (models)
+          connection.registerModels(models, { bindModels: false });
+
+        if (connection.isStarted())
+          return;
+
+        return connection.start();
+      };
+
       let app = this.getApplication();
       if (typeof app.createDatabaseConnection !== 'function')
         throw new Error('DatabaseModule::connectToDatabase: You must define a "createDatabaseConnection" method on your Application class.');
@@ -118,12 +127,10 @@ class DatabaseModule extends BaseModule {
       if (!(connection instanceof ConnectionBase) && typeof connection === 'function' && connection.prototype instanceof ConnectionBase) {
         const ConnectionKlass = connection;
         connection = new ConnectionKlass(databaseConfig);
-
-        await connection.start();
-      } else if (!connection.isStarted()) {
-        await connection.start();
       }
 
+      await registerModelsAndStartConnection(connection);
+
       this.getLogger().info(`Connection to ${dbConnectionString} has been established successfully!`);
 
       return connection;
@@ -155,5 +162,3 @@ class DatabaseModule extends BaseModule {
     this.getLogger().info('All database connections closed successfully!');
   }
 }
-
-module.exports = { DatabaseModule };

package/lib/modules/index.d.ts

@@ -0,0 +1,2 @@
+export * from './module-base';
+export * from './database-module';

package/lib/modules/index.mjs

@@ -0,0 +1,2 @@
+export * from './module-base.mjs';
+export * from './database-module.mjs';

package/{src/modules/base-module.d.ts → lib/modules/module-base.d.ts}

@@ -2,20 +2,13 @@ import { GenericObject } from '../interfaces/common';
 import { Application } from '../application';
 import { Logger } from '../logger';
 
-export declare type BaseModuleClass = typeof BaseModule;
-
-export declare type ModuleClasses = Array<BaseModuleClass>;
-export declare type Modules = Array<BaseModule>;
-
-export declare class BaseModule {
-  public declare static fileWatcherQueueName: string;
+export declare type Modules = Array<ModuleBase>;
 
+export declare class ModuleBase {
   public static getModuleName(): string;
+  public static getOptionsScopeName(): string;
   public static shouldUse(application: Application, options: GenericObject): boolean;
 
-  public fileWatcherGetMonitorPaths(options?: GenericObject): Array<string>;
-  public fileWatcherHandler(options?: GenericObject): Promise<void>;
-
   public constructor(application: Application);
   public getApplication(): Application;
   public getLogger(): Logger;

package/{src/modules/base-module.js → lib/modules/module-base.mjs}

@@ -1,8 +1,10 @@
-'use strict';
-
-class BaseModule {
+export class ModuleBase {
   static getModuleName() {
-    throw new Error('BaseModule::getModuleName: Should not have been called. Child module must implement "static getModuleName(){}"');
+    return this.name;
+  }
+
+  static getOptionsScopeName() {
+    return this.getModuleName().toLowerCase().replace(/module$/i, '');
   }
 
   static shouldUse() {
@@ -17,9 +19,19 @@ class BaseModule {
         configurable: true,
         value:        application,
       },
+      'options': {
+        enumerable:   false,
+        configurable: true,
+        get:          () => (application.getOptions() || {})[this.constructor.getOptionsScopeName()] || {},
+        set:          () => {},
+      },
     });
   }
 
+  getOptions() {
+    return this.options;
+  }
+
   getApplication() {
     return this.application;
   }
@@ -39,5 +51,3 @@ class BaseModule {
   async stop() {
   }
 }
-
-module.exports = { BaseModule };

package/lib/tasks/index.d.ts

@@ -0,0 +1,2 @@
+export * from './task-base';
+export * from './task-module';

package/lib/tasks/index.mjs

@@ -0,0 +1,2 @@
+export * from './task-base.mjs';
+export * from './task-module.mjs';

package/{src → lib}/tasks/task-base.d.ts

@@ -2,6 +2,7 @@ import { GenericObject } from '../interfaces/common';
 import { Application } from '../application';
 import { Logger } from '../logger';
 import { ConnectionBase, ModelClass, Models } from 'mythix-orm';
+import { DateTime } from 'luxon';
 
 export declare type Tasks = { [key: string]: TaskBase };
 
@@ -18,30 +19,19 @@ export declare interface TaskInfo {
 }
 
 export declare class TaskBase {
-  public static onTaskClassCreate(Klass: TaskClass): TaskClass;
-
-  public static getFrequency(taskIndex?: number): number;
-  public static getStartDelay(taskIndex?: number): number;
-  public static shouldRun(taskIndex: number, lastTime: number | null, currentTime: number, diff: number): boolean;
+  public static getWorkerCount(): number;
+  public static getTaskName(): string;
+  public static nextRun(taskInstance: TaskBase, lastTime: null | number, currentTime: number, diff: null | number): DateTime;
 
   declare public application: Application;
   declare public logger: Logger;
-  declare public runID: string;
 
   public constructor(application: Application, logger: Logger, runID: string);
   public start(options?: GenericObject): Promise<any>;
   public stop(): Promise<any>;
   public getApplication(): Application;
   public getLogger(): Logger;
-  public getRunID(): string;
-  public getNumberOfWorkers(): number;
   public getModel(name: string): ModelClass;
   public getModels(): Models;
   public getConnection(connection?: ConnectionBase): ConnectionBase;
-
-  // Deprecated
-  public getDBConnection(connection?: ConnectionBase): ConnectionBase;
-
-  public getFrequency(taskIndex?: number): number;
-  public getStartDelay(taskIndex?: number): number;
 }

package/lib/tasks/task-base.mjs

@@ -0,0 +1,73 @@
+import { DateTime }  from 'luxon';
+
+export class TaskBase {
+  static getWorkerCount() {
+    return 1;
+  }
+
+  static getTaskName() {
+    return this.name.toLowerCase().replace(/task$/i, '');
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  static nextRun(taskInstance, lastTime, currentTime, diff) {
+    return DateTime.now().plus({ seconds: 60 });
+  }
+
+  constructor(application, logger, workerIndex) {
+    Object.defineProperties(this, {
+      'application': {
+        writable:     false,
+        enumerable:   false,
+        configurable: true,
+        value:        application,
+      },
+      'logger': {
+        writable:     false,
+        enumerable:   false,
+        configurable: true,
+        value:        logger,
+      },
+      'workerIndex': {
+        writable:     false,
+        enumerable:   false,
+        configurable: true,
+        value:        workerIndex || 0,
+      },
+    });
+  }
+
+  async start() {
+  }
+
+  async stop() {
+
+  }
+
+  getApplication() {
+    return this.application;
+  }
+
+  getLogger() {
+    if (this.logger)
+      return this.logger;
+
+    let application = this.getApplication();
+    return application.getLogger();
+  }
+
+  getModel(name) {
+    let application = this.getApplication();
+    return application.getModel(name);
+  }
+
+  getModels() {
+    let application = this.getApplication();
+    return application.getModels();
+  }
+
+  getConnection(connection) {
+    let application = this.getApplication();
+    return application.getConnection(connection);
+  }
+}

package/{src → lib}/tasks/task-module.d.ts

@@ -1,7 +1,7 @@
-import { BaseModule } from '../modules/base-module';
+import { ModuleBase } from '../modules/module-base';
 import { Tasks, TaskInfo } from './task-base';
 
-export declare class TaskModule extends BaseModule {
+export declare class TaskModule extends ModuleBase {
   public getTaskFilePaths(tasksPath: string): Array<string>;
   public loadTasks(tasksPath: string): Tasks;
   public runTasks(): Promise<void>;
@@ -13,5 +13,5 @@ export declare class TaskModule extends BaseModule {
   public waitForAllTasksToFinish(): Promise<void>;
 
   declare public tasks: Tasks;
-  declare public taskInfo: { [ key: string ]: TaskInfo };
+  declare public taskInfo: { [key: string]: TaskInfo };
 }