mythix 1.2.0 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mythix",
-  "version": "1.2.0",
+  "version": "2.0.0",
   "description": "Mythix is a NodeJS web-app framework",
   "main": "src/index.js",
   "scripts": {
@@ -19,26 +19,18 @@
   },
   "homepage": "https://github.com/th317erd/mythix#readme",
   "devDependencies": {
+    "@spothero/eslint-plugin-spothero": "github:spothero/eslint-plugin-spothero",
+    "eslint": "^8.13.0",
     "colors": "^1.4.0",
     "diff": "^5.1.0",
     "jasmine": "^4.0.2"
   },
   "dependencies": {
-    "@spothero/eslint-plugin-spothero": "github:spothero/eslint-plugin-spothero",
     "chokidar": "^3.5.3",
-    "deep-diff": "^1.0.2",
-    "eslint": "^8.13.0",
     "express": "^4.17.3",
     "express-busboy": "^8.0.2",
     "form-data": "^4.0.0",
-    "inflection": "^1.13.2",
-    "lodash": "^4.17.21",
     "nife": "^1.8.1",
-    "object-hash": "^3.0.0",
-    "pg": "^8.7.3",
-    "pg-hstore": "^2.3.4",
-    "prompts": "^2.4.2",
-    "sequelize": "^6.18.0",
-    "sqlite3": "^5.0.9"
+    "prompts": "^2.4.2"
   }
 }

package/src/application.js

