mythix-orm 1.0.1

package/lib/proxy-class/index.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./proxy-class');

package/lib/proxy-class/proxy-class.js

@@ -0,0 +1,269 @@
+/* eslint-disable no-unused-vars */
+/* eslint-disable max-classes-per-file */
+/* eslint-disable lines-between-class-members */
+
+'use strict';
+
+const APPLY                       = Symbol.for('@_apply');
+const CALLABLE                    = Symbol.for('@_callable');
+const CONSTRUCT                   = Symbol.for('@_construct');
+const DEFINE_PROPERTY             = Symbol.for('@_defineProperty');
+const DELETE_PROPERTY             = Symbol.for('@_deleteProperty');
+const GET                         = Symbol.for('@_get');
+const GET_OWN_PROPERTY_DESCRIPTOR = Symbol.for('@_getOwnPropertyDescriptor');
+const GET_PROTOTYPEOF             = Symbol.for('@_getPrototypeOf');
+const HAS                         = Symbol.for('@_has');
+const IS_EXTENSIBLE               = Symbol.for('@_isExtensible');
+const MISSING                     = Symbol.for('@_missing');
+const OWN_KEYS                    = Symbol.for('@_ownKeys');
+const PREVENT_EXTENSIONS          = Symbol.for('@_preventExtensions');
+const SET                         = Symbol.for('@_set');
+const SET_PROTOTYPEOF             = Symbol.for('@_setPrototypeOf');
+const PROXY                       = Symbol.for('@__proxy');
+const TARGET                      = Symbol.for('@__target');
+const SELF                        = Symbol.for('@__rootInstance');
+const AUTO_CALL_CALLER            = Symbol.for('@__autoCallCaller');
+const AUTO_CALL_CALLED            = Symbol.for('@__autoCallCalled');
+const AUTO_CALL                   = Symbol.for('@__autoCall');
+
+function shouldSkipProxy(prop) {
+  if (prop === PROXY || prop === TARGET || prop === SELF || prop === AUTO_CALL_CALLER || prop === AUTO_CALL_CALLED || prop === AUTO_CALL)
+    return true;
+
+  if (prop in Object.prototype)
+    return true;
+
+  return false;
+}
+
+class ProxyClass {
+  static APPLY = APPLY;
+  static CALLABLE = CALLABLE;
+  static CONSTRUCT = CONSTRUCT;
+  static DEFINE_PROPERTY = DEFINE_PROPERTY;
+  static DELETE_PROPERTY = DELETE_PROPERTY;
+  static GET = GET;
+  static GET_OWN_PROPERTY_DESCRIPTOR = GET_OWN_PROPERTY_DESCRIPTOR;
+  static GET_PROTOTYPEOF = GET_PROTOTYPEOF;
+  static HAS = HAS;
+  static IS_EXTENSIBLE = IS_EXTENSIBLE;
+  static MISSING = MISSING;
+  static OWN_KEYS = OWN_KEYS;
+  static PREVENT_EXTENSIONS = PREVENT_EXTENSIONS;
+  static SET = SET;
+  static SET_PROTOTYPEOF = SET_PROTOTYPEOF;
+  static PROXY = PROXY;
+  static TARGET = TARGET;
+  static SELF = SELF;
+  static AUTO_CALL_CALLER = AUTO_CALL_CALLER;
+  static AUTO_CALL_CALLED = AUTO_CALL_CALLED;
+  static AUTO_CALL = AUTO_CALL;
+
+  static shouldSkipProxy = shouldSkipProxy;
+
+  static autoCall(func) {
+    Object.defineProperties(func, {
+      [AUTO_CALL]: {
+        writable:     true,
+        enumberable:  false,
+        configurable: true,
+        value:        true,
+      },
+    });
+
+    return func;
+  }
+
+  static createProxy(_proxyTarget, forceSpecifiedContext) {
+    let me = (forceSpecifiedContext) ? this : (this[SELF] || this);
+    let proxyTarget = _proxyTarget || me[CALLABLE] || me;
+
+    let proxy = new Proxy(proxyTarget, {
+      apply: function(target, thisArg, argumentsList) {
+        return me[APPLY].call(me, target, thisArg, argumentsList);
+      },
+      construct: function(target, argumentsList, newTarget) {
+        return me[CONSTRUCT].call(me, target, argumentsList, newTarget);
+      },
+      defineProperty: function(target, key, descriptor) {
+        return me[DEFINE_PROPERTY].call(me, target, key, descriptor);
+      },
+      deleteProperty: function(target, prop) {
+        return me[DELETE_PROPERTY].call(me, target, prop);
+      },
+      get: function(target, prop, receiver) {
+        if (shouldSkipProxy(prop))
+          return me[prop];
+
+        if (typeof prop !== 'symbol' && prop !== '__autoCall' && prop !== '__call') {
+          let autoCall = me[AUTO_CALL_CALLER];
+          if (typeof autoCall === 'function' && me[AUTO_CALL_CALLED] === false) {
+            me[AUTO_CALL_CALLED] = true;
+            autoCall.call(me);
+          }
+        }
+
+        if (prop in me) {
+          let value = me[GET].call(me, target, prop, receiver);
+
+          if (typeof value === 'function' && value[AUTO_CALL] === true)
+            return me.constructor.createProxy.call(Object.create(me), value, true).__autoCall(value);
+
+          return value;
+        }
+
+        return me[MISSING].call(me, target, prop, receiver);
+      },
+      getOwnPropertyDescriptor: function(target, prop) {
+        return me[GET_OWN_PROPERTY_DESCRIPTOR].call(me, target, prop);
+      },
+      getPrototypeOf: function(target) {
+        return me[GET_PROTOTYPEOF].call(me, target);
+      },
+      has: function(target, prop) {
+        return me[HAS].call(me, target, prop);
+      },
+      isExtensible: function(target) {
+        return me[IS_EXTENSIBLE].call(me, target);
+      },
+      ownKeys: function(target) {
+        return me[OWN_KEYS].call(me, target);
+      },
+      preventExtensions: function(target) {
+        return me[PREVENT_EXTENSIONS].call(me, target);
+      },
+      set: function(target, prop, value, receiver) {
+        if (typeof prop !== 'symbol' && prop !== '__autoCall' && prop !== '__call') {
+          let autoCall = me[AUTO_CALL_CALLER];
+          if (typeof autoCall === 'function' && me[AUTO_CALL_CALLED] === false) {
+            me[AUTO_CALL_CALLED] = true;
+            autoCall.call(me);
+          }
+        }
+
+        return me[SET].call(me, target, prop, value, receiver);
+      },
+      setPrototypeOf: function(target, prototype) {
+        return me[SET_PROTOTYPEOF].call(me, target, prototype);
+      },
+    });
+
+    Object.defineProperties(me, {
+      [PROXY]: {
+        writable:     true,
+        enumberable:  false,
+        configurable: true,
+        value:        proxy,
+      },
+      [TARGET]: {
+        writable:     true,
+        enumberable:  false,
+        configurable: true,
+        value:        proxyTarget,
+      },
+      [SELF]: {
+        writable:     true,
+        enumberable:  false,
+        configurable: true,
+        value:        me,
+      },
+    });
+
+    return proxy;
+  }
+
+  constructor() {
+    Object.defineProperties(this, {
+      [AUTO_CALL_CALLER]: {
+        writable:     true,
+        enumberable:  false,
+        configurable: true,
+        value:        null,
+      },
+      [AUTO_CALL_CALLED]: {
+        writable:     true,
+        enumberable:  false,
+        configurable: true,
+        value:        false,
+      },
+    });
+
+    let proxy = ProxyClass.createProxy.call(this);
+    return proxy;
+  }
+
+  __autoCall(caller) {
+    this[AUTO_CALL_CALLER] = caller;
+    this[AUTO_CALL_CALLED] = false;
+
+    return this;
+  }
+
+  __call(caller) {
+    return ProxyClass.createProxy.call(this, caller.bind(this[PROXY]));
+  }
+
+  [APPLY](target, thisArg, argumentsList) {
+    return target.apply(thisArg, argumentsList);
+  }
+
+  [CONSTRUCT](target, argumentsList, newTarget) {
+    let self = Object.create(target.prototype);
+    let result = newTarget.apply(self, argumentsList);
+
+    if (!result || typeof result !== 'object')
+      return self;
+
+    return result;
+  }
+
+  [DEFINE_PROPERTY](target, key, descriptor) {
+    return Object.defineProperty(this, key, descriptor);
+  }
+
+  [DELETE_PROPERTY](target, prop) {
+    return delete this[prop];
+  }
+
+  [GET](target, prop) {
+    return this[prop];
+  }
+
+  [GET_OWN_PROPERTY_DESCRIPTOR](target, prop) {
+    return Object.getOwnPropertyDescriptor(target, prop);
+  }
+
+  [GET_PROTOTYPEOF](target) {
+    return Object.getPrototypeOf(this);
+  }
+
+  [HAS](target, prop) {
+    return (prop in this);
+  }
+
+  [IS_EXTENSIBLE](target) {
+    return Object.isExtensible(this);
+  }
+
+  [MISSING]() {
+  }
+
+  [OWN_KEYS](target) {
+    return Reflect.ownKeys(this);
+  }
+
+  [PREVENT_EXTENSIONS](target) {
+    return Object.preventExtensions(this);
+  }
+
+  [SET](target, prop, value) {
+    this[prop] = value;
+    return true;
+  }
+
+  [SET_PROTOTYPEOF](target, prototype) {
+    return Object.setPrototypeOf(this, prototype);
+  }
+}
+
+module.exports = ProxyClass;

