mythix-orm 1.0.1

package/spec/proxy-class/proxy-class-spec.js

@@ -0,0 +1,173 @@
+/* eslint-disable max-classes-per-file */
+/* eslint-disable new-cap */
+/* eslint-disable no-magic-numbers */
+
+'use strict';
+
+/* global describe, it, expect */
+
+const ProxyClass = require('../../lib/proxy-class');
+
+describe('ProxyClass', () => {
+  it('can overload getter', () => {
+    let props = [];
+    let derpCalled = false;
+    let helloCalled = false;
+
+    class ProxyTest extends ProxyClass {
+      [ProxyClass.GET](target, prop) {
+        props.push(prop);
+        return super[ProxyClass.GET].apply(this, arguments);
+      }
+
+      derp() {
+        derpCalled = true;
+      }
+
+      hello() {
+        helloCalled = true;
+      }
+    }
+
+    let test = new ProxyTest();
+    test.derp();
+    test.hello();
+
+    expect(props).toEqual([ 'derp', 'hello' ]);
+    expect(derpCalled).toBe(true);
+    expect(helloCalled).toBe(true);
+  });
+
+  it('can overload setter', () => {
+    let props = [];
+
+    class ProxyTest extends ProxyClass {
+      [ProxyClass.SET](target, prop, value, receiver) {
+        props.push(prop);
+        return super[ProxyClass.SET].apply(this, [ target, prop, `${value}_modified`, receiver ]);
+      }
+    }
+
+    let test = new ProxyTest();
+    test.derp = 'stuff';
+    test.hello = 'world';
+
+    expect(props).toEqual([ 'derp', 'hello' ]);
+    expect(test.derp).toEqual('stuff_modified');
+    expect(test.hello).toEqual('world_modified');
+  });
+
+  it('can be callable', () => {
+    let givenArgs;
+
+    class ProxyTest extends ProxyClass {
+      [ProxyClass.CALLABLE](...args) {
+        givenArgs = args;
+      }
+    }
+
+    let test = new ProxyTest();
+    test('hello', 'world');
+
+    expect(givenArgs).toEqual([ 'hello', 'world' ]);
+  });
+
+  it('can modify it to be callable', () => {
+    let givenArgs;
+
+    class ProxyTest extends ProxyClass {
+    }
+
+    let test = new ProxyTest();
+    expect(() => test('hello', 'world')).toThrow(new TypeError('test is not a function'));
+
+    test = test.__call((...args) => {
+      givenArgs = args;
+    });
+
+    test('hello', 'world');
+    expect(givenArgs).toEqual([ 'hello', 'world' ]);
+  });
+
+  it('can setup an autocaller', () => {
+    let autoCallArgs;
+    let givenArgs;
+
+    class ProxyTestResult extends ProxyClass {
+      hello() {
+        return 'world';
+      }
+    }
+
+    class ProxyTest extends ProxyClass {
+      getHello() {
+        return new ProxyTestResult().__call((...args) => {
+          givenArgs = args;
+        }).__autoCall((...args) => {
+          autoCallArgs = args;
+        });
+      }
+    }
+
+    // Should not call autocaller
+    let test = new ProxyTest();
+    test.getHello()('hello', 'world');
+
+    expect(givenArgs).toEqual([ 'hello', 'world' ]);
+    expect(autoCallArgs).toBe(undefined);
+
+    // Should call autocaller
+    givenArgs = undefined;
+    autoCallArgs = undefined;
+
+    test = new ProxyTest();
+
+    // .stuff should trigger autocall
+    let magic = test.getHello();
+    magic.stuff;
+
+    expect(givenArgs).toBe(undefined);
+    expect(autoCallArgs).toEqual([]);
+
+    // Should not call autocaller a second time
+    givenArgs = undefined;
+    autoCallArgs = undefined;
+    magic.derp;
+
+    expect(givenArgs).toBe(undefined);
+    expect(autoCallArgs).toBe(undefined);
+  });
+
+  it('can specify a method as autocall', () => {
+    let givenArgs;
+    let callCount = 0;
+
+    class ProxyTest extends ProxyClass {
+      NOT = ProxyClass.autoCall(function(...args) {
+        callCount++;
+        givenArgs = args;
+      });
+    }
+
+    // Should not be called just by fetching the method name
+    let test = new ProxyTest();
+    test.NOT;
+
+    expect(callCount).toEqual(0);
+
+    // Should be called once when called directly
+    callCount = 0;
+
+    test.NOT('hello', 'world');
+    expect(callCount).toEqual(1);
+    expect(givenArgs).toEqual([ 'hello', 'world' ]);
+
+    // Should be called once when called indirectly
+    callCount = 0;
+    givenArgs = undefined;
+
+    test.NOT.derp;
+    expect(callCount).toEqual(1);
+    expect(givenArgs).toEqual([]);
+  });
+});

