mythix 3.0.0 → 4.0.2

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

@@ -1,220 +0,0 @@
-'use strict';
-
-const chokidar        = require('chokidar');
-const Nife            = require('nife');
-const { BaseModule }  = require('../modules/base-module');
-
-class FileWatcherModule extends BaseModule {
-  static getModuleName() {
-    return 'FileWatcherModule';
-  }
-
-  static shouldUse(application, options) {
-    if (options.autoReload === false)
-      return false;
-
-    return true;
-  }
-
-  constructor(application) {
-    super(application);
-
-    Object.defineProperties(this, {
-      'fileWatcher': {
-        writable:     true,
-        enumerable:   false,
-        configurable: true,
-        value:        null,
-      },
-      'watchedPathsCache': {
-        writable:     true,
-        enumerable:   false,
-        configurable: true,
-        value:        null,
-      },
-    });
-
-    // Inject methods into the application
-    Object.defineProperties(application, {
-      'autoReload': {
-        writable:     true,
-        enumerable:   false,
-        configurable: true,
-        value:        this.autoReload.bind(this),
-      },
-    });
-  }
-
-  getMonitoredPaths(options) {
-    if (this.watchedPathsCache)
-      return this.watchedPathsCache;
-
-    let application     = this.getApplication();
-    let moduleInstances = application.getModules();
-    let allPaths        = [];
-
-    for (let i = 0, il = moduleInstances.length; i < il; i++) {
-      let moduleInstance = moduleInstances[i];
-      let queueName = moduleInstance.constructor.fileWatcherQueueName;
-      if (!queueName || typeof moduleInstance.fileWatcherGetMonitorPaths !== 'function')
-        continue;
-
-      let paths = moduleInstance.fileWatcherGetMonitorPaths(options);
-      if (paths)
-        allPaths = allPaths.concat(paths);
-    }
-
-    this.watchedPathsCache = Nife.uniq(allPaths);
-
-    return this.watchedPathsCache;
-  }
-
-  isWatchedFile(_monitoredPaths, filePath) {
-    let monitoredPaths = Nife.toArray(_monitoredPaths);
-
-    for (let i = 0, il = monitoredPaths.length; i < il; i++) {
-      let monitoredPath = monitoredPaths[i];
-      if (!monitoredPath)
-        continue;
-
-      if (filePath.substring(0, monitoredPath.length) === monitoredPath)
-        return true;
-    }
-
-    return false;
-  }
-
-  getFileScope(options, filePath) {
-    let application     = this.getApplication();
-    let moduleInstances = application.getModules();
-
-    for (let i = 0, il = moduleInstances.length; i < il; i++) {
-      let moduleInstance = moduleInstances[i];
-      let queueName = moduleInstance.constructor.fileWatcherQueueName;
-      if (!queueName)
-        continue;
-
-      let paths = moduleInstance.fileWatcherGetMonitorPaths(options);
-      if (this.isWatchedFile(paths, filePath))
-        return queueName;
-    }
-
-    return 'default';
-  }
-
-  async autoReload(_set, shuttingDown) {
-    let options = this.getApplication().getOptions();
-    if (arguments.length === 0)
-      return options.autoReload;
-
-    let set = !!_set;
-
-    if (!shuttingDown)
-      options.autoReload = set;
-
-    if (this.fileWatcher) {
-      try {
-        await this.fileWatcher.close();
-      } catch (error) {
-        console.error(error);
-      }
-    }
-
-    if (shuttingDown)
-      return;
-
-    if (!set)
-      return;
-
-    this.watchedPathsCache = null;
-
-    const filesChanged = (eventName, path) => {
-      if (filesChangedTimeout)
-        clearTimeout(filesChangedTimeout);
-
-      let scopeName = this.getFileScope(options, path);
-      let scope     = filesChangedQueue[scopeName];
-      if (!scope)
-        scope = filesChangedQueue[scopeName] = {};
-
-      scope[path] = eventName;
-
-      filesChangedTimeout = setTimeout(() => {
-        this.watchedFilesChanged(Object.assign({}, filesChangedQueue));
-
-        filesChangedTimeout = null;
-        filesChangedQueue = {};
-      }, 500);
-    };
-
-    let filesChangedQueue = {};
-    let filesChangedTimeout;
-    let monitoredPaths = this.getMonitoredPaths(options);
-
-    this.fileWatcher = chokidar.watch(monitoredPaths, {
-      persistent:     true,
-      followSymlinks: true,
-      usePolling:     false,
-      ignoreInitial:  true,
-      interval:       200,
-      binaryInterval: 500,
-      depth:          10,
-    });
-
-    this.fileWatcher.on('all', filesChanged);
-  }
-
-  async watchedFilesChanged(files) {
-    const flushRequireCache = (path) => {
-      try {
-        delete require.cache[require.resolve(path)];
-      } catch (error) {
-        console.error('Error while trying to flush require cache to reload modified files: ', error);
-      }
-    };
-
-    const flushRequireCacheForFiles = (type, filesToFlushCache) => {
-      for (let i = 0, il = filesToFlushCache.length; i < il; i++) {
-        let fileName = filesToFlushCache[i];
-        flushRequireCache(fileName);
-
-        this.getLogger().info(`Loading ${type} ${fileName}...`);
-      }
-    };
-
-    let application     = this.getApplication();
-    let options         = application.getOptions();
-    let moduleInstances = application.getModules();
-
-    for (let i = 0, il = moduleInstances.length; i < il; i++) {
-      let moduleInstance = moduleInstances[i];
-      let queueName = moduleInstance.constructor.fileWatcherQueueName;
-      if (!queueName || typeof moduleInstance.fileWatcherHandler !== 'function')
-        continue;
-
-      let scope       = files[queueName];
-      let fileNames   = Object.keys(scope || {});
-
-      if (Nife.isEmpty(fileNames))
-        continue;
-
-      flushRequireCacheForFiles(queueName, fileNames);
-
-      try {
-        await moduleInstance.fileWatcherHandler.call(moduleInstance, options);
-      } catch (error) {
-        this.getLogger().error(`Error while attempting to reload ${queueName}`, error);
-      }
-    }
-  }
-
-  async start(options) {
-    await this.autoReload(options.autoReload, false);
-  }
-
-  async stop() {
-    await this.autoReload(false, true);
-  }
-}
-
-module.exports = { FileWatcherModule };