package/lib/query-engine/field-scope.js

@@ -0,0 +1,99 @@
+'use strict';
+
+const Nife            = require('nife');
+const ProxyClass      = require('../proxy-class');
+const QueryEngineBase = require('./query-engine-base');
+
+function addOperatorToQuery(name, inverseName, value) {
+  if (Nife.instanceOf(value, 'object'))
+    throw new Error(`QueryEngine::addOperatorToQuery: ${name}(${value}) makes no sense...`);
+
+  this._addToQuery({
+    condition:        true,
+    operator:         name,
+    inverseOperator:  inverseName,
+    value:            this._fetchOperatorValue(value),
+  });
+
+  return this._fetchScope('model');
+}
+
+class FieldScope extends QueryEngineBase {
+  NOT = ProxyClass.autoCall(function() {
+    this._addToQuery({ logical: true, operator: 'NOT', not: !this.currentContext.not });
+    return this[ProxyClass.PROXY];
+  });
+
+  unscoped() {
+    return this.currentContext.queryEngineScope.unscoped(this.currentContext);
+  }
+
+  toString(...args) {
+    if (args.length === 0)
+      return `${this.constructor.name} {}`;
+
+    return this.currentContext.queryEngineScope.toString(...args);
+  }
+
+  toSQL() {
+    return this.currentContext.queryEngineScope.toSQL();
+  }
+
+  _fetchOperatorValue(_value) {
+    let value = _value;
+    if (!value)
+      return value;
+
+    if (value._isMythixModel) {
+      // If a model class was supplied, then get the model query engine
+      // and the primary key of the model
+
+      let pkFieldName = value.getPrimaryKeyFieldName();
+      if (Nife.isEmpty(pkFieldName))
+        throw new Error(`${this.constructor.name}::_fetchOperatorValue: Invalid operation: You asked me to match against a model class, but model has no primary key, so I do not know what to match against.`);
+
+      return value.where(this.getConnection())[pkFieldName];
+    } else if (value._mythixModelInstance) {
+      // If a model instance was supplied
+      // then get the model's PK value
+      let pkFieldName = value.getPrimaryKeyFieldName();
+      if (Nife.isEmpty(pkFieldName))
+        throw new Error(`${this.constructor.name}::_fetchOperatorValue: Invalid operation: You asked me to match against a model instance, but model has no primary key, so I do not know what to match against.`);
+
+      return value[pkFieldName];
+    }
+
+    return value;
+  }
+
+  EQ(value) {
+    return addOperatorToQuery.call(this, 'EQ', 'NEQ', value);
+  }
+
+  NEQ(value) {
+    return addOperatorToQuery.call(this, 'NEQ', 'EQ', value);
+  }
+
+  GT(value) {
+    return addOperatorToQuery.call(this, 'GT', 'LTE', value);
+  }
+
+  GTE(value) {
+    return addOperatorToQuery.call(this, 'GTE', 'LT', value);
+  }
+
+  LT(value) {
+    return addOperatorToQuery.call(this, 'LT', 'GTE', value);
+  }
+
+  LTE(value) {
+    return addOperatorToQuery.call(this, 'LTE', 'GT', value);
+  }
+
+  [ProxyClass.MISSING](target, prop) {
+    let lowerScope = this._fetchScope('model');
+    return lowerScope[prop];
+  }
+}
+
+module.exports = FieldScope;

