mythix-orm 1.0.1

package/lib/utils/query-utils.js

@@ -0,0 +1,186 @@
+'use strict';
+
+const Nife = require('nife');
+
+// The code below will take a "query object"
+// and convert it into Mythix ORM query.
+//
+// "query objects" are objects with a simple
+// structure and convention to build complex queries.
+//
+// Fields inside these objects can have operators,
+// which are postfixed to the field name. For example,
+// you could create a filter to find a user by name
+// with the following query object:
+// { "firstName=": "John", "lastName!=": "Bob" }
+// which would find all users with the first name
+// of "John", and any last name except "Bob".
+//
+// AND and OR conditions are also supported. These
+// work based of the structure of the object itself.
+// If an array is used, then OR is in effect.
+// If an object is used, then AND is in effect.
+// For example, the following query object:
+// [ { firstName: "John", lastName: "Brown" }, { firstName: "Mary", lastName: "Smith" } ]
+// would result in the following query:
+// WHERE ((firstName = 'John' AND lastName = 'Brown') OR (firstName = 'Mary' AND lastName = 'Smith')),
+// finding either user John Brown, or Mary Smith.
+//
+// IN and NOT IN operators are handled automatically
+// when the operator is either "=" or "!=", and the
+// provided value is an array. For example:
+// { firstName: [ 'John', 'Bob', 'Mary' ] }
+// would result in the following query:
+// WHERE firstName IN ('John', 'Bob', 'Mary')
+
+const FILTER_OPERATORS = {
+  '=':  (Model, fieldName, query, value) => {
+    return query.AND[fieldName].EQ(value);
+  },
+  '!=': (Model, fieldName, query, value) => {
+    return query.AND[fieldName].NEQ(value);
+  },
+  '>':  (Model, fieldName, query, value) => {
+    return query.AND[fieldName].GT(value);
+  },
+  '>=': (Model, fieldName, query, value) => {
+    return query.AND[fieldName].GTE(value);
+  },
+  '<':  (Model, fieldName, query, value) => {
+    return query.AND[fieldName].LT(value);
+  },
+  '<=': (Model, fieldName, query, value) => {
+    return query.AND[fieldName].LTE(value);
+  },
+  // Between
+  '><': (Model, fieldName, query, value) => {
+    return query.AND(Model.where[fieldName].GTE(value[0]).AND[fieldName].LTE(value[1]));
+  },
+  // Not between
+  '<>': (Model, fieldName, query, value) => {
+    return query.AND(Model.where[fieldName].LT(value[0]).OR[fieldName].GT(value[1]));
+  },
+  // Like (TODO: Mythix ORM needs to support this)
+  '*':  (Model, fieldName, query, value) => {
+    return query.EQ(value);
+  },
+  // NOT Like (TODO: Mythix ORM needs to support this)
+  '!*': (Model, fieldName, query, value) => {
+    return query.EQ(value);
+  },
+};
+
+function parseFilterFieldAndOperator(fieldName) {
+  let operator = '=';
+  let field;
+
+  ('' + fieldName).replace(/^\s*(\w+)\s*(.*)$/, (m, _field, _operator) => {
+    field = _field.trim();
+
+    if (Nife.isNotEmpty(_operator))
+      operator = _operator.trim();
+  });
+
+  if (Nife.isEmpty(field))
+    throw new Error('generateQueryFromFilter: "field" is blank');
+
+  if (!Object.prototype.hasOwnProperty.call(FILTER_OPERATORS, operator))
+    throw new Error(`generateQueryFromFilter: Unknown operator "${operator}"`);
+
+  return { field, operator };
+}
+
+function generateQueryFromFilter(connection, Model, _filter, _depth) {
+  const getOperator = (name) => {
+    let func = FILTER_OPERATORS[name];
+    if (!func)
+      throw new Error(`generateQueryFromFilter: No such operator "${name}"`);
+
+    return func;
+  };
+
+  let filter  = _filter;
+  let query   = Model.where(connection);
+  let depth   = _depth || 0;
+
+  // [ { id: 1 }, { name: 'derp' }, [ { 'dob>=': '2000-01-01', 'role': [ 'person', 'dog' ] } ] ]...
+  //   SQL = `id = 1 OR name = 'derp' OR (dob >= '2000-01-01' AND role IN [ 'person', 'dog' ])`
+
+  // If filter provided is a mythix model,
+  // then convert the model attributes to
+  // an object so we can iterate the attributes
+  if (!Nife.instanceOf(filter, 'array', 'object', 'set', 'map')) {
+    if (Model.isModel(filter)) {
+      let pkFieldName     = filter.getPrimaryKeyFieldName();
+      let primaryKeyValue = filter[pkFieldName];
+
+      if (pkFieldName && primaryKeyValue != null)
+        filter = { [pkFieldName]: primaryKeyValue };
+      else
+        filter = filter.toJSON();
+    } else {
+      return;
+    }
+  }
+
+  Nife.iterate(filter, ({ key, value: _value, type }) => {
+    let isArrayType = (type === 'Array' || type === 'Set');
+    let fieldName   = (isArrayType) ? null : key;
+    let value       = _value;
+
+    if (isArrayType && value == null)
+      return;
+
+    if (value === undefined)
+      return;
+
+    if (isArrayType && (Nife.instanceOf(value, 'array', 'object', 'set', 'map') || Model.isModel(value))) {
+      query = query.OR(generateQueryFromFilter(connection, Model, value, depth + 1));
+    } else {
+      let {
+        field,
+        operator,
+      } = parseFilterFieldAndOperator(fieldName);
+
+      if (!field)
+        return;
+
+      let modelField = Model.getField(field);
+      if (!modelField || modelField.type.isVirtual())
+        return;
+
+      let queryOperator = getOperator(operator);
+
+      if (operator !== '<>' && operator !== '><' && Nife.instanceOf(value, 'array', 'set')) {
+        if (Nife.instanceOf(value, 'set'))
+          value = Array.from(value.values());
+
+        value = value.filter((v) => Nife.isNotEmpty(v));
+
+        if (Nife.isEmpty(value))
+          return;
+
+        if (operator === '=' || operator === '!=')
+          queryOperator = getOperator(operator);
+        else
+          throw new Error(`Invalid array value for operator "${operator}"`);
+      }
+
+      if (value === null) {
+        if (operator === '=' || operator === '!=')
+          queryOperator = getOperator(operator);
+        else
+          throw new Error(`Invalid "NULL" value for operator "${operator}"`);
+      }
+
+      query = queryOperator(Model, field, query, value);
+    }
+  });
+
+  return query;
+}
+
+module.exports = {
+  parseFilterFieldAndOperator,
+  generateQueryFromFilter,
+};

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "mythix-orm",
+  "version": "1.0.1",
+  "description": "ORM for Mythix framework",
+  "main": "lib/index.js",
+  "type": "commonjs",
+  "scripts": {
+    "coverage": "clear ; node ./node_modules/.bin/nyc ./node_modules/.bin/jasmine",
+    "test": "node ./node_modules/.bin/jasmine",
+    "test-debug": "node --inspect-brk ./node_modules/.bin/jasmine",
+    "test-watch": "watch 'clear ; node ./node_modules/.bin/jasmine' . --wait=2 --interval=1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/th317erd/mythix-orm.git"
+  },
+  "keywords": [
+    "orm",
+    "mysql",
+    "postgres",
+    "postgresql",
+    "mssql",
+    "mongo",
+    "snowflake",
+    "database",
+    "sql",
+    "no-sql"
+  ],
+  "author": "Wyatt Greenway",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/th317erd/mythix-orm/issues"
+  },
+  "homepage": "https://github.com/th317erd/mythix-orm#readme",
+  "devDependencies": {
+    "@spothero/eslint-plugin-spothero": "github:spothero/eslint-plugin-spothero",
+    "better-sqlite3": "^7.6.2",
+    "colors": "^1.4.0",
+    "diff": "^5.1.0",
+    "eslint": "^8.13.0",
+    "jasmine": "^4.1.0",
+    "nyc": "^15.1.0"
+  },
+  "dependencies": {
+    "events": "^3.3.0",
+    "inflection": "^1.13.2",
+    "moment": "^2.29.3",
+    "nife": "^1.11.2",
+    "sqlstring": "^2.3.3",
+    "uuid": "^8.3.2",
+    "xid-js": "^1.0.1"
+  },
+  "nyc": {
+    "reporter": [
+      "text",
+      "html"
+    ],
+    "exclude": [
+      "spec/**",
+      "lib/proxy-class/proxy-class.js"
+    ]
+  }
+}