package/src/modules/index.d.ts

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

package/src/modules/index.js

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

package/src/tasks/index.d.ts

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

package/src/tasks/index.js

@@ -1,11 +0,0 @@
-'use strict';
-
-const { TaskBase }    = require('./task-base');
-const { TaskModule }  = require('./task-module');
-const { defineTask }  = require('./task-utils');
-
-module.exports = {
-  TaskBase,
-  TaskModule,
-  defineTask,
-};

package/src/tasks/task-base.js

@@ -1,117 +0,0 @@
-'use strict';
-
-const { DateTime } = require('luxon');
-
-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 nextRun(taskIndex, lastTime, currentTime, diff) {
-    if (!lastTime)
-      return DateTime.now().plus({ milliseconds: this.getStartDelay(taskIndex) });
-
-    return DateTime.now().plus({ milliseconds: Math.max(0, this.getFrequency(taskIndex) - diff) });
-  }
-
-  constructor(application, logger, runID) {
-    Object.defineProperties(this, {
-      'application': {
-        writable:     false,
-        enumerable:   false,
-        configurable: true,
-        value:        application,
-      },
-      'logger': {
-        writable:     true,
-        enumerable:   false,
-        configurable: true,
-        value:        logger,
-      },
-      'runID': {
-        writable:     false,
-        enumerable:   false,
-        configurable: true,
-        value:        runID,
-      },
-    });
-  }
-
-  async start() {
-  }
-
-  async stop() {
-
-  }
-
-  getApplication() {
-    return this.application;
-  }
-
-  getLogger() {
-    let logger = this.logger;
-    if (!logger) {
-      let application = this.getApplication();
-      logger = application.getLogger();
-    }
-
-    return logger;
-  }
-
-  getRunID() {
-    return this.runID;
-  }
-
-  getNumberOfWorkers() {
-    let workers = this.constructor.workers || 1;
-    return workers;
-  }
-
-  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);
-  }
-
-  // Deprecated
-  getDBConnection(connection) {
-    return this.getConnection(connection);
-  }
-
-  getFrequency(taskIndex) {
-    return this.constructor.getFrequency(taskIndex);
-  }
-
-  getStartDelay(taskIndex) {
-    return this.constructor.getStartDelay(taskIndex);
-  }
-}
-
-module.exports = { TaskBase };

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

