@izara_project/izara-shared-search-and-sort 1.0.1 → 1.0.2

package/src/FiltersSharedLib.js

@@ -0,0 +1,1543 @@
+/*
+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 { isEmpty as isEmpty } from 'lodash';
+import complexFilterShared from '@izara_project/izara-core-library-complex-filter';
+
+function validateFilterElement(
+  filterElements,
+  logicalElements
+) {
+  let validate = false;
+  let countsBracket = 0;
+  let operationCounts = 0;
+  let logicalCounts = 0;
+  for (let logicalElement of Object.values(logicalElements)) {
+    if (logicalElement.logicalElementType === "openBracket" || logicalElement.logicalElementType === "closeBracket") {
+      countsBracket = countsBracket + 1;
+    } else if (logicalElement.logicalElementType === "operation") {
+      operationCounts = operationCounts + 1;
+    } else if (logicalElement.logicalElementType === "logical"
+      || logicalElement.logicalElementType === "childComplexFilter"
+      || logicalElement.logicalElementType === "identifiers"
+      || logicalElement.logicalElementType === "translateIds"
+      || logicalElement.logicalElementType === "traversal"
+    ) {
+      logicalCounts = logicalCounts + 1;
+    }
+  }
+  let logicalElementsLength = logicalCounts + operationCounts;
+  let filtersLength = Object.keys(filterElements).length;
+  console.log('check count: ', {
+    countsBracket,
+    operationCounts,
+    logicalCounts,
+    logicalElementsLength,
+    filtersLength
+  });
+
+  if (filtersLength === logicalElementsLength) {
+    validate = true;
+  }
+  return validate
+}
+
+function createFiltersRequest(
+  _izContext,
+  objType,
+  initialLogicalElementId,
+  logicalElements,
+  values,
+) {
+  _izContext.logger.debug('createFiltersRequest: ', {
+    objType,
+    initialLogicalElementId,
+    logicalElements,
+    values,
+  });
+
+  let filterMainId = null;
+  let filterMainObject = {};
+  let operation = null;
+
+  let errorsObject = {};
+  let errorsFound = [];
+  let status = 'valid';
+
+  //* validate combine logicalStructure
+  let [validateObject, validateFilterMainId, validateFilterObject, validateErrorsObject, validateErrors] = validateCombinationStructure(
+    _izContext,
+    initialLogicalElementId,
+    logicalElements,
+    values
+  );
+  _izContext.logger.debug('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 = [];
+
+  [
+    filterMainId,
+    filterMainObject,
+    operation,
+    operationErrorsObject,
+    operationErrors
+  ] = filterLogicalElements(
+    _izContext,
+    objType,
+    initialLogicalElementId,
+    logicalElements,
+    values,
+  );
+  _izContext.logger.debug('final return filterLogicalElements: ', {
+    filterMainId,
+    filterMainObject,
+    operation,
+    operationErrorsObject,
+    operationErrors
+  });
+
+  if (errorsFound.length > 0 || filterMainId === null) {
+    Object.assign(errorsObject, operationErrorsObject);
+    errorsFound = errorsFound.concat(operationErrors);
+    return [
+      null,
+      'invalid',
+      errorsObject,
+      errorsFound
+    ];
+  };
+
+  let filterElements = {};
+  if (filterMainObject.filterElement.hasOwnProperty('filterElements')) {
+    filterElements = filterMainObject.filterElement.filterElements;
+
+    delete filterMainObject.filterElement.filterElements;
+    Object.assign(filterElements, { [filterMainId]: filterMainObject });
+  };
+
+  if (isEmpty(filterElements)) {
+    filterElements = {
+      [filterMainId]: filterMainObject
+    };
+  };
+
+  let complexFilterRequest = {
+    objType: objType,
+    filterMainId: filterMainId,
+    filterElements: filterElements
+  };
+  _izContext.logger.debug('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,
+    errorsObject,
+    errorsFound
+  ];
+
+};
+
+function validateCombinationStructure(
+  _izContext,
+  initialLogicalElementId,
+  logicalElements,
+  values
+) {
+  _izContext.logger.debug('validateCombinationStructure: ', {
+    initialLogicalElementId,
+    logicalElements,
+    values
+  });
+
+  let validateObject = true;
+  let errorsObject = {};
+  let errorsFound = []
+
+  let runningFilterMainId = null;
+  let runningFilterObject = null;
+  let currentFilterMainId = null;
+  let currentFilterObject = null;
+  let lastOperation = null;
+
+  for (const [logicalElementId, logicalElementObject] of Object.entries(logicalElements)) {
+    _izContext.logger.debug('iterate logicalElements: ', { initialLogicalElementId, logicalElementId, logicalElementObject });
+
+    if (initialLogicalElementId !== logicalElementId) {
+      continue;
+    };
+    _izContext.logger.debug('----------------- start logicalElement --------------');
+
+    if (!logicalElementObject.hasOwnProperty("logicalElementType")) {
+      errorsObject[logicalElementId] = `this logical structure is not set logicalElementType`;
+      errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set logicalElementType`);
+    };
+    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`);
+    };
+
+    let logicalElementType = logicalElementObject.logicalElementType;
+
+    if (logicalElementType === 'operation') {
+      _izContext.logger.debug('----------------- operation --------------');
+      _izContext.logger.debug('logicalElementObject: ', logicalElementObject);
+
+      lastOperation = logicalElementObject.operation;
+      _izContext.logger.debug('lastOperation: ', lastOperation);
+
+      if (isEmpty(lastOperation)) {
+        _izContext.logger.debug('no operation: ', logicalElementObject.operation);
+        errorsObject[logicalElementId] = `this logical structure is not set operation parameter`;
+        errorsFound.push(`this logical structure type: operation: ${logicalElementId} is not set operation parameter`);
+        break;
+      };
+
+      if (logicalElementObject.nextLogicalElementId !== null) {
+        initialLogicalElementId = logicalElementObject.nextLogicalElementId;
+      };
+      continue;
+    };
+
+    if (logicalElementType === 'openBracket') {
+      _izContext.logger.debug('----------------- openBracket --------------');
+
+      let nextElementId = null;
+
+      [validateObject, currentFilterMainId, currentFilterObject, errorsObject, errorsFound, nextElementId] = validateCombinationStructure(
+        _izContext,
+        logicalElementObject.nextLogicalElementId,
+        logicalElements,
+        values
+      );
+      _izContext.logger.debug('return validateCombinationStruce for openBracket: ', {
+        validateObject,
+        currentFilterMainId,
+        currentFilterObject,
+        errorsObject,
+        errorsFound,
+        nextElementId
+      });
+
+      if (nextElementId !== null) {
+        initialLogicalElementId = nextElementId;
+      };
+
+    } else if (logicalElementType === 'closeBracket') {
+      _izContext.logger.debug('----------------- closeBracket --------------');
+
+      return [
+        true,
+        runningFilterMainId,
+        runningFilterObject,
+        errorsObject,
+        errorsFound,
+        logicalElementObject.nextLogicalElementId
+      ];
+
+    } else if (logicalElementType === 'logical') {
+      _izContext.logger.debug('----------------- logical --------------');
+      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('fieldName')) {
+        errorsObject[logicalElementId] = `this logical structure is not set fieldName`;
+        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set fieldName`);
+      };
+      if (!logicalElementObject.hasOwnProperty('comparison')) {
+        errorsObject[logicalElementId] = `this logical structure is not set comparison`;
+        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set comparison`);
+      };
+      if (!logicalElementObject.hasOwnProperty('value')) {
+        errorsObject[logicalElementId] = `this logical structure is not set value`;
+        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set value`);
+      };
+
+      currentFilterMainId = logicalElementId;
+      currentFilterObject = logicalElementObject;
+
+      if (logicalElementObject.nextLogicalElementId !== null) {
+        initialLogicalElementId = logicalElementObject.nextLogicalElementId;
+      };
+
+    } else if (logicalElementType === 'childComplexFilter') {
+      _izContext.logger.debug('----------------- childComplexFilter --------------');
+      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('pathLinkType')) {
+        errorsObject[logicalElementId] = `this logical structure is not set pathLinkType`;
+        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set pathLinkType`);
+      } else {
+        if (!logicalElementObject.pathLinkType.hasOwnProperty('objType')
+          && !logicalElementObject.pathLinkType.hasOwnProperty('relType')
+          && !logicalElementObject.pathLinkType.hasOwnProperty('direction')
+        ) {
+          errorsObject[logicalElementId] = `this logical structure is not set properties in pathLinkType in type: childComplexFilter`;
+          errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set {objType | relType | direction} in pathLinkType in type: childComplexFilter`);
+        };
+      };
+
+      let parantObjType = logicalElementObject.objType;
+      _izContext.logger.debug('check parantObjType: ', {
+        parantObjType
+      });
+
+      let [
+        childValidate,
+        childElementId,
+        childElementObject,
+        childErrorsObject,
+        childErrorsFound
+      ] = this.validateCombinationStructure(
+        _izContext,
+        logicalElementObject.childLogicalElementId,
+        logicalElements,
+        values
+      );
+      _izContext.logger.debug('return validateCombinationStruce for childComplexFilter: ', {
+        childValidate,
+        childElementId,
+        childElementObject,
+        childErrorsObject,
+        childErrorsFound
+      });
+
+      if (!childValidate || childErrorsFound.length > 0) {
+        Object.assign(errorsObject, childErrorsObject);
+        errorsFound = errorsFound.concat(childErrorsFound);
+      };
+
+      currentFilterMainId = logicalElementId;
+      currentFilterObject = logicalElementObject;
+
+      if (logicalElementObject.nextLogicalElementId !== null) {
+        initialLogicalElementId = logicalElementObject.nextLogicalElementId;
+      };
+
+    } else if (logicalElementType === 'translateIds') {
+      _izContext.logger.debug("----------------- translateIds --------------", logicalElementObject);
+
+      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('childIdentifiers')) {
+        errorsObject[logicalElementId] = `this logical structure is not set childIdentifiers`;
+        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set childIdentifiers`);
+      };
+      if (!logicalElementObject.hasOwnProperty('pathLinkType')) {
+        errorsObject[logicalElementId] = `this logical structure is not set pathLinkType`;
+        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set pathLinkType`);
+      } else {
+        if (!logicalElementObject.pathLinkType.hasOwnProperty('objType')
+          && !logicalElementObject.pathLinkType.hasOwnProperty('relType')
+          && !logicalElementObject.pathLinkType.hasOwnProperty('direction')
+        ) {
+          errorsObject[logicalElementId] = `this logical structure is not set properties in pathLinkType`;
+          errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set {objType | relType | direction} in pathLinkType`);
+        };
+      };
+
+      currentFilterMainId = logicalElementId;
+      currentFilterObject = logicalElementObject;
+
+      if (logicalElementObject.nextLogicalElementId !== null) {
+        initialLogicalElementId = logicalElementObject.nextLogicalElementId;
+      };
+
+    } else if (logicalElementType === 'identifiers') {
+      _izContext.logger.debug('----------------- identifiers --------------', logicalElementObject);
+      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('fieldName')) {
+        errorsObject[logicalElementId] = `this logical structure is not set fieldName`;
+        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set fieldName`);
+      };
+      if (!logicalElementObject.hasOwnProperty('comparison')) {
+        errorsObject[logicalElementId] = `this logical structure is not set comparison`;
+        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set comparison`);
+      };
+      if (!logicalElementObject.hasOwnProperty('value')) {
+        errorsObject[logicalElementId] = `this logical structure is not set value`;
+        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set value`);
+      };
+
+      currentFilterMainId = logicalElementId;
+      currentFilterObject = logicalElementObject;
+
+      if (logicalElementObject.nextLogicalElementId !== null) {
+        initialLogicalElementId = logicalElementObject.nextLogicalElementId;
+      };
+
+    } else if (logicalElementType === 'traversal') {
+      _izContext.logger.debug('----------------- traversal --------------', logicalElementObject);
+      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('traversals')) {
+        errorsObject[logicalElementId] = `this logical structure is not set traversals`;
+        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set traversals`);
+      };
+
+      currentFilterMainId = logicalElementId;
+      currentFilterObject = logicalElementObject;
+
+      if (logicalElementObject.nextLogicalElementId !== null) {
+        initialLogicalElementId = logicalElementObject.nextLogicalElementId;
+      };
+
+    };
+
+    let operationErrorsFound = {};
+    let operationFilterObject = [];
+    [
+      runningFilterMainId,
+      runningFilterObject,
+      operationFilterObject,
+      operationErrorsFound
+    ] = this.validateOperation(
+      _izContext,
+      runningFilterMainId,
+      runningFilterObject,
+      lastOperation,
+      currentFilterMainId,
+      currentFilterObject
+    );
+    _izContext.logger.debug('return validateOperation: ', {
+      runningFilterMainId,
+      runningFilterObject,
+      operationFilterObject,
+      operationErrorsFound
+    });
+
+    if (operationErrorsFound.length > 0) {
+      Object.assign(errorsObject, operationFilterObject);
+      errorsFound = errorsFound.concat(operationErrorsFound);
+      break;
+    };
+
+  };
+
+  if (errorsFound.length > 0) {
+    validateObject = false;
+  };
+
+  return [
+    validateObject,
+    runningFilterMainId,
+    runningFilterObject,
+    errorsObject,
+    errorsFound
+  ];
+
+}
+
+function validateOperation(
+  _izContext,
+  runningFilterMainId,
+  runningFilterObject,
+  lastOperation,
+  currentFilterMainId,
+  currentFilterObject,
+) {
+  _izContext.logger.debug('validateOperation: ', {
+    runningFilterMainId,
+    runningFilterObject,
+    lastOperation,
+    currentFilterMainId,
+    currentFilterObject,
+  });
+
+  let errorsObject = {};
+  let errorsFound = [];
+
+  if (!currentFilterObject) {
+    errorsObject[currentFilterMainId] = 'cannot found current filterElement object';
+    errorsFound.push(`${currentFilterMainId}: cannot found current filterElement object`);
+    return [null, null, errorsObject, errorsFound];
+  };
+
+  if (!runningFilterObject) {
+    return [currentFilterMainId, currentFilterObject, errorsObject, errorsFound];
+  };
+
+  if (!lastOperation) {
+
+    let returnNextElementId = null;
+    let returnNextElementObject = null;
+
+    if (runningFilterObject.logicalElementType === 'openBracket') {
+      if (currentFilterObject.logicalElementType === 'closeBracket') {
+
+        errorsObject[currentFilterMainId] = `this path has logicalElementType: ${runningFilterObject.logicalElementType} and ${currentFilterObject.logicalElementType} are error`;
+        errorsFound.push(`${currentFilterMainId}: this path has logicalElementType: ${runningFilterObject.logicalElementType} and ${currentFilterObject.logicalElementType} are error`);
+
+      } else {
+
+        runningFilterObject.nextLogicalElementId = currentFilterMainId;
+        currentFilterObject.previousLogicalElementId = runningFilterMainId;
+
+        operations = Object.assign(runningFilterObject, currentFilterObject);
+
+        _izContext.logger.debug('operations: ', operations);
+        returnNextElementId = currentFilterMainId;
+        returnNextElementObject = currentFilterObject;
+
+      };
+
+    } else if (runningFilterObject.logicalElementType === 'closeBracket') {
+      if (currentFilterObject.logicalElementType === "closeBracket") {
+
+        runningFilterObject.nextLogicalElementId = currentFilterMainId;
+        currentFilterObject.previousLogicalElementId = runningFilterMainId;
+
+        operations = Object.assign(runningFilterObject, currentFilterObject);
+        _izContext.logger.debug('operations: ', operations);
+
+        returnNextElementId = currentFilterMainId;
+        returnNextElementObject = currentFilterObject;
+
+      } else {
+        errorsObject[currentFilterMainId] = `this path has logicalElementType: ${runningFilterObject.logicalElementType} and ${currentFilterObject.logicalElementType} are error`;
+        errorsFound.push(`${currentFilterMainId}: this path has logicalElementType: ${runningFilterObject.logicalElementType} and ${currentFilterObject.logicalElementType} are error`);
+      };
+
+    } else {
+
+      if (currentFilterObject.logicalElementType === 'closeBracket') {
+
+        runningFilterObject.nextLogicalElementId = currentFilterMainId;
+        currentFilterObject.previousLogicalElementId = runningFilterMainId;
+
+        operations = Object.assign(runningFilterObject, currentFilterObject);
+        _izContext.logger.debug('operations: ', operations);
+
+        returnNextElementId = currentFilterMainId;
+        returnNextElementObject = nextLogicalElementObject;
+      } else {
+        errorsObject[currentFilterMainId] = `this path has logicalElementType: ${runningFilterObject.logicalElementType} and ${currentFilterObject.logicalElementType} are error`;
+        errorsFound.push(`${currentFilterMainId}: this path has logicalElementType: ${runningFilterObject.logicalElementType} and ${currentFilterObject.logicalElementType} are error`);
+      };
+    };
+
+    return [returnNextElementId, returnNextElementObject, errorsObject, errorsFound];
+
+  };
+
+  if (runningFilterMainId && lastOperation && currentFilterMainId) {
+
+    // let operationFilterObject = {
+    //   runningFilterMainId: runningFilterObject,
+    //   operation: lastOperation,
+    //   currentFilterMainId: currentFilterObject
+    // };
+    // // let operationFilterMainId = hash(operationFilterObject);
+
+    return [currentFilterMainId, currentFilterObject, errorsObject, errorsFound];
+
+  } else {
+    errorsFound.push("found some error that not expect");
+    return [null, null, errorsObject, errorsFound];
+  };
+};
+
+function filterLogicalElements(
+  _izContext,
+  objType,
+  initialLogicalElementId,
+  logicalElements,
+  values,
+  nextLogicalElementId = null,
+  runningFilterMainId = null,
+  runningFilterObject = null,
+  lastLogicalOperator = null,
+  currentFilterMainId = null,
+  currentFilterObject = null
+) {
+  _izContext.logger.debug('filterLogicalElements: ', {
+    objType,
+    initialLogicalElementId,
+    logicalElements,
+    values,
+    nextLogicalElementId,
+    runningFilterMainId,
+    runningFilterObject,
+    lastLogicalOperator,
+    currentFilterMainId,
+    currentFilterObject
+  });
+
+  let errorsObject = {};
+  let errorsFound = [];
+
+  let operation = null;
+  let operationErrorsFound = [];
+  let lastNextLogicalElementId = null;
+  let currentLogicalElementId = initialLogicalElementId;
+
+  if (nextLogicalElementId !== null) {
+    currentLogicalElementId = nextLogicalElementId;
+  }
+
+  let logicalElement = logicalElements[currentLogicalElementId];
+  _izContext.logger.debug('logicalElement: ', logicalElement)
+
+  if (isEmpty(logicalElement)) {
+    errorsObject[currentLogicalElementId] = 'this logicalElement not found';
+    errorsFound.push(`${currentLogicalElementId}: this logicalElement not found`);
+  };
+  if (!logicalElement.hasOwnProperty('logicalElementType')) {
+    errorsObject[currentLogicalElementId] = 'this logicalElement is not set logicalElementType';
+    errorsFound.push(`${currentLogicalElementId}: this logicalElement  not set logicalElementType`);
+  };
+
+  let logicalElementType = logicalElement.logicalElementType;
+  _izContext.logger.debug('logicalElementType: ', logicalElementType);
+
+  if (logicalElementType === "openBracket") {
+
+    let nextElementId = null;
+
+    [
+      currentFilterMainId,
+      currentFilterObject,
+      operation,
+      errorsObject,
+      errorsFound,
+      nextElementId
+    ] = filterLogicalElements(
+      _izContext,
+      objType,
+      initialLogicalElementId,
+      logicalElements,
+      values,
+      logicalElement.nextLogicalElementId
+    );
+    _izContext.logger.debug('return filterLogicalElement for openBracket: ', {
+      currentFilterMainId,
+      currentFilterObject,
+      operation,
+      errorsObject, errorsFound,
+      lastNextLogicalElementId
+    });
+
+    if (nextElementId !== null) {
+      lastNextLogicalElementId = nextElementId;
+    }
+
+  } else if (logicalElementType === "closeBracket") {
+
+    return [
+      runningFilterMainId,
+      runningFilterObject,
+      null,
+      errorsObject,
+      errorsFound,
+      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;
+
+  }
+
+  _izContext.logger.debug("check logicalElement: ", logicalElement);
+  _izContext.logger.debug("check logicalElementType: ", logicalElementType);
+  _izContext.logger.debug("check filter main id: ", {
+    runningFilterMainId,
+    lastLogicalOperator,
+    currentFilterMainId
+  });
+
+  _izContext.logger.debug("check filter main id: ", {
+    runningFilterMainId,
+    runningFilterObject,
+    lastLogicalOperator,
+    currentFilterMainId,
+    currentFilterObject
+  });
+
+  if (logicalElementType === "logical") {
+
+    _izContext.logger.debug('------------------ logicalElementType: logical ----------------');
+
+    if (!logicalElement.hasOwnProperty('objType')) {
+      errorsObject[initialLogicalElementId] = `this logical structure is not set objType`;
+      errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} is not set objType`);
+    };
+    if (hash(objType) !== hash(logicalElement.objType)) {
+      errorsObject[currentLogicalElementId] = `it' s not the same level objType to process this logicalElement`;
+      errorsFound.push(`it' s not the same level objType to process this logicalElement: ${currentLogicalElementId}`);
+    };
+    if (!logicalElement.hasOwnProperty('fieldName')) {
+      errorsObject[currentLogicalElementId] = `this logical structure is not set fieldName`;
+      errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} is not set fieldName`);
+    };
+    if (!logicalElement.hasOwnProperty('comparison')) {
+      errorsObject[currentLogicalElementId] = `this logical structure is not set comparison`;
+      errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} is not set comparison`);
+    };
+    if (!logicalElement.hasOwnProperty('value')) {
+      errorsObject[currentLogicalElementId] = `this logical structure is not set value`;
+      errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} is not set value`);
+    }
+
+    let value = values[logicalElement.value];
+    _izContext.logger.debug('value: ', value);
+
+    if (isEmpty(value)) {
+      errorsObject[currentLogicalElementId] = `value is empty`;
+      errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} value is empty`);
+    } else {
+      if (value.hasOwnProperty('valueSource')) {
+
+        if (value.valueSource !== 'perParentIdentifier') {
+          errorsObject[currentLogicalElementId] = `valueType is not set type: perParentIdentifier`;
+          errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} has valueType is not set type: perParentIdentifier`);
+        };
+
+        //* create complexFilter normalize here
+        currentFilterObject = {
+          objType: logicalElement.objType,
+          filterElement: {
+            filterType: logicalElementType,
+            fieldName: logicalElement.fieldName,
+            comparison: logicalElement.comparison,
+            valueType: value.valueSource,
+            perParentIdentifierFieldname: value.perParentIdentifierFieldname
+          }
+        };
+
+      } else {
+
+        //* create complexFilter normalize here
+        currentFilterObject = {
+          objType: logicalElement.objType,
+          filterElement: {
+            filterType: logicalElement.logicalElementType,
+            fieldName: logicalElement.fieldName,
+            comparison: logicalElement.comparison,
+            value: values[logicalElement.value].value
+          }
+        };
+      };
+    };
+    _izContext.logger.debug('currentFilterObject: ', currentFilterObject);
+
+    currentFilterMainId = hash(currentFilterObject);
+    _izContext.logger.debug('currentFilterMainId: ', currentFilterMainId);
+
+    if (logicalElement.nextLogicalElementId !== null) {
+      lastNextLogicalElementId = logicalElement.nextLogicalElementId;
+    }
+
+  } else if (logicalElementType === "childComplexFilter") {
+    _izContext.logger.debug('------------------ logicalElementType: childComplexFilter ----------------');
+
+    if (!logicalElement.hasOwnProperty('objType')) {
+      errorsObject[currentLogicalElementId] = `this logical structure is not set objType`;
+      errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} is not set objType`);
+    };
+    if (hash(objType) !== hash(logicalElement.objType)) {
+      errorsObject[currentLogicalElementId] = `it' s not the same level objType to process this logicalElement`
+      errorsFound.push(`it' s not the same level objType to process this logicalElement: ${currentLogicalElementId}`)
+    };
+
+    if (!logicalElement.hasOwnProperty('pathLinkType')) {
+      errorsObject[currentLogicalElementId] = `this logical structure is not set pathLinkType`;
+      errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} is not set pathLinkType`);
+    } else {
+      if (!logicalElement.pathLinkType.hasOwnProperty('objType')
+        || !logicalElement.pathLinkType.hasOwnProperty('relType')
+        || !logicalElement.pathLinkType.hasOwnProperty('direction')
+      ) {
+        errorsObject[currentLogicalElementId] = `this logical structure is not set properties in pathLinkType`;
+        errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} is not set {objType | relType | direction} in pathLinkType`);
+      };
+    };
+
+    let childLogicalElementId = logicalElement.childLogicalElementId;
+
+    if (childLogicalElementId === null) {
+      errorsObject[currentLogicalElementId] = `this logicalType: childComplexFilter is not set childLogicalElementId`;
+      errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} logicalType: childComplexFilter is not set childLogicalElementId`);
+    }
+
+    if (errorsFound.length > 0) {
+      return [null, null, null, errorsObject, errorsFound];
+    };
+
+    let [
+      childFilterMainId,
+      childFilterObject,
+      operation,
+      childErrorsObject,
+      childErrorsFound,
+      childNextLogicalElementId
+    ] = filterLogicalElements(
+      _izContext,
+      logicalElement.pathLinkType.objType,
+      initialLogicalElementId,
+      logicalElements,
+      values,
+      logicalElement.childLogicalElementId
+    );
+    _izContext.logger.debug('return child filterLogicalElement for child complexFilter: ', {
+      childFilterMainId,
+      childFilterObject,
+      operation,
+      childErrorsObject,
+      childErrorsFound,
+      childNextLogicalElementId
+    });
+    if (childErrorsFound.length > 0) {
+      Object.assign(errorsObject, childErrorsObject);
+      errorsFound = errorsFound.concat(childErrorsFound)
+    }
+
+    let filterElements = splitFilterElements(
+      _izContext,
+      childFilterMainId,
+      childFilterObject
+    );
+    _izContext.logger.debug('filterElements: ', filterElements);
+    let setRequestProperties = {};
+
+    if (!isEmpty(logicalElement.requestProperties)) {
+      _izContext.logger.debug('logicalElement: ', logicalElement);
+
+      for (const [tag, requestPropertyId] of Object.entries(logicalElement.requestProperties)) {
+        _izContext.logger.debug('set requestProperties: ', { tag, requestPropertyId });
+
+        let requestPropertyObject = values[requestPropertyId];
+
+        if (requestPropertyObject.hasOwnProperty('valueSource')) {
+          errorsObject[initialLogicalElementId] = `requestProperties in filter logicalStructure set valueSource`;
+          errorsFound.push(`this filter logical structure logicalElementId: ${initialLogicalElementId} set valueSource`);
+          continue;
+        };
+
+        setRequestProperties[tag] = requestPropertyObject.value;
+
+      };
+    };
+
+    currentFilterObject = {
+      objType: logicalElement.objType,
+      filterElement: {
+        filterType: logicalElementType,
+        filterElements: filterElements,
+        childFilterElementId: childFilterMainId,
+        pathLinkType: logicalElement.pathLinkType,
+        requestProperties: setRequestProperties ?? {}
+      }
+    };
+    _izContext.logger.debug('currentFilterObject: ', currentFilterObject);
+
+    currentFilterMainId = hash(currentFilterObject);
+    _izContext.logger.debug('currentFilterMainId: ', currentFilterMainId);
+
+    if (logicalElement.nextLogicalElementId !== null) {
+      lastNextLogicalElementId = logicalElement.nextLogicalElementId;
+    }
+
+  } else if (logicalElementType === "traversal") {
+
+    _izContext.logger.debug('logicalElementType: ', f);
+  } else if (logicalElementType === "translateIds") {
+
+    _izContext.logger.debug('logicalElementType: ', g);
+  } else if (logicalElementType === "identifiers") {
+
+    _izContext.logger.debug('logicalElementType: ', h);
+  }
+
+  if (errorsFound.length > 0) {
+    return [null, null, null, errorsObject, errorsFound, null];
+  }
+
+  if (lastNextLogicalElementId !== null) {
+
+    [runningFilterMainId, runningFilterObject, operation, operationErrorsFound] = complexFilterShared.validateOperation(
+      _izContext,
+      objType,
+      runningFilterMainId,
+      runningFilterObject,
+      lastLogicalOperator,
+      currentFilterMainId,
+      currentFilterObject
+    );
+    _izContext.logger.debug('return validateOperation for lastNextLogicalElementId == null: ', {
+      runningFilterMainId,
+      runningFilterObject,
+      operation,
+      operationErrorsFound
+    });
+
+    if (!isEmpty(operation)) {
+      lastLogicalOperator = null;
+    }
+
+    let [
+      nextFilterMainId,
+      nextFilterObject,
+      operations,
+      nextErrorObject,
+      nextErrorFound,
+      nextElementId
+    ] = filterLogicalElements(
+      _izContext,
+      objType,
+      initialLogicalElementId,
+      logicalElements,
+      values,
+      lastNextLogicalElementId,
+      runningFilterMainId,
+      runningFilterObject,
+      lastLogicalOperator,
+    );
+    _izContext.logger.debug('return validateOperation for lastNextLogicalElementId !== null: ', {
+      nextFilterMainId,
+      nextFilterObject,
+      operations,
+      nextErrorObject,
+      nextErrorFound,
+      nextElementId
+    });
+
+    if (nextErrorFound.length > 0) {
+      Object.assign(errorsObject, nextErrorObject);
+      errorsFound = errorsFound.concat(nextErrorFound);
+    }
+
+    if (nextElementId !== null) {
+      let filterErrorObject = {};
+      let filterErrorFound = [];
+
+      [
+        runningFilterMainId,
+        runningFilterObject,
+        operation,
+        filterErrorObject,
+        filterErrorFound,
+        nextElementId
+      ] = filterLogicalElements(
+        _izContext,
+        objType,
+        initialLogicalElementId,
+        logicalElements,
+        values,
+        nextElementId,
+        nextFilterMainId,
+        nextFilterObject,
+        lastLogicalOperator
+      );
+      _izContext.logger.debug('return validateOperation for lastNextLogicalElementId !== null: ', {
+        runningFilterMainId,
+        runningFilterObject,
+        operation,
+        filterErrorObject,
+        filterErrorFound,
+        nextElementId
+      });
+      return [
+        runningFilterMainId,
+        runningFilterObject,
+        operation,
+        filterErrorObject,
+        filterErrorFound,
+        nextElementId
+      ];
+    } else {
+      return [
+        nextFilterMainId,
+        nextFilterObject,
+        operation,
+        errorsObject,
+        errorsFound,
+        nextElementId
+      ];
+    }
+
+  } else {
+
+    [runningFilterMainId, runningFilterObject, operation, operationErrorsFound] = complexFilterShared.validateOperation(
+      _izContext,
+      objType,
+      runningFilterMainId,
+      runningFilterObject,
+      lastLogicalOperator,
+      currentFilterMainId,
+      currentFilterObject
+    );
+    _izContext.logger.debug('return validateOperation for lastNextLogicalElementId == null: ', {
+      runningFilterMainId,
+      runningFilterObject,
+      operation,
+      operationErrorsFound
+    });
+
+    if (operationErrorsFound.length > 0) {
+      errorsFound = errorsFound.concat(operationErrorsFound)
+    }
+
+    return [runningFilterMainId, runningFilterObject, operation, errorsObject, errorsFound, null];
+
+  }
+
+};
+
+
+
+function combineLogicalStructure(
+  _izContext,
+  objType,
+  initialLogicalElementId,
+  logicalElements,
+) {
+  _izContext.logger.debug('combineLogicalStructure: ', {
+    objType,
+    initialLogicalElementId,
+    logicalElements,
+  });
+
+  let returnInitialElementId = null;
+  let initialLogicalElementObject = logicalElements[initialLogicalElementId]
+  if (initialLogicalElementObject.logicalElementType !== 'logicalStructure') {
+    returnInitialElementId = initialLogicalElementId;
+  } else {
+    returnInitialElementId = logicalElements[initialLogicalElementId].initialLogicalElementId;
+  };
+  _izContext.logger.debug('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)) {
+    _izContext.logger.debug('extract logicalELements: ', { initialLogicalElementId, logicalElementId, logicalElementObject });
+
+    if (initialLogicalElementId !== logicalElementId) {
+      continue;
+    };
+
+    let logicalElementType = logicalElementObject.logicalElementType;
+    _izContext.logger.debug('logicalElementType: ', logicalElementType);
+
+    if (logicalElementType === 'openBracket') {
+      _izContext.logger.debug('----------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') {
+      _izContext.logger.debug('----------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') {
+      _izContext.logger.debug('----------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') {
+      _izContext.logger.debug('----------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(
+      _izContext,
+      previousLogicalElementId,
+      previousLogicalElementObject,
+      operationLogicalElementId,
+      operationLogicalElementObject,
+      nextLogicalElementId,
+      nextLogicalElementObject
+    );
+    _izContext.logger.debug('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
+
+  _izContext.logger.debug('returnLogicalElements: ', { returnLogicalElements });
+
+  let returnComplexLogicalStructure = {
+    objType: objType,
+    initialLogicalElementId: returnInitialElementId,
+    logicalElements: returnLogicalElements
+  };
+
+  return [returnComplexLogicalStructure, errorsObject, errorsFound];
+
+};
+
+function combineOperation(
+  _izContext,
+  previousLogicalElementId,
+  previousLogicalElementObject,
+  operationLogicalElementId,
+  operationLogicalElementObject,
+  nextLogicalElementId,
+  nextLogicalElementObject
+) {
+  _izContext.logger.debug('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) {
+    _izContext.logger.debug('------------ 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;
+            _izContext.logger.debug('checkNextLogicalElementId:', checkNextLogicalElementId);
+
+            for (let i = 0; i < Object.entries(previousLogicalElementObject).length; i++) {
+              let [logicalElementId, logicalObject] = Object.entries(previousLogicalElementObject)[i];
+              _izContext.logger.debug('extract logical element: ', { logicalElementId, logicalObject });
+
+              if (logicalElementId !== checkNextLogicalElementId) {
+                continue;
+              };
+
+              _izContext.logger.debug('------------- 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);
+        _izContext.logger.debug('operations: ', operations);
+
+        returnnextElementId = nextLogicalElementId;
+        returnNextElementObject = nextLogicalElementObject;
+
+      } else {
+
+        previousLogicalElementObject[previousLogicalElementId].nextLogicalElementId = nextLogicalElementId;
+        nextLogicalElementObject[nextLogicalElementId].previousLogicalElementId = previousLogicalElementId;
+
+        operations = Object.assign(previousLogicalElementObject, nextLogicalElementObject);
+
+        _izContext.logger.debug('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);
+        _izContext.logger.debug('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') {
+
+        _izContext.logger.debug('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;
+            _izContext.logger.debug('checkNextLogicalElementId:', checkNextLogicalElementId);
+
+            for (let i = 0; i < Object.entries(previousLogicalElementObject).length; i++) {
+              let [logicalElementId, logicalObject] = Object.entries(previousLogicalElementObject)[i];
+              _izContext.logger.debug('extract logical element: ', { logicalElementId, logicalObject });
+
+              if (logicalElementId !== checkNextLogicalElementId) {
+                continue;
+              };
+
+              _izContext.logger.debug('------------- 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);
+        _izContext.logger.debug("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) {
+    _izContext.logger.debug('------------ 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;
+
+    _izContext.logger.debug('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 splitFilterElements(
+  _izContext,
+  runningFilterMainId,
+  runningFilterObject,
+  currentFilterMainId = null,
+  currentFilterObject = null
+) {
+  _izContext.logger.debug('split FilterElements: ', {
+    runningFilterMainId,
+    runningFilterObject,
+    currentFilterMainId,
+    currentFilterObject
+  });
+
+  let filterElements = {};
+
+  // if (runningFilterObject.filterElement.filterType === 'logical'
+  //   || runningFilterObject.filterElement.filterType === 'identifiers'
+  //   || runningFilterObject.filterElement.filterType === 'translateIds'
+  //   || runningFilterObject.filterElement.filterType === 'traversal'
+  // ) {}
+
+  if (runningFilterObject.filterElement.filterType === 'operation') {
+    _izContext.logger.debug('-------- operation ----------');
+
+    Object.assign(filterElements, runningFilterObject.filterElement.filterElements);
+    delete runningFilterObject.filterElement.filterElements;
+    filterElements[runningFilterMainId] = runningFilterObject;
+
+  } else if (runningFilterObject.filterElement.filterType === 'childComplexFilter') {
+    _izContext.logger.debug('-------- childComplexFilter ----------');
+
+    Object.assign(filterElements, runningFilterObject.filterElement.filterElements);
+    delete runningFilterObject.filterElement.filterElements;
+    filterElements[runningFilterMainId] = runningFilterObject;
+
+  } else {
+    _izContext.logger.debug(` -------- ${runningFilterObject.filterElement.filterType} ----------`);
+    //'logical'| 'identifiers'|'translateIds'|'traversal'
+    filterElements[runningFilterMainId] = runningFilterObject;
+  };
+
+  if (currentFilterObject !== null) {
+    if (currentFilterObject.filterElement.filterType === 'operation') {
+      _izContext.logger.debug('-------- operation ----------');
+
+      Object.assign(filterElements, currentFilterObject.filterElement.filterElements);
+      delete currentFilterObject.filterElement.filterElements;
+      filterElements[currentFilterMainId] = currentFilterObject;
+
+    } else if (currentFilterObject.filterElement.filterType === 'childComplexFilter') {
+      _izContext.logger.debug('-------- childComplexFilter ----------');
+
+      Object.assign(filterElements, currentFilterObject.filterElement.filterElements);
+      delete currentFilterObject.filterElement.filterElements;
+      filterElements[currentFilterMainId] = currentFilterObject;
+
+    } else {
+      _izContext.logger.debug(` -------- ${currentFilterObject.filterElement.filterType} ----------`);
+      //'logical'| 'identifiers'|'translateIds'|'traversal'
+      filterElements[currentFilterMainId] = currentFilterObject;
+    };
+  };
+
+  return filterElements;
+
+};
+
+
+export default {
+  //* create filter
+  createFiltersRequest,
+  validateCombinationStructure,
+  // validateOperation,
+  // filterLogicalElements,
+  // splitFilterElements,
+
+  combineLogicalStructure,
+  // combineOperation,
+
+}