package/spec/query-engine/__snapshots__/QueryEngine-operations-query_operations_and_chaining-can_chain_query_conditions-001.snapshot

@@ -0,0 +1,94 @@
+[
+  {
+    "operator": "MODEL",
+    "modelName": "User",
+    "dialect": "none",
+    "rootModelName": "User",
+    "currentScopeName": "model"
+  },
+  {
+    "operator": "FIELD",
+    "fieldName": "id",
+    "Field": {
+      "type": {},
+      "allowNull": false,
+      "primaryKey": true,
+      "fieldName": "id",
+      "columnName": "id"
+    },
+    "rootFieldName": "id",
+    "rootField": {
+      "type": {},
+      "allowNull": false,
+      "primaryKey": true,
+      "fieldName": "id",
+      "columnName": "id"
+    },
+    "currentScopeName": "field"
+  },
+  {
+    "value": 1,
+    "condition": true,
+    "operator": "EQ",
+    "inverseOperator": "NEQ"
+  },
+  {
+    "logical": true,
+    "operator": "AND",
+    "and": true,
+    "or": false,
+    "not": false
+  },
+  {
+    "operator": "FIELD",
+    "fieldName": "firstName",
+    "Field": {
+      "type": {
+        "length": 64
+      },
+      "allowNull": true,
+      "index": true,
+      "fieldName": "firstName",
+      "columnName": "firstName"
+    },
+    "currentScopeName": "field"
+  },
+  {
+    "value": "Test",
+    "condition": true,
+    "operator": "EQ",
+    "inverseOperator": "NEQ"
+  },
+  {
+    "logical": true,
+    "operator": "AND",
+    "and": true,
+    "or": false,
+    "not": false
+  },
+  {
+    "logical": true,
+    "operator": "NOT",
+    "not": true
+  },
+  {
+    "operator": "FIELD",
+    "fieldName": "lastName",
+    "Field": {
+      "type": {
+        "length": 64
+      },
+      "allowNull": true,
+      "index": true,
+      "fieldName": "lastName",
+      "columnName": "lastName"
+    },
+    "currentScopeName": "field"
+  },
+  {
+    "value": "Stuff",
+    "condition": true,
+    "operator": "EQ",
+    "inverseOperator": "NEQ"
+  }
+]

package/spec/query-engine/__snapshots__/QueryEngine-operations-query_operations_and_chaining-can_construct_a_query_context_with_a_model_call-001.snapshot

@@ -0,0 +1,35 @@
+[
+  {
+    "operator": "MODEL",
+    "modelName": "User",
+    "dialect": "none",
+    "rootModelName": "User",
+    "currentScopeName": "model"
+  },
+  {
+    "operator": "FIELD",
+    "fieldName": "id",
+    "Field": {
+      "type": {},
+      "allowNull": false,
+      "primaryKey": true,
+      "fieldName": "id",
+      "columnName": "id"
+    },
+    "rootFieldName": "id",
+    "rootField": {
+      "type": {},
+      "allowNull": false,
+      "primaryKey": true,
+      "fieldName": "id",
+      "columnName": "id"
+    },
+    "currentScopeName": "field"
+  },
+  {
+    "value": "test",
+    "condition": true,
+    "operator": "EQ",
+    "inverseOperator": "NEQ"
+  }
+]