package/lib/query-engine/index.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const QueryEngineBase = require('./query-engine-base');
+const QueryEngine     = require('./query-engine');
+const ModelScope      = require('./model-scope');
+const FieldScope      = require('./field-scope');
+
+module.exports = {
+  QueryEngineBase,
+  QueryEngine,
+  ModelScope,
+  FieldScope,
+};

package/lib/query-engine/model-scope.js

@@ -0,0 +1,198 @@
+'use strict';
+
+const Nife            = require('nife');
+const ProxyClass      = require('../proxy-class');
+const QueryEngineBase = require('./query-engine-base');
+const {
+  LiteralBase,
+  DistinctLiteral,
+} = require('../connection/literals');
+
+class ModelScope extends QueryEngineBase {
+  _getField(fieldName) {
+    let Model = this.currentContext.Model;
+    return Model.getField(fieldName);
+  }
+
+  _getQueryEngineClass() {
+    return this.currentContext.queryEngine;
+  }
+
+  Field(fieldName) {
+    let field = this._getField(fieldName);
+    if (!field)
+      throw new Error(`QueryEngine::ModelScope::Field: Requested field "${fieldName}" not found.`);
+
+    return this._newFieldScope(field);
+  }
+
+  [ProxyClass.MISSING](target, prop) {
+    if (prop === 'where' || prop === '$')
+      return this._fetchScope('model');
+
+    let field = this._getField(prop);
+    if (field)
+      return this._newFieldScope(field);
+
+    let lowerScope = this._fetchScope('queryEngine');
+    return lowerScope[prop];
+  }
+
+  unscoped() {
+    return this.currentContext.queryEngineScope.unscoped(this.currentContext);
+  }
+
+  toString(...args) {
+    if (args.length === 0)
+      return `${this.constructor.name} {}`;
+
+    return this.currentContext.queryEngineScope.toString(...args);
+  }
+
+  toSQL() {
+    return this.currentContext.queryEngineScope.toSQL();
+  }
+
+  NOT = ProxyClass.autoCall(function() {
+    this._addToQuery({ logical: true, operator: 'NOT', not: !this.currentContext.not });
+    return this._fetchScope('model');
+  });
+
+  AND = ProxyClass.autoCall(function(value) {
+    this._addToQuery({ logical: true, operator: 'AND', and: true, or: false, not: false, value });
+    return this._fetchScope('model');
+  });
+
+  OR = ProxyClass.autoCall(function(value) {
+    this._addToQuery({ logical: true, operator: 'OR', and: false, or: true, not: false, value });
+    return this._fetchScope('model');
+  });
+
+  LIMIT(_value) {
+    let value = _value;
+    if (typeof value !== 'number' || isNaN(value) || value < 0)
+      throw new Error('QueryEngine::ModelScope::LIMIT: Value provided must be a valid positive number, or Infinity.');
+
+    value = Math.round(value);
+    this._addToQuery({ control: true, operator: 'LIMIT', value, limit: value });
+
+    return this._fetchScope('model');
+  }
+
+  OFFSET(_value) {
+    let value = _value;
+    if (typeof value !== 'number' || !isFinite(value) || value < 0)
+      throw new Error('QueryEngine::ModelScope::OFFSET: Value provided must be a valid positive number.');
+
+    value = Math.round(value);
+    this._addToQuery({ control: true, operator: 'OFFSET', value, offset: value });
+
+    return this._fetchScope('model');
+  }
+
+  ORDER(...args) {
+    let values = Nife.arrayFlatten(args);
+
+    values = Nife.toArray(values).filter((value) => {
+      if (value == null)
+        return false;
+
+      if (!Nife.instanceOf(value, 'string'))
+        throw new Error('QueryEngine::ModelScope::ORDER: Invalid value provided. All values provided must be strings. If you want to change the sort order of a given column, add "+" (ASC) or "-" (DESC) to be beginning of the field name. Example: .ORDER("+createdAt"), or .ORDER([ "-name", "+createdAt" ]).');
+
+      return true;
+    });
+
+    this._addToQuery({ control: true, operator: 'ORDER', value: values, order: values });
+    return this._fetchScope('model');
+  }
+
+  PROJECT(...args) {
+    let values = Nife.arrayFlatten(args);
+
+    values = Nife.toArray(values).map((value) => {
+      if (value == null)
+        return;
+
+      // Pass literals directly through
+      if (value instanceof LiteralBase)
+        return value;
+
+      // Is the projection a model?
+      if (value._isMythixModel)
+        return value;
+
+      // Is the projection a field?
+      if (value.Model && value.fieldName)
+        return value;
+
+      if (!Nife.instanceOf(value, 'string'))
+        throw new Error('QueryEngine::ModelScope::PROJECT: Invalid value provided. All values provided must be strings.');
+
+      return value;
+    }).filter(Boolean);
+
+    this._addToQuery({ control: true, operator: 'PROJECT', value: values });
+    return this._fetchScope('model');
+  }
+
+  DISTINCT = ProxyClass.autoCall(function(fullyQualifiedName) {
+    let currentQuery  = this;
+    let distinctValue = fullyQualifiedName;
+
+    if (arguments.length === 0) {
+      let context = this._getRawQueryContext();
+      let rootModel = context.rootModel;
+      if (!rootModel)
+        throw new Error(`${this.constructor.name}::DISTINCT: Attempted to apply DISTINCT to the root model of the query, but no root model was found.`);
+
+      let pkFieldName = rootModel.getPrimaryKeyFieldName();
+      if (!pkFieldName)
+        throw new Error(`${this.constructor.name}::DISTINCT: Attempted to apply DISTINCT to the root model of the query, but the root model has no primary key. Try directly specifying the DISTINCT field instead.`);
+
+      distinctValue = new DistinctLiteral(`${rootModel.getModelName()}:${pkFieldName}`);
+      currentQuery = this.PROJECT(`-${rootModel.getModelName()}:${pkFieldName}`);
+    } else if (fullyQualifiedName) {
+      distinctValue = new DistinctLiteral(fullyQualifiedName);
+      currentQuery = this.PROJECT(`-${fullyQualifiedName}`);
+    }
+
+    currentQuery._addToQuery({ control: true, operator: 'DISTINCT', value: distinctValue, distinct: distinctValue });
+    return this._fetchScope('model');
+  });
+
+  INNER_JOIN = ProxyClass.autoCall(function() {
+    this._addToQuery({ control: true, operator: 'JOIN', value: 'inner', joinType: 'inner', joinOuter: false });
+    return this._fetchScope('model');
+  });
+
+  LEFT_JOIN = ProxyClass.autoCall(function(outerJoin) {
+    this._addToQuery({ control: true, operator: 'JOIN', value: 'left', joinType: 'left', joinOuter: !!outerJoin });
+    return this._fetchScope('model');
+  });
+
+  RIGHT_JOIN = ProxyClass.autoCall(function(outerJoin) {
+    this._addToQuery({ control: true, operator: 'JOIN', value: 'right', joinType: 'right', joinOuter: !!outerJoin });
+    return this._fetchScope('model');
+  });
+
+  FULL_JOIN = ProxyClass.autoCall(function(outerJoin) {
+    this._addToQuery({ control: true, operator: 'JOIN', value: 'full', joinType: 'full', joinOuter: !!outerJoin });
+    return this._fetchScope('model');
+  });
+
+  CROSS_JOIN = ProxyClass.autoCall(function() {
+    this._addToQuery({ control: true, operator: 'JOIN', value: 'cross', joinType: 'cross', joinOuter: false });
+    return this._fetchScope('model');
+  });
+
+  JOIN(type) {
+    if (Nife.isEmpty(type) || !Nife.instanceOf(type, 'string'))
+      throw new Error('QueryEngine::ModelScope::JOIN: Invalid value provided. Value must be a valid string specifying JOIN type.');
+
+    this._addToQuery({ control: true, operator: 'JOIN', value: type, joinType: type, joinOuter: false });
+    return this._fetchScope('model');
+  }
+}
+
+module.exports = ModelScope;