package/playground/test01.js

@@ -0,0 +1,15 @@
+'use strict';
+
+class _Test {
+
+}
+
+const Test = new Proxy(_Test, {
+  set(obj, prop, value) {
+    console.log('Setting: ', obj, prop, value);
+  },
+});
+
+class Test2 extends Test {
+  fields = { derp: true };
+}

package/spec/connection/connection-base-spec.js

@@ -0,0 +1,126 @@
+/* eslint-disable no-magic-numbers */
+
+'use strict';
+
+/* global describe, it, expect, beforeAll, fail, spyOn */
+
+const { Model, ConnectionBase, Types } = require('../../lib');
+const { User } = require('../support/models');
+
+class TestModel extends Model {
+  static fields = {
+    'id': {
+      type:         Types.UUIDV4,
+      defaultValue: Types.UUIDV4.Default.UUIDV4,
+      allowNull:    false,
+      primaryKey:   true,
+    },
+    'firstName': {
+      type:         Types.STRING(64),
+      allowNull:    true,
+      index:        true,
+    },
+    'lastName': {
+      type:         Types.STRING(64),
+      allowNull:    true,
+      index:        true,
+    },
+  };
+}
+
+describe('ConnectionBase', () => {
+  let connection;
+
+  beforeAll(() => {
+    try {
+      connection = new ConnectionBase({ models: [ TestModel ] });
+    } catch (error) {
+      console.error('Error in BeforeAll: ', error);
+    }
+  });
+
+  describe('Model', () => {
+    describe('where', () => {
+      it('should be able to get a query engine from where', () => {
+        expect(User.where(connection)._getRawQuery()[0].rootModelName).toEqual('User');
+        expect(User.where(connection)._getRawQuery()[0].Model.getModelName()).toEqual('User');
+      });
+    });
+
+    describe('getUnscopedQueryEngine', () => {
+      it('should be able to get a query engine from getUnscopedQueryEngine', () => {
+        let user = new TestModel();
+
+        expect(user.getUnscopedQueryEngine()._getRawQuery()[0].rootModelName).toEqual('TestModel');
+        expect(user.getUnscopedQueryEngine()._getRawQuery()[0].Model.getModelName()).toEqual('TestModel');
+      });
+    });
+
+    describe('getQueryEngine', () => {
+      it('should be able to get a query engine from getQueryEngine', () => {
+        let user = new TestModel();
+
+        expect(user.getQueryEngine()._getRawQuery()[0].rootModelName).toEqual('TestModel');
+        expect(user.getQueryEngine()._getRawQuery()[0].Model.getModelName()).toEqual('TestModel');
+      });
+    });
+  });
+
+  describe('getModel', () => {
+    it('should be able to get a model by name', () => {
+      let model = connection.getModel('TestModel');
+      expect(model.getModelName()).toEqual('TestModel');
+    });
+
+    it('should be able to get a model by a fully qualified name', () => {
+      let model = connection.getModel('TestModel:id');
+      expect(model.getModelName()).toEqual('TestModel');
+
+      model = connection.getModel('TestModel::id.field');
+      expect(model.getModelName()).toEqual('TestModel');
+
+      model = connection.getModel('TestModel::');
+      expect(model.getModelName()).toEqual('TestModel');
+    });
+  });
+
+  describe('getField', () => {
+    it('should fail if model not defined', () => {
+      let field = connection.getField('firstName');
+      expect(field).toBe(undefined);
+    });
+
+    it('should be able to get a field by name', () => {
+      let field = connection.getField('firstName', 'TestModel');
+      expect(field.fieldName).toEqual('firstName');
+      expect(field.Model.getModelName()).toEqual('TestModel');
+    });
+
+    it('should be able to get a field by a fully qualified name', () => {
+      let field = connection.getField('TestModel:firstName');
+      expect(field.fieldName).toEqual('firstName');
+      expect(field.Model.getModelName()).toEqual('TestModel');
+    });
+  });
+
+  describe('start', () => {
+    it('should throw an unimplemented error', async () => {
+      try {
+        await connection.start();
+        fail('unreachable');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect(error.message).toEqual('ConnectionBase::start: Child class is required to implement "start".');
+      }
+    });
+  });
+
+  describe('stop', () => {
+    it('should unbind all event listeners', async () => {
+      spyOn(connection, 'removeAllListeners').and.callThrough();
+      await connection.stop();
+
+      expect(connection.removeAllListeners.calls.count()).toEqual(1);
+    });
+  });
+});