package/spec/query-engine/__snapshots__/QueryEngine-operations-query_operations_and_chaining-can_construct_a_query_context_with_a_model_sub-001.snapshot

@@ -0,0 +1,35 @@
+[
+  {
+    "operator": "MODEL",
+    "modelName": "User",
+    "dialect": "none",
+    "rootModelName": "User",
+    "currentScopeName": "model"
+  },
+  {
+    "operator": "FIELD",
+    "fieldName": "id",
+    "Field": {
+      "type": {},
+      "allowNull": false,
+      "primaryKey": true,
+      "fieldName": "id",
+      "columnName": "id"
+    },
+    "rootFieldName": "id",
+    "rootField": {
+      "type": {},
+      "allowNull": false,
+      "primaryKey": true,
+      "fieldName": "id",
+      "columnName": "id"
+    },
+    "currentScopeName": "field"
+  },
+  {
+    "value": "test",
+    "condition": true,
+    "operator": "EQ",
+    "inverseOperator": "NEQ"
+  }
+]

package/spec/query-engine/__snapshots__/QueryEngine-operations-query_operations_and_chaining-can_set_a_default_scope_on_a_model-001.snapshot

@@ -0,0 +1,57 @@
+[
+  {
+    "operator": "MODEL",
+    "modelName": "ScopedUser",
+    "dialect": "none",
+    "rootModelName": "ScopedUser",
+    "currentScopeName": "model"
+  },
+  {
+    "operator": "FIELD",
+    "fieldName": "firstName",
+    "Field": {
+      "type": {
+        "length": 64
+      },
+      "allowNull": true,
+      "index": true,
+      "fieldName": "firstName",
+      "columnName": "firstName"
+    },
+    "rootFieldName": "firstName",
+    "rootField": {
+      "type": {
+        "length": 64
+      },
+      "allowNull": true,
+      "index": true,
+      "fieldName": "firstName",
+      "columnName": "firstName"
+    },
+    "currentScopeName": "field"
+  },
+  {
+    "value": "Bob",
+    "condition": true,
+    "operator": "EQ",
+    "inverseOperator": "NEQ"
+  },
+  {
+    "operator": "FIELD",
+    "fieldName": "id",
+    "Field": {
+      "type": {},
+      "allowNull": false,
+      "primaryKey": true,
+      "fieldName": "id",
+      "columnName": "id"
+    },
+    "currentScopeName": "field"
+  },
+  {
+    "value": "test",
+    "condition": true,
+    "operator": "EQ",
+    "inverseOperator": "NEQ"
+  }
+]

package/spec/query-engine/__snapshots__/QueryEngine-operations-query_operations_and_chaining-can_unscope_default_scope_on_a_model-001.snapshot

@@ -0,0 +1,35 @@
+[
+  {
+    "operator": "MODEL",
+    "modelName": "ScopedUser",
+    "dialect": "none",
+    "rootModelName": "ScopedUser",
+    "currentScopeName": "model"
+  },
+  {
+    "operator": "FIELD",
+    "fieldName": "id",
+    "Field": {
+      "type": {},
+      "allowNull": false,
+      "primaryKey": true,
+      "fieldName": "id",
+      "columnName": "id"
+    },
+    "rootFieldName": "id",
+    "rootField": {
+      "type": {},
+      "allowNull": false,
+      "primaryKey": true,
+      "fieldName": "id",
+      "columnName": "id"
+    },
+    "currentScopeName": "field"
+  },
+  {
+    "value": "test",
+    "condition": true,
+    "operator": "EQ",
+    "inverseOperator": "NEQ"
+  }
+]

