@izara_project/izara-shared-search-and-sort 1.0.5 → 1.0.7

package/src/LogicalStructureSharedLib.js

@@ -23,6 +23,7 @@ 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 { getObjectSchema } from '@izara_project/izara-shared-service-schemas';
 const MAX_ITER = 4;
 
 
@@ -428,146 +429,754 @@ function combineOperation(
 
 };
 
+// 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);
 
-function findLastLogicalElements(
-  initialLogicalElementId,
-  logicalElements
-) {
-  let lastCurrentLogicalId = null;
+  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);
 
-  let logicaclElement = logicalElements[initialLogicalElementId];
-  _izContext.logger.debug('logicaclElement: ', logicaclElement);
+  // ---- add closeBracket
+  console.log("------create closeBracket------");
+  const MAX_LOGICAL_ELEMENTS = 1000;
 
-  if (logicaclElement.nextLogicalElementId !== null) {
+  let working_logicalElementId = filterLogicalStucture.initialLogicalElementId;
 
-    lastCurrentLogicalId = findLastLogicalElements(
-      logicaclElement.nextLogicalElementId,
-      logicalElements
-    )
+  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);
 
-  } else {
-    lastCurrentLogicalId = initialLogicalElementId;
+      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;
   }
 
-  return lastCurrentLogicalId
+  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 addBrackets(
-  filtersStructure
+function checkObjType(
+  fromObjType,
+  toObjType
 ) {
 
-  let logicalElements = {};
+  let from = {
+    serviceTag: fromObjType.serviceTag,
+    objectType: fromObjType.objectType
+  };
 
-  let uuid_openBracket = uuidV4();
-  _izContext.logger.debug('uuid_openBracket: ', uuid_openBracket);
+  let to = {
+    serviceTag: toObjType.serviceTag,
+    objectType: toObjType.objectType
+  };
 
-  let openBracketObject = {
-    logicalElementType: "openBracket",
-    previousLogicalElementId: null,
-    nextLogicalElementId: filtersStructure.initialLogicalElementId
+  if (hash(to) === hash(from)) {
+    return true;
   };
-  _izContext.logger.debug('openBracketObject: ', openBracketObject);
 
-  filtersStructure.logicalElements[filtersStructure.initialLogicalElementId].previousLogicalElementId = uuid_openBracket;
+  return false;
 
-  let lastLogicalElementId = findLastLogicalElements(
-    filtersStructure.initialLogicalElementId,
-    filtersStructure.logicalElements
-  );
-  _izContext.logger.debug('lastLogicalElementId: ', lastLogicalElementId);
+};
+
+// 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,
+  // getSchemaFn,
+  PATHCONSTANCES = null,
+) {
+  try {
+    console.log('----- function validateSearchTypeFilterType -----', {
+      requiredObjType,
+      filtersStructure,
+      path,
+      // getSchemaFn,
+    });
+
+    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);
 
-  let uuid_closeBracket = uuidV4();
-  _izContext.logger.debug('uuid_closeBracket: ', uuid_closeBracket);
+          if (i + 1 === path.length) {
+            console.log(`------------------- final path: ${i} ---------------------`);
 
-  filtersStructure.logicalElements[lastLogicalElementId].nextLogicalElementId = uuid_closeBracket;
+            if (previousLogicalElementId !== null) {
 
-  let closeBracket = {
-    logicalElementType: "closeBracket",
-    previousLogicalElementId: lastLogicalElementId,
-    nextLogicalElementId: 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;
+
+                      if (PATHCONSTANCES != null) {
+
+                        for (const objType of PATHCONSTANCES.objTypes) {
+                          if (checkObjType(objType, childLogicalElement.objType) === true) {
+                            if (!childLogicalElement.hasOwnProperty('childLogicalElementId')) {
+
+                              // let childSchema = await getObjectSchema.getObjSchemaS3WithCache(
+                              let childSchema = await getObjectSchema.getObjSchemaS3WithoutHierarchy(
+                                {},// _izContext, maybe delete
+                                childLogicalElement.objType
+                              );
+                              // let childSchema = await getObjectSchema.getObjSchemaWithoutHierarchy(
+                              //   getSchemaFn,
+                              //   childLogicalElement.objType
+                              // );
+                              console.log('childSchema: ', childSchema);
+
+                              if (childSchema.hasOwnProperty('extendObjType')) {
+                                if (checkObjType(requiredObjType, childSchema.extendObjType) === true) {
+                                  checkChild = false;
+                                  break;
+                                };
+                              };
+                            };
+                            checkChild = true;
+                            break;
+                          };
+                        };
+                      } else {
+                        checkChild = true;
+                      };
+
+                      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(
+                    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(
+                  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) {
+    console.log('error ValidateSearchTypeFilterType: ', err)
+    throw (err);
   };
-  _izContext.logger.debug('closeBracket: ', closeBracket);
-
-  logicalElements = Object.assign({ [uuid_openBracket]: openBracketObject }, filtersStructure.logicalElements, { [uuid_closeBracket]: closeBracket });
-  _izContext.logger.debug('logicalElements: ', logicalElements);
-
-  return [
-    uuid_openBracket,
-    uuid_closeBracket,
-    {
-      objType: filtersStructure.objType,
-      initialLogicalElementId: uuid_openBracket,
-      logicalElements: logicalElements
-    }
-  ]
 
-}
+};
+//###################################################################################################################################################################################
 
-function combineLogicalElements(
-  firstFilterStructure,
-  secondFilterStructure,
-  operator = "AND"
+function createChildComplexFilterStructure(
+  logicalElements,
+  previousLogicalElementId,
+  previousLogicalElement,
+  currentLogicalElementId,
+  currentLogicalElement,
+  filtersStructure
 ) {
-  _izContext.logger.debug('combineLogicalElements: ', {
-    firstFilterStructure,
-    secondFilterStructure,
-    operator
+  console.log('createChildComplexFilterStructure: ', {
+    logicalElements,
+    previousLogicalElementId,
+    previousLogicalElement,
+    currentLogicalElementId,
+    currentLogicalElement,
+    filtersStructure
   });
 
-  let objType = firstFilterStructure.objType;
+  let errorsFound = [];
 
-  let [firstInitialLogicalElementId, firstLastLogicalElementId, firstFiltersStructureBrcket] = addBrackets(
-    firstFilterStructure
-  );
-  _izContext.logger.debug("first filterStructure addBrackets", {
-    firstInitialLogicalElementId,
-    firstLastLogicalElementId,
-    firstFiltersStructureBrcket
-  })
-
-  let [secondInitialLogicalElementId, secondLastLogicalElementId, secondFiltersStructureBrcket] = addBrackets(
-    secondFilterStructure
+  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,
+  // getSchemaFn
+) {
+  console.log('----- function findObjTypePathToAnotherObjType -----', {
+    fromObjType,
+    toObjType,
+    PATHCONSTANCES,
+    // getSchemaFn
+  });
+
+  let [path, errorsObject, errorsFound] = await recursiveFindObjTypeTypePathToAnotherObjType(
+    PATHCONSTANCES,
+    fromObjType,
+    toObjType,
+    // getSchemaFn
   );
-  _izContext.logger.debug("second filterStructure addBrackets", {
-    secondInitialLogicalElementId,
-    secondLastLogicalElementId,
-    secondFiltersStructureBrcket
-  })
-
-  let uuid_operation = uuidV4();
-  _izContext.logger.debug('uuid_operation: ', uuid_operation);
-
-  let operationObject = {
-    logicalElementType: 'operation',
-    previousLogicalElementId: firstLastLogicalElementId,
-    nextLogicalElementId: secondInitialLogicalElementId,
-    operation: operator
+  console.log('return path', {
+    path,
+    errorsObject,
+    errorsFound
+  });
+
+  if (path !== null) {
+    console.log('--------------- will return -----------------');
+    return [path, errorsObject, errorsFound];
   };
-  _izContext.logger.debug('operationObject: ', operationObject);
 
-  firstFiltersStructureBrcket.logicalElements[firstLastLogicalElementId].nextLogicalElementId = uuid_operation;
-  secondFiltersStructureBrcket.logicalElements[secondInitialLogicalElementId].previousLogicalElementId = uuid_operation;
+  return [path, errorsObject, errorsFound];
 
-  let logicalElements = Object.assign(firstFiltersStructureBrcket.logicalElements, { [uuid_operation]: operationObject }, secondFiltersStructureBrcket.logicalElements);
-  _izContext.logger.debug('logicalElements: ', logicalElements);
+};
 
-  return {
-    objType: objType,
-    initialLogicalElementId: firstInitialLogicalElementId,
-    logicalElements: logicalElements
+async function recursiveFindObjTypeTypePathToAnotherObjType(
+  PATHCONSTANCES,
+  fromObjType,
+  toObjType,
+  // getSchemaFn,
+  iter = 1
+) {
+  console.log('----- function recursiveFindObjTypeTypePathToAnotherObjType -----', {
+    PATHCONSTANCES,
+    fromObjType,
+    toObjType,
+    // getSchemaFn,
+    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
+    );
+    // const objectRelationship = await getObjectSchema.getObjectRelationship(
+    //   getSchemaFn,
+    //   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,
+      );
+      // const objectSchema = await getObjectSchema.getObjSchemaWithoutHierarchy(
+      //   getSchemaFn,
+      //   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,
+        // getSchemaFn,
+        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 {
+  //* front-end
+  changeObjTypePath,
+  findObjTypePathToAnotherObjType,
+
+
+  //* use in back-end
   combineLogicalStructure,
-  // combineOperation,
-  combineLogicalElements,
-  addBrackets,
-  combineLogicalElements
+  checkAndCreateBracket,
+  // changeObjTypePath,
+  // findObjTypePathToAnotherObjType,
+
 }