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

package/src/DataFieldsSharedLib.js

@@ -0,0 +1,1037 @@
+/*
+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 { validatorSchema } from "@izara_project/izara-middleware";
+// let { pattern } = validatorSchema.stringNotEmpty();
+// export default [...]
+
+import { objectHash as hash } from '@izara_project/izara-shared-core';  //const hash = require('@izara_project/izara-shared-core').objectHash;
+import { isEmpty as isEmpty } from 'lodash';
+import filtersSharedLib from './FiltersSharedLib'; //const filtersSharedLib = require('./FiltersSharedLib');
+
+async function createRequiredData(
+  _izContext,
+  objType,
+  requiredDataFields,
+  complexFilterCombinations,
+  perParentCombinations,
+  requiredDataLinkStepObjects,
+  requiredDataLinkSteps,
+  values,
+) {
+  _izContext.logger.debug('createRequiredData: ', {
+    objType,
+    requiredDataFields,
+    complexFilterCombinations,
+    perParentCombinations,
+    requiredDataLinkStepObjects,
+    values,
+  });
+
+  let errorsObject = {};
+  let errorsFound = [];
+
+  let requiredDataHash = null;
+  let requiredDataObject = {};
+  let linkPathObjects = {};
+  let linkPathSteps = {};
+  let setPerParentCombinations = {};
+  let setComplexFilterCombinations = {};
+  let setFilterElementsLink = {}
+
+  _izContext.logger.debug('--------------- start requiredData  fields ---------------')
+  for (const requiredDataFieldId of requiredDataFields) {
+    _izContext.logger.debug('extract requiredDataFields: ', requiredDataFieldId);
+
+    let requiredDataLinkObject = requiredDataLinkStepObjects[requiredDataFieldId];
+    _izContext.logger.debug('requiredDataLinkObject: ', requiredDataLinkObject);
+
+    let linkSteps = requiredDataLinkObject.linkSteps;
+    _izContext.logger.debug('initial data: ', { linkSteps });
+
+    let [fieldName, returnValue, linkPathErrorObject, linkPathErrorsFound] = await createLinkPath(
+      _izContext,
+      linkSteps,
+      requiredDataLinkStepObjects,
+      requiredDataLinkSteps,
+      perParentCombinations,
+      complexFilterCombinations,
+      values,
+      errorsObject,
+      errorsFound
+    );
+    _izContext.logger.debug('return createLinkPath: ', {
+      fieldName,
+      returnValue,
+      linkPathErrorObject,
+      linkPathErrorsFound
+    });
+
+    if (linkPathErrorsFound.length > 0) {
+      Object.assign(errorsObject, linkPathErrorObject);
+      errorsFound = errorsFound.concat(linkPathErrorsFound);
+    };
+
+    if (fieldName === null) {
+      return {
+        requiredDataHash: null,
+        requiredDataObject: requiredDataObject,
+        linkPathObjects: linkPathObjects,
+        linkPathSteps: linkPathSteps,
+        complexFilterCombinations: setComplexFilterCombinations,
+        perParentCombinations: setPerParentCombinations,
+        filterElements: setFilterElementsLink,
+        status: 'invalid',
+        errorsObject: errorsObject,
+        errorsFound: errorsFound
+      };
+    };
+
+    if (returnValue.hasOwnProperty('linkSteps')) {
+      if (returnValue.hasOwnProperty('linkStepObjects')) {
+        Object.assign(linkPathSteps, returnValue.linkStepObjects)
+      }
+
+      if (returnValue.hasOwnProperty('sortFieldLinkPathObjects') && !isEmpty(returnValue.sortFieldLinkPathObjects)) {
+        //* maybe will combine in all that top
+        Object.assign(linkPathSteps, returnValue.sortFieldLinkPathObjects.linkStepObjects);
+        Object.assign(linkPathObjects, returnValue.sortFieldLinkPathObjects.linkPathObjects);
+      }
+
+      let pathObject = {
+        initialObjType: objType,
+        linkSteps: returnValue.linkSteps
+      };
+      _izContext.logger.debug('pathObject: ', pathObject);
+
+      let pathId = hash(pathObject);
+      _izContext.logger.debug('pathId: ', pathId);
+
+      let setObject = {
+        fieldName: fieldName,
+        linkPathObjectId: pathId
+      };
+
+      Object.assign(linkPathObjects, { [pathId]: pathObject });
+
+      let requiredFieldNameObject = {
+        fieldName: fieldName,
+        linkPathObjects: linkPathObjects,
+        linkPathSteps: linkPathSteps
+      };
+
+      if (returnValue.hasOwnProperty('complexFilterCombinations')) {
+        requiredFieldNameObject.complexFilterCombinations = returnValue.complexFilterCombinations;
+        Object.assign(setComplexFilterCombinations, returnValue.complexFilterCombinations);
+
+        setObject.complexFilterCombinationIds = []
+        for (const filterMainId of Object.keys(returnValue.complexFilterCombinations)) {
+          if (!setObject.complexFilterCombinationIds.includes(filterMainId)) {
+            setObject.complexFilterCombinationIds.push(filterMainId);
+          }
+        };
+      };
+
+      if (returnValue.hasOwnProperty('perParentCombinations')) {
+        requiredFieldNameObject.perParentCombinations = returnValue.perParentCombinations;
+        Object.assign(setPerParentCombinations, returnValue.perParentCombinations);
+      };
+
+      if (returnValue.hasOwnProperty('filterElements')) {
+        requiredFieldNameObject.filterElements = returnValue.filterElements;
+        Object.assign(setFilterElementsLink, returnValue.filterElements);
+      };
+      _izContext.logger.debug('requiredFieldNameObject: ', requiredFieldNameObject);
+
+      let requiredDataFieldNameId = hash(requiredFieldNameObject);
+      _izContext.logger.debug('requiredDataFieldNameId: ', requiredDataFieldNameId);
+
+      if (isEmpty(requiredDataObject)) {
+        requiredDataObject = {
+          [requiredDataFieldNameId]: setObject
+        };
+
+      } else {
+        requiredDataObject[requiredDataFieldNameId] = setObject;
+      };
+
+    } else {
+      _izContext.logger.debug("------- requiredData has only fieldName ---------");
+
+      let requiredFieldNameObject = {
+        fieldName: fieldName
+      };
+      _izContext.logger.debug("requiredFieldNameObject: ", requiredFieldNameObject);
+
+      let requiredDataFieldNameId = hash(requiredFieldNameObject);
+      _izContext.logger.debug("requiredDataFieldNameId: ", requiredDataFieldNameId);
+
+      if (isEmpty(requiredDataObject)) {
+
+        requiredDataObject = {
+          [requiredDataFieldNameId]: requiredFieldNameObject
+        };
+
+      } else {
+        requiredDataObject[requiredDataFieldNameId] = requiredFieldNameObject;
+      };
+    }
+    _izContext.logger.debug("before return linkPath: ", { requiredDataObject, linkPathObjects, linkPathSteps });
+  }
+
+  let requiredObject = {};
+
+  if (!isEmpty(requiredDataObject)) {
+    requiredObject.requiredDataObjects = requiredDataObject;
+    if (!isEmpty(linkPathObjects)) {
+      requiredObject.linkPathObjects = linkPathObjects;
+    };
+    if (!isEmpty(linkPathSteps)) {
+      requiredObject.linkPathSteps = linkPathSteps
+    };
+  };
+
+  if (!isEmpty(setComplexFilterCombinations)) {
+    requiredObject.complexFilterCombinations = setComplexFilterCombinations;
+  };
+
+  if (!isEmpty(setPerParentCombinations)) {
+    requiredObject.perParentCombinations = setPerParentCombinations;
+  };
+
+  if (!isEmpty(setFilterElementsLink)) {
+    requiredObject.filterElements = setFilterElementsLink;
+  };
+  _izContext.logger.debug('requiredObject: ', requiredObject);
+
+  if (!isEmpty(requiredObject)) {
+    requiredDataHash = hash(requiredObject);
+    _izContext.logger.debug('requiredDataHash: ', requiredDataHash);
+  }
+
+  let status = 'valid"';
+  if (errorsFound.length > 0) {
+    status = 'invalid';
+  };
+
+  _izContext.logger.debug('return : ', {
+    requiredDataHash: requiredDataHash,
+    requiredDataObjects: requiredDataObject,
+    linkPathObjects: linkPathObjects,
+    linkPathSteps: linkPathSteps,
+    complexFilterCombinations: setComplexFilterCombinations,
+    perParentCombinations: setPerParentCombinations,
+    filterElements: setFilterElementsLink,
+    status: status,
+    errorsObject: errorsObject,
+    errorsFound: errorsFound
+  });
+
+  return {
+    requiredDataHash: requiredDataHash,
+    requiredDataObjects: requiredDataObject,
+    linkPathObjects: linkPathObjects,
+    linkPathSteps: linkPathSteps,
+    complexFilterCombinations: setComplexFilterCombinations,
+    perParentCombinations: setPerParentCombinations,
+    filterElements: setFilterElementsLink,
+    status: status,
+    errorsObject: errorsObject,
+    errorsFound: errorsFound
+  };
+
+}
+
+
+async function createLinkPath(
+  _izContext,
+  linkSteps,
+  requiredDataLinkStepObjects,
+  requiredDataLinkSteps,
+  perParentCombinations,
+  complexFilterCombinations,
+  values,
+  errorsObject,
+  errorsFound,
+  index = 0,
+  previousLinkId = null,
+  previousLink = null
+) {
+  _izContext.logger.debug('create LinkPath: ', {
+    linkSteps,
+    requiredDataLinkStepObjects,
+    requiredDataLinkSteps,
+    perParentCombinations,
+    complexFilterCombinations,
+    values,
+    errorsObject,
+    errorsFound,
+    index,
+    previousLinkId,
+    previousLink
+  });
+  let fieldName = null;
+  let returnValue = {}; //* must return only linkPath params
+  // let linkPathSteps = [];
+  // let linkPathStepObjects = {};
+  // let filterElementsLink = {};
+  // let perParentCombination = {};
+
+  // let errorsObject = {}
+  // let errorsFound = [];
+
+  // let childLinkStep = null
+  // let childLinkErrorObject = {};
+  // let childLinkErrors = []
+
+  let linkStepId = linkSteps[index];
+  _izContext.logger.debug('linkStepId: ', linkStepId);
+
+  let linkStep = requiredDataLinkSteps[linkStepId];
+  _izContext.logger.debug('linkStep: ', linkStep);
+
+  if (index + 1 === linkSteps.length) {
+    // last link that has only fieldName
+    _izContext.logger.debug('---------- is final link ----------', { index, linkStep });
+
+    return [linkStep.fieldName, returnValue, errorsObject, errorsFound]
+
+  } else {
+    // has nextLink
+    _izContext.logger.debug('---------- is next link ----------', { index, linkStep });
+
+    let conditionsPromise = checkConditionsLink(
+      // let [conditions, conditionErrObject, conditionErrFound] = await this.checkConditionsLink(
+      _izContext,
+      linkStep.pathLinkType.objType,
+      linkStep,
+      perParentCombinations,
+      complexFilterCombinations,
+      values,
+      linkSteps,
+      requiredDataLinkStepObjects,
+      requiredDataLinkSteps,
+      errorsObject,
+      errorsFound
+    );
+
+    [fieldName, returnValue, errorsObject, errorsFound] = await createLinkPath(
+      _izContext,
+      linkSteps,
+      requiredDataLinkStepObjects,
+      requiredDataLinkSteps,
+      perParentCombinations,
+      complexFilterCombinations,
+      values,
+      errorsObject,
+      errorsFound,
+      index + 1
+    )
+    _izContext.logger.debug('createLinkPath in link', {
+      fieldName,
+      returnValue,
+      errorsObject,
+      errorsFound,
+      index
+    });
+
+    _izContext.logger.debug('linkStep', linkStep);
+
+    let [conditions, conditionErrObject, conditionErrFound] = await conditionsPromise;
+
+    if (conditionErrFound.length > 0) {
+      Object.assign(errorsObject, conditionErrObject);
+      errorsFound = errorsFound.concat(conditionErrFound);
+    };
+
+    if (!isEmpty(returnValue)) {
+      _izContext.logger.debug('----------------- has returnValue ---------------------', { index, fieldName, returnValue, conditions })
+
+      let linkStepObject = {
+        pathLinkType: linkStep.pathLinkType
+      }
+
+      if (conditions.hasOwnProperty('filterElements')) {
+        for (const filterElementId of Object.keys(conditions.filterElements)) {
+          linkStepObject.filterElementId = filterElementId;
+
+          if (returnValue.hasOwnProperty('filterElements')) {
+            Object.assign(returnValue['filterElements'], conditions.filterElements);
+          } else {
+            returnValue.filterElements = conditions.filterElements;
+          }
+        }
+      }
+
+      if (conditions.hasOwnProperty('requestProperties')) {
+        linkStepObject.requestProperties = conditions.requestProperties;
+      };
+
+      if (conditions.hasOwnProperty('aggregate')) {
+        if (conditions.hasOwnProperty('sortFields')) {
+          linkStepObject.aggregate = conditions.aggregate;
+          linkStepObject.sortFields = conditions.sortFields;
+        };
+      };
+
+      if (conditions.hasOwnProperty('linkPathObjects')) {
+        if (conditions.hasOwnProperty('linkStepObjects')) {
+
+          linkStepObject.requiredDataFields = conditions.requiredDataFields;
+
+          if (returnValue.hasOwnProperty("sortFieldLinkPathObjects")) {
+            Object.assign(returnValue.sortFieldLinkPathObjects["linkPathObjects"], conditions.linkPathObjects);
+            Object.assign(returnValue.sortFieldLinkPathObjects["linkStepObjects"], conditions.linkStepObjects);
+          } else {
+            returnValue.sortFieldLinkPathObjects = {
+              linkPathObjects: conditions.linkPathObjects,
+              linkStepObjects: conditions.linkStepObjects
+            }
+          }
+
+          if (conditions.hasOwnProperty("setFilterCombinations") && !isEmpty(conditions.setFilterCombinations)) {
+
+            if (conditions.setFilterCombinations.hasOwnProperty('filterElements')) {
+              Object.assign(returnValue["filterElements"], conditions.setFilterCombinations.filterElements.filterElements);
+            }
+
+            if (conditions.setFilterCombinations.hasOwnProperty('perParentCombinations')) {
+              Object.assign(returnValue["perParentCombinations"], conditions.setFilterCombinations.perParentCombinations);
+            };
+
+            if (conditions.setFilterCombinations.hasOwnProperty('complexFilterCombinations')) {
+              Object.assign(returnValue['complexFilterCombinations'], conditions.setFilterCombinations.complexFilterCombinations);
+            };
+          }
+
+          _izContext.logger.debug('returnValue', returnValue);
+
+        } else {
+          //* error
+          errorsObject[linkStepId] = `has linkPathObject but no data`;
+          errorsFound.push(`${linkStepId} no data in linkPathObject`)
+        }
+      }
+
+      if (conditions.hasOwnProperty('combine')) {
+        linkStepObject.combine = conditions.combine;
+      };
+
+      if (conditions.hasOwnProperty('perParentCombinationIds')) {
+        if (conditions.hasOwnProperty('perParentCombinationObjects')) {
+          linkStepObject.perParentCombinationIds = conditions.perParentCombinationIds;
+          if (returnValue.hasOwnProperty("perParentCombinations")) {
+            Object.assign(returnValue["perParentCombinations"], conditions.perParentCombinationObjects);
+          } else {
+            returnValue.perParentCombinations = conditions.perParentCombinationObjects;
+          }
+        };
+      };
+
+      if (conditions.hasOwnProperty('applyCombinations')) {
+        if (conditions.hasOwnProperty('complexFilterCombinationObjects')) {
+          linkStepObject.applyCombinations = conditions.applyCombinations;
+          if (returnValue.hasOwnProperty("complexFilterCombinations")) {
+            Object.assign(returnValue["complexFilterCombinations"], conditions.complexFilterCombinationObjects);
+          } else {
+            returnValue.complexFilterCombinations = conditions.complexFilterCombinationObjects;
+          }
+        };
+      };
+
+      _izContext.logger.debug('linkStepObject', linkStepObject);
+      let linkStepId = hash(linkStepObject);
+      _izContext.logger.debug('linkStepId', linkStepId);
+
+      returnValue['linkSteps'].unshift(linkStepId);
+      returnValue['linkStepObjects'] = Object.assign({ [linkStepId]: linkStepObject }, returnValue['linkStepObjects']);
+      _izContext.logger.debug('returnValue', returnValue);
+
+    } else {
+      _izContext.logger.debug('----------------- no returnValue ---------------------', { index, fieldName, conditions })
+      //returnValue: {  linkSteps, linkStepsObjects, perParent, combinations, sortFieldLinkStepObjects  }
+      //sortFieldLinkStepObjects  from in sortField in link
+
+      let linkStepObject = {
+        pathLinkType: linkStep.pathLinkType
+      };
+
+      if (conditions.hasOwnProperty('filterElements')) {
+        for (const filterElementId of Object.keys(conditions.filterElements)) {
+          linkStepObject.filterElementId = filterElementId;
+          returnValue.filterElements = conditions.filterElements;
+        };
+      };
+
+      if (conditions.hasOwnProperty('requestProperties')) {
+        linkStepObject.requestProperties = conditions.requestProperties;
+      };
+
+      if (conditions.hasOwnProperty('aggregate')) {
+        if (conditions.hasOwnProperty('sortFields')) {
+          linkStepObject.aggregate = conditions.aggregate;
+          linkStepObject.sortFields = conditions.sortFields;
+        };
+      };
+
+      if (conditions.hasOwnProperty('linkPathObjects')) {
+        if (conditions.hasOwnProperty('linkStepObjects')) {
+
+          linkStepObject.requiredDataFields = conditions.requiredDataFields;
+
+          if (returnValue.hasOwnProperty("sortFieldLinkPathObjects")) {
+            Object.assign(returnValue.sortFieldLinkPathObjects["linkPathObjects"], conditions.linkPathObjects);
+            Object.assign(returnValue.sortFieldLinkPathObjects["linkStepObjects"], conditions.linkStepObjects);
+          } else {
+            returnValue.sortFieldLinkPathObjects = {
+              linkPathObjects: conditions.linkPathObjects,
+              linkStepObjects: conditions.linkStepObjects
+            }
+          }
+
+          if (returnValue.hasOwnProperty("sortFieldLinkPathObjects")) {
+            Object.assign(returnValue.sortFieldLinkPathObjects["linkPathObjects"], conditions.linkPathObjects);
+            Object.assign(returnValue.sortFieldLinkPathObjects["linkStepObjects"], conditions.linkStepObjects);
+          } else {
+            returnValue.sortFieldLinkPathObjects = {
+              linkPathObjects: conditions.linkPathObjects,
+              linkStepObjects: conditions.linkStepObjects
+            }
+          }
+
+          if (conditions.hasOwnProperty("setFilterCombinations") && !isEmpty(conditions.setFilterCombinations)) {
+
+            if (conditions.setFilterCombinations.hasOwnProperty('filterElements')) {
+              Object.assign(returnValue["filterElements"], conditions.setFilterCombinations.filterElements);
+            }
+
+            if (conditions.setFilterCombinations.hasOwnProperty('perParentCombinations')) {
+              Object.assign(returnValue["perParentCombinations"], conditions.perParentCombinations);
+            };
+
+            if (conditions.setFilterCombinations.hasOwnProperty('complexFilterCombinations')) {
+              Object.assign(returnValue['complexFilterCombinations'], conditions.complexFilterCombinations);
+            };
+          }
+
+        } else {
+          //* error
+          errorsObject[linkStepId] = `has linkPathObject but no data`;
+          errorsFound.push(`${linkStepId} no data in linkPathObject`)
+        }
+      }
+
+      if (conditions.hasOwnProperty('combine')) {
+        linkStepObject.combine = conditions.combine;
+      };
+
+      if (conditions.hasOwnProperty('perParentCombinationIds')) {
+        if (conditions.hasOwnProperty('perParentCombinationObjects')) {
+          linkStepObject.perParentCombinationIds = conditions.perParentCombinationIds;
+          returnValue.perParentCombinations = conditions.perParentCombinationObjects;
+        };
+      };
+
+      if (conditions.hasOwnProperty('applyCombinations')) {
+        if (conditions.hasOwnProperty('complexFilterCombinationObjects')) {
+          linkStepObject.applyCombinations = conditions.applyCombinations;
+          returnValue.complexFilterCombinations = conditions.complexFilterCombinationObjects;
+        };
+      };
+
+      _izContext.logger.debug('linkStepObject', linkStepObject);
+      let linkStepId = hash(linkStepObject);
+      _izContext.logger.debug('linkStepId', linkStepId);
+
+      returnValue.linkSteps = [linkStepId];
+      returnValue.linkStepObjects = {
+        [linkStepId]: linkStepObject
+      };
+      _izContext.logger.debug('returnValue', returnValue);
+    }
+  }
+  return [fieldName, returnValue, errorsObject, errorsFound]
+}
+
+
+async function checkConditionsLink(
+  _izContext,
+  objType,
+  linkStepObject,
+  perParentCombinations,
+  complexFilterCombinations,
+  values,
+  linkSteps,
+  requiredDataLinkStepObjects,
+  requiredDataLinkSteps,
+  errorsObject,
+  errorsFound
+) {
+  _izContext.logger.debug('checkConditionsLink:', {
+    objType,
+    linkStepObject,
+    perParentCombinations,
+    complexFilterCombinations,
+    values,
+    linkSteps,
+    requiredDataLinkStepObjects,
+    requiredDataLinkSteps,
+    errorsObject,
+    errorsFound
+  });
+
+
+  let conditionLinkObject = {}
+
+  if (linkStepObject.hasOwnProperty('filterElements')) {
+    _izContext.logger.debug('------------ has filterElements ------------');
+
+    let [complexFilterRequest, status, filterErrorsObject, filterErrorsFound] = filtersSharedLib.createComplexFilter(
+      _izContext,
+      linkStepObject.filterElements.objType,
+      linkStepObject.filterElements.initialLogicalElementId,
+      linkStepObject.filterElements.logicalElements,
+      values
+    );
+    _izContext.logger.debug('return complexFilter for filterElements: ', {
+      complexFilterRequest,
+      status,
+      filterErrorsObject,
+      filterErrorsFound
+    });
+
+    if (filterErrorsFound.length > 0) {
+      Object.assign(errorsObject, filterErrorsObject)
+      errorsFound = errorsFound.concat(filterErrorsFound)
+    };
+    conditionLinkObject.filterElements = complexFilterRequest.filterElements;
+    _izContext.logger.debug('conditionLinkObject in condition link: ', conditionLinkObject);
+  }
+
+  if (linkStepObject.hasOwnProperty('aggregate')) {
+    _izContext.logger.debug('------------ has aggregate ------------');
+    if (!linkStepObject.hasOwnProperty('sortFields')) {
+      errorsFound.push('if has aggregate need to has sortFields, too');
+    };
+    conditionLinkObject.aggregate = linkStepObject.aggregate;
+    conditionLinkObject.sortFields = [];
+
+    if (linkStepObject.hasOwnProperty('combine')) {
+      conditionLinkObject.combine = linkStepObject.combine;
+    }
+
+    let linkPathObjects = {};
+    let sortFieldObjects = [];
+
+    let requiredDataObjects = {}
+    let requiredDataFields = [];
+    let requiredDataStepObjects = {};
+
+    let setComplexFilterCombinations = {};
+    let setPerParentCombinations = {};
+    let setFilterElements = {};
+
+    _izContext.logger.debug('linkStepObject.sortFields', linkStepObject.sortFields);
+
+    for (const sortField of linkStepObject.sortFields) {
+      _izContext.logger.debug('sortField: ', sortField);
+      _izContext.logger.debug('requiredDataLinkSteps: ', requiredDataLinkSteps);
+      let requiredDataLinkStepSortField = requiredDataLinkStepObjects[sortField.requiredDataLinkStepObjectId];
+      _izContext.logger.debug('requiredDataLinkStepSortField: ', requiredDataLinkStepSortField);
+
+      _izContext.logger.debug(' requiredDataLinkStepSortField.linkSteps: ', requiredDataLinkStepSortField.linkSteps);
+
+      //* make all linkPath in here and send out to combine allLinkPath
+      let [fieldName, childLinkStep, linkErrorsObject, linkErrorsFound] = await createLinkPath(
+        _izContext,
+        requiredDataLinkStepSortField.linkSteps,
+        requiredDataLinkStepObjects,
+        requiredDataLinkSteps,
+        perParentCombinations,
+        complexFilterCombinations,
+        values,
+        errorsObject,
+        errorsFound
+      );
+      _izContext.logger.debug(' cratelinkPath in checkCondition for sortField: ', {
+        fieldName,
+        childLinkStep,
+        linkErrorsObject,
+        linkErrorsFound
+      });
+
+      if (!isEmpty(childLinkStep)) {
+
+        //* create linkPathObject from child
+        let pathObject = {
+          initialObjType: objType,
+          linkSteps: childLinkStep.linkSteps
+        };
+        _izContext.logger.debug('pathObject: ', pathObject);
+
+        let pathId = hash(pathObject);
+        _izContext.logger.debug('pathId: ', pathId);
+
+        _izContext.logger.debug('linkPathObjects xxxxxx: ', linkPathObjects);
+
+        Object.assign(linkPathObjects, { [pathId]: pathObject });
+
+        if (childLinkStep.hasOwnProperty('complexFilterCombinations')) {
+          Object.assign(setComplexFilterCombinations, childLinkStep.complexFilterCombinations);
+        };
+
+        if (childLinkStep.hasOwnProperty('perParentCombinations')) {
+          Object.assign(setPerParentCombinations, childLinkStep.perParentCombinations);
+        };
+
+        if (childLinkStep.hasOwnProperty('filterElements')) {
+          Object.assign(setFilterElements, childLinkStep.filterElements);
+        };
+
+        if (isEmpty(requiredDataObjects)) {
+          requiredDataObjects = {
+            [pathId]: pathObject
+          };
+        } else {
+          Object.assign(requiredDataObjects, { [pathId]: pathObject })
+        };
+
+        if (isEmpty(requiredDataStepObjects)) {
+          requiredDataStepObjects = childLinkStep.linkStepObjects;
+        } else {
+          Object.assign(requiredDataStepObjects, childLinkStep.linkStepObjects);
+        };
+
+        requiredDataFields.push({
+          fieldName: fieldName,
+          linkPathObjectId: pathId,
+          // dataType: sortField.dataType
+        });
+
+      } else {
+        requiredDataFields.push({
+          fieldName: fieldName
+        });
+      };
+
+      sortFieldObjects.push({
+        fieldName: fieldName,
+        dataType: sortField.dataType
+      });
+      _izContext.logger.debug('sortFieldObjects: ', sortFieldObjects);
+
+    };
+
+    conditionLinkObject.sortFields = sortFieldObjects;
+
+    if (!isEmpty(requiredDataStepObjects)) {
+      conditionLinkObject.linkPathObjects = requiredDataObjects;
+      conditionLinkObject.linkStepObjects = requiredDataStepObjects;
+      conditionLinkObject.requiredDataFields = requiredDataFields;
+      conditionLinkObject.setFilterCombinations = {};
+
+      if (!isEmpty(setComplexFilterCombinations)) {
+        conditionLinkObject.setFilterCombinations.complexFilterCombinations = setComplexFilterCombinations;
+      };
+      if (!isEmpty(setPerParentCombinations)) {
+        conditionLinkObject.setFilterCombinations.perParentCombinations = setPerParentCombinations;
+      };
+      if (!isEmpty(setFilterElements)) {
+        conditionLinkObject.setFilterCombinations.filterElements = setFilterElements;
+      };
+    };
+
+    _izContext.logger.debug('conditionLinkObject: ', conditionLinkObject);
+
+  } else {
+    if (linkStepObject.hasOwnProperty('combine')) {
+      errorsFound.push('this link set combine must set aggregate and sortFields, too');
+    }
+  };
+
+  if (linkStepObject.hasOwnProperty('requestProperties')) {
+    _izContext.logger.debug('------------ link has requestProperties ------------');
+
+    let perParentCombinationIds = [];
+    let perParentCombinationObjects = {}
+    let complexFilterCombinationObjects = {};
+    let applyCombinations = [];
+
+    for (const [tag, requestPropertyId] of Object.entries(linkStepObject.requestProperties)) {
+      _izContext.logger.debug('extract requestProperties', { tag, requestPropertyId });
+      let requestPropertyObject = values[requestPropertyId];
+      _izContext.logger.debug('extract requestProperties', requestPropertyObject);
+
+
+      if (requestPropertyObject.hasOwnProperty('valueSource')) {
+
+        if (requestPropertyObject.valueSource === 'perParentCombination') {
+          _izContext.logger.debug('------------- perParentCombinations -------------');
+
+          let perParentCombinationObject = perParentCombinations[requestPropertyObject.perParentCombinationId];
+          _izContext.logger.debug('perParentCombinationObject', perParentCombinationObject);
+
+          let [complexFilterRequest, status, perParentErrorsObject, perParentErrorsFound] = filtersSharedLib.createComplexFilter(
+            _izContext,
+            perParentCombinationObject.objType,
+            perParentCombinationObject.initialLogicalElementId,
+            perParentCombinationObject.logicalElements,
+            values,
+          );
+          _izContext.logger.debug('return complexFilter for perParentCombinations: ', {
+            complexFilterRequest,
+            status,
+            perParentErrorsObject,
+            perParentErrorsFound
+          });
+
+          if (perParentErrorsFound.length > 0) {
+            errorsObject[requestPropertyObject.perParentCombinationId] = 'perParentCombination has error in complexFilter';
+            Object.assign(errorsObject, perParentErrorsObject);
+            errorsFound = errorsFound.concat(perParentErrorsFound);
+          };
+
+          perParentCombinationIds.push({
+            tag: tag,
+            filterMainId: complexFilterRequest.filterMainId,
+          });
+          Object.assign(perParentCombinationObjects, {
+            [complexFilterRequest.filterMainId]: {
+              objType: complexFilterRequest.objType,
+              filterMainId: complexFilterRequest.filterMainId,
+              filterElements: complexFilterRequest.filterElements
+            }
+          });
+          _izContext.logger.debug('set perParentCombinations: ', { perParentCombinationIds, perParentCombinationObjects });
+
+        } else if (requestPropertyObject.valueSource === 'complexFilterCombination') {
+          _izContext.logger.debug('------------- complexFilterCombination will set applyCombinations -------------', complexFilterCombinations);
+
+          let complexFilterCombinationId = requestPropertyObject.complexFilterCombinationId;
+          _izContext.logger.debug('complexFilterCombinationId: ', complexFilterCombinationId);
+
+          let complexFilterCombinationObject = complexFilterCombinations[complexFilterCombinationId];
+          _izContext.logger.debug('complexFilterCombinationObject: ', complexFilterCombinationObject);
+
+          let [complexFilterRequest, status, complexFilterErrorsObject, complexFilterErrorsFound] = filtersSharedLib.createComplexFilter(
+            _izContext,
+            complexFilterCombinationObject.objType,
+            complexFilterCombinationObject.initialLogicalElementId,
+            complexFilterCombinationObject.logicalElements,
+            values
+          );
+          _izContext.logger.debug('return complexFilter for complexFilterCombinations: ', {
+            complexFilterRequest,
+            status,
+            complexFilterErrorsObject,
+            complexFilterErrorsFound
+          });
+
+          if (status === 'invalid' || complexFilterErrorsFound.length > 0) {
+            errorsObject[complexFilterCombinationId] = 'complexFilterCombination has error in complexFilter';
+            Object.assign(errorsObject, complexFilterErrorsObject)
+            errorsFound.push('complexFilterCombinations has errorsFound');
+            errorsFound = errorsFound.concat(complexFilterErrorsFound);
+            break;
+          };
+
+          applyCombinations.push({
+            tag: tag,
+            filterMainId: complexFilterRequest.filterMainId,
+            // identifiersFieldName: requestPropertyObject.identifierFieldName
+          });
+          _izContext.logger.debug('applyCombinations: ', applyCombinations);
+
+          Object.assign(complexFilterCombinationObjects, {
+            [complexFilterRequest.filterMainId]: {
+              objType: complexFilterRequest.objType,
+              filterMainId: complexFilterRequest.filterMainId,
+              filterElements: complexFilterRequest.filterElements
+            }
+          });
+          // Object.assign(perParentCombinationObjects, complexFilterRequest.filterElements);
+        };
+
+      } else {
+
+        if (isEmpty(conditionLinkObject)) {
+          conditionLinkObject = {
+            requestProperties: {
+              [tag]: values[requestPropertyId].value
+            }
+          };
+        } else {
+          if (conditionLinkObject.hasOwnProperty('requestProperties')) {
+            conditionLinkObject.requestProperties[tag] = values[requestPropertyId].value;
+          } else {
+            conditionLinkObject['requestProperties'] = {
+              [tag]: values[requestPropertyId].value
+            };
+          };
+        };
+      };
+    };
+
+    _izContext.logger.debug('perParentCombinations: ', {
+      perParentCombinationIds,
+      perParentCombinationObjects,
+      applyCombinations
+    });
+
+    if (!isEmpty(perParentCombinationIds)) {
+      conditionLinkObject.perParentCombinationIds = perParentCombinationIds;
+      conditionLinkObject.perParentCombinationObjects = perParentCombinationObjects;
+    };
+
+    if (!isEmpty(applyCombinations)) {
+      conditionLinkObject.applyCombinations = applyCombinations
+      conditionLinkObject.complexFilterCombinationObjects = complexFilterCombinationObjects;
+    };
+    _izContext.logger.debug('conditionLinkObject: ', conditionLinkObject);
+  }
+  _izContext.logger.debug('conditionLinkObject', conditionLinkObject);
+  return [conditionLinkObject, errorsObject, errorsFound];
+}
+
+
+function checkConditionsLinkStep(
+  _izContext,
+  multipleIdentifiers,
+  linkConfig,
+  combine
+) {
+  // let returnValue = {
+  //   canAggregateCompare: true | false | required, // toMany=true(optional)|(multipleIds=true&combine=true(required)*if toMany=false require must agg/comp*)
+  //   canCombine: true | false, // multipleIds=true*if set must set agg/comp*(or only show when aggregate is added)
+  //   canPerParent: true | false, // current relationship has request properties
+  //   canFilters: true | false
+  // }
+  let canAggregateCompare = false;
+  let canCombine = false;
+  let canPerParent = false;
+  let canFilters = false;
+
+  let toMany = false;
+  if (linkConfig.other.linkType === 'many') {
+    toMany = true;
+  }
+
+  let requestProperties = false;
+  if (linkConfig.hasOwnProperty('requestProperties')) {
+    requestProperties = true;
+  }
+  if (multipleIdentifiers) {
+    if (toMany) {
+      if (combine) {
+        canAggregateCompare = 'required';
+        canFilters = true;
+        canCombine = true;
+        if (requestProperties) {
+          canPerParent = true;
+        }
+      } else {
+        canAggregateCompare = true;
+        canCombine = true;
+        canFilters = true;
+        if (requestProperties) {
+          canPerParent = true;
+        }
+      }
+    } else {
+      canAggregateCompare = true;
+      canCombine = true;
+      if (requestProperties) {
+        canPerParent = true;
+      }
+    }
+  } else {
+    if (toMany) {
+      canAggregateCompare = true;
+      canFilters = true;
+
+      // if (requestProperties) {  //* no case yet.
+      //   canPerParent = true;
+      //   canCombine = true;
+      // }
+    }
+  }
+  return {
+    canAggregateCompare: canAggregateCompare,
+    canCombine: canCombine,
+    canPerParent: canPerParent,
+    canFilters: canFilters,
+    requestProperties: requestProperties //use when linkConfig has request but set no set perParent : false, use requestPropertyType: value
+  }
+}
+
+
+function checkMultipleIdentifers(
+  _izContext,
+  linkConfig = {},
+  aggregate = false,
+  comparison = false,
+  combine = false,
+  applyCombinations = false,
+  multipleIdentifiers = false,
+) {
+  let manyIdentifiers = null;
+  if (!isEmpty(linkConfig)) {
+    let toMany = false;
+    if (linkConfig.other.linkType === 'many') {
+      toMany = true;
+    };
+
+    if (multipleIdentifiers) {
+      if (toMany || !toMany) {
+        if (!combine) {
+          manyIdentifiers = true;
+        } else {
+          if (aggregate) {
+            manyIdentifiers = false;
+          }
+        }
+      }
+    } else {
+      if (toMany) {
+        if (aggregate) {
+          manyIdentifiers = false;
+        } else {
+          manyIdentifiers = true;
+        }
+      } else {
+        if (!aggregate && !combine && !applyCombinations && !comparison) {
+          manyIdentifiers = false;
+        }
+      }
+    }
+  }
+  return manyIdentifiers
+}
+
+export default {
+  //* create reqioredData normalize structure to backend
+  createRequiredData,
+  createLinkPath,
+  checkConditionsLink,
+
+  //* check settings of linkStep
+  checkConditionsLinkStep,
+  checkMultipleIdentifers
+}