mythix 1.2.0 → 2.0.2

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"
-  }
-}

package/spec/controllers/controller-utils-spec.js

@@ -1,145 +0,0 @@
-'use strict';
-
-/* global describe, it, expect */
-
-const ControllerUtils = require('../../src/controllers/controller-utils');
-
-describe('controller-utils', function() {
-  describe('buildMethodMatcher', function() {
-    it('should be able to create a method matcher', function() {
-      let matchFunc = ControllerUtils.buildMethodMatcher('*');
-      expect(matchFunc(null)).toBe(true);
-      expect(matchFunc('')).toBe(true);
-      expect(matchFunc('GET')).toBe(true);
-      expect(matchFunc('get')).toBe(true);
-      expect(matchFunc('Post')).toBe(true);
-
-      matchFunc = ControllerUtils.buildMethodMatcher([ 'GET', '*' ]);
-      expect(matchFunc('')).toBe(true);
-      expect(matchFunc('GET')).toBe(true);
-      expect(matchFunc('get')).toBe(true);
-      expect(matchFunc('Post')).toBe(true);
-
-      matchFunc = ControllerUtils.buildMethodMatcher('GET');
-      expect(matchFunc('GET')).toBe(true);
-      expect(matchFunc('get')).toBe(true);
-      expect(matchFunc('GETs')).toBe(false);
-      expect(matchFunc('post')).toBe(false);
-
-      matchFunc = ControllerUtils.buildMethodMatcher([ 'get', 'POST' ]);
-      expect(matchFunc('GET')).toBe(true);
-      expect(matchFunc('get')).toBe(true);
-      expect(matchFunc('POST')).toBe(true);
-      expect(matchFunc('head')).toBe(false);
-
-      matchFunc = ControllerUtils.buildMethodMatcher(/(get|post)/i);
-      expect(matchFunc('GET')).toBe(true);
-      expect(matchFunc('get')).toBe(true);
-      expect(matchFunc('gets')).toBe(true);
-      expect(matchFunc('POST')).toBe(true);
-      expect(matchFunc('POSTs')).toBe(true);
-      expect(matchFunc('head')).toBe(false);
-    });
-  });
-
-  describe('buildContentTypeMatcher', function() {
-    it('should be able to create a content-type matcher', function() {
-      let matcher = ControllerUtils.buildContentTypeMatcher('*');
-      expect(matcher.regexp.toString()).toBe('/.*/i');
-      expect(matcher('application/json')).toBe(true);
-      expect(matcher('anything')).toBe(true);
-      expect(matcher()).toBe(true);
-
-      matcher = ControllerUtils.buildContentTypeMatcher('application/json');
-      expect(matcher.regexp.toString()).toBe('/(application\\/json)/i');
-      expect(matcher('application/json')).toBe(true);
-      expect(matcher('application/json; charset=UTF-8')).toBe(true);
-      expect(matcher('text/plain')).toBe(false);
-
-      matcher = ControllerUtils.buildContentTypeMatcher(/^(application\/json|text\/plain)$/i);
-      expect(matcher.regexp.toString()).toBe('/^(application\\/json|text\\/plain)$/i');
-      expect(matcher('application/json')).toBe(true);
-      expect(matcher('application/json; charset=UTF-8')).toBe(false);
-      expect(matcher('text/plain')).toBe(true);
-      expect(matcher('text/plain;')).toBe(false);
-    });
-  });
-
-  describe('buildPathMatcher', function() {
-    it('should be able to build a parser from a route name', function() {
-      let matchFunc = ControllerUtils.buildPathMatcher('person<id?:integer = 0>_stuff');
-      expect(matchFunc('person120_stuff')).toEqual({ id: 120 });
-      expect(matchFunc('person_stuff')).toEqual({});
-
-      matchFunc = ControllerUtils.buildPathMatcher('objects/<id>');
-      expect(matchFunc('objects')).toBe(undefined);
-      expect(matchFunc('objects/')).toBe(undefined);
-      expect(matchFunc('objects/1')).toEqual({ id: 1 });
-
-      matchFunc = ControllerUtils.buildPathMatcher('objects/<id?>');
-      expect(matchFunc('objects')).toEqual({});
-      expect(matchFunc('objects/')).toEqual({});
-      expect(matchFunc('objects/1')).toEqual({ id: 1 });
-
-      matchFunc = ControllerUtils.buildPathMatcher('values/<truthy:boolean>');
-      expect(matchFunc('values')).toBe(undefined);
-      expect(matchFunc('values/')).toBe(undefined);
-      expect(matchFunc('values/1')).toBe(undefined);
-      expect(matchFunc('values/derp')).toBe(undefined);
-      expect(matchFunc('values/true')).toEqual({  truthy: true });
-      expect(matchFunc('values/True')).toEqual({  truthy: true });
-      expect(matchFunc('values/TRUE')).toEqual({  truthy: true });
-      expect(matchFunc('values/false')).toEqual({ truthy: false });
-      expect(matchFunc('values/False')).toEqual({ truthy: false });
-      expect(matchFunc('values/FALSE')).toEqual({ truthy: false });
-
-      matchFunc = ControllerUtils.buildPathMatcher('values/<str:magic>', { magic: (part) => `MAGIC:${part}!!!`});
-      expect(matchFunc('values')).toBe(undefined);
-      expect(matchFunc('values/')).toBe(undefined);
-      expect(matchFunc('values/1')).toEqual({ str: 'MAGIC:1!!!' });
-      expect(matchFunc('values/derp')).toEqual({ str: 'MAGIC:derp!!!' });
-    });
-  });
-
-  describe('buildRoutes', function() {
-    it('should be able to compile routes', function() {
-      // let allRoutes = ControllerUtils.buildRoutes({
-      //   'api': {
-      //     'v1': {
-      //       'test': {
-      //         methods:    [ 'GET', 'POST' ],
-      //         accept:     'application/json',
-      //         controller: 'Something.test',
-      //         children:   [
-      //           {
-      //             priority:   10,
-      //             methods:    'GET',
-      //             controller: 'Something.children.get',
-      //           },
-      //           {
-      //             priority:   11,
-      //             methods:    'POST',
-      //             controller: 'Something.children.post',
-      //           },
-      //           {
-      //             'do-something/<id:int>': {
-      //               priority:   10,
-      //               methods:    'GET',
-      //               controller: 'Something.children.get.doSomething',
-      //             },
-      //           },
-      //         ],
-      //       },
-      //       'test2': {
-      //         priority:   0,
-      //         methods:    [ 'POST', '*' ],
-      //         controller: 'Something.test2',
-      //       },
-      //     },
-      //   },
-      // });
-
-      // console.log('ALL ROUTES: ', allRoutes);
-    });
-  });
-});

