mythix-orm 1.10.2 → 1.11.0

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

@@ -3,11 +3,64 @@
 const Nife            = require('nife');
 const ProxyClass      = require('../proxy-class');
 const QueryEngineBase = require('./query-engine-base');
+const QueryUtils      = require('../utils/query-utils');
 const {
   LiteralBase,
   DistinctLiteral,
 } = require('../connection/literals');
 
+function applyOrderClause(extraData, ...args) {
+  let entities = Nife.arrayFlatten(args);
+
+  entities = Nife.toArray(entities).map((value) => {
+    if (value == null)
+      return;
+
+    // Pass literals directly through
+    if (LiteralBase.isLiteral(value))
+      return value;
+
+    // Is the projection a field?
+    if (value.Model && value.fieldName)
+      return `${value.Model.getModelName()}:${value.fieldName}`;
+
+    if (!Nife.instanceOf(value, 'string'))
+      throw new Error('QueryEngine::ModelScope::ORDER: Invalid value provided. All values provided must be strings, fields, or literals. 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 value;
+  }).filter(Boolean);
+
+  let context = this.getOperationContext();
+  let order = this.margeFields(
+    context.order,
+    entities,
+    extraData,
+    { isOrderBy: true },
+  );
+
+  this._pushOperationOntoStack({
+    control:   true,
+    operator:  'ORDER',
+    queryProp: 'ORDER',
+    value:     entities,
+    order,
+  });
+
+  return this._fetchScope('model');
+}
+
+function wrapOrderClause(func) {
+  func.DESC = (...args) => {
+    return applyOrderClause.call(this, { direction: '-' }, ...args);
+  };
+
+  func.ASC = (...args) => {
+    return applyOrderClause.call(this, { direction: '+' }, ...args);
+  };
+
+  return func;
+}
+
 class ModelScope extends QueryEngineBase {
   _getField(fieldName) {
     let Model = this.currentContext.Model;
@@ -46,18 +99,22 @@ class ModelScope extends QueryEngineBase {
     return this.currentContext.queryEngineScope.toString(...args);
   }
 
+  margeFields(currentFields, incomingFields, extraData, options) {
+    return QueryUtils.margeFields(this, currentFields, incomingFields, extraData, options);
+  }
+
   NOT = ProxyClass.autoCall(function() {
-    this._pushOperationOntoStack({ logical: true, operator: 'NOT', not: !this.currentContext.not });
+    this._pushOperationOntoStack({ logical: true, operator: 'NOT', queryProp: 'NOT', not: !this.currentContext.not });
     return this._fetchScope('model');
   });
 
   AND = ProxyClass.autoCall(function(value) {
-    this._pushOperationOntoStack({ logical: true, operator: 'AND', and: true, or: false, not: false, value });
+    this._pushOperationOntoStack({ logical: true, operator: 'AND', queryProp: 'AND', and: true, or: false, not: false, value });
     return this._fetchScope('model');
   });
 
   OR = ProxyClass.autoCall(function(value) {
-    this._pushOperationOntoStack({ logical: true, operator: 'OR', and: false, or: true, not: false, value });
+    this._pushOperationOntoStack({ logical: true, operator: 'OR', queryProp: 'OR', and: false, or: true, not: false, value });
     return this._fetchScope('model');
   });
 
@@ -67,7 +124,7 @@ class ModelScope extends QueryEngineBase {
       throw new Error('QueryEngine::ModelScope::LIMIT: Value provided must be a valid positive number, or Infinity.');
 
     value = Math.round(value);
-    this._pushOperationOntoStack({ control: true, operator: 'LIMIT', value, limit: value });
+    this._pushOperationOntoStack({ control: true, operator: 'LIMIT', queryProp: 'LIMIT', value, limit: value });
 
     return this._fetchScope('model');
   }
@@ -78,32 +135,93 @@ class ModelScope extends QueryEngineBase {
       throw new Error('QueryEngine::ModelScope::OFFSET: Value provided must be a valid positive number.');
 
     value = Math.round(value);
-    this._pushOperationOntoStack({ control: true, operator: 'OFFSET', value, offset: value });
+    this._pushOperationOntoStack({ control: true, operator: 'OFFSET', queryProp: 'OFFSET', value, offset: value });
 
     return this._fetchScope('model');
   }
 
-  ORDER(...args) {
-    let values = Nife.arrayFlatten(args);
+  ORDER = wrapOrderClause.call(this, (...args) => {
+    return applyOrderClause.call(this, { direction: '+' }, ...args);
+  });
+
+  GROUP_BY(...args) {
+    let entities = Nife.arrayFlatten(args);
 
-    values = Nife.toArray(values).filter((value) => {
+    entities = Nife.toArray(entities).map((value) => {
       if (value == null)
-        return false;
+        return;
+
+      // Pass literals directly through
+      if (LiteralBase.isLiteral(value))
+        return value;
+
+      // Is the projection a field?
+      if (value.Model && value.fieldName)
+        return `${value.Model.getModelName()}:${value.fieldName}`;
 
       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" ]).');
+        throw new Error('QueryEngine::ModelScope::GROUP_BY: Invalid value provided. All values provided must be strings, fields, or literals. 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 value;
+    }).filter(Boolean);
+
+    let context = this.getOperationContext();
+    let groupBy = this.margeFields(
+      context.groupBy,
+      entities,
+      {},
+      { isGroupBy: true },
+    );
+
+    this._pushOperationOntoStack({
+      control:   true,
+      operator:  'GROUP_BY',
+      queryProp: 'GROUP_BY',
+      value:     entities,
+      groupBy,
+    });
+
+    return this._fetchScope('model');
+  }
+
+  HAVING(query) {
+    this._pushOperationOntoStack({ control: true, operator: 'HAVING', queryProp: 'HAVING', value: query, having: query });
+    return this._fetchScope('model');
+  }
+
+  EXISTS(_query) {
+    let query         = _query;
+    let queryContext  = (QueryEngineBase.isQuery(query)) ? query.getOperationContext() : null;
+    if (!queryContext || !queryContext.hasCondition)
+      throw new Error('QueryEngine::ModelScope::EXISTS: Provided value must be a query with conditions.');
+
+    if (!queryContext.projection) {
+      let Model   = queryContext.Model;
+      let pkField = Model.getPrimaryKeyField();
+
+      if (pkField)
+        query = query.clone().PROJECT(pkField);
+      else
+        throw new Error('QueryEngine::ModelScope::EXISTS: Provided query must have only a single field projected.');
+    }
 
-      return true;
+    this._pushOperationOntoStack({
+      condition:       true,
+      operator:        'EXISTS',
+      inverseOperator: 'NOT EXISTS',
+      queryProp:       'EXISTS',
+      value:           query,
+      having:          query,
+      hasCondition:    true,
     });
 
-    this._pushOperationOntoStack({ control: true, operator: 'ORDER', value: values, order: values });
     return this._fetchScope('model');
   }
 
   PROJECT(...args) {
-    let values = Nife.arrayFlatten(args);
+    let entities = Nife.arrayFlatten(args);
 
-    values = Nife.toArray(values).map((value) => {
+    entities = Nife.toArray(entities).map((value) => {
       if (value == null)
         return;
 
@@ -119,63 +237,78 @@ class ModelScope extends QueryEngineBase {
       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.');
+      if (!Nife.instanceOf(value, 'string')) {
+        console.log(entities);
+        throw new Error(`QueryEngine::ModelScope::PROJECT: Invalid value provided [${value.toString()}]. All values provided must be strings.`);
+      }
 
       return value;
     }).filter(Boolean);
 
-    this._pushOperationOntoStack({ control: true, operator: 'PROJECT', value: values });
+    let context = this.getOperationContext();
+    let projection = this.margeFields(
+      context.projection,
+      entities,
+      {},
+      { isProjection: true },
+    );
+
+    this._pushOperationOntoStack({
+      control:   true,
+      operator:  'PROJECT',
+      queryProp: 'PROJECT',
+      value:     entities,
+      projection,
+    });
+
     return this._fetchScope('model');
   }
 
   DISTINCT = ProxyClass.autoCall(function(fullyQualifiedName) {
     let currentQuery  = this;
     let distinctValue = fullyQualifiedName;
+    let context       = this.getOperationContext();
 
     if (arguments.length === 0) {
-      let context = this.getOperationContext();
       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}`);
+      if (rootModel) {
+        let pkFieldName = rootModel.getPrimaryKeyFieldName();
+        if (pkFieldName)
+          distinctValue = new DistinctLiteral(`${rootModel.getModelName()}:${pkFieldName}`);
+      }
+
+      if (!distinctValue)
+        distinctValue = new DistinctLiteral();
     } else if (fullyQualifiedName) {
       distinctValue = new DistinctLiteral(fullyQualifiedName);
-      currentQuery = this.PROJECT(`-${fullyQualifiedName}`);
     }
 
-    currentQuery._pushOperationOntoStack({ control: true, operator: 'DISTINCT', value: distinctValue, distinct: distinctValue });
+    currentQuery._pushOperationOntoStack({ sqlFunc: true, operator: 'DISTINCT', queryProp: 'DISTINCT', value: distinctValue, distinct: distinctValue });
     return this._fetchScope('model');
   });
 
   INNER_JOIN = ProxyClass.autoCall(function() {
-    this._pushOperationOntoStack({ control: true, operator: 'JOIN', value: 'inner', joinType: 'inner', joinOuter: false });
+    this._pushOperationOntoStack({ join: true, operator: 'JOIN', queryProp: 'INNER_JOIN', value: 'inner', joinType: 'inner', joinOuter: false });
     return this._fetchScope('model');
   });
 
   LEFT_JOIN = ProxyClass.autoCall(function(outerJoin) {
-    this._pushOperationOntoStack({ control: true, operator: 'JOIN', value: 'left', joinType: 'left', joinOuter: !!outerJoin });
+    this._pushOperationOntoStack({ join: true, operator: 'JOIN', queryProp: 'LEFT_JOIN', value: 'left', joinType: 'left', joinOuter: !!outerJoin });
     return this._fetchScope('model');
   });
 
   RIGHT_JOIN = ProxyClass.autoCall(function(outerJoin) {
-    this._pushOperationOntoStack({ control: true, operator: 'JOIN', value: 'right', joinType: 'right', joinOuter: !!outerJoin });
+    this._pushOperationOntoStack({ join: true, operator: 'JOIN', queryProp: 'RIGHT_JOIN', value: 'right', joinType: 'right', joinOuter: !!outerJoin });
     return this._fetchScope('model');
   });
 
   FULL_JOIN = ProxyClass.autoCall(function(outerJoin) {
-    this._pushOperationOntoStack({ control: true, operator: 'JOIN', value: 'full', joinType: 'full', joinOuter: !!outerJoin });
+    this._pushOperationOntoStack({ join: true, operator: 'JOIN', queryProp: 'FULL_JOIN', value: 'full', joinType: 'full', joinOuter: !!outerJoin });
     return this._fetchScope('model');
   });
 
   CROSS_JOIN = ProxyClass.autoCall(function() {
-    this._pushOperationOntoStack({ control: true, operator: 'JOIN', value: 'cross', joinType: 'cross', joinOuter: false });
+    this._pushOperationOntoStack({ join: true, operator: 'JOIN', queryProp: 'CROSS_JOIN', value: 'cross', joinType: 'cross', joinOuter: false });
     return this._fetchScope('model');
   });
 
@@ -183,7 +316,7 @@ class ModelScope extends QueryEngineBase {
     if (!(Nife.instanceOf(type, 'string') || LiteralBase.isLiteral(type)))
       throw new Error('QueryEngine::ModelScope::JOIN: Invalid value provided. Value must be a valid string or Literal specifying JOIN type.');
 
-    this._pushOperationOntoStack({ control: true, operator: 'JOIN', value: type, joinType: type, joinOuter: false });
+    this._pushOperationOntoStack({ join: true, operator: 'JOIN', queryProp: 'JOIN', value: type, joinType: type, joinOuter: false });
     return this._fetchScope('model');
   }
 }

package/lib/query-engine/query-engine-base.js

@@ -13,8 +13,8 @@ class QueryEngineBase extends ProxyClass {
     return uuid++;
   }
 
-  static isQueryContext(value) {
-    return !!(value && value.isQueryContext);
+  static isQueryOperationContext(value) {
+    return !!(value && value.isQueryOperationContext);
   }
 
   static isQuery(value) {
@@ -33,7 +33,7 @@ class QueryEngineBase extends ProxyClass {
     return false;
   }
 
-  static queryContextType(queryContext) {
+  static queryOperationInfo(queryContext) {
     let contextParams = {
       hasCondition: false,
       hasField:     false,
@@ -124,8 +124,10 @@ class QueryEngineBase extends ProxyClass {
     let modelName       = Model.getModelName();
     let context         = this.currentContext;
     let extra           = {};
+    let isFirst         = !context.rootModel;
+    let connection      = this.getConnection();
 
-    if (!context.rootModel) {
+    if (isFirst) {
       extra.rootModelName = modelName;
       extra.rootModel = Model;
     }
@@ -141,13 +143,10 @@ class QueryEngineBase extends ProxyClass {
         throw new Error(`QueryEngine: Model "${Model.getModelName()}" is on a different connection dialect than the current query dialect of "${context.dialect}". You can not match different connection dialects in the same query.`);
     }
 
-    if (!dialect) {
-      let connection = this.getConnection();
-      if (connection)
-        dialect = connection.dialect;
-    }
+    if (!dialect && connection)
+      dialect = connection.dialect;
 
-    let newContext  = this._inheritContext(context, 'model', { operator: 'MODEL', Model, modelName, dialect }, extra);
+    let newContext  = this._inheritContext(context, 'model', { operator: 'MODEL', queryProp: 'Model', Model, modelName, dialect, value: modelName }, extra);
     let newScope    = new ModelScopeClass(newContext);
 
     // We shouldn't add this scope if this is
@@ -155,6 +154,9 @@ class QueryEngineBase extends ProxyClass {
     if (context.Model !== Model)
       context.operationStack.push(newContext);
 
+    if (isFirst)
+      newScope = newScope.PROJECT(Model);
+
     // But we always need to return the scope
     // for the proxy to work properly
     return newScope;
@@ -171,7 +173,7 @@ class QueryEngineBase extends ProxyClass {
       extra.rootField = Field;
     }
 
-    let newContext  = this._inheritContext(context, 'field', { operator: 'FIELD', fieldName, Field }, extra);
+    let newContext  = this._inheritContext(context, 'field', { operator: 'FIELD', queryProp: 'Field', fieldName, Field, value: fieldName }, extra);
     let newScope    = new FieldScopeClass(newContext);
 
     // We shouldn't add this scope if this is
@@ -223,7 +225,7 @@ class QueryEngineBase extends ProxyClass {
           let currentContext = operationStack[operationStack.length - 1];
           return currentContext || context;
         },
-        set:          () => {},
+        set: () => {},
       },
     });
   }
@@ -289,7 +291,6 @@ class QueryEngineBase extends ProxyClass {
       else
         console.log(`${operator} -> ${queryPart.value}`);
     }
-
   }
 
   _pushOperationOntoStack(queryPart, _context) {
@@ -409,6 +410,38 @@ class QueryEngineBase extends ProxyClass {
     let checkContextKeys = _checkContextKeys || [ 'value' ];
     walkQueries(this, null, null, 0);
   }
+
+  getAllModelsUsedInQuery() {
+    let Models  = new Set();
+    let query   = this.getOperationStack();
+
+    for (let i = 0, il = query.length; i < il; i++) {
+      let queryPart = query[i];
+
+      if (Object.prototype.hasOwnProperty.call(queryPart, 'operator') && queryPart.operator === 'MODEL') {
+        let Model = queryPart.Model;
+        Models.add(Model);
+      } else if (Object.prototype.hasOwnProperty.call(queryPart, 'condition') && queryPart.condition === true) {
+        let operatorValue = queryPart.value;
+        if (!QueryEngineBase.isQuery(operatorValue) || operatorValue.queryHasConditions())
+          continue;
+
+        let SubModels = operatorValue.getAllModelsUsedInQuery();
+        for (let j = 0, jl = SubModels.length; j < jl; j++) {
+          let Model = SubModels[j];
+          Models.add(Model);
+        }
+      }
+    }
+
+    let allModels = Array.from(Models.values());
+    return allModels;
+  }
+
+  isModelUsedInQuery(Model) {
+    let allModels = this.getAllModelsUsedInQuery();
+    return (allModels.indexOf(Model) >= 0);
+  }
 }
 
 module.exports = QueryEngineBase;

package/lib/query-engine/query-engine.d.ts

@@ -19,9 +19,9 @@ export declare interface CallableInterface {
 export declare class QueryEngine<T = ConnectionBase> {
   // QueryEngineBase
   static generateID(): number;
-  static isQueryContext(value: any): boolean;
+  static isQueryOperationContext(value: any): boolean;
   static isQuery(value: any): boolean;
-  static queryContextType(queryContext: GenericObject): { hasCondition: boolean; hasField: boolean; hasModel: boolean; };
+  static queryOperationInfo(queryContext: GenericObject): { hasCondition: boolean; hasField: boolean; hasModel: boolean; };
 
   public getModelScopeClass(): QueryEngine;
   public getFieldScopeClass(): QueryEngine;
@@ -48,6 +48,7 @@ export declare class QueryEngine<T = ConnectionBase> {
   public filter(callback: (operation: GenericObject, index: number, operations: Array<GenericObject>, query: QueryEngine) => GenericObject): QueryEngine;
   public map(callback: (operation: GenericObject, index: number, operations: Array<GenericObject>, query: QueryEngine) => GenericObject): QueryEngine;
   public walk(callback: (query: QueryEngine, parent: GenericObject | null, contextKey: string, depth: number) => GenericObject, checkContextKeys?: Array<string>): void;
+  public getAllModelsUsedInQuery(): Array<ModelClass>;
 
   // QueryEngine
   public getModelScopeClass(): QueryEngineClass;
@@ -78,8 +79,11 @@ export declare class QueryEngine<T = ConnectionBase> {
   public Field(fieldName: string): QueryEngine;
   public LIMIT(value: number): QueryEngine;
   public OFFSET(value: number): QueryEngine;
-  public ORDER(...args: Array<string | Array<string>>): QueryEngine;
-  public PROJECT(...args: Array<string | ModelClass | LiteralBase | Field>): QueryEngine;
+  public ORDER(...args: Array<LiteralBase | Field | string | Array<LiteralBase | Field | string>>): QueryEngine;
+  public GROUP_BY(...args: Array<LiteralBase | Field | string | Array<LiteralBase | Field | string>>): QueryEngine;
+  public HAVING(query: QueryEngine): QueryEngine;
+  public EXISTS(query: QueryEngine): QueryEngine;
+  public PROJECT(...args: Array<string | ModelClass | LiteralBase | Field | Array<string | ModelClass | LiteralBase | Field>>): QueryEngine;
 
   declare public NOT: {
     (): QueryEngine;

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

@@ -20,9 +20,9 @@ class QueryEngine extends QueryEngineBase {
     let context = Object.assign(
       Object.create(_context || {}),
       {
-        currentScopeName: 'queryEngine',
-        isQueryContext:   true,
-        contextID:        QueryEngineBase.generateID(),
+        currentScopeName:        'queryEngine',
+        isQueryOperationContext: true,
+        contextID:               QueryEngineBase.generateID(),
       },
     );
 
@@ -39,15 +39,15 @@ class QueryEngine extends QueryEngineBase {
     return this._newModelScope(model);
   }
 
-  unscoped(context) {
+  unscoped() {
+    let context           = this.getOperationContext();
     let QueryEngineClass  = this.constructor;
-    let currentContext    = context || this.currentContext;
     let queryEngine       = new QueryEngineClass({
-      connection: currentContext.connection,
+      connection: this.getConnection(),
     });
 
-    if (currentContext.rootModelName)
-      queryEngine = queryEngine[currentContext.rootModelName];
+    if (context.rootModelName)
+      queryEngine = queryEngine[context.rootModelName];
 
     return queryEngine;
   }
@@ -59,36 +59,23 @@ class QueryEngine extends QueryEngineBase {
     return queryGenerator.toConnectionString(this, ...args);
   }
 
-  MERGE(_queryEngine) {
-    let queryEngine = _queryEngine;
-    if (!queryEngine)
+  MERGE(_incomingQueryEngine, _options) {
+    let incomingQueryEngine = _incomingQueryEngine;
+    if (!incomingQueryEngine)
       return this;
 
-    let thisQueryContext = this.getOperationContext();
-    if (!QueryEngine.isQuery(queryEngine) && Nife.instanceOf(queryEngine, 'array', 'object', 'map', 'set'))
-      queryEngine = Utils.generateQueryFromFilter(this.getConnection(), thisQueryContext.rootModel, queryEngine);
-
-    let sourceQuery           = queryEngine.getOperationStack();
-    let currentModel          = thisQueryContext.Model;
-    let skipLogicalOperators  = true;
-
-    for (let i = 0, il = sourceQuery.length; i < il; i++) {
-      let queryPart     = sourceQuery[i];
-      let mergeContext  = Utils.objectAssignSpecial(queryPart, null, [
-        // Skip the following keys
-        // as they are provided by the
-        // parent queryEngine
-        'connection',
-        'fieldContext',
-        'isQueryContext',
-        'modelContext',
-        'queryEngineScope',
-        'operationStack',
-        'rootContext',
-        'rootModel',
-        'rootModelName',
-        '_queryFinalized',
-      ]);
+    let options           = _options || {};
+    let thisQueryContext  = this.getOperationContext();
+    if (!QueryEngine.isQuery(incomingQueryEngine) && Nife.instanceOf(incomingQueryEngine, 'array', 'object', 'map', 'set'))
+      incomingQueryEngine = Utils.generateQueryFromFilter(this.getConnection(options.connection), thisQueryContext.rootModel, incomingQueryEngine);
+
+    let incomingOperationStack      = incomingQueryEngine.getOperationStack();
+    let skippingLogical             = true;
+    let logicalOperatorEncountered  = false;
+    let queryEngine                 = this.clone();
+
+    for (let i = 0, il = incomingOperationStack.length; i < il; i++) {
+      let queryPart = incomingOperationStack[i];
 
       // For merges, we want to skip the first logical operators
       // found before any other operation.
@@ -98,32 +85,38 @@ class QueryEngine extends QueryEngineBase {
       // Since the result we want here is OR merge, not AND merge
       // we skip the first "AND" we encounter, leaving the "OR" as
       // the current logical operator.
-      if (skipLogicalOperators && Object.prototype.hasOwnProperty.call(mergeContext, 'logical') && mergeContext.logical) {
-        if (mergeContext.value == null && (mergeContext.operator === 'AND' || mergeContext.operator === 'OR'))
+      // Logical operators do not always come first in the query,
+      // so we need to rely on "logicalOperatorEncountered" to
+      // ensure we skip only the first one (or first few in a sequence).
+      if (skippingLogical && Object.prototype.hasOwnProperty.call(queryPart, 'logical') && queryPart.logical) {
+        if (queryPart.value == null && (queryPart.operator === 'AND' || queryPart.operator === 'OR')) {
+          logicalOperatorEncountered = true;
           continue;
+        }
       }
 
-      if (Object.prototype.hasOwnProperty.call(mergeContext, 'operator')) {
-        // Skip unneeded duplicate model entries
-        if (mergeContext.operator === 'MODEL') {
-          if (mergeContext.Model === currentModel)
-            continue;
+      if (logicalOperatorEncountered)
+        skippingLogical = false;
 
-          currentModel = mergeContext.Model;
-        } else if (mergeContext.operator !== 'FIELD') {
-          skipLogicalOperators = false;
-        }
+      let value = queryPart.value;
+      if (Object.prototype.hasOwnProperty.call(queryPart, 'control') && queryPart.control === true) {
+        if (queryPart.operator === 'PROJECT' && options.projections !== true)
+          continue;
+
+        if (queryPart.operator === 'ORDER' && options.orders === false)
+          continue;
+
+        if (queryPart.operator === 'GROUP_BY' && options.groupBys === false)
+          continue;
+
+        if (queryPart.operator === 'PROJECT' || queryPart.operator === 'ORDER' || queryPart.operator === 'GROUP_BY')
+          value = [ '+' ].concat(value);
       }
 
-      this._pushOperationOntoStack(Object.assign({
-        Model:      queryPart.Model,
-        modelName:  queryPart.modelName,
-        Field:      queryPart.Field,
-        fieldName:  queryPart.fieldName,
-      }, mergeContext));
+      queryEngine = queryEngine[queryPart.queryProp](value, ...(queryPart.queryExtraArgs || []));
     }
 
-    return this;
+    return queryEngine;
   }
 
   async all(options) {

package/lib/types/concrete/datetime-type.js

@@ -269,6 +269,6 @@ class DateTimeType extends Type {
 }
 
 module.exports = {
-  DATETIME:   Type.wrapConstructor(DateTimeType),
+  DATETIME: Type.wrapConstructor(DateTimeType),
   DateTimeType,
 };

package/lib/types/concrete/serialized-type.js

@@ -110,13 +110,13 @@ class SerializedType extends Type {
       options = { type: options };
 
     options = {
-      serialize:    ({ value }) => {
+      serialize: ({ value }) => {
         if (value == null)
           return value;
 
         return JSON.stringify(value);
       },
-      deserialize:  ({ value }) => {
+      deserialize: ({ value }) => {
         if (value == null)
           return value;
 

package/lib/types/virtual/model-type.js

@@ -72,12 +72,12 @@ const TYPE_OPERATIONS = {
       if (!model.isDirty())
         return model;
 
-      let [ storedModel ] = await connection.update(model.getModel(), [ model ], options);
+      await connection.update(model.getModel(), [ model ], options);
 
       // Update this model to reflect the update
-      ModelUtils.setRelationalValues(connection, this.getModel(), this, storedModel.getModel(), storedModel);
+      ModelUtils.setRelationalValues(connection, this.getModel(), this, model.getModel(), model);
 
-      return storedModel;
+      return model;
     }, options);
 
     // Save needs to go outside of the transaction