mythix 1.2.0 → 2.0.0

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!');
   }
 }

package/src/tasks/task-module.js

@@ -1,7 +1,6 @@
 'use strict';
 
 const Nife            = require('nife');
-const { Sequelize }   = require('sequelize');
 const { BaseModule }  = require('../modules/base-module');
 const {
   fileNameWithoutExtension,
@@ -85,7 +84,7 @@ class TaskModule extends BaseModule {
     let connection  = (typeof application.getDBConnection === 'function') ? application.getDBConnection() : null;
     let dbConfig    = (typeof application.getDBConfig === 'function') ? application.getDBConfig() : null;
     let tasks       = {};
-    let args        = { application: this, Sequelize, connection, dbConfig };
+    let args        = { application: this, connection, dbConfig };
 
     for (let i = 0, il = taskFiles.length; i < il; i++) {
       let taskFile = taskFiles[i];
@@ -102,15 +101,6 @@ class TaskModule extends BaseModule {
       }
     }
 
-    Object.defineProperties(tasks, {
-      '_files': {
-        writable:     true,
-        enumberable:  false,
-        configurable: true,
-        value:        taskFiles,
-      },
-    });
-
     return tasks;
   }
 

package/src/tasks/task-utils.js

@@ -83,13 +83,12 @@ class TimeHelpers {
 function defineTask(taskName, definer, _parent) {
   let parentKlass = _parent || TaskBase;
 
-  return function({ application, Sequelize, connection, dbConfig }) {
+  return function({ application, connection, dbConfig }) {
     let time = new TimeHelpers();
 
     let Klass = definer({
       Parent: parentKlass,
       application,
-      Sequelize,
       connection,
       dbConfig,
       taskName,

package/src/utils/test-utils.js

@@ -3,21 +3,16 @@
 /* global process */
 
 const Nife                  = require('nife');
+const { Utils }             = require('mythix-orm');
 const { Logger }            = require('../logger');
-const HTTPUtils             = require('./http-utils');
 const { HTTPInterface }     = require('./http-interface');
 const { DatabaseModule }    = require('../modules/database-module');
 const { HTTPServerModule }  = require('../http-server/http-server-module');
 
 class TestDatabaseModule extends DatabaseModule {
-  getDatabaseConfig() {
-    let config = super.getDatabaseConfig();
-    return Object.assign({}, config, { dialect: 'sqlite', storage: ':memory:' });
-  }
-
   getTablePrefix() {
     let prefix = super.getTablePrefix();
-    return `${prefix.replace(/_test/g, '')}_test_`.replace(/_+/g, '_');
+    return `${prefix.replace(/_test/g, '')}_test_`.replace(/_+/g, '_').replace(/\W+/g, '_');
   }
 }
 
@@ -69,9 +64,10 @@ function createTestApplication(Application) {
 
     constructor(_opts) {
       let opts = Nife.extend(true, {
-        autoReload: false,
-        runTasks:   false,
-        testMode:   true,
+        environment:  'test',
+        autoReload:   false,
+        runTasks:     false,
+        testMode:     true,
       }, _opts || {});
 
       super(opts);
@@ -103,33 +99,53 @@ function createTestApplication(Application) {
       let result = await super.start(...args);
 
       if (typeof this.getDBConnection === 'function') {
-        let dbConnection = this.getDBConnection();
-        await dbConnection.sync({ force: true, logging: false });
+        let connection = this.getDBConnection();
+        await this.createAllTables(connection);
       }
 
       return result;
     }
 
+    async createAllTables(connection) {
+      const createTable = async (connection, Model, options) => {
+        return await connection.createTable(Model, options);
+      };
+
+      let models      = connection.getModels();
+      let modelNames  = Object.keys(models);
+
+      modelNames = Utils.sortModelNamesByCreationOrder(connection, modelNames);
+
+      for (let i = 0, il = modelNames.length; i < il; i++) {
+        let modelName = modelNames[i];
+        let model     = models[modelName];
+
+        await createTable(connection, model, { ifNotExists: true });
+      }
+    }
+
     async truncateAllTables(exclude) {
-      let dbConnection  = this.getDBConnection();
-      let models        = this.getModels();
-      let modelNames    = Object.keys(models);
+      let connection  = this.getDBConnection();
+      let models      = this.getModels();
+      let modelNames  = Object.keys(models);
 
-      await dbConnection.query('PRAGMA foreign_keys = OFF');
+      modelNames = Utils.sortModelNamesByCreationOrder(connection, modelNames);
+
+      await connection.enableForeignKeyConstraints(false);
 
       try {
-        for (let i = 0, il = modelNames.length; i < il; i++) {
+        for (let i = modelNames.length - 1; i >= 0; i--) {
           let modelName = modelNames[i];
           if (exclude && exclude.indexOf(modelName) >= 0)
             continue;
 
-          let model = models[modelName];
-          await dbConnection.query(`DELETE FROM "${model.tableName}"`);
+          let Model = models[modelName];
+          await connection.truncate(Model);
         }
       } catch (error) {
         console.error('TRUNCATE ERROR: ', error);
       } finally {
-        await dbConnection.query('PRAGMA foreign_keys = ON');
+        await connection.enableForeignKeyConstraints(true);
       }
     }
 
@@ -140,36 +156,8 @@ function createTestApplication(Application) {
       try {
         let Klass = callback.call(this, OriginalModel);
 
-        const modelConverter = (model) => {
-          if (model == null)
-            return model;
-
-          if (model instanceof Array)
-            return model.map(modelConverter);
-
-          // Do a direct assign to "dataValues"
-          // "set" modifies the id
-          let newModelInstance = new Klass();
-          Object.assign(newModelInstance.dataValues, model.dataValues);
-
-          return newModelInstance;
-        };
-
-        const modelStaticBind = (name) => {
-          const originalMethod = Klass[name];
-
-          return (async function(...args) {
-            let results = await originalMethod.call(Klass, ...args);
-            return modelConverter(results);
-          }).bind(Klass);
-        };
-
-        Klass.where = modelStaticBind('where');
-        Klass.all = modelStaticBind('all');
-        Klass.first = modelStaticBind('first');
-        Klass.last = modelStaticBind('last');
-
-        models[modelName] = Klass;
+        let connection = this.getDBConnection();
+        connection.registerModel(Klass);
 
         return await runner.call(this, Klass);
       } finally {

package/.eslintrc.js

@@ -1,94 +0,0 @@
-'use strict';
-
-/* eslint-disable no-magic-numbers */
-
-module.exports = {
-  'env': {
-    'browser':  true,
-    'commonjs': true,
-    'es2021':   true,
-  },
-  'extends': [
-    'eslint:recommended',
-  ],
-  'parserOptions': {
-    'ecmaVersion': 'latest',
-  },
-  'plugins': [
-    '@spothero/eslint-plugin-spothero',
-  ],
-  'rules': {
-    '@spothero/spothero/ternary-parentheses': 'error',
-    'arrow-parens':                           'error',
-    'arrow-spacing':                          [ 'error', { before: true, after: true } ],
-    'block-scoped-var':                       'warn',
-    'block-spacing':                          'error',
-    'brace-style':                            [ 'error', '1tbs' ],
-    'camelcase':                              'warn',
-    'comma-dangle':                           [ 'error', 'always-multiline' ],
-    'comma-spacing':                          [ 'error', { before: false, after: true } ],
-    'comma-style':                            [ 'error', 'last' ],
-    'curly':                                  [ 'error', 'multi-or-nest', 'consistent' ],
-    'default-case-last':                      'error',
-    'default-param-last':                     'error',
-    'eqeqeq':                                 [ 'error', 'smart' ],
-    'func-call-spacing':                      [ 'error', 'never' ],
-    'guard-for-in':                           'error',
-    'implicit-arrow-linebreak':               [ 'error', 'beside' ],
-    'indent':                                 [ 'error', 2, { 'SwitchCase': 1 } ],
-    'jsx-quotes':                             [ 'error', 'prefer-double' ],
-    'key-spacing':                            [ 'error', { beforeColon: false, afterColon: true, mode: 'minimum', 'align': 'value' } ],
-    'keyword-spacing':                        [ 'error', { before: true, after: true } ],
-    'linebreak-style':                        [ 'error', 'unix' ],
-    'lines-between-class-members':            'error',
-    'max-classes-per-file':                   [ 'error', 3 ],
-    'new-cap':                                [ 'error', { 'properties': false } ],
-    'new-parens':                             'error',
-    'no-array-constructor':                   'warn',
-    'no-caller':                              'error',
-    'no-confusing-arrow':                     'error',
-    'no-empty':                               'warn',
-    'no-eq-null':                             0,
-    'no-eval':                                'error',
-    'no-extend-native':                       'error',
-    'no-extra-label':                         'error',
-    'no-floating-decimal':                    'error',
-    'no-global-assign':                       'error',
-    'no-implied-eval':                        'error',
-    'no-labels':                              'error',
-    'no-lone-blocks':                         'warn',
-    'no-loop-func':                           0,
-    'no-magic-numbers':                       [ 'warn', { ignoreArrayIndexes: true, ignoreDefaultValues: true, ignore: [ -1, 0, 1, 2, 16, 32, 64, 128, 256, 1024, 2048, 200, 301, 302, 400, 401, 403, 404, 500 ] } ],
-    'no-nested-ternary':                      'error',
-    'no-param-reassign':                      'error',
-    'no-promise-executor-return':             'error',
-    'no-return-assign':                       'error',
-    'no-sequences':                           'error',
-    'no-shadow':                              0,
-    'no-throw-literal':                       'warn',
-    'no-trailing-spaces':                     'error',
-    'no-unmodified-loop-condition':           'warn',
-    'no-unreachable-loop':                    'warn',
-    'no-unreachable':                         'warn',
-    'no-unused-private-class-members':        'warn',
-    'no-unused-vars':                         'warn',
-    'no-whitespace-before-property':          'error',
-    'nonblock-statement-body-position':       [ 'error', 'below' ],
-    'one-var':                                [ 'error', 'never' ],
-    'quotes':                                 [ 'error', 'single' ],
-    'radix':                                  'error',
-    'rest-spread-spacing':                    [ 'error', 'never' ],
-    'semi-spacing':                           [ 'error', { before: false, after: true } ],
-    'semi-style':                             [ 'error', 'last' ],
-    'semi':                                   'error',
-    'space-before-blocks':                    'error',
-    'space-infix-ops':                        'error',
-    'space-unary-ops':                        [ 'error', { words: false, nonwords: false } ],
-    'strict':                                 'error',
-    'switch-colon-spacing':                   [ 'error', { before: false, after: true } ],
-    'template-curly-spacing':                 'error',
-    'template-tag-spacing':                   'error',
-    'wrap-iife':                              [ 'error', 'inside' ],
-    'yoda':                                   'error',
-  },
-};

package/.vscode/settings.json

@@ -1,7 +0,0 @@
-{
-  "workbench.colorCustomizations": {
-    "activityBar.background": "#5F0A17",
-    "titleBar.activeBackground": "#840E20",
-    "titleBar.activeForeground": "#FFFBFC"
-  }
-}