mythix-orm 1.10.2 → 1.11.1

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

@@ -3,11 +3,128 @@
 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) {
+  const applyQueryOrder = (_order, replace) => {
+    let query = this;
+    let order = Nife.toArray(_order).filter(Boolean);
+
+    let asc = order.filter((thisOrder) => {
+      if (!Nife.instanceOf(thisOrder, 'string'))
+        return true;
+
+      if (thisOrder.charAt(0) === '-')
+        return false;
+
+      return true;
+    });
+
+    let desc = order.filter((thisOrder) => {
+      if (!Nife.instanceOf(thisOrder, 'string'))
+        return false;
+
+      if (thisOrder.charAt(0) !== '-')
+        return false;
+
+      return true;
+    });
+
+    if (Nife.isNotEmpty(asc)) {
+      asc = asc.map((thisOrder) => {
+        if (!Nife.instanceOf(thisOrder, 'string'))
+          return thisOrder;
+
+        return thisOrder.replace(/^\+/, '');
+      });
+
+      // eslint-disable-next-line new-cap
+      query = (replace) ? ASC(asc) : ASC('+', asc);
+    }
+
+    if (Nife.isNotEmpty(desc)) {
+      desc = desc.map((thisOrder) => {
+        if (!Nife.instanceOf(thisOrder, 'string'))
+          return thisOrder;
+
+        return thisOrder.replace(/^-/, '');
+      });
+
+      // eslint-disable-next-line new-cap
+      query = (replace) ? DESC(desc) : DESC('+', desc);
+    }
+
+    return query;
+  };
+
+  const DESC = (...args) => {
+    return applyOrderClause.call(this, { direction: '-' }, ...args);
+  };
+
+  const ASC = (...args) => {
+    return applyOrderClause.call(this, { direction: '+' }, ...args);
+  };
+
+  const ADD = (...args) => {
+    return applyQueryOrder(args, false);
+  };
+
+  const REPLACE = (...args) => {
+    return applyQueryOrder(args, true);
+  };
+
+  func.DESC = DESC;
+  func.ASC = ASC;
+  func.ADD = ADD;
+  func.REPLACE = REPLACE;
+
+  return func;
+}
+
 class ModelScope extends QueryEngineBase {
   _getField(fieldName) {
     let Model = this.currentContext.Model;
@@ -46,18 +163,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 +188,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 +199,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);
+  });
 
-    values = Nife.toArray(values).filter((value) => {
+  GROUP_BY(...args) {
+    let entities = Nife.arrayFlatten(args);
+
+    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 true;
+      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.');
+    }
+
+    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 +301,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 +380,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,21 @@ 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 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 ORDER: {
+    (...args: Array<LiteralBase | Field | string | Array<LiteralBase | Field | string>>): QueryEngine;
+
+    ASC: (...args: Array<LiteralBase | Field | string | Array<LiteralBase | Field | string>>) => QueryEngine;
+    DESC: (...args: Array<LiteralBase | Field | string | Array<LiteralBase | Field | string>>) => QueryEngine;
+    ADD: (...args: Array<LiteralBase | Field | string | Array<LiteralBase | Field | string>>) => QueryEngine;
+    REPLACE: (...args: Array<LiteralBase | Field | string | Array<LiteralBase | Field | string>>) => QueryEngine;
+
+    name: QueryEngine;
+  };
 
   declare public NOT: {
     (): QueryEngine;