@izara_project/izara-shared-search-and-sort 1.0.4 → 1.0.6

package/src/LogicalStructureSharedLib.js

@@ -0,0 +1,1152 @@
+/*
+Copyright (C) 2025 Sven Mason <http://izara.io>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+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 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';
+const MAX_ITER = 4;
+
+
+function combineLogicalStructure(
+  objType,
+  initialLogicalElementId,
+  logicalElements,
+) {
+  console.log('combineLogicalStructure: ', {
+    objType,
+    initialLogicalElementId,
+    logicalElements,
+  });
+
+  let returnInitialElementId = null;
+  let initialLogicalElementObject = logicalElements[initialLogicalElementId]
+  if (initialLogicalElementObject.logicalElementType !== 'logicalStructure') {
+    returnInitialElementId = initialLogicalElementId;
+  } else {
+    returnInitialElementId = logicalElements[initialLogicalElementId].initialLogicalElementId;
+  };
+  console.log('returnInitialElementId', returnInitialElementId);
+
+  let previousLogicalElementId = null;
+  let previousLogicalElementObject = null;
+
+  let operationLogicalElementId = null;
+  let operationLogicalElementObject = null;
+
+  let nextLogicalElementId = null;
+  let nextLogicalElementObject = null;
+
+  let returnLogicalElements = {};
+
+  let errorsObject = {};
+  let errorsFound = [];
+
+  for (const [logicalElementId, logicalElementObject] of Object.entries(logicalElements)) {
+    console.log('extract logicalELements: ', { initialLogicalElementId, logicalElementId, logicalElementObject });
+
+    if (initialLogicalElementId !== logicalElementId) {
+      continue;
+    };
+
+    let logicalElementType = logicalElementObject.logicalElementType;
+    console.log('logicalElementType: ', logicalElementType);
+
+    if (logicalElementType === 'openBracket') {
+      console.log('----------type: openBracket ----------');
+      if (!logicalElementObject.hasOwnProperty('previousLogicalElementId')) {
+        errorsObject[logicalElementId] = `this logical structure is not set previousLogicalElementId`;
+        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set previousLogicalElementId`);
+      };
+      if (!logicalElementObject.hasOwnProperty('nextLogicalElementId')) {
+        errorsObject[logicalElementId] = `this logical structure is not set nextLogicalElementId`;
+        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set nextLogicalElementId`);
+      };
+
+      nextLogicalElementId = logicalElementId;
+      nextLogicalElementObject = { [nextLogicalElementId]: logicalElementObject };
+      initialLogicalElementId = logicalElementObject.nextLogicalElementId;
+
+    } else if (logicalElementType === 'logicalStructure') {
+      console.log('----------type: logicalStructure ----------');
+
+      if (!logicalElementObject.hasOwnProperty('objType')) {
+        errorsObject[logicalElementId] = `this logical structure is not set objType`;
+        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set objType`);
+      };
+      if (!logicalElementObject.hasOwnProperty('initialLogicalElementId')) {
+        errorsObject[logicalElementId] = `this logical structure is not set initialLogicalElementId`;
+        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set initialLogicalElementId`);
+      };
+      if (!logicalElementObject.hasOwnProperty('previousLogicalElementId')) {
+        errorsObject[logicalElementId] = `this logical structure is not set previousLogicalElementId`;
+        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set previousLogicalElementId`);
+      };
+      if (!logicalElementObject.hasOwnProperty('nextLogicalElementId')) {
+        errorsObject[logicalElementId] = `this logical structure is not set nextLogicalElementId`;
+        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set nextLogicalElementId`);
+      };
+      if (!logicalElementObject.hasOwnProperty('logicalElements')) {
+        errorsObject[logicalElementId] = `this logical structure is not set logicalElements`;
+        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set logicalElements`);
+      };
+
+      nextLogicalElementId = logicalElementObject.initialLogicalElementId;
+      nextLogicalElementObject = logicalElementObject.logicalElements;
+
+      if (logicalElementObject.nextLogicalElementId !== null) {
+        initialLogicalElementId = logicalElementObject.nextLogicalElementId;
+      };
+
+    } else if (logicalElementType === 'operation') {
+      console.log('----------type: operation ----------');
+      if (!logicalElementObject.hasOwnProperty('previousLogicalElementId')) {
+        errorsObject[logicalElementId] = `this logical structure is not set previousLogicalElementId`;
+        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set previousLogicalElementId`);
+      };
+      if (!logicalElementObject.hasOwnProperty('nextLogicalElementId')) {
+        errorsObject[logicalElementId] = `this logical structure is not set nextLogicalElementId`;
+        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set nextLogicalElementId`);
+      };
+      if (!logicalElementObject.hasOwnProperty('operation')) {
+        errorsObject[logicalElementId] = `this logical structure is not set operation`;
+        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set operation`);
+      };
+
+      operationLogicalElementId = logicalElementId;
+      operationLogicalElementObject = logicalElementObject;
+      initialLogicalElementId = logicalElementObject.nextLogicalElementId;
+      continue;
+
+    } else if (logicalElementType === 'closeBracket') {
+      console.log('----------type: closeBracket ----------');
+      if (!logicalElementObject.hasOwnProperty('previousLogicalElementId')) {
+        errorsObject[logicalElementId] = `this logical structure is not set previousLogicalElementId`;
+        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set previousLogicalElementId`);
+      };
+      if (!logicalElementObject.hasOwnProperty('nextLogicalElementId')) {
+        errorsObject[logicalElementId] = `this logical structure is not set nextLogicalElementId`;
+        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set nextLogicalElementId`);
+      };
+
+      nextLogicalElementId = logicalElementId;
+      nextLogicalElementObject = { [nextLogicalElementId]: logicalElementObject };
+      initialLogicalElementId = logicalElementObject.nextLogicalElementId;
+
+    } else {
+      //* error
+      errorsObject[logicalElementId] = `has error on logicalElementType: ${logicalElementType}`;
+      errorsFound.push(`has error on logicalElementType in logicalElementId: ${logicalElementId}`);
+    };
+
+    if (errorsFound.length > 0) {
+      return [null, errorsObject, errorsFound];
+    };
+
+    let operations = null;
+    let operationErrorObjects = {};
+    let operationErrors = [];
+
+    [
+      previousLogicalElementId,
+      previousLogicalElementObject,
+      operations,
+      operationErrorObjects,
+      operationErrors
+    ] = combineOperation(
+      previousLogicalElementId,
+      previousLogicalElementObject,
+      operationLogicalElementId,
+      operationLogicalElementObject,
+      nextLogicalElementId,
+      nextLogicalElementObject
+    );
+    console.log('return combineOperation: ', {
+      previousLogicalElementId,
+      previousLogicalElementObject,
+      operations,
+      operationErrors
+    });
+
+    if (operationErrors.length > 0) {
+      Object.assign(errorsObject, operationErrorObjects);
+    };
+
+    if (operations !== null) {
+      Object.assign(returnLogicalElements, operations);
+      operationLogicalElementId = null;
+      operationLogicalElementObject = null;
+    } else {
+      Object.assign(returnLogicalElements, previousLogicalElementObject);
+    };
+
+  } //end iterate logicalElements
+
+  console.log('returnLogicalElements: ', { returnLogicalElements });
+
+  let returnComplexLogicalStructure = {
+    objType: objType,
+    initialLogicalElementId: returnInitialElementId,
+    logicalElements: returnLogicalElements
+  };
+
+  return [returnComplexLogicalStructure, errorsObject, errorsFound];
+
+};
+
+function combineOperation(
+  previousLogicalElementId,
+  previousLogicalElementObject,
+  operationLogicalElementId,
+  operationLogicalElementObject,
+  nextLogicalElementId,
+  nextLogicalElementObject
+) {
+  console.log('combineOperation: ', {
+    previousLogicalElementId,
+    previousLogicalElementObject,
+    operationLogicalElementId,
+    operationLogicalElementObject,
+    nextLogicalElementId,
+    nextLogicalElementObject
+  });
+
+  let errorsObject = {};
+  let errorsFound = []
+
+  if (!nextLogicalElementObject) {
+    errorsFound.push('cannot found current filterElement object')
+    return [null, null, null, errorsObject, errorsFound];
+  };
+
+  if (!previousLogicalElementObject) {
+    return [nextLogicalElementId, nextLogicalElementObject, null, errorsObject, errorsFound];
+  };
+
+  if (!operationLogicalElementObject) {
+    console.log('------------ previous & current ------------', {
+      previousLogicalElementId,
+      previousLogicalElementObject,
+      operationLogicalElementId,
+      operationLogicalElementObject,
+      nextLogicalElementId,
+      nextLogicalElementObject
+    });
+
+    let operations = {};
+    let returnnextElementId = null;
+    let returnNextElementObject = null;
+
+    if (previousLogicalElementObject[previousLogicalElementId].logicalElementType === 'openBracket') {
+      if (nextLogicalElementObject[nextLogicalElementId].logicalElementType === 'closeBracket') {
+
+        if (Object.entries(previousLogicalElementObject).length <= 2) {
+
+          previousLogicalElementObject[previousLogicalElementId].nextLogicalElementId = nextLogicalElementId;
+          nextLogicalElementObject[nextLogicalElementId].previousLogicalElementId = previousLogicalElementId;
+
+        } else {
+
+          if (previousLogicalElementObject[previousLogicalElementId].nextLogicalElementId === null) {
+            previousLogicalElementObject[previousLogicalElementId].nextLogicalElementId = nextLogicalElementId;
+            nextLogicalElementObject[nextLogicalElementId].previousLogicalElementId = previousLogicalElementId;
+
+          } else {
+
+            let checkNextLogicalElementId = previousLogicalElementObject[previousLogicalElementId].nextLogicalElementId;
+            console.log('checkNextLogicalElementId:', checkNextLogicalElementId);
+
+            for (let i = 0; i < Object.entries(previousLogicalElementObject).length; i++) {
+              let [logicalElementId, logicalObject] = Object.entries(previousLogicalElementObject)[i];
+              console.log('extract logical element: ', { logicalElementId, logicalObject });
+
+              if (logicalElementId !== checkNextLogicalElementId) {
+                continue;
+              };
+
+              console.log('------------- has next logicalElemet to continue -------------');
+
+              if (logicalObject.nextLogicalElementId !== null) {
+                checkNextLogicalElementId = logicalObject.nextLogicalElementId;
+                continue;
+              } else {
+                previousLogicalElementObject[logicalElementId].nextLogicalElementId = nextLogicalElementId;
+                nextLogicalElementObject[nextLogicalElementId].previousLogicalElementId = logicalElementId;
+              };
+            };
+          };
+        };
+
+        operations = Object.assign(previousLogicalElementObject, nextLogicalElementObject);
+        console.log('operations: ', operations);
+
+        returnnextElementId = nextLogicalElementId;
+        returnNextElementObject = nextLogicalElementObject;
+
+      } else {
+
+        previousLogicalElementObject[previousLogicalElementId].nextLogicalElementId = nextLogicalElementId;
+        nextLogicalElementObject[nextLogicalElementId].previousLogicalElementId = previousLogicalElementId;
+
+        operations = Object.assign(previousLogicalElementObject, nextLogicalElementObject);
+
+        console.log('operations: ', operations);
+        returnnextElementId = nextLogicalElementId;
+        returnNextElementObject = nextLogicalElementObject;
+
+      };
+
+    } else if (previousLogicalElementObject[previousLogicalElementId].logicalElementType === 'closeBracket') {
+
+      if (nextLogicalElementObject[nextLogicalElementId].logicalElementType === 'closeBracket') {
+
+        previousLogicalElementObject[previousLogicalElementId].nextLogicalElementId = nextLogicalElementId;
+        nextLogicalElementObject[nextLogicalElementId].previousLogicalElementId = previousLogicalElementId;
+
+        operations = Object.assign(previousLogicalElementObject, nextLogicalElementObject);
+        console.log('operations: ', operations);
+
+        returnnextElementId = nextLogicalElementId;
+        returnNextElementObject = nextLogicalElementObject;
+
+      } else {
+        errorsObject[nextLogicalElementId] = 'this path has logical structure error';
+        errorsFound.push(`${nextLogicalElementId}: this path has logical structure error`);
+      };
+
+    } else {
+
+      if (nextLogicalElementObject[nextLogicalElementId].logicalElementType === 'closeBracket') {
+
+        console.log('previousLogicalElementObject: ', previousLogicalElementObject);
+
+        if (Object.entries(previousLogicalElementObject).length <= 2) {
+
+          previousLogicalElementObject[previousLogicalElementId].nextLogicalElementId = nextLogicalElementId;
+          nextLogicalElementObject[nextLogicalElementId].previousLogicalElementId = previousLogicalElementId;
+
+        } else {
+
+          if (previousLogicalElementObject[previousLogicalElementId].nextLogicalElementId === null) {
+            previousLogicalElementObject[previousLogicalElementId].nextLogicalElementId = nextLogicalElementId;
+            nextLogicalElementObject[nextLogicalElementId].previousLogicalElementId = previousLogicalElementId;
+
+          } else {
+
+            let checkNextLogicalElementId = previousLogicalElementObject[previousLogicalElementId].nextLogicalElementId;
+            console.log('checkNextLogicalElementId:', checkNextLogicalElementId);
+
+            for (let i = 0; i < Object.entries(previousLogicalElementObject).length; i++) {
+              let [logicalElementId, logicalObject] = Object.entries(previousLogicalElementObject)[i];
+              console.log('extract logical element: ', { logicalElementId, logicalObject });
+
+              if (logicalElementId !== checkNextLogicalElementId) {
+                continue;
+              };
+
+              console.log('------------- has next logicalElemet to continue -------------');
+
+              if (logicalObject.nextLogicalElementId !== null) {
+                checkNextLogicalElementId = logicalObject.nextLogicalElementId;
+                continue;
+              } else {
+                previousLogicalElementObject[logicalElementId].nextLogicalElementId = nextLogicalElementId;
+                nextLogicalElementObject[nextLogicalElementId].previousLogicalElementId = logicalElementId;
+              };
+            };
+          };
+        };
+
+        operations = Object.assign(previousLogicalElementObject, nextLogicalElementObject);
+        console.log("operations: ", operations);
+
+        returnnextElementId = nextLogicalElementId;
+        returnNextElementObject = nextLogicalElementObject;
+
+      } else {
+        errorsObject[nextLogicalElementId] = 'this path has logical structure error';
+        errorsFound.push(`${nextLogicalElementId}: this path has logical structure error`);
+      };
+    };
+    return [returnnextElementId, returnNextElementObject, operations, errorsObject, errorsFound];
+  };
+
+  if (previousLogicalElementObject && operationLogicalElementObject && nextLogicalElementObject) {
+    console.log('------------ previous & operation & current ------------', {
+      previousLogicalElementId,
+      previousLogicalElementObject,
+      operationLogicalElementId,
+      operationLogicalElementObject,
+      nextLogicalElementId,
+      nextLogicalElementObject
+    });
+
+    let operations = {};
+
+    previousLogicalElementObject[previousLogicalElementId].nextLogicalElementId = operationLogicalElementId;
+    nextLogicalElementObject[nextLogicalElementId].previousLogicalElementId = operationLogicalElementId;
+
+    operationLogicalElementObject.previousLogicalElementId = previousLogicalElementId;
+    operationLogicalElementObject.nextLogicalElementId = nextLogicalElementId;
+
+    console.log('after set previous and next: ', {
+      previousLogicalElementObject,
+      operationLogicalElementObject,
+      nextLogicalElementObject
+    });
+
+    operations = Object.assign(previousLogicalElementObject, { [operationLogicalElementId]: operationLogicalElementObject }, nextLogicalElementObject);
+
+    return [nextLogicalElementId, nextLogicalElementObject, operations, errorsObject, errorsFound];
+
+  } else {
+    errorsObject[previousLogicalElementId] = 'found error that incorrect of logical structure';
+    errorsObject[currentLogicalElementId] = 'found error that incorrect of logical structure';
+    errorsObject[operationLogicalElementId] = 'found error that incorrect of logical structure';
+    errorsFound.push('found error that incorrect of logical structure');
+
+    return [null, null, null, errorsObject, errorsFound];
+  };
+
+};
+
+// function combineLogicalElements(
+//   firstFilterStructure,
+//   secondFilterStructure,
+//   operator = "AND"
+// ) {
+//   console.log('combineLogicalElements: ', {
+//     firstFilterStructure,
+//     secondFilterStructure,
+//     operator
+//   });
+
+//   let objType = firstFilterStructure.objType;
+
+//   let [firstInitialLogicalElementId, firstLastLogicalElementId, firstFiltersStructureBrcket] = addBrackets(
+//     firstFilterStructure
+//   );
+//   console.log("first filterStructure addBrackets", {
+//     firstInitialLogicalElementId,
+//     firstLastLogicalElementId,
+//     firstFiltersStructureBrcket
+//   })
+
+//   let [secondInitialLogicalElementId, secondLastLogicalElementId, secondFiltersStructureBrcket] = addBrackets(
+//     secondFilterStructure
+//   );
+//   console.log("second filterStructure addBrackets", {
+//     secondInitialLogicalElementId,
+//     secondLastLogicalElementId,
+//     secondFiltersStructureBrcket
+//   })
+
+//   let uuid_operation = uuidV4();
+//   console.log('uuid_operation: ', uuid_operation);
+
+//   let operationObject = {
+//     logicalElementType: 'operation',
+//     previousLogicalElementId: firstLastLogicalElementId,
+//     nextLogicalElementId: secondInitialLogicalElementId,
+//     operation: operator
+//   };
+//   console.log('operationObject: ', operationObject);
+
+//   firstFiltersStructureBrcket.logicalElements[firstLastLogicalElementId].nextLogicalElementId = uuid_operation;
+//   secondFiltersStructureBrcket.logicalElements[secondInitialLogicalElementId].previousLogicalElementId = uuid_operation;
+
+//   let logicalElements = Object.assign(firstFiltersStructureBrcket.logicalElements, { [uuid_operation]: operationObject }, secondFiltersStructureBrcket.logicalElements);
+//   console.log('logicalElements: ', logicalElements);
+
+//   return {
+//     objType: objType,
+//     initialLogicalElementId: firstInitialLogicalElementId,
+//     logicalElements: logicalElements
+//   };
+
+// }
+
+
+//...function check exist bracket
+function checkAndCreateBracket(filterLogicalStucture) {
+  console.log("checkAndCreateBracket params::::", filterLogicalStucture);
+
+  let errorsFound = [];
+
+  // if >1 element need to add brackets
+  if (filterLogicalStucture.logicalElements[filterLogicalStucture.initialLogicalElementId].nextLogicalElementId !== null) {
+    console.log("nextLogicalElementId != null", filterLogicalStucture.logicalElements[filterLogicalStucture.initialLogicalElementId].nextLogicalElementId);
+    [filterLogicalStucture, errorsFound] = createLogicalElementBracket(filterLogicalStucture);
+  }
+  console.log("nextLogicalElementId = null");
+  return [filterLogicalStucture, errorsFound];
+}
+
+function createLogicalElementBracket(filterLogicalStucture) {
+  console.log("createLogicalElementBracket params::::", filterLogicalStucture);
+
+  // ---- add closeBracket
+  console.log("------create closeBracket------");
+  const MAX_LOGICAL_ELEMENTS = 1000;
+
+  let working_logicalElementId = filterLogicalStucture.initialLogicalElementId;
+
+  for (let infiniteCheck = 0; infiniteCheck <= MAX_LOGICAL_ELEMENTS; infiniteCheck++) {
+    //// 1000 should = limit CONST MAX_LOGICAL_ELEMENTS
+    // console.log("-----working_logicalElementId-----", working_logicalElementId);
+    if (filterLogicalStucture.logicalElements[working_logicalElementId].nextLogicalElementId === null) {
+      console.log("-----last logicalElement-----", filterLogicalStucture.logicalElements[working_logicalElementId]);
+      let closeBracket_uuid = uuidV4(); //uuidV4
+      console.log("closeBracket_uuid", closeBracket_uuid);
+
+      filterLogicalStucture.logicalElements[closeBracket_uuid] = {
+        logicalElementType: "closeBracket",
+        previousLogicalElementId: working_logicalElementId,
+        nextLogicalElementId: null,
+      };
+
+      filterLogicalStucture.logicalElements[working_logicalElementId].nextLogicalElementId = closeBracket_uuid;
+      console.log("------filterLogicalStucture before break loop------", filterLogicalStucture);
+      break;
+    }
+    if (infiniteCheck >= MAX_LOGICAL_ELEMENTS) {
+      // throw no retry error
+      // throw new NoRetryError("Error: max count logicalElement");
+      return [null, ["Error: max count logicalElement"]]
+    }
+
+    working_logicalElementId = filterLogicalStucture.logicalElements[working_logicalElementId].nextLogicalElementId;
+  }
+
+  console.log("------filterLogicalStucture before add open bracket------", filterLogicalStucture);
+
+  // ---- add openBracket
+
+  console.log("start create  openBracket");
+  console.log("start logicalElement====>", filterLogicalStucture.logicalElements[filterLogicalStucture.initialLogicalElementId]);
+
+  let openBracket_uuid = uuidV4(); //uuidV4
+  console.log("openBracket_uuid", openBracket_uuid);
+  console.log("filterLogicalStucture before return:::::>>>>", filterLogicalStucture);
+
+  filterLogicalStucture.logicalElements[openBracket_uuid] = {
+    logicalElementType: "openBracket",
+    previousLogicalElementId: null,
+    nextLogicalElementId: filterLogicalStucture.initialLogicalElementId,
+  };
+
+  filterLogicalStucture.logicalElements[filterLogicalStucture.initialLogicalElementId].previousLogicalElementId = openBracket_uuid;
+  filterLogicalStucture.initialLogicalElementId = openBracket_uuid;
+  return [filterLogicalStucture, []];
+}
+
+function checkObjType(
+  fromObjType,
+  toObjType
+) {
+
+  let from = {
+    serviceTag: fromObjType.serviceTag,
+    objectType: fromObjType.objectType
+  };
+
+  let to = {
+    serviceTag: toObjType.serviceTag,
+    objectType: toObjType.objectType
+  };
+
+  if (hash(to) === hash(from)) {
+    return true;
+  };
+
+  return false;
+
+};
+
+// validate to changed searchType and filterType
+/**
+ * recieved request thougth sortedResult??? case specail filter
+ * @param {string} requiredSearchType
+ * @param {string[]} filterArrays
+ *
+ * return [filters]
+ */
+async function changeObjTypePath(
+  requiredObjType,
+  filtersStructure,
+  path = null,
+) {
+  try {
+    console.log('----- function validateSearchTypeFilterType -----', {
+      requiredObjType,
+      filtersStructure,
+      path
+    });
+
+    let filterLogicalStructure = {};
+
+    let errorsObject = {};
+    let errorsFound = [];
+
+    if (path !== null) {
+      console.log('-------------- continue process path --------------');
+
+      let logicalElements = {};
+      let previousLogicalElementId = null;
+      let previousLogicalElement = null;
+      let currentLogicalElementId = null;
+      let currentLogicalElement = null;
+
+      if (path.length > 1) {
+
+        for (let i = 0; i < path.length; i++) {
+
+          let pathObject = path[i];
+          let logicalStructureElements = filtersStructure.logicalElements;
+          console.log('logicalStructureElements', logicalStructureElements);
+
+          let initialLogicalElementId = filtersStructure.initialLogicalElementId;
+          console.log('initialLogicalElementId', initialLogicalElementId);
+
+          if (i + 1 === path.length) {
+            console.log(`------------------- final path: ${i} ---------------------`);
+
+            if (previousLogicalElementId !== null) {
+
+              if (checkObjType(pathObject.objType, logicalElements[previousLogicalElementId].objType) !== true) {
+                errorsFound.push('objType is not equals in structure');
+                console.log('before return: ', {
+                  filterLogicalStructure: {},
+                  errorsObject,
+                  errorsFound
+                });
+                return [{}, errorsObject, errorsFound];
+              };
+
+              filterLogicalStructure = {
+                objType: pathObject.objType,
+                initialLogicalElementId: previousLogicalElementId,
+                logicalElements: logicalElements
+              };
+              console.log('filterLogicalStructure: ', filterLogicalStructure);
+
+            } else {
+              if (checkObjType(requiredObjType, filtersStructure.objType) === true) {
+                filterLogicalStructure = filtersStructure;
+              } else {
+                errorsFound.push('objType is not equals in structure');
+                console.log('before return: ', {
+                  filterLogicalStructure: {},
+                  errorsObject,
+                  errorsFound
+                });
+                return [{}, errorsObject, errorsFound];
+              };
+            };
+
+          } else {
+            console.log(`------------------- between path: ${i} ---------------------`);
+
+            let logicalElementsStructure = logicalStructureElements[initialLogicalElementId];
+            console.log('logicalElementsStructure', logicalElementsStructure);
+
+            if (previousLogicalElement !== null) {
+
+              currentLogicalElementId = uuidV4();
+              console.log('currentLogicalElementId: ', currentLogicalElementId);
+
+              currentLogicalElement = {
+                logicalElementType: 'childComplexFilter',
+                previousLogicalElementId: null,
+                nextLogicalElementId: null,
+                childLogicalElementId: filtersStructure.initialLogicalElementId,
+
+                objType: pathObject.pathLinkType.objType,
+                pathLinkType: {
+                  objType: pathObject.objType,
+                  relType: pathObject.pathLinkType.relType,
+                  direction: pathObject.pathLinkType.direction
+                }
+              };
+              console.log('currentLogicalElement', currentLogicalElement);
+
+              let logicalStructure;
+              [previousLogicalElementId, previousLogicalElement, logicalStructure, errorsFound] = createChildComplexFilterStructure(
+                logicalElements,
+                previousLogicalElementId,
+                previousLogicalElement,
+                currentLogicalElementId,
+                currentLogicalElement,
+                filtersStructure
+              );
+              console.log('return create child ', {
+                previousLogicalElementId,
+                previousLogicalElement,
+                logicalStructure,
+                errorsFound
+              });
+
+              logicalElements = logicalStructure;
+
+            } else {
+
+              if (logicalElementsStructure.logicalElementType === 'childComplexFilter') {
+
+                let childLogicalElementId = logicalElementsStructure.childLogicalElementId;
+                console.log('childLogicalElementId', childLogicalElementId);
+
+                if (childLogicalElementId !== null) {
+                  console.log('-------- has child filter structure --------');
+
+                  let childLogicalElement = logicalStructureElements[childLogicalElementId];
+                  console.log('childLogicalElement', childLogicalElement);
+
+                  let pathCheck = false;
+
+                  for (const pathObj of path) {
+                    if (checkObjType(childLogicalElement.objType, pathObj.objType) === true) {
+                      pathCheck = true;
+                    };
+                  };
+
+                  if (pathCheck) {
+
+                    if (logicalElementsStructure.nextLogicalElementId === null) {
+
+                      //* delete level of objType
+                      let checkChild = false;
+                      for (const objType of PATHCONSTANCES.objTypes) {
+                        if (checkObjType(objType, childLogicalElement.objType) === true) {
+                          if (!childLogicalElement.hasOwnProperty('childLogicalElementId')) {
+
+                            // let childSchema = await getObjectSchema.getObjSchemaS3(
+                            let childSchema = await getObjectSchema.getObjSchemaS3WithoutHierarchy(
+                              {},  //_izContext maybe delete
+                              childLogicalElement.objType
+                            );
+                            console.log('childSchema: ', childSchema);
+
+                            if (childSchema.hasOwnProperty('extendObjType')) {
+                              if (checkObjType(requiredObjType, childSchema.extendObjType) === true) {
+                                checkChild = false;
+                                break;
+                              };
+                            };
+                          };
+                          checkChild = true;
+                          break;
+                        };
+                      };
+
+                      if (checkChild) {
+
+                        delete filtersStructure.logicalElements[initialLogicalElementId];
+                        console.log('filtersStructure: ', filtersStructure);
+
+                        filtersStructure.objType = childLogicalElement.objType;
+                        filtersStructure.initialLogicalElementId = childLogicalElementId;
+                        filtersStructure.logicalElements[childLogicalElementId].previousLogicalElementId = null;
+                        console.log('after filtersStructure: ', filtersStructure);
+
+                        logicalElements = filtersStructure.logicalElements;
+
+                        continue;
+
+                      };
+                    };
+                  };
+
+                  currentLogicalElementId = uuidV4();
+                  console.log('currentLogicalElementId: ', currentLogicalElementId)
+
+                  currentLogicalElement = {
+                    logicalElementType: 'childComplexFilter',
+                    previousLogicalElementId: null,
+                    nextLogicalElementId: null,
+                    childLogicalElementId: filtersStructure.initialLogicalElementId,
+
+                    objType: pathObject.pathLinkType.objType,
+                    pathLinkType: {
+                      objType: pathObject.objType,
+                      relType: pathObject.pathLinkType.relType,
+                      direction: pathObject.pathLinkType.direction
+                    }
+                  };
+                  console.log('currentLogicalElement', currentLogicalElement);
+
+                  let logicalStructure = {};
+                  [previousLogicalElementId, previousLogicalElement, logicalStructure, errorsFound] = createChildComplexFilterStructure(
+                    _izContext,
+                    logicalElements,
+                    previousLogicalElementId,
+                    previousLogicalElement,
+                    currentLogicalElementId,
+                    currentLogicalElement,
+                    filtersStructure
+                  )
+                  console.log('return create child', {
+                    previousLogicalElementId,
+                    previousLogicalElement,
+                    logicalStructure,
+                    errorsFound
+                  });
+
+                  logicalElements = logicalStructure;
+                  console.log('logicalElements: ', logicalElements);
+
+                  // if (logicalElementsStructure.nextLogicalElementId !== null) {
+                  //  console.log("-------- no child filter structure --------", vvv);
+                  // }
+
+                } else {
+                  console.log('-------- no child filter structure --------', vvv);
+
+                }
+
+              } else {
+
+                currentLogicalElementId = uuidV4();
+                console.log('currentLogicalElementId: ', currentLogicalElementId);
+
+                currentLogicalElement = {
+                  logicalElementType: 'childComplexFilter',
+                  previousLogicalElementId: null,
+                  nextLogicalElementId: null,
+                  childLogicalElementId: filtersStructure.initialLogicalElementId,
+
+                  objType: pathObject.pathLinkType.objType,
+                  pathLinkType: {
+                    objType: pathObject.objType,
+                    relType: pathObject.pathLinkType.relType,
+                    direction: pathObject.pathLinkType.direction
+                  }
+                };
+                console.log('currentLogicalElement', currentLogicalElement);
+
+                let logicalStructure = {};
+                // change function name ==> set logicalElementId
+                [previousLogicalElementId, previousLogicalElement, logicalStructure, errorsFound] = createChildComplexFilterStructure(
+                  _izContext,
+                  logicalElements,
+                  previousLogicalElementId,
+                  previousLogicalElement,
+                  currentLogicalElementId,
+                  currentLogicalElement,
+                  filtersStructure
+                )
+                console.log('return create child', {
+                  previousLogicalElementId,
+                  previousLogicalElement,
+                  logicalStructure,
+                  errorsFound
+                });
+                logicalElements = logicalStructure;
+              };
+            };
+          };
+        };
+      } else {
+        console.log('------------ path euals 1 -----------');
+        console.log('pathObject', path[0]);
+
+        if (checkObjType(requiredObjType, filtersStructure.objType) === true) {
+          filterLogicalStructure = filtersStructure;
+        } else {
+          errorsObject = {
+            [requiredObjType.objectType]: `is not equals objType in filter structure: objType: ${filtersStructure.objType.objectType}`
+          };
+          errorsFound.push(`${requiredObjType.objectType} is not equals objType in filter structure: objType: ${filtersStructure.objType.objectType}`);
+          return [filterLogicalStructure, errorsObject, errorsFound];
+        };
+      };
+    };
+
+    console.log('before return filterLogicalStructure: ', {
+      path,
+      filterLogicalStructure,
+      errorsObject,
+      errorsFound
+    });
+    return [filterLogicalStructure, errorsObject, errorsFound];
+
+  } catch (err) {
+    _izContext.logger.error('error ValidateSearchTypeFilterType: ', err)
+    throw (err);
+  };
+
+};
+//###################################################################################################################################################################################
+
+function createChildComplexFilterStructure(
+  logicalElements,
+  previousLogicalElementId,
+  previousLogicalElement,
+  currentLogicalElementId,
+  currentLogicalElement,
+  filtersStructure
+) {
+  console.log('createChildComplexFilterStructure: ', {
+    logicalElements,
+    previousLogicalElementId,
+    previousLogicalElement,
+    currentLogicalElementId,
+    currentLogicalElement,
+    filtersStructure
+  });
+
+  let errorsFound = [];
+
+  if (!currentLogicalElement) {
+    errorsFound.push('no current logical element to process');
+    return [previousLogicalElementId, previousLogicalElement, logicalElements, errorsFound];
+  };
+
+  if (!previousLogicalElement) {
+    filtersStructure.logicalElements[filtersStructure.initialLogicalElementId].previousLogicalElementId = currentLogicalElementId;
+    logicalElements = Object.assign({ [currentLogicalElementId]: currentLogicalElement }, logicalElements, filtersStructure.logicalElements);
+  } else {
+
+    currentLogicalElement.childLogicalElementId = previousLogicalElementId;
+    console.log('currentLogicalElement', currentLogicalElement);
+
+    logicalElements[previousLogicalElementId].previousLogicalElementId = currentLogicalElementId;
+    console.log('logicalElements', logicalElements);
+
+    logicalElements = Object.assign({ [currentLogicalElementId]: currentLogicalElement }, logicalElements);
+    console.log('after logicalElements', logicalElements);
+
+  };
+
+  previousLogicalElementId = currentLogicalElementId;
+  previousLogicalElement = currentLogicalElement;
+
+  return [previousLogicalElementId, previousLogicalElement, logicalElements, errorsFound];
+};
+
+async function findObjTypePathToAnotherObjType(
+  fromObjType,
+  toObjType,
+  PATHCONSTANCES
+) {
+  console.log('----- function findObjTypePathToAnotherObjType -----', {
+    fromObjType,
+    toObjType
+  });
+
+  let [path, errorsObject, errorsFound] = await recursiveFindObjTypeTypePathToAnotherObjType(
+    PATHCONSTANCES,
+    fromObjType,
+    toObjType,
+  );
+  console.log('return path', {
+    path,
+    errorsObject,
+    errorsFound
+  });
+
+  if (path !== null) {
+    console.log('--------------- will return -----------------');
+    return [path, errorsObject, errorsFound];
+  };
+
+  return [path, errorsObject, errorsFound];
+
+};
+
+async function recursiveFindObjTypeTypePathToAnotherObjType(
+  PATHCONSTANCES,
+  fromObjType,
+  toObjType,
+  iter = 1
+) {
+  console.log('----- function recursiveFindObjTypeTypePathToAnotherObjType -----', {
+    PATHCONSTANCES,
+    fromObjType,
+    toObjType,
+    iter
+  });
+
+  let errorsObject = {};
+  let errorsFound = [];
+
+  let continueProcess = false;
+
+  for (const objType of PATHCONSTANCES.objTypes) {
+    console.log('objType: ', objType);
+    if (checkObjType(fromObjType, objType) === true) {
+      // if (hash(fromObjType) === hash(objType)) {
+      continueProcess = true;
+    };
+  };
+
+  if (continueProcess) {
+    console.log('------------ continue to find path --------------');
+
+    if (checkObjType(fromObjType, toObjType) === true) {
+      // if (hash(fromObjType) === hash(toObjType)) {
+      return [[{ objType: toObjType }], errorsObject, errorsFound];
+    };
+
+    if (iter >= MAX_ITER) {
+      return [null, errorsObject, errorsFound];
+    };
+
+    // let objectRelationship = await getObjectSchema.getObjectRelationshipWithCache(
+    const objectRelationship = await getObjectSchema.getObjectRelationship(
+      {},  //_izContext maybe delete
+      fromObjType
+    );
+    console.log("objectRelationship: ", { fromObjType, objectRelationship });
+
+    let path = null;
+    let previousNextPath = null;
+    let currentNextPath = null;
+
+    for (const relationshipObject of objectRelationship) {
+      console.log('relationshipObject: ', relationshipObject);
+
+      let relType = relationshipObject.relType;
+      console.log('relType: ', relType);
+
+      let otherObjType = relationshipObject.other.objType;
+      console.log('otherObjType: ', otherObjType);
+
+      let relCheck = false;
+
+      for (const relPath of PATHCONSTANCES.relTypes) {
+        if (hash(relType) === hash(relPath)) {
+          relCheck = true;
+          break;
+        };
+      };
+
+      if (!relCheck) {
+        //* no relationshipTag in constance
+        continue;
+      };
+
+      // const objectSchema = await getObjectSchema.getObjSchemaS3WithCache(
+      const objectSchema = await getObjectSchema.getObjSchemaS3WithoutHierarchy(
+        {}, //_izContext maybe delete
+        toObjType,
+      );
+      console.log('objectSchema: ', objectSchema);
+      console.log('before relationshipObject: ', {
+        from: fromObjType,
+        to: toObjType,
+        next: otherObjType,
+        relationshipObject
+      });
+
+      if (objectSchema.hasOwnProperty('extendObjType')) {
+        if (checkObjType(otherObjType, objectSchema.extendObjType) === true) {
+          // if (hash(nextObjType) === hash(objectSchema.extendObjType)) {
+          otherObjType = toObjType;
+        };
+      };
+      console.log('after relationshipObject: ', {
+        from: fromObjType,
+        to: toObjType,
+        next: otherObjType,
+        relationshipObject
+      });
+
+      let pathErrorsObject;
+      let pathErrorsFound;
+
+      //* recurvsive path
+      [currentNextPath, pathErrorsObject, pathErrorsFound] = await recursiveFindObjTypeTypePathToAnotherObjType(
+        PATHCONSTANCES,
+        otherObjType,
+        toObjType,
+        iter + 1
+      );
+      console.log('return recursive path: ', {
+        currentNextPath,
+        pathErrorsObject,
+        pathErrorsFound
+      });
+
+      if (currentNextPath !== null) {
+
+        previousNextPath = currentNextPath;
+
+        let addPath = {
+          objType: fromObjType,
+          pathLinkType: {
+            objType: otherObjType,
+            relType: relType,
+            direction: relationshipObject.other.direction
+          }
+        };
+        console.log('addPath: ', addPath);
+
+        previousNextPath.unshift(addPath);
+        console.log('path: ', path);
+
+      } else {
+        continue;
+      };
+
+      if (previousNextPath !== null) {
+        if (path !== null) {
+          if (path.length > previousNextPath.length) {
+            path = previousNextPath;
+          };
+          console.log('path: ', path);
+          return [path, errorsObject, errorsFound];
+        } else {
+          path = previousNextPath;
+        };
+      };
+    };// end iterate relType
+
+    // if (previousNextPath !== null) {
+    if (path !== null) {
+      if (path.length > previousNextPath.length) {
+        path = previousNextPath;
+      };
+      console.log('path: ', path);
+      return [path, errorsObject, errorsFound];
+    };
+
+  } else {
+    errorsObject = {
+      [fromObjType.objectType]: 'cannot found this objType that can process in path'
+    };
+    errorsFound.push(`${fromObjType.objectType}: cannot found objType that can process in path`);
+  };
+
+  return [null, errorsObject, errorsFound];
+
+};
+
+
+export default {
+  combineLogicalStructure,
+  // combineOperation,
+  // combineLogicalElements,
+
+  checkAndCreateBracket,
+
+  changeObjTypePath,
+  findObjTypePathToAnotherObjType
+}