package/spec/connection/literals/average-literal-spec.js

@@ -0,0 +1,45 @@
+/* eslint-disable no-magic-numbers */
+
+'use strict';
+
+/* global describe, it, expect, beforeAll */
+
+const ConnectionBase              = require('../../../lib/connection/connection-base');
+const { AverageLiteral, Literal } = require('../../../lib/connection/literals');
+
+describe('AverageLiteral', () => {
+  let connection;
+  let User;
+
+  beforeAll(async () => {
+    try {
+      connection = new ConnectionBase({
+        bindModels: false,
+        models:     require('../../support/models'),
+      });
+
+      let models = connection.getModels();
+      User = models.User;
+    } catch (error) {
+      console.error('Error in beforeAll: ', error);
+    }
+  });
+
+  describe('toString', () => {
+    it('can turn a fully qualified name into a min projection', () => {
+      expect((new AverageLiteral('User:id')).toString(connection)).toEqual('AVG("users"."id")');
+    });
+
+    it('will throw an exception if no field is present', () => {
+      expect(() => (new AverageLiteral()).toString(connection)).toThrow(new TypeError('AverageLiteral::fullyQualifiedNameToDefinition: Unable to find field for fully qualified name "undefined".'));
+    });
+
+    it('can turn a raw field into a projection field', () => {
+      expect((new AverageLiteral(User.fields.firstName)).toString(connection)).toEqual('AVG("users"."firstName")');
+    });
+
+    it('can provide a SQL literal', () => {
+      expect((new AverageLiteral(new Literal('test'))).toString(connection)).toEqual('AVG(test)');
+    });
+  });
+});