package/spec/query-engine/query-engine-spec.js

@@ -0,0 +1,99 @@
+/* eslint-disable no-magic-numbers */
+
+'use strict';
+
+/* global describe, it, expect, beforeAll */
+
+const Nife = require('nife');
+const { ConnectionBase, QueryEngine } = require('../../lib');
+const matchesSnapshot = require('../support/snapshots');
+
+describe('QueryEngine', () => {
+  let connection;
+  let User;
+  let ScopedUser;
+
+  beforeAll(() => {
+    connection = new ConnectionBase({
+      bindModels: false,
+      models:     require('../support/models'),
+    });
+
+    let models = connection.getModels();
+    User = models.User;
+    ScopedUser = models.ScopedUser;
+  });
+
+  const getFilteredContext = (parts) => {
+    return parts.map((part) => {
+      return Object.assign({}, part, {
+        contextID:    undefined,
+        modelContext: undefined,
+        fieldContext: undefined,
+      });
+    });
+  };
+
+  // fdescribe('operations', () => {
+  //   it('can live happily without a connection', () => {
+  //     expect((new QueryEngine().User.id('derp'))._getRawQuery()).toBe([ ]);
+  //   });
+  // });
+
+  describe('isQueryContext', () => {
+    it('can validly detect a query context', () => {
+      expect(QueryEngine.isQueryContext({})).toBe(false);
+      expect(QueryEngine.isQueryContext(User.where)).toBe(false);
+      expect(QueryEngine.isQueryContext(User.where._getRawQueryContext())).toBe(true);
+    });
+  });
+
+  describe('queryContextType', () => {
+    it('can validly detect a query context type', () => {
+      expect(QueryEngine.queryContextType(User.where._getRawQueryContext())).toEqual({
+        hasCondition: false,
+        hasField:     false,
+        hasModel:     true,
+      });
+
+      expect(QueryEngine.queryContextType(User.where.id._getRawQueryContext())).toEqual({
+        hasCondition: false,
+        hasField:     true,
+        hasModel:     true,
+      });
+
+      expect(QueryEngine.queryContextType(User.where.id.EQ('test')._getRawQueryContext())).toEqual({
+        hasCondition: true,
+        hasField:     true,
+        hasModel:     true,
+      });
+    });
+  });
+
+  describe('query operations and chaining', () => {
+    it('can set a default scope on a model', () => {
+      let context = ScopedUser.where.id.EQ('test')._getRawQuery();
+      expect(matchesSnapshot(getFilteredContext(context))).toEqual(true);
+    });
+
+    it('can unscope default scope on a model', () => {
+      let context = ScopedUser.where.unscoped().id.EQ('test')._getRawQuery();
+      expect(matchesSnapshot(getFilteredContext(context))).toEqual(true);
+    });
+
+    it('can construct a query context with a model sub-key', () => {
+      let context = User.where.id.EQ('test')._getRawQuery();
+      expect(matchesSnapshot(getFilteredContext(context))).toEqual(true);
+    });
+
+    it('can construct a query context with a model call', () => {
+      let context = User.where('id').EQ('test')._getRawQuery();
+      expect(matchesSnapshot(getFilteredContext(context))).toEqual(true);
+    });
+
+    it('can chain query conditions', () => {
+      let context = User.where.id.EQ(1).AND.firstName.EQ('Test').AND.NOT.lastName.EQ('Stuff')._getRawQuery();
+      expect(matchesSnapshot(getFilteredContext(context))).toEqual(true);
+    });
+  });
+});

package/spec/support/jasmine.json

@@ -0,0 +1,13 @@
+{
+  "spec_dir": "spec",
+  "spec_files": [
+    "**/*[sS]pec.?(m)js"
+  ],
+  "helpers": [
+    "helpers/**/*.?(m)js"
+  ],
+  "env": {
+    "stopSpecOnExpectationFailure": false,
+    "random": true
+  }
+}