package/spec/controllers/generate-client-api-interface-spec.js

@@ -1,156 +0,0 @@
-'use strict';
-
-/* global describe, it, beforeAll, expect, __dirname */
-
-const { generateClientAPIInterface }  = require('../../src/controllers/generate-client-api-interface');
-const { newTestApplication }          = require('../support/application');
-const { _matchesSnapshot }            = require('../support/snapshots');
-
-const matchesSnapshot = _matchesSnapshot.bind(this, __dirname);
-
-function getRoutes() {
-  return {
-    'api': {
-      'v1': {
-        'auth': {
-          'authenticate': [
-            {
-              'methods':    [ 'GET' ],
-              'controller': 'AuthController.authenticate',
-            },
-            {
-              'name':       'login',
-              'methods':    [ 'POST' ],
-              'accept':     [ 'application/json' ],
-              'controller': 'AuthController.authenticate',
-            },
-          ],
-          'sendMagicLink': [
-            {
-              'name':       'sendMagicLink',
-              'methods':    [ 'POST' ],
-              'accept':     [ 'application/json' ],
-              'controller': 'AuthController.sendMagicLink',
-            },
-          ],
-          'registerUser': [
-            {
-              'name':       'registerUser',
-              'methods':    [ 'POST' ],
-              'accept':     [ 'application/json' ],
-              'controller': 'AuthController.registerUser',
-            },
-          ],
-        },
-        'user': {
-          '/<userID:string>': [
-            {
-              'name':       'getUser',
-              'methods':    [ 'GET' ],
-              'accept':     [ 'application/json' ],
-              'controller': 'UserController.show',
-            },
-            {
-              'name':       'updateUser',
-              'methods':    [ 'POST', 'PATCH' ],
-              'accept':     [ 'application/json' ],
-              'controller': 'UserController.update',
-            },
-          ],
-          '/search':    {
-            'name':       'searchUsers',
-            'methods':    [ 'POST' ],
-            'accept':     [ 'application/json' ],
-            'controller': 'UserController.list',
-          },
-          '/': [
-            {
-              'name':       'getUsers',
-              'methods':    [ 'GET' ],
-              'accept':     [ 'application/json' ],
-              'controller': 'UserController.list',
-            },
-          ],
-        },
-        'organization': {
-          '/<organizationID:string>': [
-            {
-              'name':       'getOrganization',
-              'methods':    [ 'GET' ],
-              'accept':     [ 'application/json' ],
-              'controller': 'OrganizationController.show',
-            },
-            {
-              'name':       'updateOrganization',
-              'methods':    [ 'POST', 'PATCH' ],
-              'accept':     [ 'application/json' ],
-              'controller': 'OrganizationController.update',
-            },
-          ],
-          '/<organizationID:string>/inviteUser': [
-            {
-              'name':       'inviteUserToOrganization',
-              'methods':    [ 'POST' ],
-              'accept':     [ 'application/json' ],
-              'controller': 'OrganizationController.inviteUser',
-            },
-          ],
-          '/search':    {
-            'name':       'searchOrganizations',
-            'methods':    [ 'POST' ],
-            'accept':     [ 'application/json' ],
-            'controller': 'OrganizationController.list',
-          },
-          '/': [
-            {
-              'name':       'getOrganizations',
-              'methods':    [ 'GET' ],
-              'accept':     [ 'application/json' ],
-              'controller': 'OrganizationController.list',
-            },
-            {
-              'name':       'createOrganization',
-              'methods':    [ 'PUT' ],
-              'accept':     [ 'application/json' ],
-              'controller': 'OrganizationController.create',
-            },
-          ],
-        },
-      },
-    },
-  };
-}
-
-describe('generateClientAPIInterface', () => {
-  let app;
-
-  beforeAll(async () => {
-    app = await newTestApplication();
-    app.getRoutes = getRoutes.bind(app);
-  });
-
-  it('should be able to generate an interface using route definitions', () => {
-    let result = generateClientAPIInterface(app);
-    expect(matchesSnapshot('generateClientAPIInterface01', result)).toBe(true);
-  });
-
-  it('should be able to generate an interface for node', () => {
-    let result = generateClientAPIInterface(app, { environment: 'node' });
-    expect(matchesSnapshot('generateClientAPIInterface02', result)).toBe(true);
-  });
-
-  it('should be able to generate an interface for the browser', () => {
-    let result = generateClientAPIInterface(app, { environment: 'browser' });
-    expect(matchesSnapshot('generateClientAPIInterface03', result)).toBe(true);
-  });
-
-  it('should be able to export a global', () => {
-    let result = generateClientAPIInterface(app, { globalName: 'API' });
-    expect(matchesSnapshot('generateClientAPIInterface04', result)).toBe(true);
-  });
-
-  it('should be able to specify a domain', () => {
-    let result = generateClientAPIInterface(app, { domain: 'http://localhost:8080' });
-    expect(matchesSnapshot('generateClientAPIInterface05', result)).toBe(true);
-  });
-});