package/spec/connection/literals/count-literal-spec.js

@@ -0,0 +1,42 @@
+/* eslint-disable no-magic-numbers */
+
+'use strict';
+
+/* global describe, it, expect, beforeAll */
+
+const ConnectionBase            = require('../../../lib/connection/connection-base');
+const { CountLiteral, Literal } = require('../../../lib/connection/literals');
+
+describe('CountLiteral', () => {
+  let connection;
+  let User;
+
+  beforeAll(async () => {
+    connection = new ConnectionBase({
+      bindModels: false,
+      models:     require('../../support/models'),
+    });
+
+    let models = connection.getModels();
+
+    User = models.User;
+  });
+
+  describe('toString', () => {
+    it('can turn a fully qualified name into a count projection', () => {
+      expect((new CountLiteral('User:id')).toString(connection)).toEqual('COUNT("users"."id")');
+    });
+
+    it('will default to star if no field is present', () => {
+      expect((new CountLiteral()).toString(connection)).toEqual('COUNT(*)');
+    });
+
+    it('can turn a raw field into a projection field', () => {
+      expect((new CountLiteral(User.fields.firstName)).toString(connection)).toEqual('COUNT("users"."firstName")');
+    });
+
+    it('can provide a SQL literal', () => {
+      expect((new CountLiteral(new Literal('test'))).toString(connection)).toEqual('COUNT(test)');
+    });
+  });
+});

