@izara_project/izara-shared-search-and-sort 1.0.8 → 1.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-shared-search-and-sort",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "Shared Libraries frontend/backend for Search and Sort stack",
   "main": "index.js",
   "scripts": {

package/src/DataFieldsSharedLib.js

@@ -22,29 +22,33 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // let { pattern } = validatorSchema.stringNotEmpty();
 // export default [...]
 
-import { objectHash as hash } from '@izara_project/izara-shared-core';  //const hash = require('@izara_project/izara-shared-core').objectHash;
+import { objectHash as hash } from '@izara_project/izara-shared-core';
 import lodash from 'lodash';
 const { isEmpty } = lodash;
-import filtersSharedLib from './FiltersSharedLib.js'; //const filtersSharedLib = require('./FiltersSharedLib');
+import filtersSharedLib from './FiltersSharedLib.js';
+import LogicalStructureSharedLib from './LogicalStructureSharedLib.js'
 
 async function createRequiredData(
   objType,
+  initialLogicalElementId,
+  logicalElements,
   requiredDataFields,
   complexFilterCombinations,
   perParentCombinations,
   requiredDataLinkStepObjects,
   requiredDataLinkSteps,
   values,
-  getSchemaFn
 ) {
   console.log('createRequiredData: ', {
     objType,
+    initialLogicalElementId,
+    logicalElements,
     requiredDataFields,
     complexFilterCombinations,
     perParentCombinations,
     requiredDataLinkStepObjects,
+    requiredDataLinkSteps,
     values,
-    getSchemaFn
   });
 
   let errorsObject = {};
@@ -69,12 +73,19 @@ async function createRequiredData(
     console.log('initial data: ', { linkSteps });
 
     let [fieldName, returnValue, linkPathErrorObject, linkPathErrorsFound] = await createLinkPath(
+      objType,
       linkSteps,
       requiredDataLinkStepObjects,
       requiredDataLinkSteps,
       perParentCombinations,
       complexFilterCombinations,
       values,
+      {
+        objType: objType,
+        initialLogicalElementId: initialLogicalElementId,
+        logicalElements: logicalElements
+      },
+      [],
       errorsObject,
       errorsFound
     );
@@ -129,15 +140,6 @@ async function createRequiredData(
         linkPathObjectId: pathId
       };
 
-      let requiredFieldNameObject = {
-        // fieldName: fieldName,
-        fieldName: setObject,
-        linkPathObjects: {
-          [pathId]: pathObject
-        },
-        linkPathSteps: returnValue.linkStepObjects
-      };
-
       if (returnValue.hasOwnProperty('complexFilterCombinations')) {
         // requiredFieldNameObject.complexFilterCombinations = returnValue.complexFilterCombinations;
         Object.assign(setComplexFilterCombinations, returnValue.complexFilterCombinations);
@@ -150,6 +152,15 @@ async function createRequiredData(
         };
       };
 
+      let requiredFieldNameObject = {
+        // fieldName: fieldName,
+        fieldName: setObject,
+        linkPathObjects: {
+          [pathId]: pathObject
+        },
+        linkPathSteps: returnValue.linkStepObjects
+      };
+
       if (returnValue.hasOwnProperty('perParentCombinations')) {
         // requiredFieldNameObject.perParentCombinations = returnValue.perParentCombinations;
         Object.assign(setPerParentCombinations, returnValue.perParentCombinations);
@@ -179,7 +190,12 @@ async function createRequiredData(
       console.log("------- requiredData has only fieldName ---------");
 
       let requiredFieldNameObject = {
-        fieldName: fieldName
+        fieldName: {
+          fieldName: fieldName
+        },
+        //* don hash
+        linkPathObjects: {},
+        linkPathSteps: {}
       };
       console.log("requiredFieldNameObject: ", requiredFieldNameObject);
 
@@ -264,12 +280,15 @@ async function createRequiredData(
 
 
 async function createLinkPath(
+  objType,
   linkSteps,
   requiredDataLinkStepObjects,
   requiredDataLinkSteps,
   perParentCombinations,
   complexFilterCombinations,
   values,
+  filtersStructure,
+  path,
   errorsObject,
   errorsFound,
   index = 0,
@@ -283,6 +302,8 @@ async function createLinkPath(
     perParentCombinations,
     complexFilterCombinations,
     values,
+    filtersStructure,
+    path,
     errorsObject,
     errorsFound,
     index,
@@ -292,6 +313,8 @@ async function createLinkPath(
   let fieldName = null;
   let returnValue = {}; //* must return only linkPath params
 
+  let sortObj = null;
+
   let linkStepId = linkSteps[index];
   console.log('linkStepId: ', linkStepId);
 
@@ -302,33 +325,63 @@ async function createLinkPath(
     // last link that has only fieldName
     console.log('---------- is final link ----------', { index, linkStep });
 
-    return [linkStep.fieldName, returnValue, errorsObject, errorsFound]
+    let sortValueObj = null;
+
+    if (linkStep.hasOwnProperty("dataType")) {
+
+      sortValueObj = {
+        dataType: linkStep.dataType,
+        value: linkStep.value
+      }
+
+    }
+
+    return [linkStep.fieldName, returnValue, errorsObject, errorsFound, sortValueObj]
 
   } else {
     // has nextLink
     console.log('---------- is next link ----------', { index, linkStep });
 
+    if (linkStep.hasOwnProperty("pathLinkType")) {
+      path.push({
+        objType: objType,
+        pathLinkType: linkStep.pathLinkType
+      });
+      console.log("path", path);
+      // console.log('---------- is next link ----------', hhhh);
+    }
+
     let conditionsPromise = checkConditionsLink(
-      // let [conditions, conditionErrObject, conditionErrFound] = await this.checkConditionsLink(
+      // let [conditions, conditionErrObject, conditionErrFound] = await checkConditionsLink(
       linkStep.pathLinkType.objType,
       linkStep,
       perParentCombinations,
       complexFilterCombinations,
       values,
+      filtersStructure,
       linkSteps,
       requiredDataLinkStepObjects,
       requiredDataLinkSteps,
+      path,
       errorsObject,
       errorsFound
     );
+    // console.log('checkConditionsLink in link', {
+    //   conditions,
+    //   conditionErrObject,
+    //   conditionErrFound
+    // });
 
-    [fieldName, returnValue, errorsObject, errorsFound] = await createLinkPath(
+    [fieldName, returnValue, errorsObject, errorsFound, sortObj] = await createLinkPath(
+      linkStep.pathLinkType.objType,
       linkSteps,
       requiredDataLinkStepObjects,
       requiredDataLinkSteps,
       perParentCombinations,
       complexFilterCombinations,
       values,
+      filtersStructure,
+      path,
       errorsObject,
       errorsFound,
       index + 1
@@ -596,7 +649,7 @@ async function createLinkPath(
       console.log('returnValue', returnValue);
     }
   }
-  return [fieldName, returnValue, errorsObject, errorsFound]
+  return [fieldName, returnValue, errorsObject, errorsFound, sortObj]
 }
 
 
@@ -606,9 +659,11 @@ async function checkConditionsLink(
   perParentCombinations,
   complexFilterCombinations,
   values,
+  filtersStructure,
   linkSteps,
   requiredDataLinkStepObjects,
   requiredDataLinkSteps,
+  path,
   errorsObject,
   errorsFound
 ) {
@@ -618,23 +673,76 @@ async function checkConditionsLink(
     perParentCombinations,
     complexFilterCombinations,
     values,
+    filtersStructure,
     linkSteps,
     requiredDataLinkStepObjects,
     requiredDataLinkSteps,
+    path,
     errorsObject,
     errorsFound
   });
 
 
-  let conditionLinkObject = {}
+  let conditionLinkObject = {};
+  let filterMainRequest = null
+
+  if (linkStepObject.hasOwnProperty("addFilterMain") && linkStepObject.addFilterMain === true) {
+
+    path.push({ objType: objType });
+    console.log('path', path);
+
+    let [filterStructureCurrent, filterErrorObject, filterErrorFound] = await LogicalStructureSharedLib.changeObjTypePath(
+      objType,
+      filtersStructure,
+      path
+    );
+
+    console.log('changeObjTypePath', {
+      filterStructureCurrent,
+      filterErrorObject,
+      filterErrorFound
+    });
+
+    if (filterErrorFound.length > 0) {
+      Object.assign(errorsObject, filterErrorObject);
+      errorsFound = errorsFound.concat('filterErrorFound');
+    } else {
+      filterMainRequest = filterStructureCurrent;
+    }
+
+  }
 
   if (linkStepObject.hasOwnProperty('filterElements')) {
     console.log('------------ has filterElements ------------');
 
+    let filters = {};
+
+    if (filterMainRequest !== null) {
+      if (hash(filterMainRequest.objType) !== hash(linkStepObject.filterElements.objType)) {
+        errorsObject[linkStepObject.filterElements.objType.objectType] = 'this linkStep has error when combine filterMain in link';
+        errorsFound.push(`${linkStepObject.filterElements.objType.objectType}: this linkStep has error when combine filterMain in link`);
+        return [null, errorsObject, errorsFound];
+      }
+
+      filters = filtersSharedLib.combineLogicalElements(
+        filterMainRequest,
+        linkStepObject.filterElements
+      );
+
+
+    } else {
+      filters = {
+        objType: linkStepObject.filterElements.objType,
+        initialLogicalElementId: linkStepObject.filterElements.initialLogicalElementId,
+        logicalElements: linkStepObject.filterElements.logicalElements,
+      }
+    }
+    console.log('filters: ', filters);
+
     let [complexFilterRequest, status, filterErrorsObject, filterErrorsFound] = filtersSharedLib.createFiltersRequest(
-      linkStepObject.filterElements.objType,
-      linkStepObject.filterElements.initialLogicalElementId,
-      linkStepObject.filterElements.logicalElements,
+      filters.objType,
+      filters.initialLogicalElementId,
+      filters.logicalElements,
       values
     );
     console.log('return complexFilter for filterElements: ', {
@@ -646,13 +754,40 @@ async function checkConditionsLink(
 
     if (filterErrorsFound.length > 0) {
       Object.assign(errorsObject, filterErrorsObject)
-      errorsFound = errorsFound.concat(filterErrorsFound);
-      return [null, errorsObject, errorsFound]
+      errorsFound = errorsFound.concat(filterErrorsFound)
     };
+
     conditionLinkObject.filterElements = complexFilterRequest.filterElements;
     console.log('conditionLinkObject in condition link: ', conditionLinkObject);
+
   }
 
+
+  // if (linkStepObject.hasOwnProperty('filterElements')) {
+  //   console.log('------------ has filterElements ------------');
+
+  //   let [complexFilterRequest, status, filterErrorsObject, filterErrorsFound] = filtersSharedLib.createFiltersRequest(
+  //     linkStepObject.filterElements.objType,
+  //     linkStepObject.filterElements.initialLogicalElementId,
+  //     linkStepObject.filterElements.logicalElements,
+  //     values
+  //   );
+  //   console.log('return complexFilter for filterElements: ', {
+  //     complexFilterRequest,
+  //     status,
+  //     filterErrorsObject,
+  //     filterErrorsFound
+  //   });
+
+  //   if (filterErrorsFound.length > 0) {
+  //     Object.assign(errorsObject, filterErrorsObject)
+  //     errorsFound = errorsFound.concat(filterErrorsFound);
+  //     return [null, errorsObject, errorsFound]
+  //   };
+  //   conditionLinkObject.filterElements = complexFilterRequest.filterElements;
+  //   console.log('conditionLinkObject in condition link: ', conditionLinkObject);
+  // }
+
   if (linkStepObject.hasOwnProperty('aggregate')) {
     console.log('------------ has aggregate ------------');
     if (!linkStepObject.hasOwnProperty('sortFields')) {
@@ -683,19 +818,25 @@ async function checkConditionsLink(
     for (const sortField of linkStepObject.sortFields) {
       console.log('sortField: ', sortField);
       console.log('requiredDataLinkSteps: ', requiredDataLinkSteps);
+      console.log('requiredDataLinkStepObjects: ', requiredDataLinkStepObjects);
       let requiredDataLinkStepSortField = requiredDataLinkStepObjects[sortField.requiredDataLinkStepObjectId];
       console.log('requiredDataLinkStepSortField: ', requiredDataLinkStepSortField);
-
-      console.log(' requiredDataLinkStepSortField.linkSteps: ', requiredDataLinkStepSortField.linkSteps);
+      console.log(' requiredDataLinkStepSortField.linkSteps: ', {
+        linkSteps: requiredDataLinkStepSortField.linkSteps,
+        requiredDataLinkStepSortField: requiredDataLinkStepSortField
+      });
 
       //* make all linkPath in here and send out to combine allLinkPath
-      let [fieldName, childLinkStep, linkErrorsObject, linkErrorsFound] = await createLinkPath(
+      let [fieldName, childLinkStep, linkErrorsObject, linkErrorsFound, sortObj] = await createLinkPath(
+        linkStepObject.pathLinkType.objType,
         requiredDataLinkStepSortField.linkSteps,
         requiredDataLinkStepObjects,
         requiredDataLinkSteps,
         perParentCombinations,
         complexFilterCombinations,
         values,
+        filtersStructure,
+        [],
         errorsObject,
         errorsFound
       );
@@ -703,7 +844,8 @@ async function checkConditionsLink(
         fieldName,
         childLinkStep,
         linkErrorsObject,
-        linkErrorsFound
+        linkErrorsFound,
+        sortObj
       });
 
       if (linkErrorsFound > 0) {
@@ -766,10 +908,19 @@ async function checkConditionsLink(
         });
       };
 
-      sortFieldObjects.push({
+      let sortObject = {
         fieldName: fieldName,
-        dataType: sortField.dataType
-      });
+        // dataType: sortField.dataType
+      }
+
+      if (sortObj !== null) {
+        if (sortObj.dataType === "array") {
+          sortObject.dataType = sortObj.dataType
+          sortObject.values = sortObj.value;
+        }
+      }
+
+      sortFieldObjects.push(sortObject);
       console.log('sortFieldObjects: ', sortFieldObjects);
 
     };

package/src/FiltersSharedLib.js

@@ -17,10 +17,10 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 "use strict";
 
-import { objectHash as hash } from '@izara_project/izara-shared-core';  //const hash = require('@izara_project/izara-shared-core').objectHash;
+import { objectHash as hash } from '@izara_project/izara-shared-core';
 import lodash from 'lodash';
+import objectHash from 'object-hash';
 const { isEmpty } = lodash;
-import complexFilterShared from '@izara_project/izara-core-library-complex-filter';
 
 function validateFilterElement(
   filterElements,
@@ -76,58 +76,65 @@ function createFiltersRequest(
   let filterMainId = null;
   let filterMainObject = {};
   let operation = null;
+  let nextFilterElementId = null;
 
   let errorsObject = {};
   let errorsFound = [];
   let status = 'valid';
 
-  //* validate combine logicalStructure
-  let [validateObject, validateFilterMainId, validateFilterObject, validateErrorsObject, validateErrors] = validateCombinationStructure(
-    objType,
-    initialLogicalElementId,
-    logicalElements,
-    values
-  );
-  console.log('return validateCombinationStructure: ', {
-    validateObject,
-    validateFilterMainId,
-    validateFilterObject,
-    validateErrorsObject,
-    validateErrors
-  });
-
-  if (!validateObject || validateErrors.length > 0) {
-    Object.assign(errorsObject, validateErrorsObject);
-    errorsFound = errorsFound.concat(validateErrors);
-    return [
-      null,
-      'invalid',
-      errorsObject,
-      errorsFound
-    ];
-  };
+  // //* validate combine logicalStructure
+  // let [validateObject, validateFilterMainId, validateFilterObject, validateErrorsObject, validateErrors] = validateCombinationStructure(
+  //   objType,
+  //   initialLogicalElementId,
+  //   logicalElements,
+  //   values
+  // );
+  // console.log('return validateCombinationStructure: ', {
+  //   validateObject,
+  //   validateFilterMainId,
+  //   validateFilterObject,
+  //   validateErrorsObject,
+  //   validateErrors
+  // });
+
+  // if (!validateObject || validateErrors.length > 0) {
+  //   Object.assign(errorsObject, validateErrorsObject);
+  //   errorsFound = errorsFound.concat(validateErrors);
+  //   return [
+  //     null,
+  //     'invalid',
+  //     errorsObject,
+  //     errorsFound
+  //   ];
+  // };
 
   let operationErrorsObject = {};
   let operationErrors = [];
+  let returnFilterElements = {};
 
   [
     filterMainId,
     filterMainObject,
     operation,
     operationErrorsObject,
-    operationErrors
+    operationErrors,
+    nextFilterElementId,
+    returnFilterElements
   ] = filterLogicalElements(
     objType,
     initialLogicalElementId,
     logicalElements,
     values,
   );
+
   console.log('final return filterLogicalElements: ', {
     filterMainId,
     filterMainObject,
     operation,
     operationErrorsObject,
-    operationErrors
+    operationErrors,
+    nextFilterElementId,
+    returnFilterElements
   });
 
   if (errorsFound.length > 0 || filterMainId === null) {
@@ -142,10 +149,9 @@ function createFiltersRequest(
   };
 
   let filterElements = {};
-  if (filterMainObject.filterElement.hasOwnProperty('filterElements')) {
-    filterElements = filterMainObject.filterElement.filterElements;
-
-    delete filterMainObject.filterElement.filterElements;
+  // if (filterMainObject.filterElement.hasOwnProperty('filterElements') || isEmpty(returnFilterElements)) {
+  if (!isEmpty(returnFilterElements)) {
+    filterElements = returnFilterElements;
     Object.assign(filterElements, { [filterMainId]: filterMainObject });
   };
 
@@ -162,18 +168,6 @@ function createFiltersRequest(
   };
   console.log('complexFilterRequest: ', complexFilterRequest);
 
-  // let validate = validateFilterElement(
-  //   complexFilterRequest.filterElements,
-  //   logicalElements
-  // );
-  // _izContext.logger.debug('validate: ', validate);
-
-  // if (validate === false) {
-  //   errorsObject[initialLogicalElementId] = 'filterElements has create fail';
-  //   errorsFound.push("filterElements has create fail");
-  //   return [null, "error", errorsObject, errorsFound]
-  // }
-
   return [
     complexFilterRequest,
     status,
@@ -273,7 +267,9 @@ function validateCombinationStructure(
         initialLogicalElementId = nextElementId;
       };
 
-    } else if (logicalElementType === 'closeBracket') {
+    }
+
+    if (logicalElementType === 'closeBracket') {
       console.log('----------------- closeBracket --------------');
 
       return [
@@ -640,7 +636,9 @@ function validateOperation(
     // check if is an operation, if not simply return currentFilterMainId
     if (!runningFilterObject || !lastLogicalOperator) {
       console.log("+++ validate no operation, R E T U R N  currentFilterMainId ++");
-      return [currentFilterMainId, currentFilterObject, null, errorsFound];
+      let filterElements = currentFilterObject.filterElement.filterElements;
+      delete currentFilterObject.filterElement.filterElements;
+      return [currentFilterMainId, currentFilterObject, null, errorsFound, filterElements];
     }
 
     let filterElements = splitFilterElements(
@@ -650,6 +648,8 @@ function validateOperation(
       currentFilterObject
     );
 
+    console.log("----------------------------------------------------- filterElements", filterElements);
+
     // create new operation FilterObject
     let operationFilterObject = {
       objType: objType,
@@ -667,6 +667,7 @@ function validateOperation(
     console.log("==== validate operationFilterMainId After Hash =====", operationFilterMainId);
 
     console.log("RETURN validate operationFilterMainId ==>", operationFilterMainId);
+    delete operationFilterObject.filterElement.filterElements;
     console.log("RETURN validate operationFilterObject ==>", operationFilterObject);
     console.log("========= [validateOperation ::: End] =======");
 
@@ -676,7 +677,7 @@ function validateOperation(
       filterMainIdB: currentFilterMainId,
     };
 
-    return [operationFilterMainId, operationFilterObject, operation, errorsFound];
+    return [operationFilterMainId, operationFilterObject, operation, errorsFound, filterElements];
 
   } catch (err) {
     throw (err)
@@ -688,6 +689,7 @@ function filterLogicalElements(
   initialLogicalElementId,
   logicalElements,
   values,
+  // filterElements = {},
   nextLogicalElementId = null,
   runningFilterMainId = null,
   runningFilterObject = null,
@@ -716,6 +718,8 @@ function filterLogicalElements(
   let lastNextLogicalElementId = null;
   let currentLogicalElementId = initialLogicalElementId;
 
+  let filterElements = {};
+
   if (nextLogicalElementId !== null) {
     currentLogicalElementId = nextLogicalElementId;
   }
@@ -735,9 +739,24 @@ function filterLogicalElements(
   let logicalElementType = logicalElement.logicalElementType;
   console.log('logicalElementType: ', logicalElementType);
 
+  if (logicalElementType === "operation") {
+
+    lastLogicalOperator = logicalElement.operation;
+
+    if (logicalElement.nextLogicalElementId === null) {
+      errorsObject[initialLogicalElementId] = `this operation structure must set nextLogicalElementId`;
+      errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} must set nextLogicalElementId`);
+    }
+
+    logicalElement = logicalElements[logicalElement.nextLogicalElementId];
+    logicalElementType = logicalElement.logicalElementType;
+
+  }
+
   if (logicalElementType === "openBracket") {
 
     let nextElementId = null;
+    let returnFilterElements = {};
 
     [
       currentFilterMainId,
@@ -745,12 +764,14 @@ function filterLogicalElements(
       operation,
       errorsObject,
       errorsFound,
-      nextElementId
+      nextElementId,
+      returnFilterElements
     ] = filterLogicalElements(
       objType,
       initialLogicalElementId,
       logicalElements,
       values,
+      // filterElements,
       logicalElement.nextLogicalElementId
     );
     console.log('return filterLogicalElement for openBracket: ', {
@@ -758,9 +779,12 @@ function filterLogicalElements(
       currentFilterObject,
       operation,
       errorsObject, errorsFound,
-      lastNextLogicalElementId
+      lastNextLogicalElementId,
+      returnFilterElements
     });
 
+    console.log("bb", bb)
+
     if (nextElementId !== null) {
       lastNextLogicalElementId = nextElementId;
     }
@@ -776,18 +800,6 @@ function filterLogicalElements(
       logicalElement.nextLogicalElementId
     ]
 
-  } else if (logicalElementType === "operation") {
-
-    lastLogicalOperator = logicalElement.operation;
-
-    if (logicalElement.nextLogicalElementId === null) {
-      errorsObject[initialLogicalElementId] = `this operation structure must set nextLogicalElementId`;
-      errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} must set nextLogicalElementId`);
-    }
-
-    logicalElement = logicalElements[logicalElement.nextLogicalElementId];
-    logicalElementType = logicalElement.logicalElementType;
-
   }
 
   console.log("check logicalElement: ", logicalElement);
@@ -922,12 +934,14 @@ function filterLogicalElements(
       operation,
       childErrorsObject,
       childErrorsFound,
-      childNextLogicalElementId
+      childNextLogicalElementId,
+      returnFilterElements
     ] = filterLogicalElements(
       logicalElement.pathLinkType.objType,
       initialLogicalElementId,
       logicalElements,
       values,
+      // filterElements,
       logicalElement.childLogicalElementId
     );
     console.log('return child filterLogicalElement for child complexFilter: ', {
@@ -936,23 +950,35 @@ function filterLogicalElements(
       operation,
       childErrorsObject,
       childErrorsFound,
-      childNextLogicalElementId
+      childNextLogicalElementId,
+      returnFilterElements
     });
     if (childErrorsFound.length > 0) {
       Object.assign(errorsObject, childErrorsObject);
       errorsFound = errorsFound.concat(childErrorsFound)
     }
 
-    let filterElements = splitFilterElements(
-      childFilterMainId,
-      childFilterObject
-    );
-    console.log('filterElements: ', filterElements);
+    delete childFilterObject.filterElement.filterElements;
+
+    if (isEmpty(returnFilterElements)) {
+      returnFilterElements = { [childFilterMainId]: childFilterObject };
+    } else {
+      returnFilterElements[childFilterMainId] = childFilterObject;
+    }
+
+
+    // let childFilterElements = splitFilterElements(
+    //   childFilterMainId,
+    //   childFilterObject
+    // );
+    // console.log('childFilterElements: ', childFilterElements);
+
+    Object.assign(filterElements, returnFilterElements);
     let setRequestProperties = {};
 
     if (!isEmpty(logicalElement.requestProperties)) {
       console.log('logicalElement: ', logicalElement);
-
+      console.log("ll", ll)
       for (const [tag, requestPropertyId] of Object.entries(logicalElement.requestProperties)) {
         console.log('set requestProperties: ', { tag, requestPropertyId });
 
@@ -973,13 +999,13 @@ function filterLogicalElements(
       objType: logicalElement.objType,
       filterElement: {
         filterType: logicalElementType,
-        filterElements: filterElements,
+        filterElements: returnFilterElements,
         childFilterElementId: childFilterMainId,
         pathLinkType: logicalElement.pathLinkType,
         requestProperties: setRequestProperties ?? {}
       }
     };
-    console.log('currentFilterObject: ', currentFilterObject);
+    console.log('currentFilterObject: ', currentFilterObject)
 
     currentFilterMainId = hash(currentFilterObject);
     console.log('currentFilterMainId: ', currentFilterMainId);
@@ -1005,8 +1031,9 @@ function filterLogicalElements(
 
   if (lastNextLogicalElementId !== null) {
 
-    // [runningFilterMainId, runningFilterObject, operation, operationErrorsFound] = complexFilterShared.validateOperation(
-    [runningFilterMainId, runningFilterObject, operation, operationErrorsFound] = validateOperation(
+    let validateFilterElements = {};
+
+    [runningFilterMainId, runningFilterObject, operation, operationErrorsFound, validateFilterElements] = validateOperation(
       objType,
       runningFilterMainId,
       runningFilterObject,
@@ -1014,13 +1041,19 @@ function filterLogicalElements(
       currentFilterMainId,
       currentFilterObject
     );
-    console.log('return validateOperation for lastNextLogicalElementId == null: ', {
+    console.log('return validateOperation for lastNextLogicalElementId !== null: ', {
       runningFilterMainId,
       runningFilterObject,
       operation,
-      operationErrorsFound
+      operationErrorsFound,
+      validateFilterElements
     });
 
+    if (currentFilterObject.objType.objectType === "productStandard") {
+      console.log("ff", currentFilterObject.filterElement.filterElements)
+      console.log("ff", ff)
+    }
+
     if (!isEmpty(operation)) {
       lastLogicalOperator = null;
     }
@@ -1031,24 +1064,27 @@ function filterLogicalElements(
       operations,
       nextErrorObject,
       nextErrorFound,
-      nextElementId
+      nextElementId,
+      returnFilterElements
     ] = filterLogicalElements(
       objType,
       initialLogicalElementId,
       logicalElements,
       values,
+      // filterElements,
       lastNextLogicalElementId,
       runningFilterMainId,
       runningFilterObject,
       lastLogicalOperator,
     );
-    console.log('return validateOperation for lastNextLogicalElementId !== null: ', {
+    console.log('return validateOperation for lastNextLogicalElementId !== null ___1: ', {
       nextFilterMainId,
       nextFilterObject,
       operations,
       nextErrorObject,
       nextErrorFound,
-      nextElementId
+      nextElementId,
+      returnFilterElements
     });
 
     if (nextErrorFound.length > 0) {
@@ -1056,7 +1092,10 @@ function filterLogicalElements(
       errorsFound = errorsFound.concat(nextErrorFound);
     }
 
+    Object.assign(filterElements, validateFilterElements, returnFilterElements);
+
     if (nextElementId !== null) {
+
       let filterErrorObject = {};
       let filterErrorFound = [];
 
@@ -1066,18 +1105,19 @@ function filterLogicalElements(
         operation,
         filterErrorObject,
         filterErrorFound,
-        nextElementId
+        nextElementId,
       ] = filterLogicalElements(
         objType,
         initialLogicalElementId,
         logicalElements,
         values,
+        // filterElements,
         nextElementId,
         nextFilterMainId,
         nextFilterObject,
         lastLogicalOperator
       );
-      console.log('return validateOperation for lastNextLogicalElementId !== null: ', {
+      console.log('return validateOperation for lastNextLogicalElementId !== null ___2: ', {
         runningFilterMainId,
         runningFilterObject,
         operation,
@@ -1094,19 +1134,22 @@ function filterLogicalElements(
         nextElementId
       ];
     } else {
+
       return [
         nextFilterMainId,
         nextFilterObject,
         operation,
         errorsObject,
         errorsFound,
-        nextElementId
+        nextElementId,
+        filterElements
       ];
     }
 
   } else {
+    let returnFilterElements = {};
 
-    [runningFilterMainId, runningFilterObject, operation, operationErrorsFound] = validateOperation(
+    [runningFilterMainId, runningFilterObject, operation, operationErrorsFound, returnFilterElements] = validateOperation(
       objType,
       runningFilterMainId,
       runningFilterObject,
@@ -1118,14 +1161,15 @@ function filterLogicalElements(
       runningFilterMainId,
       runningFilterObject,
       operation,
-      operationErrorsFound
+      operationErrorsFound,
+      returnFilterElements
     });
 
     if (operationErrorsFound.length > 0) {
       errorsFound = errorsFound.concat(operationErrorsFound)
     }
 
-    return [runningFilterMainId, runningFilterObject, operation, errorsObject, errorsFound, null];
+    return [runningFilterMainId, runningFilterObject, operation, errorsObject, errorsFound, null, returnFilterElements];
 
   }
 
@@ -1152,14 +1196,14 @@ function splitFilterElements(
   //   || runningFilterObject.filterElement.filterType === 'traversal'
   // ) {}
 
-  if (runningFilterObject.logicalElementType === 'operation') {
+  if (runningFilterObject.filterElement.filterType === 'operation') {
     console.log('-------- operation ----------');
 
     Object.assign(filterElements, runningFilterObject.filterElement.filterElements);
     // delete runningFilterObject.filterElement.filterElements;
     filterElements[runningFilterMainId] = runningFilterObject;
 
-  } else if (runningFilterObject.logicalElementType === 'childComplexFilter') {
+  } else if (runningFilterObject.filterElement.filterType === 'childComplexFilter') {
     console.log('-------- childComplexFilter ----------');
 
     Object.assign(filterElements, runningFilterObject.filterElement.filterElements);
@@ -1167,28 +1211,28 @@ function splitFilterElements(
     filterElements[runningFilterMainId] = runningFilterObject;
 
   } else {
-    console.log(` -------- ${runningFilterObject.logicalElementType} ----------`);
+    console.log(` -------- ${runningFilterObject.filterElement.filterType} ----------`);
     //'logical'| 'identifiers'|'translateIds'|'traversal'
     filterElements[runningFilterMainId] = runningFilterObject;
   };
 
   if (currentFilterObject !== null) {
-    if (currentFilterObject.logicalElementType === 'operation') {
+    if (currentFilterObject.filterType === 'operation') {
       console.log('-------- operation ----------');
 
       Object.assign(filterElements, currentFilterObject.filterElement.filterElements);
       // delete currentFilterObject.filterElement.filterElements;
       filterElements[currentFilterMainId] = currentFilterObject;
 
-    } else if (currentFilterObject.logicalElementType === 'childComplexFilter') {
+    } else if (currentFilterObject.filterElement.filterType === 'childComplexFilter') {
       console.log('-------- childComplexFilter ----------');
 
       Object.assign(filterElements, currentFilterObject.filterElement.filterElements);
-      // delete currentFilterObject.filterElement.filterElements;
+      delete currentFilterObject.filterElement.filterElements;
       filterElements[currentFilterMainId] = currentFilterObject;
 
     } else {
-      console.log(` -------- ${currentFilterObject.logicalElementType} ----------`);
+      console.log(` -------- ${currentFilterObject.filterElement.filterType} ----------`);
       //'logical'| 'identifiers'|'translateIds'|'traversal'
       filterElements[currentFilterMainId] = currentFilterObject;
     };
@@ -1203,7 +1247,7 @@ export default {
   //* create filter
   createFiltersRequest,
   validateCombinationStructure,
-  // validateOperation,
   filterLogicalElements,
+  // validateOperation,
   // splitFilterElements,
 }

package/src/InitialSchemaLib.js

@@ -18,8 +18,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 'use strict';
 import LogicalStructureSharedLib from './LogicalStructureSharedLib.js';
 
-function initSchemaFn(getObjSchemaS3WithoutHierarchy, getObjectRelationship) { //getObjectLinks
-  return LogicalStructureSharedLib.initSchemaFn(getObjSchemaS3WithoutHierarchy, getObjectRelationship);
+function initSchemaFn(getObjSchemaS3WithHierarchyShared, getObjectLinksShared) {
+  return LogicalStructureSharedLib.initSchemaFn(getObjSchemaS3WithHierarchyShared, getObjectLinksShared);
 }
 
 export default {

package/src/LogicalStructureSharedLib.js

@@ -18,24 +18,23 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 'use strict';
 
 
-import { objectHash as hash } from '@izara_project/izara-shared-core';  //const hash = require('@izara_project/izara-shared-core').objectHash;
+import { objectHash as hash } from '@izara_project/izara-shared-core';
 import lodash from 'lodash';
 const { isEmpty } = lodash;
-import { v4 as uuidV4 } from 'uuid'; //const { v4: uuidv4 } = require('uuid');
-// import { getObjectSchema } from '@izara_project/izara-core-library-service-schemas';
+import { v4 as uuidV4 } from 'uuid';
 const MAX_ITER = 4;
 
 let getObjectSchema = {};
 
-function initSchemaFn(getObjSchemaS3WithoutHierarchy, getObjectRelationship) { //getObjectLinks
+function initSchemaFn(getObjSchemaS3WithHierarchyShared, getObjectLinksShared) {
   getObjectSchema = {
-    getObjSchemaS3WithoutHierarchy,
-    getObjectRelationship: getObjectRelationship // getObjectRelationship: getObjectLinks
+    getObjSchemaS3WithHierarchyShared,
+    getObjectLinksShared
   }
-
   return getObjectSchema;
 }
 
+
 function combineLogicalStructure(
   objType,
   initialLogicalElementId,
@@ -752,7 +751,7 @@ async function changeObjTypePath(
                             if (!childLogicalElement.hasOwnProperty('childLogicalElementId')) {
 
                               // let childSchema = await getObjectSchema.getObjSchemaS3WithCache(
-                              let childSchema = await getObjectSchema.getObjSchemaS3WithoutHierarchyV2(
+                              let childSchema = await getObjectSchema.getObjSchemaS3WithHierarchyShared(
                                 childLogicalElement.objType
                               );
                               console.log('childSchema: ', childSchema);
@@ -810,7 +809,6 @@ async function changeObjTypePath(
 
                   let logicalStructure = {};
                   [previousLogicalElementId, previousLogicalElement, logicalStructure, errorsFound] = createChildComplexFilterStructure(
-                    _izContext,
                     logicalElements,
                     previousLogicalElementId,
                     previousLogicalElement,
@@ -860,7 +858,6 @@ async function changeObjTypePath(
                 let logicalStructure = {};
                 // change function name ==> set logicalElementId
                 [previousLogicalElementId, previousLogicalElement, logicalStructure, errorsFound] = createChildComplexFilterStructure(
-                  _izContext,
                   logicalElements,
                   previousLogicalElementId,
                   previousLogicalElement,
@@ -909,9 +906,7 @@ async function changeObjTypePath(
   };
 
 };
-//###################################################################################################################################################################################
-
-
+// ###################################################################################################################################################################################
 
 
 function createChildComplexFilterStructure(
@@ -1028,9 +1023,7 @@ async function recursiveFindObjTypeTypePathToAnotherObjType(
       return [null, errorsObject, errorsFound];
     };
 
-    // let objectRelationship = await getObjectSchema.getObjectRelationshipWithCache(
-    const objectRelationship = await getObjectSchema.getObjectRelationship(
-      {},  //_izContext maybe delete
+    const objectRelationship = await getObjectSchema.getObjectLinksShared(
       fromObjType
     );
     console.log("objectRelationship: ", { fromObjType, objectRelationship });
@@ -1063,8 +1056,7 @@ async function recursiveFindObjTypeTypePathToAnotherObjType(
       };
 
       // const objectSchema = await getObjectSchema.getObjSchemaS3WithCache(
-      const objectSchema = await getObjectSchema.getObjSchemaS3WithoutHierarchy(
-        {}, //_izContext maybe delete
+      const objectSchema = await getObjectSchema.getObjSchemaS3WithHierarchyShared(
         toObjType,
       );
       console.log('objectSchema: ', objectSchema);

package/src/SearchSortSharedLib.js

@@ -18,12 +18,12 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 "use strict";
 
 //* searchResultMain record
-import { objectHash as hash } from '@izara_project/izara-shared-core';  //const hash = require('@izara_project/izara-shared-core').objectHash;
+import { objectHash as hash } from '@izara_project/izara-shared-core';
 import lodash from 'lodash';
 const { isEmpty } = lodash;
-import filtersSharedLib from './FiltersSharedLib.js'; //const filtersSharedLib = require('./FiltersSharedLib');
+import filtersSharedLib from './FiltersSharedLib.js';
 import dataFieldsSharedLib from './DataFieldsSharedLib.js';
-import LogicalStructureSharedLib from './LogicalStructureSharedLib.js';
+
 
 async function createSearchRequest(
   objType,
@@ -35,7 +35,6 @@ async function createSearchRequest(
   requiredDataLinkStepObjects,
   requiredDataLinkSteps,
   values,
-  getSchemaFn
 ) {
   console.log('createSearchResult: ', {
     objType,
@@ -57,13 +56,14 @@ async function createSearchRequest(
 
   let requiredDataPromise = dataFieldsSharedLib.createRequiredData(
     objType,
+    initialLogicalElementId,
+    logicalElements,
     requiredDataFields,
     complexFilterCombinations,
     perParentCombinations,
     requiredDataLinkStepObjects,
     requiredDataLinkSteps,
     values,
-    getSchemaFn
   );
 
   //* create complexFilter normalize to send backend
@@ -105,11 +105,11 @@ async function createSearchRequest(
   let requiredData = await requiredDataPromise;
   console.log('return create requiredData: ', requiredData);
 
-  // if (requiredData.status === 'invalid' || requiredData.errorsFound.length > 0) {
-  //   Object.assign(errorsObject, requiredData.errorsObject)
-  //   errorsFound.push('requiredData cannot create');
-  //   errorsFound = errorsFound.concat(requiredData.errorsFound);
-  // }
+  if (requiredData.status === 'invalid' || requiredData.errorsFound.length > 0) {
+    Object.assign(errorsObject, requiredData.errorsObject)
+    errorsFound.push('requiredData cannot create');
+    errorsFound = errorsFound.concat(requiredData.errorsFound);
+  }
 
   if (errorsFound.length > 0) {
     return [null, 'invalid', errorsObject, errorsFound]