@@ -1,46 +0,0 @@
-import { ConnectionBase } from 'mythix-orm';
-import { Application } from '../application';
-import { GenericObject } from '../interfaces/common';
-import { TaskClass } from './task-base';
-
-export declare class TimeHelpers {
-  constructor(days?: number, hours?: number, minutes?: number, seconds?: number);
-  clone(days?: number, hours?: number, minutes?: number, seconds?: number): TimeHelpers;
-  reset(): TimeHelpers;
-  days(days: number): TimeHelpers;
-  hours(hours: number): TimeHelpers;
-  minutes(minutes: number): TimeHelpers;
-  seconds(seconds: number): TimeHelpers;
-  totalSeconds(): number;
-  totalMilliseconds(): number;
-
-  declare public _days: number;
-  declare public _hours: number;
-  declare public _minutes: number;
-  declare public _seconds: number;
-}
-
-export declare type TimeHelpersClass = typeof TimeHelpers;
-
-export declare interface DefineTaskContext {
-  Parent: TaskClass;
-  application: Application;
-  connection: ConnectionBase;
-  dbConfig: GenericObject;
-  taskName: string;
-  time: TimeHelpers;
-}
-
-export declare function defineTask(
-  taskName: string,
-  definer: (context: DefineTaskContext) => TaskClass,
-  parent?: TaskClass,
-): (context: {
-  application: Application,
-  connection: ConnectionBase,
-  dbConfig: GenericObject,
-}) => TaskClass;
-
-export declare namespace defineTask {
-  const TimeHelpers: TimeHelpersClass;
-}

package/src/tasks/task-utils.js

