mythix-orm 1.10.2 → 1.11.0

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.0",
   "description": "ORM for Mythix framework",
   "main": "lib/index",
   "type": "commonjs",