mythix 1.0.1

package/src/logger.js

@@ -0,0 +1,211 @@
+const Path        = require('path');
+const FileSystem  = require('fs');
+
+const LEVEL_ERROR   = 1;
+const LEVEL_WARN    = 2;
+const LEVEL_INFO    = 3;
+const LEVEL_DEBUG   = 4;
+
+function errorStackToString(rootPath, error) {
+  return ('\n -> ' + error.stack.split(/\n+/).slice(1).map((part) => `${part.replace(/^\s+at\s+/, '')}\n`).join(' -> ')).trimEnd();
+}
+
+function writeToWriterObject(writer, type, _output) {
+  var method = writer[type],
+      output = _output;
+
+  if (this._customWriter || typeof method !== 'function') {
+    method = writer.write;
+    output = `${output}\n`;
+  }
+
+  if (typeof method === 'function')
+    method.call(writer, output);
+}
+
+function logToWriter(type, ..._args) {
+  var args = (_args.map((_arg) => {
+    var arg = _arg;
+
+    if (arg instanceof Error) {
+      var formattedStack = (typeof this._errorStackFormatter === 'function')
+                              ? this._errorStackFormatter.call(this, this._rootPath, arg)
+                              : errorStackToString.call(this, this._rootPath, arg);
+
+      arg = `${arg.name}: ${arg.message}: ${formattedStack}`;
+    } else if (arg && typeof arg.valueOf() === 'function') {
+      arg = arg.valueOf();
+    }
+
+    if (arg === true)
+      return 'true';
+    else if (arg === false)
+      return 'false';
+    else if (typeof arg === 'number')
+      return ('' + arg);
+    else if (typeof arg === 'string')
+      return arg;
+
+    try {
+      arg = JSON.stringify(arg);
+    } catch (e) {
+      return '<LOGGER_ERROR>';
+    }
+
+    return arg;
+  }));
+
+  var formatter = this._formatter;
+  var writer    = this._writer;
+  var content   = args.join(' ');
+  var output    = `${type.charAt(0).toUpperCase()}, [${(new Date()).toISOString()} #${this._pid}] -- : ${(typeof formatter === 'function') ? formatter(content) : content}`;
+
+  writeToWriterObject.call(this, (!writer) ? console : writer, type, output);
+}
+
+class Logger {
+  constructor(_opts) {
+    var opts = Object.assign({
+      level:                LEVEL_INFO,
+      writer:               null,
+      rootPath:             process.cwd(),
+      errorStackFormatter:  null,
+    }, _opts || {}, {
+      pid:      process.pid,
+    });
+
+    // If string, assume file path
+    var customWriter = false;
+    if (typeof opts.writer === 'string') {
+      opts.writer = FileSystem.createWriteStream(opts.writer, {
+        flags:      'a',
+        encoding:   'utf8',
+        emitClose:  true,
+      });
+
+      customWriter = true;
+    }
+
+    Object.defineProperties(this, {
+      '_level': {
+        writable:     false,
+        enumerable:   false,
+        configurable: false,
+        value:        opts.level,
+      },
+      '_writer': {
+        writable:     false,
+        enumerable:   false,
+        configurable: false,
+        value:        opts.writer,
+      },
+      '_customWriter': {
+        writable:     false,
+        enumerable:   false,
+        configurable: false,
+        value:        customWriter,
+      },
+      '_pid': {
+        writable:     false,
+        enumerable:   false,
+        configurable: false,
+        value:        opts.pid,
+      },
+      '_formatter': {
+        writable:     false,
+        enumerable:   false,
+        configurable: false,
+        value:        opts.formatter,
+      },
+      '_rootPath': {
+        writable:     false,
+        enumerable:   false,
+        configurable: false,
+        value:        opts.rootPath,
+      },
+      '_errorStackFormatter': {
+        writable:     false,
+        enumerable:   false,
+        configurable: false,
+        value:        opts.errorStackFormatter,
+      },
+    });
+  }
+
+  clone(extraOpts) {
+    return new this.constructor(Object.assign({
+      level:      this._level,
+      writer:     this._writer,
+      pid:        this._pid,
+      formatter:  this._formatter,
+      rootPath:   this._rootPath,
+    }, extraOpts || {}));
+  }
+
+  isErrorLevel() {
+    return (this._level >= LEVEL_ERROR);
+  }
+
+  isWarningLevel() {
+    return (this._level >= LEVEL_WARN);
+  }
+
+  isInfoLevel() {
+    return (this._level >= LEVEL_INFO);
+  }
+
+  isDebugLevel() {
+    return (this._level >= LEVEL_DEBUG);
+  }
+
+  error(...args) {
+    if (this.isErrorLevel())
+      logToWriter.call(this, 'error', ...args);
+  }
+
+  warn(...args) {
+    if (this.isWarningLevel())
+      logToWriter.call(this, 'warn', ...args);
+  }
+
+  info(...args) {
+    if (this.isInfoLevel())
+      logToWriter.call(this, 'info', ...args);
+  }
+
+  debug(...args) {
+    if (this.isDebugLevel())
+      logToWriter.call(this, 'debug', ...args);
+  }
+
+  log(...args) {
+    if (this.isErrorLevel())
+      logToWriter.call(this, 'log', ...args);
+  }
+
+  stop() {
+    return new Promise((resolve, reject) => {
+      if (this._customWriter) {
+        this._writer.end((err) => {
+          if (err)
+            return reject(err);
+
+          resolve();
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+}
+
+Object.assign(Logger, {
+  ERROR:  LEVEL_ERROR,
+  WARN:   LEVEL_WARN,
+  INFO:   LEVEL_INFO,
+  DEBUG:  LEVEL_DEBUG,
+});
+
+module.exports = {
+  Logger,
+};

package/src/models/index.js

@@ -0,0 +1,14 @@
+const { Model } = require('./model');
+
+const {
+  defineModel,
+  getModelPrimaryKeyField,
+  buildModelRelations,
+} = require('./model-utils');
+
+module.exports = {
+  Model,
+  defineModel,
+  getModelPrimaryKeyField,
+  buildModelRelations,
+};

package/src/models/model-utils.js

@@ -0,0 +1,259 @@
+const Nife        = require('nife');
+const Inflection  = require('inflection');
+const { Model }   = require('./model');
+
+function relationHelper(type) {
+  return function(target, _options) {
+    const getName = () => {
+      if (options.name)
+        return options.name;
+
+      if (type.match(/many/i))
+        return Inflection.pluralize(target);
+      else
+        return target.toLowerCase();
+    };
+
+    var options               = _options || {};
+    var defaultOnDeleteAction = 'RESTRICT';
+    if (options.allowNull)
+      defaultOnDeleteAction = 'SET NULL';
+
+    return {
+      type,
+      target,
+      onDelete:   options.onDelete || defaultOnDeleteAction,
+      onUpdate:   options.onUpdate || options.onDelete || defaultOnDeleteAction,
+      field:      options.field,
+      name:       getName(),
+      allowNull:  (options.hasOwnProperty('allowNull')) ? options.allowNull : false,
+    };
+  };
+}
+
+const RELATION_HELPERS = {
+  hasOne:         relationHelper('hasOne'),
+  belongsTo:      relationHelper('belongsTo'),
+  hasMany:        relationHelper('belongsToMany'),
+  belongsToMany:  relationHelper('belongsToMany'),
+};
+
+function defineModel(modelName, definer, _parent) {
+  function compileModelFields(Klass, DataTypes) {
+    var fields      = Klass.fields;
+    var fieldNames  = Object.keys(fields);
+
+    for (var i = 0, il = fieldNames.length; i < il; i++) {
+      var fieldName = fieldNames[i];
+      var field     = fields[fieldName];
+
+      if (!field.field) {
+        var columnName = Nife.camelCaseToSnakeCase(fieldName);
+        field.field = columnName;
+      }
+
+      if (field.type === DataTypes.BIGINT) {
+        if (!field.get) {
+          field.get = function(name) {
+            var value = this.getDataValue(name);
+            if (value == null)
+              return null;
+
+            return BigInt(value);
+          };
+        }
+
+        if (!field.set) {
+          field.set = function(_value, name) {
+            var value = _value;
+            if (value == null)
+              value = null;
+            else
+              value = BigInt(value);
+
+            return this.setDataValue(name, value);
+          }
+        }
+      }
+    }
+
+    return fields;
+  }
+
+  function cleanModelFields(Klass) {
+    var finalFields = {};
+    var fields      = Klass.fields;
+    var fieldNames  = Object.keys(fields);
+
+    for (var i = 0, il = fieldNames.length; i < il; i++) {
+      var fieldName = fieldNames[i];
+      var field     = fields[fieldName];
+      var newField  = Nife.extend(Nife.extend.FILTER, (key) => !key.match(/^(index)$/), {}, field);
+
+      finalFields[fieldName] = newField;
+    }
+
+    return finalFields;
+  }
+
+  function generateIndexes(Klass) {
+    var finalIndexes  = [];
+    var fields        = Klass.fields;
+    var fieldNames    = Object.keys(fields);
+
+    for (var i = 0, il = fieldNames.length; i < il; i++) {
+      var fieldName = fieldNames[i];
+      var field     = fields[fieldName];
+
+      if (field.index) {
+        if (field.index === 'unique') {
+          finalIndexes.push({
+            unique: true,
+            fields: [ field.field ],
+          });
+        } else {
+          finalIndexes.push({
+            unique: false,
+            fields: [ field.field ],
+          });
+        }
+      }
+    }
+
+    finalIndexes = finalIndexes.concat(Klass.indexes || [], [
+      {
+        unique: false,
+        fields: [ 'created_at' ],
+      },
+      {
+        unique: false,
+        fields: [ 'updated_at' ],
+      }
+    ]);
+
+    return finalIndexes;
+  }
+
+  return function({ application, Sequelize, connection }) {
+    var Klass = definer({
+      Parent:   (_parent) ? _parent : Model,
+      Type:     Sequelize.DataTypes,
+      Relation: RELATION_HELPERS,
+      Sequelize,
+      connection,
+      modelName,
+      application,
+    });
+
+    Klass.name = modelName;
+
+    var pluralName = (Klass.pluralName) ? Klass.pluralName : Inflection.pluralize(modelName);
+    if (Klass.pluralName !== pluralName)
+      Klass.pluralName = pluralName;
+
+    Klass.fields = compileModelFields(Klass, Sequelize.DataTypes);
+
+    var indexes = generateIndexes(Klass);
+
+    Klass.fields = cleanModelFields(Klass);
+
+    var applicationOptions = application.getOptions();
+    var tableName;
+
+    tableName = (`${Nife.get(applicationOptions, 'database.tablePrefix', '')}${Nife.camelCaseToSnakeCase(pluralName)}`).toLowerCase();
+
+    Klass.init(Klass.fields, {
+      underscored:      true,
+      freezeTableName:  true,
+      sequelize:        connection,
+      tableName,
+      modelName,
+      indexes,
+    });
+
+    Klass.getApplication = () => application;
+    Klass.getLogger = () => application.getLogger();
+
+    Klass.getPrimaryKeyField      = getModelPrimaryKeyField.bind(this, Klass);
+    Klass.getPrimaryKeyFieldName  = () => (getModelPrimaryKeyField(Klass).field);
+
+    if (typeof Klass.onModelClassCreate === 'function')
+      Klass = Klass.onModelClassCreate(Klass);
+
+    return { [modelName]: Klass };
+  };
+}
+
+function getModelPrimaryKeyField(Klass) {
+  var fields      = Klass.fields;
+  var fieldNames  = Object.keys(fields);
+
+  for (var i = 0, il = fieldNames.length; i < il; i++) {
+    var fieldName = fieldNames[i];
+    var field     = fields[fieldName];
+
+    if (field.primaryKey)
+      return field;
+  }
+}
+
+function buildModelRelations(models) {
+  var modelNames = Object.keys(models);
+  for (var i = 0, il = modelNames.length; i < il; i++) {
+    var modelName = modelNames[i];
+    var model     = models[modelName];
+    var relations = model.relations;
+
+    if (!relations)
+      continue;
+
+    for (var j = 0, jl = relations.length; j < jl; j++) {
+      var relation        = relations[j];
+      var type            = relation.type;
+      var fieldName       = Nife.camelCaseToSnakeCase(relation.field);
+      var targetModelName = relation.target;
+      var targetModel     = models[targetModelName];
+
+      if (!targetModel)
+        throw new Error(`${modelName} relation error: target model ${targetModelName} not found`);
+
+      var primaryKeyField;
+
+      if (type.match(/^belongs/)) {
+        primaryKeyField = getModelPrimaryKeyField(targetModel);
+
+        if (!primaryKeyField)
+          throw new Error(`${modelName} relation error: primary key for model ${targetModelName} not found`);
+
+        if (!fieldName)
+          fieldName = `${Nife.camelCaseToSnakeCase(targetModelName)}_${primaryKeyField.field}`;
+      } else {
+        primaryKeyField = getModelPrimaryKeyField(model);
+
+        if (!primaryKeyField)
+          throw new Error(`${modelName} relation error: primary key for model ${modelName} not found`);
+
+        if (!fieldName)
+          fieldName = `${Nife.camelCaseToSnakeCase(modelName)}_${primaryKeyField.field}`;
+      }
+
+      var pkFieldCopy = Nife.extend(Nife.extend.FILTER, (key) => !key.match(/^(field|primaryKey)$/), {}, primaryKeyField);
+
+      // Build relation options for sequelize
+      var options = {
+        onDelete:   relation.onDelete,
+        onUpdate:   relation.onUpdate,
+        foreignKey: Object.assign(pkFieldCopy, { name: relation.name, field: fieldName }),
+      };
+
+      // Set relation on model
+      model[type](targetModel, options);
+    }
+  }
+}
+
+module.exports = {
+  defineModel,
+  getModelPrimaryKeyField,
+  buildModelRelations,
+};

package/src/models/model.js

@@ -0,0 +1,85 @@
+const Nife          = require('nife');
+const { Sequelize } = require('sequelize');
+
+class Model extends Sequelize.Model {
+  getApplication() {
+    return this.constructor.getApplication();
+  }
+
+  getLogger() {
+    var application = this.getApplication();
+    return application.getLogger();
+  }
+
+  getPrimaryKeyField() {
+    return this.constructor.getPrimaryKeyField();
+  }
+
+  getPrimaryKeyFieldName() {
+    return this.constructor.getPrimaryKeyFieldName();
+  }
+
+  static prepareWhereStatement(conditions) {
+    if (Nife.isEmpty(conditions))
+      return undefined;
+
+    const Ops       = Sequelize.Op;
+    var finalQuery  = {};
+    var keys        = Object.keys(conditions);
+
+    for (var i = 0, il = keys.length; i < il; i++) {
+      var key   = keys[i];
+      var value = conditions[key];
+
+      if (value === undefined)
+        continue;
+
+      if (value === null) {
+        finalQuery[key] = { [Ops.is]: value };
+      } else if (Nife.instanceOf(value, 'number', 'string', 'boolean', 'bigint')) {
+        finalQuery[key] = { [Ops.eq]: value };
+      } else if (Nife.instanceOf(value, 'array') && Nife.isNotEmpty(value)) {
+        finalQuery[key] = { [Ops.in]: value };
+      } else if (Nife.isNotEmpty(value)) {
+        finalQuery[key] = value;
+      }
+    }
+
+    return finalQuery;
+  }
+
+  static onModelClassCreate(Klass) {
+    Klass.first = Klass.first.bind(this, Klass);
+    Klass.last  = Klass.last.bind(this, Klass);
+
+    return Klass;
+  }
+
+  static async first(Model, conditions, _order) {
+    var options = {};
+    var query   = Model.prepareWhereStatement(conditions);
+
+    if (Nife.isNotEmpty(query))
+      options.where = query;
+
+    var order = _order;
+    if (!order)
+      order = [ Model.getPrimaryKeyFieldName() ];
+
+    options.order = order;
+
+    return await Model.findOne(options);
+  }
+
+  static async last(Model, conditions, _order) {
+    var order = _order;
+    if (!order)
+      order = [ Model.getPrimaryKeyFieldName(), 'DESC' ];
+
+    return await Model.first(conditions, order);
+  }
+}
+
+module.exports = {
+  Model,
+};

package/src/tasks/index.js

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

package/src/tasks/task-base.js

@@ -0,0 +1,120 @@
+class TaskBase {
+  constructor(application, logger, runID) {
+    Object.defineProperties(this, {
+      'application': {
+        writable:     false,
+        enumberable:  false,
+        configurable: true,
+        value:        application,
+      },
+      'logger': {
+        writable:     true,
+        enumberable:  false,
+        configurable: true,
+        value:        logger,
+      },
+      'runID': {
+        writable:     false,
+        enumberable:  false,
+        configurable: true,
+        value:        runID,
+      },
+    });
+  }
+
+  async start() {
+  }
+
+  async stop() {
+
+  }
+
+  getApplication() {
+    return this.application;
+  }
+
+  getLogger() {
+    var logger = this.logger;
+    if (!logger) {
+      var application = this.getApplication();
+      logger = application.getLogger();
+    }
+
+    return logger;
+  }
+
+  getRunID() {
+    return this.runID;
+  }
+
+  getNumberOfWorkers() {
+    var workers = this.constructor.workers || 1;
+    return workers;
+  }
+
+  getModel(name) {
+    var application = this.application;
+    return application.getModel(name);
+  }
+
+  getModels() {
+    var application = this.application;
+    return application.getModels();
+  }
+
+  getDBConnection() {
+    var application = this.application;
+    return application.getDBConnection();
+  }
+
+  getFrequency() {
+    return this.constructor.getFrequency();
+  }
+
+  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) {
+    var workers     = Task.workers || 1;
+    var frequency   = Task.getFrequency(taskIndex);
+    var startDelay  = Task._startDelay || 0;
+
+    if (workers > 1) {
+      var shift = (frequency / workers);
+      startDelay = Math.round(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;
+  }
+}
+
+module.exports = {
+  TaskBase,
+};