@@ -1,130 +0,0 @@
-'use strict';
-
-const Nife          = require('nife');
-const { TaskBase }  = require('./task-base');
-
-const SECONDS_PER_MINUTE      = 60;
-const MINUTES_PER_HOUR        = 60;
-const SECONDS_PER_HOUR        = (SECONDS_PER_MINUTE * MINUTES_PER_HOUR);
-const HOURS_PER_DAY           = 24;
-const MINUTES_PER_DAY         = (MINUTES_PER_HOUR * HOURS_PER_DAY);
-const SECONDS_PER_DAY         = (MINUTES_PER_DAY * SECONDS_PER_MINUTE);
-const MILLISECONDS_PER_SECOND = 1000;
-
-class TimeHelpers {
-  constructor(_days, _hours, _minutes, _seconds) {
-    Object.defineProperties(this, {
-      '_days': {
-        writable:     true,
-        enumerable:   false,
-        configurable: true,
-        value:        _days || 0,
-      },
-      '_hours': {
-        writable:     true,
-        enumerable:   false,
-        configurable: true,
-        value:        _hours || 0,
-      },
-      '_minutes': {
-        writable:     true,
-        enumerable:   false,
-        configurable: true,
-        value:        _minutes || 0,
-      },
-      '_seconds': {
-        writable:     true,
-        enumerable:   false,
-        configurable: true,
-        value:        _seconds || 0,
-      },
-    });
-
-    this.days     = this.days.bind(this);
-    this.hours    = this.hours.bind(this);
-    this.minutes  = this.minutes.bind(this);
-    this.seconds  = this.seconds.bind(this);
-  }
-
-  clone(_days, _hours, _minutes, _seconds) {
-    return new TimeHelpers(_days || this._days, _hours || this._hours, _minutes || this._minutes, _seconds || this._seconds);
-  }
-
-  reset() {
-    return new TimeHelpers();
-  }
-
-  days(days) {
-    return this.clone(days);
-  }
-
-  hours(hours) {
-    return this.clone(undefined, hours);
-  }
-
-  minutes(minutes) {
-    return this.clone(undefined, undefined, minutes);
-  }
-
-  seconds(seconds) {
-    return this.clone(undefined, undefined, undefined, seconds);
-  }
-
-  totalSeconds() {
-    let totalTime = (this._days * SECONDS_PER_DAY) + (this._hours * SECONDS_PER_HOUR) + (this._minutes * SECONDS_PER_MINUTE) + this._seconds;
-    return totalTime;
-  }
-
-  totalMilliseconds() {
-    return Math.round(this.totalSeconds() * MILLISECONDS_PER_SECOND);
-  }
-}
-
-function defineTask(taskName, definer, _parent) {
-  let parentKlass = _parent || TaskBase;
-
-  return function({ application, connection, dbConfig }) {
-    let time = new TimeHelpers();
-
-    let Klass = definer({
-      Parent: parentKlass,
-      application,
-      connection,
-      dbConfig,
-      taskName,
-      time,
-    });
-
-    if (typeof Klass.prototype.execute !== 'function')
-      throw new Error(`Error while defining task ${taskName}: "execute" method is required`);
-
-    Klass.taskName = taskName;
-
-    Klass._frequency = Klass.frequency;
-    if (Klass._frequency instanceof TimeHelpers)
-      Klass._frequency = Klass._frequency.totalSeconds();
-
-    Klass._startDelay = Klass.startDelay;
-    if (Klass._startDelay instanceof TimeHelpers)
-      Klass._startDelay = Klass._startDelay.totalSeconds();
-
-    if (Nife.instanceOf(Klass._frequency, 'number') && (Klass._frequency <= 0 || !isFinite(Klass._frequency)))
-      throw new Error(`Error while defining task ${taskName}: "static frequency" must be a valid number of seconds`);
-    else if (Klass._frequency && !Nife.instanceOf(Klass._frequency, 'number'))
-      throw new Error(`Error while defining task ${taskName}: "static frequency" must be a valid number of seconds`);
-
-    if (Nife.instanceOf(Klass._startDelay, 'number') && (Klass._startDelay < 0 || !isFinite(Klass._startDelay)))
-      throw new Error(`Error while defining task ${taskName}: "static startDelay" must be a valid number of seconds`);
-    else if (Klass._startDelay && !Nife.instanceOf(Klass._startDelay, 'number'))
-      throw new Error(`Error while defining task ${taskName}: "static startDelay" must be a valid number of seconds`);
-
-    if (typeof Klass.onTaskClassCreate === 'function')
-      Klass = Klass.onTaskClassCreate(Klass);
-
-    return { [taskName]: Klass };
-  };
-}
-
-defineTask.TimeHelpers = TimeHelpers;
-
-module.exports = { defineTask };

package/src/utils/index.js

@@ -1,25 +0,0 @@
-'use strict';
-
-const { wrapConfig } = require('./config-utils');
-
-const {
-  walkDir,
-  fileNameWithoutExtension,
-} = require('./file-utils');
-
-const HTTPUtils         = require('./http-utils');
-const CryptoUtils       = require('./crypto-utils');
-const TestUtils         = require('./test-utils');
-const MimeUtils         = require('./mime-utils');
-const { HTTPInterface } = require('./http-interface');
-
-module.exports = {
-  CryptoUtils,
-  HTTPUtils,
-  MimeUtils,
-  TestUtils,
-  HTTPInterface,
-  fileNameWithoutExtension,
-  walkDir,
-  wrapConfig,
-};