mythix-orm 1.10.2 → 1.11.1

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

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

@@ -140,17 +140,17 @@ class RelationalTypeBase extends Type {
       };
 
       let target = {
-        Model:      leftContext.Model,
-        modelName:  leftContext.modelName,
-        field:      leftContext.Field,
-        fieldName:  leftContext.fieldName,
+        Model:     leftContext.Model,
+        modelName: leftContext.modelName,
+        field:     leftContext.Field,
+        fieldName: leftContext.fieldName,
       };
 
       let source = {
-        Model:      rightContext.Model,
-        modelName:  rightContext.modelName,
-        field:      rightContext.Field,
-        fieldName:  rightContext.fieldName,
+        Model:     rightContext.Model,
+        modelName: rightContext.modelName,
+        field:     rightContext.Field,
+        fieldName: rightContext.fieldName,
       };
 
       // The primary model is always the target
@@ -205,10 +205,10 @@ class RelationalTypeBase extends Type {
         let targetField     = fkField.getTargetField(connection);
         let targetFieldName = fkField.getTargetFieldName(connection);
         let fkContext       = {
-          Model:      targetModel,
-          modelName:  targetModelName,
-          field:      targetField,
-          fieldName:  targetFieldName,
+          Model:     targetModel,
+          modelName: targetModelName,
+          field:     targetField,
+          fieldName: targetFieldName,
         };
 
         if (!isAlreadyVisited(fkContext, rightQueryContext))
@@ -222,10 +222,10 @@ class RelationalTypeBase extends Type {
         let targetField     = fkField.getTargetField(connection);
         let targetFieldName = fkField.getTargetFieldName(connection);
         let fkContext       = {
-          Model:      targetModel,
-          modelName:  targetModelName,
-          field:      targetField,
-          fieldName:  targetFieldName,
+          Model:     targetModel,
+          modelName: targetModelName,
+          field:     targetField,
+          fieldName: targetFieldName,
         };
 
         if (!isAlreadyVisited(leftQueryContext, fkContext))
@@ -245,16 +245,16 @@ class RelationalTypeBase extends Type {
     // be copying field values from
     let targetModelName = TargetModel.getModelName();
     let source      = {
-      Model:      TargetModel,
-      modelName:  targetModelName,
-      Field:      TargetField,
-      fieldName:  TargetField.fieldName,
+      Model:     TargetModel,
+      modelName: targetModelName,
+      Field:     TargetField,
+      fieldName: TargetField.fieldName,
     };
     let target    = {
-      Model:      PrimaryModel,
-      modelName:  PrimaryModel.getModelName(),
-      Field:      context.field,
-      fieldName:  context.field.fieldName,
+      Model:     PrimaryModel,
+      modelName: PrimaryModel.getModelName(),
+      Field:     context.field,
+      fieldName: context.field.fieldName,
     };
 
     if (!isAlreadyVisited(source, target))

package/lib/utils/index.js

@@ -7,7 +7,6 @@ const AsyncStore  = require('./async-store');
 
 const {
   collect,
-  objectAssignSpecial,
   valueToDateTime,
 } = MiscUtils;
 
@@ -31,6 +30,7 @@ const {
 const {
   parseFilterFieldAndOperator,
   generateQueryFromFilter,
+  margeFields,
 } = QueryUtils;
 
 const {
@@ -48,7 +48,6 @@ module.exports = {
 
   // MiscUtils
   collect,
-  objectAssignSpecial,
   valueToDateTime,
 
   // ModelUtils
@@ -70,6 +69,7 @@ module.exports = {
   // QueryUtils
   parseFilterFieldAndOperator,
   generateQueryFromFilter,
+  margeFields,
 
   // AsyncStore
   getContextStore,

package/lib/utils/misc-utils.d.ts

@@ -2,5 +2,4 @@ import { DateTime } from 'luxon';
 import { GenericObject } from '../interfaces/common';
 
 declare function collect(iterator: AsyncIterator<any>): Promise<Array<any>>;
-declare function objectAssignSpecial(obj: GenericObject, proto?: GenericObject | null, skipKeys?: Array<string> | GenericObject): GenericObject;
 declare function valueToDateTime(value: DateTime | Date | number | BigInt | string, format?: string): DateTime;

package/lib/utils/misc-utils.js

@@ -12,29 +12,6 @@ async function collect(iterator) {
   return items;
 }
 
-function objectAssignSpecial(obj, proto, skipKeys) {
-  const isKeySkipped = (key) => {
-    if (Array.isArray(skipKeys))
-      return (skipKeys.indexOf(key) >= 0);
-
-    return Object.prototype.hasOwnProperty.call(skipKeys, key);
-  };
-
-  let newObj  = Object.create(proto || {});
-  let keys    = Object.keys(obj);
-
-  // eslint-disable-next-line guard-for-in
-  for (let i = 0, il = keys.length; i < il; i++) {
-    let key = keys[i];
-    if (skipKeys && isKeySkipped(key))
-      continue;
-
-    newObj[key] = obj[key];
-  }
-
-  return newObj;
-}
-
 function valueToDateTime(value, format) {
   if (DateTime.isDateTime(value)) {
     return value;
@@ -59,6 +36,5 @@ function valueToDateTime(value, format) {
 
 module.exports = {
   collect,
-  objectAssignSpecial,
   valueToDateTime,
 };

package/lib/utils/model-utils.js

@@ -127,19 +127,18 @@ function fieldToFullyQualifiedName(field, Model) {
 }
 
 function sortModelNamesByDependencyOrder(connection, _modelNames, dependencyHelper) {
-  const recursiveAdd = (modelName, _depth) => {
+  const recursiveAdd = (modelName, alreadyVisisted) => {
     if (modelNames.indexOf(modelName) < 0)
       return;
 
-    let depth = _depth || 0;
-
-    // eslint-disable-next-line no-magic-numbers
-    if (depth > 10)
-      throw new Error(`ModelUtils::sortModelNamesByDependencyOrder: Cyclic dependency detected with model "${modelName}".`);
-
     if (finalOrder.has(modelName))
       return;
 
+    if (alreadyVisited.has(modelName))
+      return;
+
+    alreadyVisited.add(modelName);
+
     let dependentModelNames = modelOrderMap[modelName];
     if (dependentModelNames == null) {
       let Model = connection.getModel(modelName);
@@ -153,22 +152,23 @@ function sortModelNamesByDependencyOrder(connection, _modelNames, dependencyHelp
 
     for (let j = 0, jl = dependentModelNames.length; j < jl; j++) {
       let dependentModelName = dependentModelNames[j];
-      recursiveAdd(dependentModelName, depth + 1);
+      recursiveAdd(dependentModelName, alreadyVisited);
     }
 
     finalOrder.set(modelName, dependentModelNames);
   };
 
-  let modelOrderMap = {};
-  let modelNames    = Nife.toArray(_modelNames).slice().sort();
-  let finalOrder    = new Map();
+  let modelOrderMap   = {};
+  let modelNames      = Nife.toArray(_modelNames).slice().sort();
+  let finalOrder      = new Map();
+  let alreadyVisited  = new Set();
 
   for (let i = 0, il = modelNames.length; i < il; i++) {
     let modelName = modelNames[i];
     if (!modelName)
       continue;
 
-    recursiveAdd(modelName);
+    recursiveAdd(modelName, alreadyVisited);
   }
 
   let sortedModelNames = Array.from(finalOrder.keys());
@@ -206,11 +206,11 @@ async function getRelationalModelStatusForField(connection, self, field, ...args
   let primaryModelName  = self.getModelName();
   let relationalMap  = {
     [primaryModelName]: {
-      create:     !self.isPersisted(),
-      instance:   self,
-      modelName:  primaryModelName,
-      Model:      PrimaryModel,
-      fields:     new Map(),
+      create:    !self.isPersisted(),
+      instance:  self,
+      modelName: primaryModelName,
+      Model:     PrimaryModel,
+      fields:    new Map(),
     },
   };
 

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

@@ -4,8 +4,15 @@ import { Model, ModelClass } from '../model';
 import { QueryEngine } from '../query-engine';
 
 export declare function parseFilterFieldAndOperator(fieldName: string): { field: string, operator: string };
+
 export declare function generateQueryFromFilter(
   connection: ConnectionBase,
   Model: ModelClass,
   filter: Array<GenericObject | Model> | GenericObject | Model,
 ): QueryEngine;
+
+export declare function margeFields(
+  connection: ConnectionBase,
+  currentFields: Map<string, any>,
+  incomingFields: Array<any>
+): Map<string, any>;

package/lib/utils/query-utils.js

@@ -34,19 +34,19 @@ const Nife = require('nife');
 // WHERE firstName IN ('John', 'Bob', 'Mary')
 
 const FILTER_OPERATORS = {
-  '=':  (Model, fieldName, query, value) => {
+  '=': (Model, fieldName, query, value) => {
     return query.AND[fieldName].EQ(value);
   },
   '!=': (Model, fieldName, query, value) => {
     return query.AND[fieldName].NEQ(value);
   },
-  '>':  (Model, fieldName, query, value) => {
+  '>': (Model, fieldName, query, value) => {
     return query.AND[fieldName].GT(value);
   },
   '>=': (Model, fieldName, query, value) => {
     return query.AND[fieldName].GTE(value);
   },
-  '<':  (Model, fieldName, query, value) => {
+  '<': (Model, fieldName, query, value) => {
     return query.AND[fieldName].LT(value);
   },
   '<=': (Model, fieldName, query, value) => {
@@ -61,7 +61,7 @@ const FILTER_OPERATORS = {
     return query.AND(Model.where[fieldName].LT(value[0]).OR[fieldName].GT(value[1]));
   },
   // Like
-  '*':  (Model, fieldName, query, value) => {
+  '*': (Model, fieldName, query, value) => {
     return query.AND[fieldName].LIKE(value);
   },
   // NOT Like
@@ -180,7 +180,178 @@ function generateQueryFromFilter(connection, Model, _filter, _depth) {
   return query;
 }
 
+function margeFields(queryEngine, currentFields, _incomingFields, extraData, _options) {
+  const RESET = 0;
+  const ADD   = 1;
+  const SUB   = 2;
+
+  const getInitialMode = (incomingFields) => {
+    for (let i = 0, il = incomingFields.length; i < il; i++) {
+      let incomingField = incomingFields[i];
+      if (!incomingField)
+        continue;
+
+      if (typeof incomingField.isLiteral === 'function' && incomingField.isLiteral(incomingField))
+        return RESET;
+
+      if (typeof incomingField.isModelClass === 'function' && incomingField.isModelClass(incomingField))
+        return RESET;
+
+      if (typeof incomingField.isField === 'function' && incomingField.isField(incomingField))
+        return RESET;
+
+      if (!Nife.instanceOf(incomingField, 'string'))
+        RESET;
+
+      let firstChar = incomingField.charAt(0);
+      if (firstChar === '+')
+        return ADD;
+
+      if (firstChar === '-')
+        return SUB;
+
+      return RESET;
+    }
+  };
+
+  const addOrRemove = (mode, key, item) => {
+    if (mode === ADD)
+      fields.set(key, { ...(extraData || {}), value: item });
+    else
+      fields.delete(key);
+  };
+
+  const addOrRemoveAllModelFields = (mode, Model) => {
+    let modelName = Model.getModelName();
+
+    Model.iterateFields(({ field, fieldName }) => {
+      if (field.type.isVirtual())
+        return;
+
+      let fullFieldName = `${modelName}:${fieldName}`;
+      addOrRemove(mode, fullFieldName, field);
+    });
+  };
+
+  let context = queryEngine.getOperationContext();
+  let incomingFields = _incomingFields.filter(Boolean);
+  if (Nife.isEmpty(incomingFields))
+    return new Map();
+
+  let options       = _options || {};
+  let connection    = queryEngine.getConnection();
+  let RootModel     = context.rootModel;
+  let rootModelName = RootModel.getModelName();
+  let mode          = getInitialMode(incomingFields);
+  let fields        = (mode === RESET) ? new Map() : new Map(currentFields);
+  let allQueryModels;
+
+  if (mode === RESET)
+    mode = ADD;
+
+  for (let i = 0, il = incomingFields.length; i < il; i++) {
+    let incomingField = incomingFields[i];
+    if (!incomingField)
+      continue;
+
+    if (typeof incomingField.isLiteral === 'function' && incomingField.isLiteral(incomingField)) {
+      if (!connection)
+        throw new Error('QueryUtils::margeFields: "connection" is required, but not found.');
+
+      let result = incomingField.toString(connection, options);
+      addOrRemove(mode, result, result);
+      continue;
+    }
+
+    if (typeof incomingField.isModelClass === 'function' && incomingField.isModelClass(incomingField)) {
+      addOrRemoveAllModelFields(mode, incomingField);
+      continue;
+    }
+
+    if (typeof incomingField.isField === 'function' && incomingField.isField(incomingField)) {
+      let fullFieldName = `${incomingField.Model.getModelName()}:${incomingField.fieldName}`;
+      addOrRemove(mode, fullFieldName, incomingField);
+      continue;
+    }
+
+    if (!Nife.instanceOf(incomingField, 'string'))
+      continue;
+
+    if (!connection)
+      throw new Error('QueryUtils::margeFields: "connection" is required, but not found.');
+
+    if (!incomingField)
+      continue;
+
+    let firstChar = incomingField.charAt(0);
+    let currentMode = mode;
+
+    if (firstChar === '+') {
+      if (incomingField.length === 1) {
+        mode = ADD;
+        continue;
+      }
+
+      currentMode = ADD;
+      incomingField = incomingField.substring(1);
+    }
+
+    if (firstChar === '-') {
+      if (incomingField.length === 1) {
+        mode = SUB;
+        continue;
+      }
+
+      currentMode = SUB;
+      incomingField = incomingField.substring(1);
+    }
+
+    if (incomingField.charAt(0) === '@') {
+      incomingField = incomingField.substring(1);
+      addOrRemove(currentMode, incomingField, incomingField);
+      continue;
+    }
+
+    if (incomingField === '*') {
+      if (!allQueryModels)
+        allQueryModels = queryEngine.getAllModelsUsedInQuery();
+
+      for (let i = 0, il = allQueryModels.length; i < il; i++) {
+        let Model = allQueryModels[i];
+        addOrRemoveAllModelFields(currentMode, Model);
+      }
+
+      continue;
+    }
+
+    let def = connection.parseQualifiedName(incomingField);
+    if (!def.modelName)
+      def.modelName = rootModelName;
+
+    let Model = connection.getModel(def.modelName);
+    if (!Model)
+      throw new Error(`QueryUtils::margeFields: Model "${def.modelName}" not found.`);
+
+    if (Nife.isEmpty(def.fieldNames)) {
+      addOrRemoveAllModelFields(currentMode, Model);
+      continue;
+    }
+
+    let modelName = Model.getModelName();
+    let fieldName = def.fieldNames[0];
+    let field     = connection.getField(fieldName, modelName);
+    if (!field)
+      throw new Error(`QueryUtils::margeFields: Field "${fieldName}" not found.`);
+
+    let fullFieldName = `${modelName}:${fieldName}`;
+    addOrRemove(currentMode, fullFieldName, field);
+  }
+
+  return fields;
+}
+
 module.exports = {
   parseFilterFieldAndOperator,
   generateQueryFromFilter,
+  margeFields,
 };

package/package.json

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