package/spec/support/models/blob-test-model.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const { Model, Types } = require('../../../lib');
+
+class BlobTest extends Model {
+  static fields = {
+    'id': {
+      type:         Types.UUIDV4,
+      defaultValue: Types.UUIDV4.Default.UUIDV4,
+      allowNull:    false,
+      primaryKey:   true,
+    },
+    'data': {
+      type:       Types.BLOB,
+    },
+  };
+}
+
+module.exports = BlobTest;

package/spec/support/models/extended-user-model.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const { Types } = require('../../../lib');
+const User      = require('./user-model');
+
+class ExtendedUser extends User {
+  static fields = User.mergeFields({
+    'id': {
+      type:         Types.INTEGER,
+      defaultValue: Types.INTEGER.Default.AUTO_INCREMENT,
+      primaryKey:   true,
+      allowNull:    false,
+      unique:       true, // should be ignored when create table query is generated
+    },
+    'createdAt': {
+      type:         Types.DATETIME(null, 'MM.DD.YYYY HH:mm:ss'),
+      defaultValue: Types.DATETIME.Default.NOW,
+      allowNull:    false,
+    },
+    'updatedAt': {
+      type:         Types.DATETIME(null, 'MM.DD.YYYY HH:mm:ss'),
+      defaultValue: Types.DATETIME.Default.NOW.UPDATE,
+      allowNull:    false,
+    },
+    'email': {
+      type:         Types.STRING(256),
+      allowNull:    false,
+      unique:       true,
+    },
+    'playerType': {
+      type:         Types.STRING(256),
+      defaultValue: 'wizard',
+      allowNull:    false,
+    },
+  });
+}
+
+module.exports = ExtendedUser;

package/spec/support/models/index.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const BlobTest        = require('./blob-test-model');
+const ExtendedUser    = require('./extended-user-model');
+const Number          = require('./number-model');
+const Role            = require('./role-model');
+const RoleThing       = require('./role-thing-model');
+const ScopedUser      = require('./scoped-user-model');
+const User            = require('./user-model');
+const UserRole        = require('./user-role-model');
+const UserThing       = require('./user-thing-model');
+const ValidationTest  = require('./validation-test-model');
+const Time            = require('./time-model');
+
+module.exports = {
+  BlobTest,
+  ExtendedUser,
+  Number,
+  Role,
+  RoleThing,
+  ScopedUser,
+  User,
+  UserRole,
+  UserThing,
+  ValidationTest,
+  Time,
+};

package/spec/support/models/number-model.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const { Model, Types } = require('../../../lib');
+
+class Number extends Model {
+  static fields = {
+    'id': {
+      type:         Types.UUIDV4,
+      defaultValue: Types.UUIDV4.Default.UUIDV4,
+      allowNull:    false,
+      primaryKey:   true,
+    },
+    'numberInt': {
+      type:         Types.INTEGER,
+      index:        true,
+    },
+    'numberFloat': {
+      type:         Types.FLOAT,
+      index:        true,
+    },
+  };
+}
+
+module.exports = Number;

package/spec/support/models/role-model.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const { Model, Types } = require('../../../lib');
+
+class Role extends Model {
+  static fields = {
+    'id': {
+      type:         Types.UUIDV4,
+      defaultValue: Types.UUIDV4.Default.UUIDV4,
+      allowNull:    false,
+      primaryKey:   true,
+    },
+    'name': {
+      type:         Types.STRING(64),
+      allowNull:    false,
+      index:        true,
+    },
+    'user': {
+      type:         Types.Model('User', ({ User, self }) => {
+        return User.$.primaryRoleID.EQ(self.primaryRoleID);
+      }),
+    },
+  };
+}
+
+module.exports = Role;