mythix-orm 1.8.3 → 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._addToQuery({ 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._addToQuery({ 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._addToQuery({ 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._addToQuery({ 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._addToQuery({ 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._addToQuery({ 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._addToQuery({ 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._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}`);
+      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._addToQuery({ 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._addToQuery({ 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._addToQuery({ 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._addToQuery({ 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._addToQuery({ 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._addToQuery({ 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._addToQuery({ 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) {
@@ -27,13 +27,13 @@ class QueryEngineBase extends ProxyClass {
     if (value._isQueryEngine)
       return true;
 
-    if (typeof value._getRawQueryContext === 'function')
+    if (typeof value.getOperationContext === 'function')
       return true;
 
     return false;
   }
 
-  static queryContextType(queryContext) {
+  static queryOperationInfo(queryContext) {
     let contextParams = {
       hasCondition: false,
       hasField:     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];
@@ -120,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;
     }
@@ -137,19 +143,19 @@ 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
     // already the current model of the scope
     if (context.Model !== Model)
-      context.queryRoot.push(newContext);
+      context.operationStack.push(newContext);
+
+    if (isFirst)
+      newScope = newScope.PROJECT(Model);
 
     // But we always need to return the scope
     // for the proxy to work properly
@@ -167,13 +173,13 @@ 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
     // 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 +199,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,40 +210,40 @@ 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:          () => {},
+        set: () => {},
       },
     });
   }
 
-  _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 +252,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 +262,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 +278,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;
@@ -285,14 +291,13 @@ class QueryEngineBase extends ProxyClass {
       else
         console.log(`${operator} -> ${queryPart.value}`);
     }
-
   }
 
-  _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 +332,115 @@ 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');
+  }
 
-    queryRootCopy.push(newContext);
+  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: [],
+    });
+
+    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);
+    };
+
+    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;
+  }
 
-    return new Klass(newContext);
+  isModelUsedInQuery(Model) {
+    let allModels = this.getAllModelsUsedInQuery();
+    return (allModels.indexOf(Model) >= 0);
   }
 }