mythix-orm 1.8.3 → 1.11.0

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.
@@ -126,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);
@@ -152,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());
@@ -205,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.8.3",
+  "version": "1.11.0",
   "description": "ORM for Mythix framework",
   "main": "lib/index",
   "type": "commonjs",