mythix 1.2.0 → 2.0.2

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,
 };

package/src/models/model.js

@@ -1,9 +1,21 @@
 'use strict';
 
-const Nife          = require('nife');
-const { Sequelize } = require('sequelize');
+const { Model: _Model } = require('mythix-orm');
+
+class Model extends _Model {
+  static getModel(modelName) {
+    if (modelName) {
+      let connection = this.getConnection();
+      return connection.getModel(modelName);
+    }
+
+    return this;
+  }
+
+  getModel(modelName) {
+    return this.constructor.getModel(modelName);
+  }
 
-class Model extends Sequelize.Model {
   getApplication() {
     return this.constructor.getApplication();
   }
@@ -13,21 +25,25 @@ class Model extends Sequelize.Model {
     return application.getLogger();
   }
 
-  getDBConnection() {
+  getDBConnection(connection) {
+    if (connection)
+      return connection;
+
     let application = this.getApplication();
-    return application.getDBConnection();
-  }
+    if (!application)
+      return null;
 
-  getPrimaryKeyField() {
-    return this.constructor.getPrimaryKeyField();
-  }
+    if (typeof application.getDBConnection === 'function')
+      return application.getDBConnection();
 
-  getPrimaryKeyFieldName() {
-    return this.constructor.getPrimaryKeyFieldName();
+    return null;
   }
 
-  getTableName() {
-    return this.constructor.getTableName();
+  getConnection(connection) {
+    if (connection)
+      return connection;
+
+    return this.getDBConnection();
   }
 
   overrideMethod(name, newMethod) {
@@ -60,143 +76,6 @@ class Model extends Sequelize.Model {
       this.overrideMethod(name, method);
     }
   }
-
-  static prepareWhereStatement(conditions) {
-    if (Nife.isEmpty(conditions))
-      return undefined;
-
-    if (conditions._mythixQuery)
-      return conditions;
-
-    const Ops       = Sequelize.Op;
-    let finalQuery  = {};
-    let keys        = Object.keys(conditions).concat(Object.getOwnPropertySymbols(conditions));
-
-    for (let i = 0, il = keys.length; i < il; i++) {
-      let key   = keys[i];
-      let value = conditions[key];
-
-      if (value === undefined)
-        continue;
-
-      let name    = key;
-      let invert  = false;
-
-      if (typeof name === 'string' && name.charAt(0) === '!') {
-        name    = name.substring(1);
-        invert  = true;
-      }
-
-      if (typeof key === 'symbol') {
-        finalQuery[key] = value;
-      } else if (value === null) {
-        finalQuery[name] = (invert) ? { [Ops.not]: value } : { [Ops.is]: value };
-      } else if (Nife.instanceOf(value, 'number', 'string', 'boolean', 'bigint')) {
-        finalQuery[name] = (invert) ? { [Ops.ne]: value } : { [Ops.eq]: value };
-      } else if (Nife.instanceOf(value, 'array') && Nife.isNotEmpty(value)) {
-        finalQuery[name] = (invert) ? { [Ops.not]: { [Ops.in]: value } } : { [Ops.in]: value };
-      } else if (Nife.isNotEmpty(value)) {
-        if (invert)
-          throw new Error(`Model.prepareWhereStatement: Attempted to invert a custom matcher "${name}"`);
-
-        finalQuery[name] = value;
-      }
-    }
-
-    if (Nife.isEmpty(finalQuery))
-      return;
-
-    Object.defineProperties(finalQuery, {
-      '_mythixQuery': {
-        writable:     false,
-        enumberable:  false,
-        configurable: false,
-        value:        true,
-      },
-    });
-
-    return finalQuery;
-  }
-
-  static getDefaultOrderBy() {
-    return [ this.getPrimaryKeyFieldName() ];
-  }
-
-  static prepareQueryOptions(conditions, _order) {
-    const Ops = Sequelize.Op;
-    let options;
-    let query;
-
-    if (conditions && Nife.isNotEmpty(conditions.where)) {
-      query = conditions.where;
-      options = Object.assign({}, conditions);
-    } else if (conditions && conditions.where !== null) {
-      query = this.prepareWhereStatement(conditions);
-    }
-
-    let order = _order;
-    if (!options && Nife.instanceOf(order, 'object')) {
-      options = Object.assign({}, order);
-      order = options.order;
-    } else if (!options) {
-      options = {};
-    }
-
-    if (Nife.isNotEmpty(query))
-      options.where = query;
-
-    if (!order && options.defaultOrder !== false) {
-      if (options.order) {
-        order = options.order;
-      } else {
-        if (typeof this.getDefaultOrderBy === 'function')
-          order = this.getDefaultOrderBy();
-        else
-          order = [ this.getPrimaryKeyFieldName() ];
-      }
-    }
-
-    options.order = order;
-    if (!Object.prototype.hasOwnProperty.call(options, 'distinct'))
-      options.distinct = true;
-
-    // If no "where" clause was specified, then grab everything
-    if (!options.where)
-      options.where = { [ this.getPrimaryKeyFieldName() ]: { [Ops.not]: null } };
-
-    if (options.debug)
-      console.log('QUERY OPTIONS: ', options);
-
-    return options;
-  }
-
-  static where(conditions) {
-    return this.prepareWhereStatement(conditions);
-  }
-
-  static async rowCount(conditions, options) {
-    return await this.count(this.prepareQueryOptions(conditions, options));
-  }
-
-  static async bulkUpdate(attrs, conditions) {
-    return await this.update(attrs, this.prepareQueryOptions(conditions, { distinct: false }));
-  }
-
-  static async all(conditions, order) {
-    return await this.findAll(this.prepareQueryOptions(conditions, order));
-  }
-
-  static async first(conditions, order) {
-    return await this.findOne(this.prepareQueryOptions(conditions, order));
-  }
-
-  static async last(conditions, _order) {
-    let order = _order;
-    if (!order)
-      order = [ [ 'createdAt', 'DESC' ] ];
-
-    return await this.first(conditions, order);
-  }
 }
 
 module.exports = {

package/src/modules/database-module.js

@@ -1,8 +1,8 @@
 'use strict';
 
-const Nife            = require('nife');
-const { Sequelize }   = require('sequelize');
-const { BaseModule }  = require('../modules/base-module');
+const Nife                = require('nife');
+const { BaseModule }      = require('../modules/base-module');
+const { ConnectionBase }  = require('mythix-orm');
 
 class DatabaseModule extends BaseModule {
   static getModuleName() {
@@ -97,31 +97,36 @@ class DatabaseModule extends BaseModule {
   }
 
   async connectToDatabase(databaseConfig) {
-    if (!databaseConfig) {
-      this.getLogger().error('Error: database connection options not defined');
-      return;
-    }
+    if (!databaseConfig)
+      throw new Error('DatabaseModule::connectToDatabase: Database connection options not defined.');
 
-    let sequelize = new Sequelize(databaseConfig);
     let dbConnectionString;
-
     if (Nife.instanceOf(databaseConfig, 'string'))
       dbConnectionString = databaseConfig;
     else
       dbConnectionString = `${databaseConfig.dialect}://${databaseConfig.host}:${databaseConfig.port || '<default port>'}/${databaseConfig.database}`;
 
     try {
-      await sequelize.authenticate();
+      let app = this.getApplication();
+      if (typeof app.createDatabaseConnection !== 'function')
+        throw new Error('DatabaseModule::connectToDatabase: You must define a "createDatabaseConnection" method on your Application class.');
 
-      this.getLogger().info(`Connection to ${dbConnectionString} has been established successfully!`);
+      let connection = await app.createDatabaseConnection(databaseConfig);
+      if (!connection)
+        throw new Error('DatabaseModule::connectToDatabase: Application::createDatabaseConnection must return a connection.');
+
+      if (!(connection instanceof ConnectionBase) && typeof connection === 'function' && connection.prototype instanceof ConnectionBase) {
+        const ConnectionKlass = connection;
+        connection = new ConnectionKlass(databaseConfig);
 
-      // SQLite needs foreign keys TURNED ON
-      // when we first connect (they default to off)
-      let dialect = sequelize.getDialect();
-      if (dialect === 'sqlite')
-        await sequelize.query('PRAGMA foreign_keys = ON');
+        await connection.start();
+      } else if (!connection.isStarted()) {
+        await connection.start();
+      }
+
+      this.getLogger().info(`Connection to ${dbConnectionString} has been established successfully!`);
 
-      return sequelize;
+      return connection;
     } catch (error) {
       this.getLogger().error(`Unable to connect to database ${dbConnectionString}:`, error);
       throw error;
@@ -146,7 +151,7 @@ class DatabaseModule extends BaseModule {
       return;
 
     this.getLogger().info('Closing database connections...');
-    await this.connection.close();
+    await this.connection.stop();
     this.getLogger().info('All database connections closed successfully!');
   }
 }