mythix-orm 1.8.3 → 1.10.2

package/lib/connection/connection-base.d.ts

@@ -81,6 +81,7 @@ declare class ConnectionBase extends EventEmitter {
   public getOptions(): ConnectionBaseOptions;
   public isStarted(): boolean;
   public toQueryEngine(queryEngineLike: any): QueryEngine | undefined;
+  public finalizeQuery(operation: string, query: QueryEngine, options: GenericObject): Promise<QueryEngine>
   public registerModel<T = ModelClass>(Model: T, options?: GenericObject): T;
   public registerModels(models: Models | Array<ModelClass>, options?: GenericObject): Models | undefined;
   public getContextValue(key: any, defaultValue?: any): any;

package/lib/connection/connection-base.js

@@ -489,6 +489,73 @@ class ConnectionBase extends EventEmitter {
     return queryEngine;
   }
 
+  async finalizeQuery(crudOperation, queryEngine, options) {
+    if (!QueryEngine.isQuery(queryEngine))
+      return queryEngine;
+
+    const finalizeQueryForModel = async (query, parent, contextKey, depth) => {
+      let operations = query.getOperationStack();
+
+      // Has query already been finalized?
+      let lastOperation = operations[operations.length - 1];
+      if (lastOperation && Object.prototype.hasOwnProperty.call(lastOperation, '_queryFinalized') && lastOperation._queryFinalized)
+        return query;
+
+      let newQuery              = query.clone();
+      let alreadyVisitedModels  = new Set();
+
+      for (let i = 0, il = operations.length; i < il; i++) {
+        let operation = operations[i];
+        if (!Object.prototype.hasOwnProperty.call(operation, 'modelName'))
+          continue;
+
+        let modelName = operation.modelName;
+        if (alreadyVisitedModels.has(modelName))
+          continue;
+
+        alreadyVisitedModels.add(modelName);
+
+        let Model = operation.Model;
+        if (typeof Model.finalizeQuery !== 'function')
+          continue;
+
+        newQuery = await Model.finalizeQuery({
+          type:           crudOperation,
+          query:          newQuery,
+          queryDepth:     depth,
+          operationIndex: i,
+          connection:     this,
+          Model,
+          modelName,
+          operation,
+          operations,
+          parent,
+          contextKey,
+          options,
+        });
+
+        if (parent && contextKey)
+          parent[contextKey] = newQuery;
+      }
+
+      // Mark as finalized
+      newQuery.getOperationContext()._queryFinalized = true;
+
+      return newQuery;
+    };
+
+    let promises = [];
+
+    queryEngine.walk((query, parent, contextKey, depth) => {
+      promises.push(finalizeQueryForModel(query, parent, contextKey, depth));
+    });
+
+    if (promises.length > 0)
+      await Promise.all(promises);
+
+    return await finalizeQueryForModel(queryEngine, null, null, 0);
+  }
+
   /// Register the provided model class.
   ///
   /// This will register the provided model class with this

package/lib/connection/query-generator-base.js

@@ -124,13 +124,13 @@ class QueryGeneratorBase {
   // eslint-disable-next-line no-unused-vars
   getAllModelsUsedInQuery(queryEngine, _options) {
     let options               = _options || {};
-    let queryEngineContextID  = queryEngine._getTopContextID();
+    let queryEngineContextID  = queryEngine.getQueryID();
     let cache                 = this.getOptionsCache(_options, `getAllModelsUsedInQuery.${queryEngineContextID}`);
     if (cache)
       return cache;
 
     let Models  = new Map();
-    let query   = queryEngine._getRawQuery();
+    let query   = queryEngine.getOperationStack();
 
     for (let i = 0, il = query.length; i < il; i++) {
       let queryPart = query[i];
@@ -257,7 +257,7 @@ class QueryGeneratorBase {
   }
 
   getProjectionFromQueryEngine(queryEngine, options) {
-    let queryEngineContextID  = queryEngine._getTopContextID();
+    let queryEngineContextID  = queryEngine.getQueryID();
     let cache                 = this.getOptionsCache(options, `getProjectionFromQueryEngine.${queryEngineContextID}`);
     if (cache)
       return cache;
@@ -413,13 +413,13 @@ class QueryGeneratorBase {
       return result;
     };
 
-    let rawQueryContext = queryEngine._getRawQueryContext();
+    let rawQueryContext = queryEngine.getOperationContext();
     let RootModel       = rawQueryContext.rootModel;
     if (!RootModel)
       throw new Error('QueryGeneratorBase::getProjectionFromQueryEngine: No root model found for query. Root model is required to generate a projection.');
 
     let hasDistinct     = rawQueryContext.distinct;
-    let projections     = collectProjectionValuesFromQuery(RootModel, queryEngine._getRawQuery());
+    let projections     = collectProjectionValuesFromQuery(RootModel, queryEngine.getOperationStack());
     let projectedFields = new Map();
     let allModels       = this.getAllModelsUsedInQuery(queryEngine, options);
     let isAdding        = true;
@@ -707,13 +707,13 @@ class QueryGeneratorBase {
 
   // eslint-disable-next-line no-unused-vars
   getOrderLimitOffset(queryEngine, options) {
-    let queryEngineContextID  = queryEngine._getTopContextID();
+    let queryEngineContextID  = queryEngine.getQueryID();
     let cache                 = this.getOptionsCache(options, `getOrderLimitOffset.${queryEngineContextID}`);
     if (cache)
       return cache;
 
-    let query     = queryEngine._getRawQuery();
-    let rootModel = queryEngine._getRawQueryContext().rootModel;
+    let query     = queryEngine.getOperationStack();
+    let rootModel = queryEngine.getOperationContext().rootModel;
     let limit;
     let offset;
     let order;
@@ -785,10 +785,10 @@ class QueryGeneratorBase {
   }
 
   getQuerySliceFromQueryPart(queryPart) {
-    let queryRoot = queryPart.queryRoot;
-    let index     = queryRoot.indexOf(queryPart);
+    let operationStack = queryPart.operationStack;
+    let index     = operationStack.indexOf(queryPart);
 
-    return queryRoot.slice(index);
+    return operationStack.slice(index);
   }
 
   _averageLiteralToString(literal, options) {

package/lib/model.d.ts

@@ -42,6 +42,21 @@ export declare interface IterateFieldsContext {
 
 export declare type IterateFieldsCallback = (context: IterateFieldsContext) => any;
 
+export declare interface FinalizeQueryContext {
+  type: 'create' | 'read' | 'update' | 'delete';
+  query: QueryEngine;
+  queryDepth: number;
+  connection: ConnectionBase;
+  Model: Model;
+  modelName: string;
+  operationIndex: number;
+  operation: GenericObject;
+  operations: Array<GenericObject>;
+  parent: GenericObject | null;
+  contextKey: string | null;
+  options: GenericObject | null;
+}
+
 export declare class Model {
   declare public static fields: LooseFields | undefined;
   declare public static _sortedFields: Array<Field> | null;
@@ -83,6 +98,8 @@ export declare class Model {
   public static defaultScope(query: QueryEngine): QueryEngine;
   public defaultScope(query: QueryEngine): QueryEngine;
 
+  public static finalizeQuery(context: FinalizeQueryContext): Promise<QueryEngine>;
+
   public static getQueryEngine(connection?: ConnectionBase, options?: GenericObject): QueryEngine;
   public getQueryEngine(connection?: ConnectionBase, options?: GenericObject): QueryEngine;
 

package/lib/model.js

@@ -673,6 +673,11 @@ class Model {
     return this.constructor.defaultScope(queryEngine);
   }
 
+  // eslint-disable-next-line no-unused-vars
+  static finalizeQuery({ type, query, queryDepth, operationIndex, operation, operations, parent, contextKey, options }) {
+    return query;
+  }
+
   /// This method is called any time a `Model.where` or
   /// `Model.$` property is accessed. It returns a query,
   /// based off this model class (as the root model).

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

@@ -19,14 +19,14 @@ function addOperatorToQuery(name, inverseName, value, extraOptions) {
   if (extraOptions)
     conditionalParams = Object.assign(conditionalParams, extraOptions);
 
-  this._addToQuery(conditionalParams);
+  this._pushOperationOntoStack(conditionalParams);
 
   return this._fetchScope('model');
 }
 
 class FieldScope extends QueryEngineBase {
   NOT = ProxyClass.autoCall(function() {
-    this._addToQuery({ logical: true, operator: 'NOT', not: !this.currentContext.not });
+    this._pushOperationOntoStack({ logical: true, operator: 'NOT', not: !this.currentContext.not });
     return this[ProxyClass.PROXY];
   });
 

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

@@ -47,17 +47,17 @@ class ModelScope extends QueryEngineBase {
   }
 
   NOT = ProxyClass.autoCall(function() {
-    this._addToQuery({ logical: true, operator: 'NOT', not: !this.currentContext.not });
+    this._pushOperationOntoStack({ 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 });
+    this._pushOperationOntoStack({ 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 });
+    this._pushOperationOntoStack({ logical: true, operator: 'OR', and: false, or: true, not: false, value });
     return this._fetchScope('model');
   });
 
@@ -67,7 +67,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._addToQuery({ control: true, operator: 'LIMIT', value, limit: value });
+    this._pushOperationOntoStack({ control: true, operator: 'LIMIT', value, limit: value });
 
     return this._fetchScope('model');
   }
@@ -78,7 +78,7 @@ class ModelScope extends QueryEngineBase {
       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 });
+    this._pushOperationOntoStack({ control: true, operator: 'OFFSET', value, offset: value });
 
     return this._fetchScope('model');
   }
@@ -96,7 +96,7 @@ class ModelScope extends QueryEngineBase {
       return true;
     });
 
-    this._addToQuery({ control: true, operator: 'ORDER', value: values, order: values });
+    this._pushOperationOntoStack({ control: true, operator: 'ORDER', value: values, order: values });
     return this._fetchScope('model');
   }
 
@@ -125,7 +125,7 @@ class ModelScope extends QueryEngineBase {
       return value;
     }).filter(Boolean);
 
-    this._addToQuery({ control: true, operator: 'PROJECT', value: values });
+    this._pushOperationOntoStack({ control: true, operator: 'PROJECT', value: values });
     return this._fetchScope('model');
   }
 
@@ -134,7 +134,7 @@ class ModelScope extends QueryEngineBase {
     let distinctValue = fullyQualifiedName;
 
     if (arguments.length === 0) {
-      let context = this._getRawQueryContext();
+      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.`);
@@ -150,32 +150,32 @@ class ModelScope extends QueryEngineBase {
       currentQuery = this.PROJECT(`-${fullyQualifiedName}`);
     }
 
-    currentQuery._addToQuery({ control: true, operator: 'DISTINCT', value: distinctValue, distinct: distinctValue });
+    currentQuery._pushOperationOntoStack({ 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 });
+    this._pushOperationOntoStack({ 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 });
+    this._pushOperationOntoStack({ 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 });
+    this._pushOperationOntoStack({ 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 });
+    this._pushOperationOntoStack({ 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 });
+    this._pushOperationOntoStack({ control: true, operator: 'JOIN', value: 'cross', joinType: 'cross', joinOuter: false });
     return this._fetchScope('model');
   });
 
@@ -183,7 +183,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._addToQuery({ control: true, operator: 'JOIN', value: type, joinType: type, joinOuter: false });
+    this._pushOperationOntoStack({ control: true, operator: 'JOIN', value: type, joinType: type, joinOuter: false });
     return this._fetchScope('model');
   }
 }

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

@@ -27,7 +27,7 @@ class QueryEngineBase extends ProxyClass {
     if (value._isQueryEngine)
       return true;
 
-    if (typeof value._getRawQueryContext === 'function')
+    if (typeof value.getOperationContext === 'function')
       return true;
 
     return false;
@@ -63,6 +63,10 @@ class QueryEngineBase extends ProxyClass {
     return this.getQueryEngineScope().getFieldScopeClass();
   }
 
+  getQueryEngineScopeClass() {
+    return this.getQueryEngineScope().constructor;
+  }
+
   _inheritContext(context, name, ...args) {
     let newContext = Object.assign(
       Object.create(context),
@@ -82,7 +86,7 @@ class QueryEngineBase extends ProxyClass {
   }
 
   _fetchScope(...scopeNames) {
-    let context = this._getRawQueryContext();
+    let context = this.getOperationContext();
 
     for (let i = 0, il = scopeNames.length; i < il; i++) {
       let scopeName = scopeNames[i];
@@ -149,7 +153,7 @@ class QueryEngineBase extends ProxyClass {
     // We shouldn't add this scope if this is
     // already the current model of the scope
     if (context.Model !== Model)
-      context.queryRoot.push(newContext);
+      context.operationStack.push(newContext);
 
     // But we always need to return the scope
     // for the proxy to work properly
@@ -173,7 +177,7 @@ class QueryEngineBase extends ProxyClass {
     // We shouldn't add this scope if this is
     // already the current field of the scope
     if (context.Field !== Field)
-      context.queryRoot.push(newContext);
+      context.operationStack.push(newContext);
 
     // But we always need to return the scope
     // for the proxy to work properly
@@ -193,8 +197,8 @@ class QueryEngineBase extends ProxyClass {
       context.rootContext = context;
     }
 
-    if (!context.queryRoot)
-      context.queryRoot = [];
+    if (!context.operationStack)
+      context.operationStack = [];
 
     if (!('and' in context))
       context.and = true;
@@ -204,19 +208,19 @@ class QueryEngineBase extends ProxyClass {
 
     // console.log(`Creating new ${this.constructor.name} scope: `, context, Object.getPrototypeOf(context));
 
-    let queryRoot = context.queryRoot;
+    let operationStack = context.operationStack;
     Object.defineProperties(this, {
-      queryRoot: {
+      operationStack: {
         writable:     false,
         enumerable:   false,
         configurable: true,
-        value:        queryRoot,
+        value:        operationStack,
       },
       currentContext: {
         enumerable:   false,
         configurable: true,
         get:          () => {
-          let currentContext = queryRoot[queryRoot.length - 1];
+          let currentContext = operationStack[operationStack.length - 1];
           return currentContext || context;
         },
         set:          () => {},
@@ -224,20 +228,20 @@ class QueryEngineBase extends ProxyClass {
     });
   }
 
-  _getTopContextID() {
+  getQueryID() {
     return this.currentContext.contextID;
   }
 
-  _getRawQueryContext() {
+  getOperationContext() {
     return this.currentContext;
   }
 
-  _getRawQuery() {
-    return this.currentContext.queryRoot;
+  getOperationStack() {
+    return this.currentContext.operationStack;
   }
 
-  _isLastPartControl() {
-    let queryParts  = this._getRawQuery();
+  isLastOperationControl() {
+    let queryParts  = this.getOperationStack();
     let lastPart    = queryParts[queryParts.length - 1];
 
     if (Object.prototype.hasOwnProperty.call(lastPart, 'control') && lastPart.control === true)
@@ -246,8 +250,8 @@ class QueryEngineBase extends ProxyClass {
     return false;
   }
 
-  _isLastPartCondition() {
-    let queryParts  = this._getRawQuery();
+  isLastOperationCondition() {
+    let queryParts  = this.getOperationStack();
     let lastPart    = queryParts[queryParts.length - 1];
 
     if (Object.prototype.hasOwnProperty.call(lastPart, 'condition') && lastPart.condition === true)
@@ -256,13 +260,13 @@ class QueryEngineBase extends ProxyClass {
     return false;
   }
 
-  _queryHasConditions() {
-    let context = this._getRawQueryContext();
+  queryHasConditions() {
+    let context = this.getOperationContext();
     return context.hasCondition;
   }
 
-  _queryHasJoins() {
-    let queryParts = this._getRawQuery();
+  queryHasJoins() {
+    let queryParts = this.getOperationStack();
     for (let i = 0, il = queryParts.length; i < il; i++) {
       let queryPart = queryParts[i];
       if (QueryEngineBase.isQuery(queryPart.value) && !queryPart.value.hasCondition)
@@ -272,8 +276,8 @@ class QueryEngineBase extends ProxyClass {
     return false;
   }
 
-  _debugQuery() {
-    let query = this._getRawQuery();
+  logQueryOperations() {
+    let query = this.getOperationStack();
     for (let i = 0, il = query.length; i < il; i++) {
       let queryPart = query[i];
       let operator  = queryPart.operator;
@@ -288,11 +292,11 @@ class QueryEngineBase extends ProxyClass {
 
   }
 
-  _addToQuery(queryPart, _context) {
-    let context   = _context || this._getRawQueryContext();
-    let queryRoot = context.queryRoot;
+  _pushOperationOntoStack(queryPart, _context) {
+    let context   = _context || this.getOperationContext();
+    let operationStack = context.operationStack;
 
-    queryRoot.push(
+    operationStack.push(
       this._inheritContext(
         context,
         null,
@@ -327,14 +331,83 @@ class QueryEngineBase extends ProxyClass {
   }
 
   clone() {
-    const Klass           = this.constructor;
-    let context           = this._getRawQueryContext();
-    let queryRootCopy     = this._getRawQuery().slice();
-    let newContext        = Object.assign(Object.create(context), { queryRoot: queryRootCopy });
+    return this.map((part) => part)._fetchScope('model');
+  }
+
+  filter(callback) {
+    const Klass           = this.getQueryEngineScopeClass();
+    let context           = this.getOperationContext();
+    let parts             = this.getOperationStack();
+    let query             = new Klass({
+      ...context.rootContext,
+      connection:     this.getConnection(),
+      operationStack: [],
+    });
+
+    for (let i = 0, il = parts.length; i < il; i++) {
+      let part = parts[i];
+      if (!part)
+        continue;
+
+      if (!callback(part, i, parts, query))
+        continue;
+
+      query._pushOperationOntoStack({ ...part });
+    }
+
+    return query;
+  }
+
+  map(callback) {
+    const Klass           = this.getQueryEngineScopeClass();
+    let context           = this.getOperationContext();
+    let parts             = this.getOperationStack();
+    let query             = new Klass({
+      ...context.rootContext,
+      connection:     this.getConnection(),
+      operationStack: [],
+    });
 
-    queryRootCopy.push(newContext);
+    for (let i = 0, il = parts.length; i < il; i++) {
+      let part = parts[i];
+      if (!part)
+        continue;
+
+      let newPart = callback({ ...part }, i, parts, query);
+      if (!newPart || typeof newPart !== 'object')
+        continue;
+
+      query._pushOperationOntoStack(newPart);
+    }
+
+    return query;
+  }
+
+  walk(callback, _checkContextKeys) {
+    const walkQueries = (query, parent, contextKey, depth) => {
+      let parts = query.getOperationStack();
+      for (let i = 0, il = parts.length; i < il; i++) {
+        let part = parts[i];
+        if (!part)
+          continue;
+
+        for (let j = 0, jl = checkContextKeys.length; j < jl; j++) {
+          let contextKey = checkContextKeys[j];
+          if (!Object.prototype.hasOwnProperty.call(part, contextKey))
+            continue;
+
+          let value = part[contextKey];
+          if (value && this.constructor.isQuery(value))
+            walkQueries(value, part, contextKey, depth + 1);
+        }
+      }
+
+      if (parent !== null)
+        callback(query, parent, contextKey, depth);
+    };
 
-    return new Klass(newContext);
+    let checkContextKeys = _checkContextKeys || [ 'value' ];
+    walkQueries(this, null, null, 0);
   }
 }
 

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

@@ -6,14 +6,14 @@ import Field from '../field';
 
 export declare interface QueryEngineOptions {
   connection: ConnectionBase;
-  [ key: string ]: any;
+  [key: string]: any;
 }
 
 export declare type QueryEngineClass = typeof QueryEngine;
 
 export declare interface CallableInterface {
   (...args: Array<any>): QueryEngine;
-  [ key: string ]: QueryEngine;
+  [key: string]: QueryEngine;
 }
 
 export declare class QueryEngine<T = ConnectionBase> {
@@ -31,33 +31,37 @@ export declare class QueryEngine<T = ConnectionBase> {
   public _newModelScope(Model: ModelClass): QueryEngine;
   public _newFieldScope(Field: Field): QueryEngine;
   public constructor(context: QueryEngineOptions);
-  public _getTopContextID(): number;
-  public _getRawQueryContext(): GenericObject;
-  public _getRawQuery(): Array<GenericObject>;
-  public _isLastPartControl(): boolean;
-  public _isLastPartCondition(): boolean;
-  public _queryHasConditions(): boolean;
-  public _queryHasJoins(): boolean;
-  public _debugQuery(): void;
-  public _addToQuery(queryPart: GenericObject, context: GenericObject): void;
+  public getQueryID(): number;
+  public getOperationContext(): GenericObject;
+  public getOperationStack(): Array<GenericObject>;
+  public isLastOperationControl(): boolean;
+  public isLastOperationCondition(): boolean;
+  public queryHasConditions(): boolean;
+  public queryHasJoins(): boolean;
+  public logQueryOperations(): void;
+  public _pushOperationOntoStack(queryPart: GenericObject, context: GenericObject): void;
   public getConnection(): ConnectionBase;
   public getModel(modelName: string): ModelClass | undefined;
   public getQueryEngineScope(): QueryEngine;
   public getQueryEngineClass(): QueryEngineClass;
   public clone(): QueryEngine;
+  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;
 
   // QueryEngine
   public getModelScopeClass(): QueryEngineClass;
   public getFieldScopeClass(): QueryEngineClass;
+  public getQueryEngineScopeClass(): QueryEngineClass;
   public Model(modelName: string): QueryEngine;
   public unscoped(context?: GenericObject): QueryEngine;
   public toString(options?: GenericObject): string;
   public MERGE(queryEngine: QueryEngine): QueryEngine;
   public all<T extends Model = Model>(options?: GenericObject): Promise<Array<T>>;
-  public fetchAll<T extends Model = Model>(options?: GenericObject): AsyncGenerator<T>;
+  public cursor<T extends Model = Model>(options?: GenericObject): AsyncGenerator<T>;
   public first<T extends Model = Model>(limit?: number | null | undefined, options?: GenericObject): Promise<T | undefined>;
   public last<T extends Model = Model>(limit?: number | null | undefined, options?: GenericObject): Promise<T | undefined>;
-  public update<T extends Model = Model>(attributes: T | GenericObject, options?: GenericObject): Promise<number>;
+  public updateAll<T extends Model = Model>(attributes: T | GenericObject, options?: GenericObject): Promise<number>;
   public destroy(options?: GenericObject): Promise<number>;
   public average(field: Field | string, options?: GenericObject): Promise<number>;
   public count(field: Field | string, options?: GenericObject): Promise<number>;
@@ -66,6 +70,7 @@ export declare class QueryEngine<T = ConnectionBase> {
   public sum(field: Field | string, options?: GenericObject): Promise<number>;
   public pluck(fields: string | Array<string>, options?: GenericObject): Promise<Array<any>>;
   public exists(options?: GenericObject): Promise<boolean>;
+  public finalizeQuery(operation: string, options: GenericObject): Promise<QueryEngine>;
 
   // ModelScope
   public _getField(fieldName: string): Field | undefined;
@@ -80,70 +85,70 @@ export declare class QueryEngine<T = ConnectionBase> {
     (): QueryEngine;
 
     name: QueryEngine;
-    [ key: string ]: QueryEngine;
+    [key: string]: QueryEngine;
   };
 
   declare public AND: {
     (query: QueryEngine): QueryEngine;
 
     name: QueryEngine;
-    [ key: string ]: QueryEngine;
+    [key: string]: QueryEngine;
   };
 
   declare public OR: {
     (query: QueryEngine): QueryEngine;
 
     name: QueryEngine;
-    [ key: string ]: QueryEngine;
+    [key: string]: QueryEngine;
   };
 
   declare public DISTINCT: {
     (fullyQualifiedName: string | Field): QueryEngine;
 
     name: QueryEngine;
-    [ key: string ]: QueryEngine;
+    [key: string]: QueryEngine;
   };
 
   declare public INNER_JOIN: {
     (): QueryEngine;
 
     name: QueryEngine;
-    [ key: string ]: QueryEngine;
+    [key: string]: QueryEngine;
   };
 
   declare public LEFT_JOIN: {
     (): QueryEngine;
 
     name: QueryEngine;
-    [ key: string ]: QueryEngine;
+    [key: string]: QueryEngine;
   };
 
   declare public RIGHT_JOIN: {
     (): QueryEngine;
 
     name: QueryEngine;
-    [ key: string ]: QueryEngine;
+    [key: string]: QueryEngine;
   };
 
   declare public FULL_JOIN: {
     (): QueryEngine;
 
     name: QueryEngine;
-    [ key: string ]: QueryEngine;
+    [key: string]: QueryEngine;
   };
 
   declare public CROSS_JOIN: {
     (): QueryEngine;
 
     name: QueryEngine;
-    [ key: string ]: QueryEngine;
+    [key: string]: QueryEngine;
   };
 
   declare public JOIN: {
     (type: string | LiteralBase): QueryEngine;
 
     name: QueryEngine;
-    [ key: string ]: QueryEngine;
+    [key: string]: QueryEngine;
   };
 
   // FieldScope
@@ -158,7 +163,7 @@ export declare class QueryEngine<T = ConnectionBase> {
   public NOT_LIKE(value: string, options?: { caseSensitive: boolean }): QueryEngine;
 
   name: QueryEngine;
-  [ key: string ]: any;
+  [key: string]: any;
 }
 
 export class ModelScope extends QueryEngine { }

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

@@ -64,11 +64,11 @@ class QueryEngine extends QueryEngineBase {
     if (!queryEngine)
       return this;
 
-    let thisQueryContext = this._getRawQueryContext();
+    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._getRawQuery();
+    let sourceQuery           = queryEngine.getOperationStack();
     let currentModel          = thisQueryContext.Model;
     let skipLogicalOperators  = true;
 
@@ -83,10 +83,11 @@ class QueryEngine extends QueryEngineBase {
         'isQueryContext',
         'modelContext',
         'queryEngineScope',
-        'queryRoot',
+        'operationStack',
         'rootContext',
         'rootModel',
         'rootModelName',
+        '_queryFinalized',
       ]);
 
       // For merges, we want to skip the first logical operators
@@ -114,7 +115,7 @@ class QueryEngine extends QueryEngineBase {
         }
       }
 
-      this._addToQuery(Object.assign({
+      this._pushOperationOntoStack(Object.assign({
         Model:      queryPart.Model,
         modelName:  queryPart.modelName,
         Field:      queryPart.Field,
@@ -125,23 +126,25 @@ class QueryEngine extends QueryEngineBase {
     return this;
   }
 
-  all(options) {
+  async all(options) {
     let connection = this.getConnection(options && options.connection);
 
     if (options && options.stream)
-      return connection.select(this, options);
-    else
-      return Utils.collect(connection.select(this, options));
+      throw new TypeError('QueryEngine::all: "stream" option set to true. For streaming, please use the "cursor" method instead.');
+
+    return await Utils.collect(connection.select(await this.finalizeQuery('read', options), options));
   }
 
-  fetchAll(options) {
-    return this.all({ ...(options || {}), stream: true });
+  async *cursor(_options) {
+    let options     = _options || {};
+    let connection  = this.getConnection(options && options.connection);
+    return yield *connection.select(await this.finalizeQuery('read', options), { ...options, stream: true });
   }
 
   async first(_limit, options) {
     let limit       = (_limit == null) ? 1 : _limit;
     let connection  = this.getConnection(options && options.connection);
-    let query       = this.clone().LIMIT(limit);
+    let query       = (await this.finalizeQuery('read', options)).clone().LIMIT(limit);
 
     let result = await Utils.collect(connection.select(query, options));
     return (_limit == null) ? result[0] : result;
@@ -150,55 +153,63 @@ class QueryEngine extends QueryEngineBase {
   async last(_limit, options) {
     let limit       = (_limit == null) ? 1 : _limit;
     let connection  = this.getConnection(options && options.connection);
-    let query       = this.clone().LIMIT(limit);
+    let query       = (await this.finalizeQuery('read', options)).clone().LIMIT(limit);
 
     let result = await Utils.collect(connection.select(query, Object.assign({}, options || {}, { reverseOrder: true })));
     return (_limit == null) ? result[0] : result.reverse();
   }
 
-  async update(attributes, options) {
+  async updateAll(attributes, options) {
     let connection = this.getConnection(options && options.connection);
-    return await connection.updateAll(this, attributes, options);
+    return await connection.updateAll(await this.finalizeQuery('update', options), attributes, options);
   }
 
   async destroy(options) {
     let connection = this.getConnection(options && options.connection);
-    return await connection.destroy(this, options);
+    return await connection.destroy(await this.finalizeQuery('delete', options), options);
   }
 
   async average(field, options) {
     let connection = this.getConnection(options && options.connection);
-    return await connection.average(this, field, options);
+    return await connection.average(await this.finalizeQuery('read', options), field, options);
   }
 
   async count(field, options) {
     let connection = this.getConnection(options && options.connection);
-    return await connection.count(this, field, options);
+    return await connection.count(await this.finalizeQuery('read', options), field, options);
   }
 
   async min(field, options) {
     let connection = this.getConnection(options && options.connection);
-    return await connection.min(this, field, options);
+    return await connection.min(await this.finalizeQuery('read', options), field, options);
   }
 
   async max(field, options) {
     let connection = this.getConnection(options && options.connection);
-    return await connection.max(this, field, options);
+    return await connection.max(await this.finalizeQuery('read', options), field, options);
   }
 
   async sum(field, options) {
     let connection = this.getConnection(options && options.connection);
-    return await connection.sum(this, field, options);
+    return await connection.sum(await this.finalizeQuery('read', options), field, options);
   }
 
   async pluck(fields, options) {
     let connection = this.getConnection(options && options.connection);
-    return await connection.pluck(this, fields, options);
+    return await connection.pluck(await this.finalizeQuery('read', options), fields, options);
   }
 
   async exists(options) {
     let connection = this.getConnection(options && options.connection);
-    return await connection.exists(this, options);
+    return await connection.exists(await this.finalizeQuery('read', options), options);
+  }
+
+  async finalizeQuery(crudOperation, options) {
+    let connection = this.getConnection();
+    if (connection && typeof connection.finalizeQuery === 'function')
+      return await connection.finalizeQuery(crudOperation, this, options);
+
+    return this;
   }
 
   [ProxyClass.MISSING](target, prop) {

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

@@ -125,7 +125,7 @@ const TYPE_OPERATIONS = {
   'get': function({ field, type }, userQuery, options, ...args) {
     const doGet = async function*() {
       let query                       = await type.prepareQuery({ connection: null, self: this, field, options }, [ userQuery ].concat(args));
-      let results                     = query.all(Object.assign({}, options, { stream: true }));
+      let results                     = query.cursor(options);
       let primaryModelRelationalArray = [];
 
       this[field.fieldName] = primaryModelRelationalArray;

package/lib/types/virtual/relational-type-base.js

@@ -170,7 +170,7 @@ class RelationalTypeBase extends Type {
     let PrimaryModel      = (context.self && context.self.getModel());
     let primaryModelName  = PrimaryModel.getModelName();
     let query             = await this.prepareQuery(Object.assign({ connection }, context), args);
-    let queryParts        = query._getRawQuery();
+    let queryParts        = query.getOperationStack();
     let queryContext      = (queryParts[queryParts.length - 1] || {});
     let TargetModel       = queryContext.rootModel;
     let TargetField       = queryContext.rootField;
@@ -186,7 +186,7 @@ class RelationalTypeBase extends Type {
       let rightQueryContext = null;
 
       if (QueryEngine.isQuery(conditionValue)) {
-        rightQueryContext = conditionValue._getRawQueryContext();
+        rightQueryContext = conditionValue.getOperationContext();
         if (rightQueryContext.condition)
           continue;
       } else {

package/lib/utils/model-utils.js

@@ -9,8 +9,9 @@ function isUUID(value) {
   return UUID.validate(value);
 }
 
-function sanitizeFieldString(str) {
-  return ('' + str).replace(/[^\w:.]+/g, '').replace(/([:.])+/g, '$1');
+function sanitizeFieldString(_str) {
+  let str = (typeof _str === 'symbol') ? (_str.toString()) : (_str + '');
+  return str.replace(/[^\w:.]+/g, '').replace(/([:.])+/g, '$1');
 }
 
 /// Parse a fully qualified field name.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mythix-orm",
-  "version": "1.8.3",
+  "version": "1.10.2",
   "description": "ORM for Mythix framework",
   "main": "lib/index",
   "type": "commonjs",