package/spec/connection/literals/distinct-literal-spec.js

@@ -0,0 +1,42 @@
+/* eslint-disable no-magic-numbers */
+
+'use strict';
+
+/* global describe, it, expect, beforeAll */
+
+const ConnectionBase                = require('../../../lib/connection/connection-base');
+const { DistinctLiteral, Literal }  = require('../../../lib/connection/literals');
+
+describe('DistinctLiteral', () => {
+  let connection;
+  let User;
+
+  beforeAll(async () => {
+    connection = new ConnectionBase({
+      bindModels: false,
+      models:     require('../../support/models'),
+    });
+
+    let models = connection.getModels();
+
+    User = models.User;
+  });
+
+  describe('toString', () => {
+    it('can turn a fully qualified name into a projection field', () => {
+      expect((new DistinctLiteral('User:id')).toString(connection)).toEqual('DISTINCT "users"."id" AS "User:id"');
+    });
+
+    it('will throw an exception if no field is present', () => {
+      expect(() => (new DistinctLiteral()).toString(connection)).toThrow(new TypeError('DistinctLiteral::fullyQualifiedNameToDefinition: Unable to find field for fully qualified name "undefined".'));
+    });
+
+    it('can turn a raw field into a projection field', () => {
+      expect((new DistinctLiteral(User.fields.firstName)).toString(connection)).toEqual('DISTINCT "users"."firstName" AS "User:firstName"');
+    });
+
+    it('can provide a SQL literal', () => {
+      expect((new DistinctLiteral(new Literal('test'))).toString(connection)).toEqual('DISTINCT test');
+    });
+  });
+});

package/spec/connection/literals/literal-spec.js

@@ -0,0 +1,26 @@
+/* eslint-disable no-magic-numbers */
+
+'use strict';
+
+/* global describe, it, expect, beforeAll */
+
+const ConnectionBase  = require('../../../lib/connection/connection-base');
+const { Literal }     = require('../../../lib/connection/literals');
+
+describe('Literal', () => {
+  let connection;
+
+  beforeAll(async () => {
+    connection = new ConnectionBase({
+      bindModels: false,
+      models:     require('../../support/models'),
+    });
+  });
+
+  describe('toString', () => {
+    it('can return anything as a literal', () => {
+      expect((new Literal('test')).toString(connection)).toEqual('test');
+      expect((new Literal('DERP(stuff)')).toString(connection)).toEqual('DERP(stuff)');
+    });
+  });
+});

package/spec/connection/literals/max-literal-spec.js