@@ -70,6 +70,7 @@ class Application extends EventEmitter {
     let ROOT_PATH = (_opts && _opts.rootPath) ? _opts.rootPath : Path.resolve(__dirname);
 
     let opts = Nife.extend(true, {
+      environment:              (process.env.NODE_ENV || 'development'),
       appName:                  this.constructor.APP_NAME,
       rootPath:                 ROOT_PATH,
       configPath:               Path.resolve(ROOT_PATH, 'config'),
@@ -81,7 +82,7 @@ class Application extends EventEmitter {
       commandsPath:             Path.resolve(ROOT_PATH, 'commands'),
       tasksPath:                Path.resolve(ROOT_PATH, 'tasks'),
       modules:                  this.constructor.getDefaultModules(),
-      autoReload:               (process.env.NODE_ENV || 'development') === 'development',
+      autoReload:               ((_opts && _opts.environment) || process.env.NODE_ENV || 'development') === 'development',
       exitOnShutdown:           null,
       runTasks:                 true,
       testMode:                 false,
@@ -229,8 +230,10 @@ class Application extends EventEmitter {
 
   loadConfig(configPath) {
     try {
+      let appOptions = this.getOptions();
+
       const config = require(configPath);
-      return wrapConfig(config);
+      return wrapConfig(Object.assign({}, config || {}, { environment: (appOptions.environment || config.environment || 'development')}));
     } catch (error) {
       this.getLogger().error(`Error while trying to load application configuration ${configPath}: `, error);
       throw error;

package/src/cli/migrations/makemigrations-command.js

@@ -138,7 +138,7 @@ module.exports = defineCommand('makemigrations', ({ Parent }) => {
 
       // Now build all model information
       connection.modelManager.forEachModel((Model) => {
-        let modelName = Model.customName || Model.name;
+        let modelName = Model.getModelName();
         let tableName = Model.getTableName(options);
 
         models.push({
@@ -799,7 +799,6 @@ module.exports = defineCommand('makemigrations', ({ Parent }) => {
 
           let oldAssertTableHasColumn = queryInterface.assertTableHasColumn;
           try {
-            // Tell Sequelize to shut up
             queryInterface.assertTableHasColumn = async () => ({ [oldColumnName]: columnDefinition });
 
             return await queryInterface.renameColumn(tableName, oldColumnName, newColumnName, options);

package/src/cli/shell-command.js

@@ -5,7 +5,6 @@ const OS                = require('os');
 const Path              = require('path');
 const REPL              = require('repl');
 const UUIDV4            = require('uuid').v4;
-const { Sequelize }     = require('sequelize');
 const { defineCommand } = require('./cli-utils');
 const {
   HTTPInterface,
@@ -55,7 +54,6 @@ module.exports = defineCommand('shell', ({ Parent }) => {
         interactiveShell.setupHistory(Path.join(OS.homedir(), `.${appName}-${environment}-history`), () => {});
 
         interactiveShell.context.UUIDV4 = UUIDV4;
-        interactiveShell.context.Sequelize = Sequelize;
         interactiveShell.context.connection = (typeof application.getDBConnection === 'function') ? application.getDBConnection() : null;
         interactiveShell.context.application = application;
         interactiveShell.context.Nife = Nife;

package/src/controllers/controller-module.js

@@ -90,15 +90,6 @@ class ControllerModule extends BaseModule {
       }
     }
 
-    Object.defineProperties(controllers, {
-      '_files': {
-        writable:     true,
-        enumberable:  false,
-        configurable: true,
-        value:        controllerFiles,
-      },
-    });
-
     return controllers;
   }
 

package/src/http-server/http-server.js

@@ -2,7 +2,6 @@
 
 /* global process */
 
-const OS            = require('os');
 const Path          = require('path');
 const FileSystem    = require('fs');
 const HTTP          = require('http');
@@ -10,7 +9,6 @@ const HTTPS         = require('https');
 const Nife          = require('nife');
 const Express       = require('express');
 const ExpressBusBoy = require('express-busboy');
-const Sequelize     = require('sequelize');
 
 const {
   HTTPBaseError,
@@ -132,9 +130,6 @@ class HTTPServer {
       if (!logger)
         logger = request.mythixLogger = this.createRequestLogger(application, request);
 
-      if (!request.Sequelize)
-        request.Sequelize = Sequelize;
-
       request.route = route;
       request.params = params;
 

package/src/models/index.js

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

package/src/models/migration-model.js

@@ -4,11 +4,11 @@ const { defineModel } = require('./model-utils');
 
 const ID_STRING_MAX_SIZE = 15;
 
-module.exports = defineModel('Migration', ({ Parent, Type }) => {
+module.exports = defineModel('Migration', ({ Parent, Types }) => {
   return class Migration extends Parent {
     static fields = {
       id: {
-        type:         Type.STRING(ID_STRING_MAX_SIZE),
+        type:         Types.STRING(ID_STRING_MAX_SIZE),
         allowNull:    false,
         primaryKey:   true,
         index:        true,

package/src/models/model-module.js

@@ -2,10 +2,8 @@
 
 /* global __dirname */
 
-const Path                    = require('path');
-const { Sequelize }           = require('sequelize');
-const { BaseModule }          = require('../modules/base-module');
-const { buildModelRelations } = require('./model-utils');
+const Path            = require('path');
+const { BaseModule }  = require('../modules/base-module');
 const {
   fileNameWithoutExtension,
   walkDir,
@@ -28,15 +26,6 @@ class ModelModule extends BaseModule {
   constructor(application) {
     super(application);
 
-    Object.defineProperties(this, {
-      'models': {
-        writable:     true,
-        enumerable:   false,
-        configurable: true,
-        value:        {},
-      },
-    });
-
     // Inject methods into the application
     Object.defineProperties(application, {
       'getModel': {
@@ -59,8 +48,7 @@ class ModelModule extends BaseModule {
   }
 
   async fileWatcherHandler(options) {
-    let models = await this.loadModels(options.modelsPath);
-    this.models = models;
+    await this.loadModels(options.modelsPath);
   }
 
   getModelFilePaths(modelsPath) {
@@ -91,7 +79,7 @@ class ModelModule extends BaseModule {
     let dbConfig    = (typeof application.getDBConfig === 'function') ? application.getDBConfig() : null;
     let modelFiles  = this.getModelFilePaths(modelsPath);
     let models      = {};
-    let args        = { application, Sequelize, connection, dbConfig };
+    let args        = { application, connection, dbConfig };
 
     for (let i = 0, il = modelFiles.length; i < il; i++) {
       let modelFile = modelFiles[i];
@@ -108,32 +96,31 @@ class ModelModule extends BaseModule {
       }
     }
 
-    buildModelRelations(models);
-
-    Object.defineProperties(models, {
-      '_files': {
-        writable:     true,
-        enumberable:  false,
-        configurable: true,
-        value:        modelFiles,
-      },
-    });
+    models = connection.registerModels(models);
 
     return models;
   }
 
-  getModel(name) {
-    let models = this.models;
-    return models[name];
+  getModel(modelName) {
+    let application = this.getApplication();
+    let connection  = (typeof application.getDBConnection === 'function') ? application.getDBConnection() : null;
+    if (!connection)
+      return;
+
+    return connection.getModel(modelName);
   }
 
   getModels() {
-    return this.models || {};
+    let application = this.getApplication();
+    let connection  = (typeof application.getDBConnection === 'function') ? application.getDBConnection() : null;
+    if (!connection)
+      return;
+
+    return connection.getModels();
   }
 
   async start(options) {
-    let models = await this.loadModels(options.modelsPath);
-    this.models = models;
+    await this.loadModels(options.modelsPath);
   }
 
   async stop() {

package/src/models/model-utils.js

@@ -1,398 +1,48 @@
 'use strict';
 
-const Nife        = require('nife');
-const Inflection  = require('inflection');
-const { Model }   = require('./model');
-
-const MILLISECONDS_PER_SECOND = 1000;
-
-function relationHelper(modelName, type) {
-  return function(target, _options) {
-    const getName = () => {
-      if (options.name)
-        return options.name;
-
-      if (type.match(/many/i))
-        return Inflection.pluralize(target.toLowerCase());
-      else
-        return target.toLowerCase();
-    };
-
-    // const getFieldName = () => {
-    //   if (options.field)
-    //     return options.field;
-
-    //   if (type.match(/many/i))
-    //     return Inflection.pluralize(target.toLowerCase());
-    //   else
-    //     return target.toLowerCase();
-    // };
-
-    let options               = _options || {};
-    let defaultOnDeleteAction = 'RESTRICT';
-    if (options.allowNull)
-      defaultOnDeleteAction = 'SET NULL';
-
-    return Object.assign({}, options, {
-      type,
-      target,
-      onDelete:   options.onDelete || defaultOnDeleteAction,
-      onUpdate:   options.onUpdate || options.onDelete || defaultOnDeleteAction,
-      field:      options.field,
-      name:       getName(),
-      allowNull:  (Object.prototype.hasOwnProperty.call(options, 'allowNull')) ? options.allowNull : true,
-    });
-  };
-}
-
-const RELATION_HELPERS = [
-  'hasOne',
-  'belongsTo',
-  'hasMany',
-  'belongsToMany',
-];
-
-function getRelationHelpers(modelName) {
-  let obj = {};
-
-  for (let i = 0, il = RELATION_HELPERS.length; i < il; i++) {
-    let type = RELATION_HELPERS[i];
-    obj[type] = relationHelper(modelName, type);
-  }
-
-  return obj;
-}
-
-function preciseNow() {
-  let janFirst2022      = 1640995200000;
-  let now               = Date.now() - janFirst2022;
-  let highResolutionNow = Nife.now();
-  let diff              = Math.floor(highResolutionNow);
-
-  return Math.floor((now + (highResolutionNow - diff)) * MILLISECONDS_PER_SECOND);
-}
+const Nife                  = require('nife');
+const { Types }             = require('mythix-orm');
+const { Model: ModelBase }  = require('./model');
 
 function defineModel(modelName, definer, _parent) {
-  function compileModelFields(Klass, DataTypes, application, connection) {
-    const createAutoIncrementor = () => {
-      return () => preciseNow();
-    };
-
-    let fields      = Klass.fields;
-    let fieldNames  = Object.keys(fields);
-    let isSQLIte    = !!('' + Nife.get(connection, 'options.dialect')).match(/sqlite/);
-
-    for (let i = 0, il = fieldNames.length; i < il; i++) {
-      let fieldName = fieldNames[i];
-      let field     = fields[fieldName];
-
-      if (!field.field) {
-        let columnName = Nife.camelCaseToSnakeCase(fieldName);
-        field.field = columnName;
-      }
-
-      if (!Object.prototype.hasOwnProperty.call(field, 'allowNull'))
-        field.allowNull = (field.primaryKey) ? false : true;
-
-      // If using SQLite, which doesn't support autoincrement
-      // on anything except the primary key, then create our
-      // own auto-incrementor for this field
-      if (field.autoIncrement && isSQLIte && !field.primaryKey) {
-        application.getLogger().warn(`!Warning!: Using an auto-increment field in SQLite on a non-primary-key column "${field.field}"! Be aware that this functionality is now emulated using high resolution timestamps. This won't work unless the column is a BIGINT. You may run into serious problems with this emulation!`);
-        field.defaultValue = createAutoIncrementor();
-      }
-
-      if (field.type === DataTypes.BIGINT) {
-        if (!field.get) {
-          field.get = function(name) {
-            let value = this.getDataValue(name);
-            if (value == null)
-              return null;
-
-            return BigInt(value);
-          };
-        }
-
-        if (!field.set) {
-          field.set = function(_value, name) {
-            let value = _value;
-            if (value == null)
-              value = null;
-            else
-              value = BigInt(value);
-
-            return this.setDataValue(name, value);
-          };
-        }
-      }
-    }
-
-    return fields;
-  }
-
-  function cleanModelFields(Klass, connection) {
-    let finalFields = {};
-    let fields      = Klass.fields;
-    let fieldNames  = Object.keys(fields);
-    let isSQLIte    = !!('' + Nife.get(connection, 'options.dialect')).match(/sqlite/);
-
-    for (let i = 0, il = fieldNames.length; i < il; i++) {
-      let fieldName = fieldNames[i];
-      let field     = fields[fieldName];
-      let newField  = Nife.extend(Nife.extend.FILTER, (key) => {
-        if (key.match(/^(index)$/))
-          return false;
-
-        // Strip "autoIncrement" if this is not the primary key
-        // and we are using sqlite for our dialect
-        if (key === 'autoIncrement' && isSQLIte && !field.primaryKey)
-          return false;
-
-        return true;
-      }, {}, field);
-
-      finalFields[fieldName] = newField;
-    }
-
-    return finalFields;
-  }
-
-  function generateIndexes(Klass) {
-    let finalIndexes  = [];
-    let fields        = Klass.fields;
-    let fieldNames    = Object.keys(fields);
-
-    for (let i = 0, il = fieldNames.length; i < il; i++) {
-      let fieldName = fieldNames[i];
-      let 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 }) {
+  return function({ application, connection }) {
     let definerArgs = {
-      Parent:   (_parent) ? _parent : Model,
-      Type:     Sequelize.DataTypes,
-      Relation: getRelationHelpers(modelName),
-      Sequelize,
+      Parent:   (_parent) ? _parent : ModelBase,
+      Types,
       connection,
       modelName,
       application,
     };
 
-    let Klass = definer(definerArgs);
-
-    Klass.customName = modelName;
-
-    if (typeof Klass.onModelClassCreate === 'function')
-      Klass = Klass.onModelClassCreate(Klass, definerArgs);
+    let Model = definer(definerArgs);
 
-    let pluralName = (Klass.pluralName) ? Klass.pluralName : Inflection.pluralize(modelName);
-    if (Klass.pluralName !== pluralName)
-      Klass.pluralName = pluralName;
+    if (typeof Model.onModelClassCreate === 'function')
+      Model = Model.onModelClassCreate(Model, definerArgs);
 
-    Klass.fields = compileModelFields(Klass, Sequelize.DataTypes, application, connection);
+    let tableName   = Model.getTableName();
+    let tablePrefix = application.getDBTablePrefix();
 
-    let indexes = generateIndexes(Klass);
+    if (tablePrefix)
+      tableName = (`${tablePrefix}${tableName}`);
 
-    Klass.fields = cleanModelFields(Klass, connection);
+    Model.getTableName  = () => tableName;
+    Model.getModelName  = () => modelName;
+    Model.getApplication = () => application;
+    Model.getLogger = () => application.getLogger();
+    Model._getConnection = (_connection) => {
+      if (_connection)
+        return _connection;
 
-    let applicationOptions = application.getOptions();
-    let tableName = Klass.tableName;
-
-    if (!tableName)
-      tableName = (`${Nife.get(applicationOptions, 'database.tablePrefix', '')}${Nife.camelCaseToSnakeCase(pluralName)}`).toLowerCase();
-
-    // Sequelize bullshit...
-    // Sequelize has undocumented static hook methods
-    // that don't align with their own hook system.
-    // Who knows what they are for, as they aren't
-    // documented, nor even called when statically
-    // defined on a model class... but... there you
-    // have it, stupid undocumented bullshit (again)
-    // that is breaking the world.
-    // So we must first check that each method isn't
-    // Sequelize bullshit, otherwise we get errors.
-    let staticHooks = {
-      beforeBulkCreate:   Klass.beforeBulkCreate,
-      beforeBulkDestroy:  Klass.beforeBulkDestroy,
-      beforeBulkUpdate:   Klass.beforeBulkUpdate,
-      beforeValidate:     Klass.beforeValidate,
-      afterValidate:      Klass.afterValidate,
-      validationFailed:   Klass.validationFailed,
-      beforeCreate:       Klass.beforeCreate,
-      beforeDestroy:      Klass.beforeDestroy,
-      beforeUpdate:       Klass.beforeUpdate,
-      beforeSave:         Klass.beforeSave,
-      beforeUpsert:       Klass.beforeUpsert,
-      afterCreate:        Klass.afterCreate,
-      afterDestroy:       Klass.afterDestroy,
-      afterUpdate:        Klass.afterUpdate,
-      afterSave:          Klass.afterSave,
-      afterUpsert:        Klass.afterUpsert,
-      afterBulkCreate:    Klass.afterBulkCreate,
-      afterBulkDestroy:   Klass.afterBulkDestroy,
-      afterBulkUpdate:    Klass.afterBulkUpdate,
+      return connection;
     };
-    let hookNames = Object.keys(staticHooks);
-    let hooks     = {};
-    for (let i = 0, il = hookNames.length; i < il; i++) {
-      let hookName = hookNames[i];
-      let hookFunc = staticHooks[hookName];
-      if (typeof hookFunc !== 'function')
-        continue;
-
-      // Are you mysterious Sequelize stupidity?
-      // If so, skip the bullshit please.
-      if (hookFunc === Sequelize.Model[hookName])
-        continue;
 
-      hooks[hookName] = hookFunc;
-    }
-
-    Klass.init(Klass.fields, {
-      underscored:      true,
-      freezeTableName:  true,
-      sequelize:        connection,
-      tableName,
-      modelName,
-      indexes,
-      name:            {
-        singular: modelName.toLowerCase(),
-        plural:   Inflection.pluralize(modelName.toLowerCase()),
-      },
-      hooks,
-    });
+    if (typeof Model.onModelClassFinalized === 'function')
+      Model = Model.onModelClassFinalized(Model, definerArgs);
 
-    Klass.getApplication = () => application;
-    Klass.getLogger = () => application.getLogger();
-    Klass.getModelName = (function() {
-      return modelName;
-    }).bind(Klass);
-
-    Klass.prototype.getModelName = function() {
-      return modelName;
-    };
-
-    Klass.getPrimaryKeyField      = getModelPrimaryKeyField.bind(this, Klass);
-    Klass.getPrimaryKeyFieldName  = () => (getModelPrimaryKeyField(Klass).field);
-
-    if (typeof Klass.onModelClassFinalized === 'function')
-      Klass = Klass.onModelClassFinalized(Klass, definerArgs);
-
-    return { [modelName]: Klass };
+    return { [modelName]: Model };
   };
 }
 
-function getModelPrimaryKeyField(Klass) {
-  let fields      = Klass.fields;
-  let fieldNames  = Object.keys(fields);
-
-  for (let i = 0, il = fieldNames.length; i < il; i++) {
-    let fieldName = fieldNames[i];
-    let field     = fields[fieldName];
-
-    if (field.primaryKey)
-      return field;
-  }
-}
-
-function buildModelRelations(models) {
-  let modelNames = Object.keys(models);
-  for (let i = 0, il = modelNames.length; i < il; i++) {
-    let modelName = modelNames[i];
-    let model     = models[modelName];
-    let relations = model.relations;
-
-    if (!relations)
-      continue;
-
-    for (let j = 0, jl = relations.length; j < jl; j++) {
-      let relation        = relations[j];
-      let type            = relation.type;
-      let fieldName       = Nife.camelCaseToSnakeCase(relation.field);
-      let targetModelName = relation.target;
-      let targetModel     = models[targetModelName];
-      let belongsType     = !!type.match(/^belongs/);
-
-      if (!targetModel)
-        throw new Error(`${modelName} relation error: target model ${targetModelName} not found`);
-
-      let primaryKeyField;
-
-      if (belongsType) {
-        primaryKeyField = getModelPrimaryKeyField(targetModel);
-
-        if (!primaryKeyField)
-          throw new Error(`${modelName} relation error: primary key for model ${targetModelName} not found`);
-
-        let pkFieldName = primaryKeyField.field;
-        if (pkFieldName === 'id')
-          pkFieldName = 'ID';
-
-        if (!fieldName)
-          fieldName = `${Nife.camelCaseToSnakeCase(targetModelName)}${Nife.snakeCaseToCamelCase(pkFieldName, true)}`;
-      } else {
-        primaryKeyField = getModelPrimaryKeyField(model);
-
-        if (!primaryKeyField)
-          throw new Error(`${modelName} relation error: primary key for model ${modelName} not found`);
-
-        let pkFieldName = primaryKeyField.field;
-        if (pkFieldName === 'id')
-          pkFieldName = 'ID';
-
-        if (!fieldName)
-          fieldName = `${Nife.camelCaseToSnakeCase(modelName)}${Nife.snakeCaseToCamelCase(pkFieldName, true)}`;
-      }
-
-      let pkFieldCopy = Nife.extend(Nife.extend.FILTER, (key) => !key.match(/^(field|primaryKey)$/), {}, primaryKeyField);
-
-      // Build relation options for sequelize
-      let options = Object.assign({}, relation, {
-        onDelete:   relation.onDelete,
-        onUpdate:   relation.onUpdate,
-        allowNull:  (relation.allowNull == null) ? true : relation.allowNull,
-        foreignKey: (relation.foreignKey) ? relation.foreignKey : Object.assign(pkFieldCopy, { name: fieldName, as: relation.name, field: Nife.camelCaseToSnakeCase(fieldName) }),
-      });
-
-      // Set relation on model
-
-      // console.log(`Creating model relation (${modelName} -> ${targetModelName}): `, type, options);
-
-      model[type](targetModel, options);
-    }
-  }
-}
-
 module.exports = {
   defineModel,
-  getModelPrimaryKeyField,
-  buildModelRelations,
 };