mythix 2.4.14 → 2.5.2

package/src/index.js

@@ -6,7 +6,7 @@ const HTTPServerScope   = require('./http-server');
 const ControllerScope   = require('./controllers');
 const CLIUtilsScope     = require('./cli');
 const TasksScope        = require('./tasks');
-const { Logger }        = require('./logger');
+const Logger            = require('./logger');
 const Utils             = require('./utils');
 const Modules           = require('./modules');
 
@@ -14,8 +14,8 @@ module.exports = {
   defineCommand:          CLIUtilsScope.defineCommand,
   defineController:       ControllerScope.defineController,
   defineModel:            ModelScope.defineModel,
+  registerModel:          ModelScope.registerModel,
   defineTask:             TasksScope.defineTask,
-  createTestApplication:  Utils.TestUtils.createTestApplication,
 
   CLI:                    CLIUtilsScope,
   ControllerBase:         ControllerScope.ControllerBase,
@@ -25,18 +25,19 @@ module.exports = {
   HTTPErrors:             HTTPServerScope.HTTPErrors,
   HTTPServer:             HTTPServerScope.HTTPServer,
   HTTPUtils:              Utils.HTTPUtils,
-  Middleware:             HTTPServerScope.Middleware,
   TaskBase:               TasksScope.TaskBase,
   Tasks:                  TasksScope,
   TestUtils:              Utils.TestUtils,
   MimeUtils:              Utils.MimeUtils,
   Model:                  ModelScope.Model,
   Modules:                {
-    ...Modules,
-    HTTPServerModule: HTTPServerScope.HTTPServerModule,
-    ModelModule:      ModelScope.ModelModule,
-    TaskModule:       TasksScope.TaskModule,
-    ControllerModule: ControllerScope.ControllerModule,
+    BaseModule:         Modules.BaseModule,
+    DatabaseModule:     Modules.DatabaseModule,
+    FileWatcherModule:  Modules.FileWatcherModule,
+    HTTPServerModule:   HTTPServerScope.HTTPServerModule,
+    ModelModule:        ModelScope.ModelModule,
+    TaskModule:         TasksScope.TaskModule,
+    ControllerModule:   ControllerScope.ControllerModule,
   },
 
   Application,

package/src/interfaces/common.ts

@@ -0,0 +1,3 @@
+export interface GenericObject {
+  [key: string]: any;
+};

package/src/logger.d.ts

@@ -0,0 +1,53 @@
+export declare interface LoggerWriter {
+  error: (...args: Array<any>) => void;
+  warn: (...args: Array<any>) => void;
+  info: (...args: Array<any>) => void;
+  debug: (...args: Array<any>) => void;
+  log: (...args: Array<any>) => void;
+}
+
+export declare type ErrorStackFormatterMethod = (rootPath: string, error: Error) => void;
+
+export declare type LoggerClass = typeof Logger;
+
+export declare interface LoggerOptions {
+  level?: number;
+  writer?: string | LoggerWriter | null;
+  rootPath?: string;
+  errorStackFormatter?: ErrorStackFormatterMethod;
+}
+
+export declare class Logger {
+  public static LEVEL_ERROR: number;
+  public static LEVEL_LOG: number;
+  public static LEVEL_WARN: number;
+  public static LEVEL_INFO: number;
+  public static LEVEL_DEBUG: number;
+
+  declare protected _level: number;
+  declare protected _writer: string;
+  declare protected _customWriter: string;
+  declare protected _pid: string;
+  declare protected _formatter: string;
+  declare protected _rootPath: string;
+  declare protected _errorStackFormatter: string;
+
+  constructor(options?: LoggerOptions);
+
+  public getLevel(): number;
+  public setLevel(level: number): void;
+  public clone(extraOpts?: LoggerOptions): Logger;
+  public isErrorLevel(): boolean;
+  public isLogLevel(): boolean;
+  public isWarningLevel(): boolean;
+  public isInfoLevel(): boolean;
+  public isDebugLevel(): boolean;
+
+  public error(...args: Array<any>): void;
+  public warn(...args: Array<any>): void;
+  public info(...args: Array<any>): void;
+  public debug(...args: Array<any>): void;
+  public log(...args: Array<any>): void;
+
+  public stop(): Promise<any>;
+}

package/src/logger.js

@@ -226,6 +226,4 @@ class Logger {
   }
 }
 
-module.exports = {
-  Logger,
-};
+module.exports = { Logger };

package/src/models/index.d.ts

@@ -0,0 +1,4 @@
+export * from './model';
+export * as ModelUtils from './model-utils';
+export { defineModel, registerModel } from './model-utils';
+export * from './migration-model';

package/src/models/index.js

@@ -2,13 +2,16 @@
 
 const { Model }       = require('./model');
 const { ModelModule } = require('./model-module');
-
+const { MigrationModel } = require('./migration-model');
 const {
   defineModel,
+  registerModel,
 } = require('./model-utils');
 
 module.exports = {
   defineModel,
+  registerModel,
   Model,
   ModelModule,
+  MigrationModel,
 };

package/src/models/migration-model.d.ts

@@ -0,0 +1,8 @@
+import { Moment } from 'moment';
+import { Model } from './model';
+
+export declare class MigrationModel extends Model {
+  declare public id: string;
+  declare public createdAt: Moment | string;
+  declare public updatedAt: Moment | string;
+}

package/src/models/migration-model.js

@@ -1,18 +1,35 @@
 'use strict';
 
-const { defineModel } = require('./model-utils');
+const { Types }         = require('mythix-orm');
+const { registerModel } = require('./model-utils');
+const { Model }         = require('./model');
 
 const ID_STRING_MAX_SIZE = 15;
 
-module.exports = defineModel('Migration', ({ Parent, Types }) => {
-  return class Migration extends Parent {
-    static fields = {
-      id: {
-        type:         Types.STRING(ID_STRING_MAX_SIZE),
-        allowNull:    false,
-        primaryKey:   true,
-        index:        true,
-      },
-    };
+class Migration extends Model {
+  static fields = {
+    id: {
+      type:         Types.STRING(ID_STRING_MAX_SIZE),
+      allowNull:    false,
+      primaryKey:   true,
+      index:        true,
+    },
+    createdAt: {
+      type:         Types.DATETIME,
+      defaultValue: Types.DATETIME.Default.NOW,
+      allowNull:    false,
+      index:        true,
+    },
+    updatedAt: {
+      type:         Types.DATETIME,
+      defaultValue: Types.DATETIME.Default.NOW.UPDATE,
+      allowNull:    false,
+      index:        true,
+    },
   };
-});
+}
+
+const modelRegisterFactory = registerModel(Migration);
+modelRegisterFactory.MigrationModel = Migration;
+
+module.exports = modelRegisterFactory;

package/src/models/model-module.d.ts

@@ -0,0 +1,9 @@
+import { ModelClass, Models } from 'mythix-orm';
+import { BaseModule } from '../modules/base-module';
+
+export declare class ModelModule extends BaseModule {
+  getModelFilePaths(modelsPath: string): Array<string>;
+  loadModels(modelsPath: string): Models;
+  getModel(modelName?: string): ModelClass | undefined;
+  getModels(): Models;
+}

package/src/models/model-module.js

@@ -86,7 +86,7 @@ class ModelModule extends BaseModule {
 
       try {
         let modelGenerator = require(modelFile);
-        if (modelGenerator['default'] && typeof modelGenerator['default'] === 'function')
+        if (modelGenerator.__esModule)
           modelGenerator = modelGenerator['default'];
 
         Object.assign(models, modelGenerator(args));
@@ -127,6 +127,4 @@ class ModelModule extends BaseModule {
   }
 }
 
-module.exports = {
-  ModelModule,
-};
+module.exports = { ModelModule };

package/src/models/model-utils.d.ts

@@ -0,0 +1,20 @@
+import { ConnectionBase, Types } from 'mythix-orm';
+import { Application } from '../application';
+
+export declare interface DefineModelContext<T> {
+  Parent: T;
+  Types: typeof Types;
+  connection: ConnectionBase;
+  modelName: string;
+  application: Application;
+}
+
+export declare function registerModel<T>(
+  Model: T,
+): (context: { application: Application, connection: ConnectionBase }) => T;
+
+export declare function defineModel<T>(
+  modelName: string,
+  definer: (context: DefineModelContext<T>) => T,
+  parent?: T,
+): (context: { application: Application, connection: ConnectionBase }) => T;

package/src/models/model-utils.js

@@ -1,8 +1,35 @@
 'use strict';
 
-const Nife                  = require('nife');
-const { Types }             = require('mythix-orm');
-const { Model: ModelBase }  = require('./model');
+const { Types } = require('mythix-orm');
+const { Model: ModelBase } = require('./model');
+
+function _setupModel(modelName, _Model, { application, connection }) {
+  let Model       = _Model;
+  let tableName   = Model.getTableName();
+  let tablePrefix = application.getDBTablePrefix();
+
+  if (tablePrefix)
+    tableName = (`${tablePrefix}${tableName}`);
+
+  Model.getTableName  = () => tableName;
+  Model.getModelName  = () => modelName;
+  Model.getApplication = () => application;
+  Model.getLogger = () => application.getLogger();
+  Model._getConnection = (_connection) => {
+    if (_connection)
+      return _connection;
+
+    return connection;
+  };
+
+  return { [modelName]: Model };
+}
+
+function registerModel(Model) {
+  return function({ application, connection }) {
+    return _setupModel(Model.getModelName(), Model, { application, connection });
+  };
+}
 
 function defineModel(modelName, definer, _parent) {
   return function({ application, connection }) {
@@ -19,30 +46,8 @@ function defineModel(modelName, definer, _parent) {
     if (typeof Model.onModelClassCreate === 'function')
       Model = Model.onModelClassCreate(Model, definerArgs);
 
-    let tableName   = Model.getTableName();
-    let tablePrefix = application.getDBTablePrefix();
-
-    if (tablePrefix)
-      tableName = (`${tablePrefix}${tableName}`);
-
-    Model.getTableName  = () => tableName;
-    Model.getModelName  = () => modelName;
-    Model.getApplication = () => application;
-    Model.getLogger = () => application.getLogger();
-    Model._getConnection = (_connection) => {
-      if (_connection)
-        return _connection;
-
-      return connection;
-    };
-
-    if (typeof Model.onModelClassFinalized === 'function')
-      Model = Model.onModelClassFinalized(Model, definerArgs);
-
-    return { [modelName]: Model };
+    return _setupModel(modelName, Model, { application, connection });
   };
 }
 
-module.exports = {
-  defineModel,
-};
+module.exports = { defineModel, registerModel };

package/src/models/model.d.ts

@@ -0,0 +1,17 @@
+import { Application } from '../application';
+import { Logger } from '../logger';
+import { ConnectionBase, Model as _Model, ModelClass } from 'mythix-orm';
+import { DefineModelContext } from './model-utils';
+
+export declare class Model extends _Model {
+  declare public static getTableName: () => string;
+  declare public static getModelName: () => string;
+  declare public static getApplication: () => Application;
+  declare public static getLogger: () => Logger;
+  declare public static _getConnection: (connection?: ConnectionBase) => ConnectionBase;
+  declare public static onModelClassFinalized?: (Model: ModelClass, definerArgs: DefineModelContext<Model>) => ModelClass;
+
+  public getApplication(): Application;
+  public getLogger(): Logger;
+  public getDBConnection(connection): ConnectionBase;
+}

package/src/models/model.js

@@ -21,6 +21,10 @@ class Model extends _Model {
     return this.constructor.getModel(modelName);
   }
 
+  getModels() {
+    return this.constructor.getModels();
+  }
+
   getApplication() {
     return this.constructor.getApplication();
   }
@@ -50,39 +54,6 @@ class Model extends _Model {
 
     return this.getDBConnection();
   }
-
-  overrideMethod(name, newMethod) {
-    let originalMethod = this[name];
-    if (typeof originalMethod !== 'function')
-      throw new TypeError(`Model: Error while attempting to override method "${name}: No such method found"`);
-
-    let boundMethod = newMethod.bind(this, originalMethod.bind(this));
-    boundMethod.unbound = newMethod;
-    boundMethod.super = originalMethod;
-
-    Object.defineProperties(this, {
-      [name]: {
-        writable:     true,
-        enumerable:   false,
-        configurable: true,
-        value:        boundMethod,
-      },
-    });
-
-    return originalMethod;
-  }
-
-  overrideMethods(methodsObj) {
-    let keys = Object.keys(methodsObj);
-    for (let i = 0, il = keys.length; i < il; i++) {
-      let name    = keys[i];
-      let method  = methodsObj[name];
-
-      this.overrideMethod(name, method);
-    }
-  }
 }
 
-module.exports = {
-  Model,
-};
+module.exports = { Model };

package/src/modules/base-module.d.ts

@@ -0,0 +1,27 @@
+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;
+
+  public static getModuleName(): string;
+  public static shouldUse(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;
+  public getConfigValue(...args: Array<any>): any;
+  public start(options?: GenericObject): Promise<any>;
+  public stop(): Promise<any>;
+
+  declare public application: Application;
+}

package/src/modules/base-module.js

@@ -5,6 +5,10 @@ class BaseModule {
     throw new Error('BaseModule::getModuleName: Should not have been called. Child module must implement "static getModuleName(){}"');
   }
 
+  static shouldUse() {
+    return true;
+  }
+
   constructor(application) {
     Object.defineProperties(this, {
       'application': {
@@ -36,6 +40,4 @@ class BaseModule {
   }
 }
 
-module.exports = {
-  BaseModule,
-};
+module.exports = { BaseModule };

package/src/modules/database-module.d.ts

@@ -0,0 +1,14 @@
+import { ConnectionBase } from 'mythix-orm';
+import { GenericObject } from '../interfaces/common';
+import { BaseModule } from './base-module';
+
+export declare class DatabaseModule extends BaseModule {
+  public getDatabaseConfig(): GenericObject;
+  public getConfig(): GenericObject;
+  public getTablePrefix(): string | null;
+  public getConnection(): ConnectionBase;
+  public connectToDatabase(databaseConfig: GenericObject): Promise<ConnectionBase>;
+
+  declare public connection: ConnectionBase;
+  declare public databaseConfig: GenericObject;
+}

package/src/modules/database-module.js

@@ -156,6 +156,4 @@ class DatabaseModule extends BaseModule {
   }
 }
 
-module.exports = {
-  DatabaseModule,
-};
+module.exports = { DatabaseModule };

package/src/modules/file-watcher-module.d.ts

@@ -0,0 +1,13 @@
+import { GenericObject } from '../interfaces/common';
+import { BaseModule } from './base-module';
+
+export declare class FileWatcherModule extends BaseModule {
+  public getMonitoredPaths(options?: GenericObject): Array<string>;
+  public isWatchedFile(monitoredPaths: Array<string>, filePath: string): boolean;
+  public getFileScope(options: GenericObject, filePath: string): string;
+  public autoReload(enable?: boolean, shuttingDown?: boolean): Promise<void>;
+  public watchedFilesChanged(files: GenericObject): Promise<void>;
+
+  declare public fileWatcher: any;
+  declare public watchedPathsCache: Array<string>;
+}

package/src/modules/file-watcher-module.js

@@ -217,6 +217,4 @@ class FileWatcherModule extends BaseModule {
   }
 }
 
-module.exports = {
-  FileWatcherModule,
-};
+module.exports = { FileWatcherModule };

package/src/modules/index.d.ts

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

package/src/modules/index.js

@@ -1,11 +1,11 @@
 'use strict';
 
-const BaseModule        = require('./base-module');
-const DatabaseModule    = require('./database-module');
-const FileWatcherModule = require('./file-watcher-module');
+const { BaseModule }        = require('./base-module');
+const { DatabaseModule }    = require('./database-module');
+const { FileWatcherModule } = require('./file-watcher-module');
 
-module.exports = Object.assign({},
+module.exports = {
   BaseModule,
   DatabaseModule,
   FileWatcherModule,
-);
+};

package/src/tasks/index.d.ts

@@ -0,0 +1,3 @@
+export * from './task-base';
+export * as TaskUtils from './task-utils';
+export { defineTask } from './task-utils';

package/src/tasks/task-base.d.ts

@@ -0,0 +1,43 @@
+import { GenericObject } from '../interfaces/common';
+import { Application } from '../application';
+import { Logger } from '../logger';
+import { ConnectionBase, ModelClass, Models } from 'mythix-orm';
+
+export declare type Tasks = { [ key: string ]: TaskBase };
+
+export declare type TaskClass = typeof TaskBase;
+
+export declare interface TaskInfo {
+  _startTime: number;
+  lastTime: number;
+  failedCount: number;
+  taskInstance: TaskBase;
+  runID: string;
+  promise: Promise<any>;
+  stop: boolean;
+}
+
+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;
+
+  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 getDBConnection(): ConnectionBase;
+  public getFrequency(taskIndex?: number): number;
+  public getStartDelay(taskIndex?: number): number;
+}

package/src/tasks/task-base.js

@@ -1,6 +1,42 @@
 'use strict';
 
 class TaskBase {
+  static onTaskClassCreate(Klass) {
+    return Klass;
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  static getFrequency(taskIndex) {
+    return this._frequency || 0;
+  }
+
+  static getStartDelay(taskIndex) {
+    let workers     = this.workers || 1;
+    let frequency   = this.getFrequency(taskIndex);
+    let startDelay  = this._startDelay || 0;
+
+    if (workers > 1) {
+      let shift = (frequency / workers);
+      startDelay = startDelay + (shift * taskIndex);
+    }
+
+    return startDelay;
+  }
+
+  static shouldRun(taskIndex, lastTime, currentTime, diff) {
+    if (!lastTime) {
+      if (diff >= this.getStartDelay(taskIndex))
+        return true;
+
+      return false;
+    }
+
+    if (diff >= this.getFrequency(taskIndex))
+      return true;
+
+    return false;
+  }
+
   constructor(application, logger, runID) {
     Object.defineProperties(this, {
       'application': {
@@ -69,54 +105,13 @@ class TaskBase {
     return application.getDBConnection();
   }
 
-  getFrequency() {
-    return this.constructor.getFrequency();
+  getFrequency(taskIndex) {
+    return this.constructor.getFrequency(taskIndex);
   }
 
-  getStartDelay() {
-    return this.constructor.getStartDelay();
-  }
-
-  static onTaskClassCreate(Klass) {
-    Klass.getFrequency  = Klass.getFrequency.bind(this, Klass);
-    Klass.getStartDelay = Klass.getStartDelay.bind(this, Klass);
-    Klass.shouldRun     = Klass.shouldRun.bind(this, Klass);
-
-    return Klass;
-  }
-
-  static getFrequency(Task /*, taskIndex */) {
-    return Task._frequency || 0;
-  }
-
-  static getStartDelay(Task, taskIndex) {
-    let workers     = Task.workers || 1;
-    let frequency   = Task.getFrequency(taskIndex);
-    let startDelay  = Task._startDelay || 0;
-
-    if (workers > 1) {
-      let shift = (frequency / workers);
-      startDelay = startDelay + (shift * taskIndex);
-    }
-
-    return startDelay;
-  }
-
-  static shouldRun(Task, taskIndex, lastTime, currentTime, diff) {
-    if (!lastTime) {
-      if (diff >= Task.getStartDelay(taskIndex))
-        return true;
-
-      return false;
-    }
-
-    if (diff >= Task.getFrequency(taskIndex))
-      return true;
-
-    return false;
+  getStartDelay(taskIndex) {
+    return this.constructor.getStartDelay(taskIndex);
   }
 }
 
-module.exports = {
-  TaskBase,
-};
+module.exports = { TaskBase };

package/src/tasks/task-module.d.ts

@@ -0,0 +1,17 @@
+import { BaseModule } from '../modules/base-module';
+import { Tasks, TaskInfo } from './task-base';
+
+export declare class TaskModule extends BaseModule {
+  public getTaskFilePaths(tasksPath: string): Array<string>;
+  public loadTasks(tasksPath: string): Tasks;
+  public runTasks(): Promise<void>;
+  public stopTasks(): void;
+  public startTasks(flushTaskInfo): Promise<void>;
+  public stopAllTasks(): Promise<void>
+  public iterateAllTaskInfos(callback: (taskInfo: TaskInfo, index: number, taskName: string) => void): void;
+  public getAllTaskPromises(): Array<Promise<any>>;
+  public waitForAllTasksToFinish(): Promise<void>;
+
+  declare public tasks: Tasks;
+  declare public taskInfo: { [ key: string ]: TaskInfo };
+}