@@ -0,0 +1,42 @@
+/* eslint-disable no-magic-numbers */
+
+'use strict';
+
+/* global describe, it, expect, beforeAll */
+
+const ConnectionBase          = require('../../../lib/connection/connection-base');
+const { MaxLiteral, Literal } = require('../../../lib/connection/literals');
+
+describe('MaxLiteral', () => {
+  let connection;
+  let User;
+
+  beforeAll(async () => {
+    connection = new ConnectionBase({
+      bindModels: false,
+      models:     require('../../support/models'),
+    });
+
+    let models = connection.getModels();
+
+    User = models.User;
+  });
+
+  describe('toString', () => {
+    it('can turn a fully qualified name into a min projection', () => {
+      expect((new MaxLiteral('User:id')).toString(connection)).toEqual('MAX("users"."id")');
+    });
+
+    it('will throw an exception if no field is present', () => {
+      expect(() => (new MaxLiteral()).toString(connection)).toThrow(new TypeError('MaxLiteral::fullyQualifiedNameToDefinition: Unable to find field for fully qualified name "undefined".'));
+    });
+
+    it('can turn a raw field into a projection field', () => {
+      expect((new MaxLiteral(User.fields.firstName)).toString(connection)).toEqual('MAX("users"."firstName")');
+    });
+
+    it('can provide a SQL literal', () => {
+      expect((new MaxLiteral(new Literal('test'))).toString(connection)).toEqual('MAX(test)');
+    });
+  });
+});

package/spec/connection/literals/min-literal-spec.js

@@ -0,0 +1,42 @@
+/* eslint-disable no-magic-numbers */
+
+'use strict';
+
+/* global describe, it, expect, beforeAll */
+
+const ConnectionBase          = require('../../../lib/connection/connection-base');
+const { MinLiteral, Literal } = require('../../../lib/connection/literals');
+
+describe('MinLiteral', () => {
+  let connection;
+  let User;
+
+  beforeAll(async () => {
+    connection = new ConnectionBase({
+      bindModels: false,
+      models:     require('../../support/models'),
+    });
+
+    let models = connection.getModels();
+
+    User = models.User;
+  });
+
+  describe('toString', () => {
+    it('can turn a fully qualified name into a min projection', () => {
+      expect((new MinLiteral('User:id')).toString(connection)).toEqual('MIN("users"."id")');
+    });
+
+    it('will throw an exception if no field is present', () => {
+      expect(() => (new MinLiteral()).toString(connection)).toThrow(new TypeError('MinLiteral::fullyQualifiedNameToDefinition: Unable to find field for fully qualified name "undefined".'));
+    });
+
+    it('can turn a raw field into a projection field', () => {
+      expect((new MinLiteral(User.fields.firstName)).toString(connection)).toEqual('MIN("users"."firstName")');
+    });
+
+    it('can provide a SQL literal', () => {
+      expect((new MinLiteral(new Literal('test'))).toString(connection)).toEqual('MIN(test)');
+    });
+  });
+});

package/spec/connection/literals/sum-literal-spec.js

@@ -0,0 +1,42 @@
+/* eslint-disable no-magic-numbers */
+
+'use strict';
+
+/* global describe, it, expect, beforeAll */
+
+const ConnectionBase          = require('../../../lib/connection/connection-base');
+const { SumLiteral, Literal } = require('../../../lib/connection/literals');
+
+describe('SumLiteral', () => {
+  let connection;
+  let User;
+
+  beforeAll(async () => {
+    connection = new ConnectionBase({
+      bindModels: false,
+      models:     require('../../support/models'),
+    });
+
+    let models = connection.getModels();
+
+    User = models.User;
+  });
+
+  describe('toString', () => {
+    it('can turn a fully qualified name into a min projection', () => {
+      expect((new SumLiteral('User:id')).toString(connection)).toEqual('SUM("users"."id")');
+    });
+
+    it('will throw an exception if no field is present', () => {
+      expect(() => (new SumLiteral()).toString(connection)).toThrow(new TypeError('SumLiteral::fullyQualifiedNameToDefinition: Unable to find field for fully qualified name "undefined".'));
+    });
+
+    it('can turn a raw field into a projection field', () => {
+      expect((new SumLiteral(User.fields.firstName)).toString(connection)).toEqual('SUM("users"."firstName")');
+    });
+
+    it('can provide a SQL literal', () => {
+      expect((new SumLiteral(new Literal('test'))).toString(connection)).toEqual('SUM(test)');
+    });
+  });
+});