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

package/src/SearchSortSharedLib.js

@@ -23,10 +23,9 @@ import lodash from 'lodash';
 const { isEmpty } = lodash;
 import filtersSharedLib from './FiltersSharedLib.js'; //const filtersSharedLib = require('./FiltersSharedLib');
 import dataFieldsSharedLib from './DataFieldsSharedLib.js';
-import searchResultShared from '@izara_project/izara-core-library-search-result';
 
 
-function createSearchRequest(
+async function createSearchRequest(
   objType,
   initialLogicalElementId,
   logicalElements,
@@ -54,6 +53,16 @@ function createSearchRequest(
   let errorsObject = {};
   let errorsFound = [];
 
+  let requiredDataPromise = dataFieldsSharedLib.createRequiredData(
+    objType,
+    requiredDataFields,
+    complexFilterCombinations,
+    perParentCombinations,
+    requiredDataLinkStepObjects,
+    requiredDataLinkSteps,
+    values,
+  );
+
   //* create complexFilter normalize to send backend
   let [
     complexFilterRequest,
@@ -79,15 +88,16 @@ function createSearchRequest(
     Object.assign(errorsObject, complexErrorsObject);
   }
 
-  let requiredData = dataFieldsSharedLib.createRequiredData(
-    objType,
-    requiredDataFields,
-    complexFilterCombinations,
-    perParentCombinations,
-    requiredDataLinkStepObjects,
-    requiredDataLinkSteps,
-    values,
-  );
+  // let requiredData = dataFieldsSharedLib.createRequiredData(
+  //   objType,
+  //   requiredDataFields,
+  //   complexFilterCombinations,
+  //   perParentCombinations,
+  //   requiredDataLinkStepObjects,
+  //   requiredDataLinkSteps,
+  //   values,
+  // );
+  let requiredData = await requiredDataPromise;
   console.log('return create requiredData: ', requiredData);
 
   if (requiredData.status === 'invalid' || requiredData.errorsFound.length > 0) {
@@ -142,7 +152,7 @@ function createSearchRequest(
 
 }
 
-function createSortRequest(
+async function createSortRequest(
   objType,
   initialLogicalElementId,
   logicalElements,
@@ -198,7 +208,7 @@ function createSortRequest(
   }
   console.log("sortFieldMain: ", sortFieldMain)
 
-  let [searchResultRequest, status, errorsObject, errorsFound] = createSearchRequest(
+  let [searchResultRequest, status, errorsObject, errorsFound] = await createSearchRequest(
     objType,
     initialLogicalElementId,
     logicalElements,

package/src/ChangeLevelSharedLib.js

@@ -1,610 +0,0 @@
-/*
-Copyright (C) 2025 Sven Mason <http://izara.io>
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU Affero General Public License as
-published by the Free Software Foundation, either version 3 of the
-License, or (at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU Affero General Public License for more details.
-
-You should have received a copy of the GNU Affero General Public License
-along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-'use strict';
-
-
-import { objectHash as hash } from '@izara_project/izara-shared-core';  //const hash = require('@izara_project/izara-shared-core').objectHash;
-import lodash from 'lodash';
-const { isEmpty } = lodash;
-import { v4 as uuidV4 } from 'uuid'; //const { v4: uuidv4 } = require('uuid');
-import { getObjectSchema } from '@izara_project/izara-core-library-service-schemas';
-const MAX_ITER = 4;
-
-function checkObjType(
-  fromObjType,
-  toObjType
-) {
-
-  let from = {
-    serviceTag: fromObjType.serviceTag,
-    objectType: fromObjType.objectType
-  };
-
-  let to = {
-    serviceTag: toObjType.serviceTag,
-    objectType: toObjType.objectType
-  };
-
-  if (hash(to) === hash(from)) {
-    return true;
-  };
-
-  return false;
-
-};
-
-// validate to changed searchType and filterType
-/**
- * recieved request thougth sortedResult??? case specail filter
- * @param {string} requiredSearchType
- * @param {string[]} filterArrays
- *
- * return [filters]
- */
-async function changeObjTypePath(
-  requiredObjType,
-  filtersStructure,
-  path = null,
-) {
-  try {
-    console.log('----- function validateSearchTypeFilterType -----', {
-      requiredObjType,
-      filtersStructure,
-      path
-    });
-
-    let filterLogicalStructure = {};
-
-    let errorsObject = {};
-    let errorsFound = [];
-
-    if (path !== null) {
-      console.log('-------------- continue process path --------------');
-
-      let logicalElements = {};
-      let previousLogicalElementId = null;
-      let previousLogicalElement = null;
-      let currentLogicalElementId = null;
-      let currentLogicalElement = null;
-
-      if (path.length > 1) {
-
-        for (let i = 0; i < path.length; i++) {
-
-          let pathObject = path[i];
-          let logicalStructureElements = filtersStructure.logicalElements;
-          console.log('logicalStructureElements', logicalStructureElements);
-
-          let initialLogicalElementId = filtersStructure.initialLogicalElementId;
-          console.log('initialLogicalElementId', initialLogicalElementId);
-
-          if (i + 1 === path.length) {
-            console.log(`------------------- final path: ${i} ---------------------`);
-
-            if (previousLogicalElementId !== null) {
-
-              if (checkObjType(pathObject.objType, logicalElements[previousLogicalElementId].objType) !== true) {
-                errorsFound.push('objType is not equals in structure');
-                console.log('before return: ', {
-                  filterLogicalStructure: {},
-                  errorsObject,
-                  errorsFound
-                });
-                return [{}, errorsObject, errorsFound];
-              };
-
-              filterLogicalStructure = {
-                objType: pathObject.objType,
-                initialLogicalElementId: previousLogicalElementId,
-                logicalElements: logicalElements
-              };
-              console.log('filterLogicalStructure: ', filterLogicalStructure);
-
-            } else {
-              if (checkObjType(requiredObjType, filtersStructure.objType) === true) {
-                filterLogicalStructure = filtersStructure;
-              } else {
-                errorsFound.push('objType is not equals in structure');
-                console.log('before return: ', {
-                  filterLogicalStructure: {},
-                  errorsObject,
-                  errorsFound
-                });
-                return [{}, errorsObject, errorsFound];
-              };
-            };
-
-          } else {
-            console.log(`------------------- between path: ${i} ---------------------`);
-
-            let logicalElementsStructure = logicalStructureElements[initialLogicalElementId];
-            console.log('logicalElementsStructure', logicalElementsStructure);
-
-            if (previousLogicalElement !== null) {
-
-              currentLogicalElementId = uuidV4();
-              console.log('currentLogicalElementId: ', currentLogicalElementId);
-
-              currentLogicalElement = {
-                logicalElementType: 'childComplexFilter',
-                previousLogicalElementId: null,
-                nextLogicalElementId: null,
-                childLogicalElementId: filtersStructure.initialLogicalElementId,
-
-                objType: pathObject.pathLinkType.objType,
-                pathLinkType: {
-                  objType: pathObject.objType,
-                  relType: pathObject.pathLinkType.relType,
-                  direction: pathObject.pathLinkType.direction
-                }
-              };
-              console.log('currentLogicalElement', currentLogicalElement);
-
-              let logicalStructure;
-              [previousLogicalElementId, previousLogicalElement, logicalStructure, errorsFound] = createChildComplexFilterStructure(
-                logicalElements,
-                previousLogicalElementId,
-                previousLogicalElement,
-                currentLogicalElementId,
-                currentLogicalElement,
-                filtersStructure
-              );
-              console.log('return create child ', {
-                previousLogicalElementId,
-                previousLogicalElement,
-                logicalStructure,
-                errorsFound
-              });
-
-              logicalElements = logicalStructure;
-
-            } else {
-
-              if (logicalElementsStructure.logicalElementType === 'childComplexFilter') {
-
-                let childLogicalElementId = logicalElementsStructure.childLogicalElementId;
-                console.log('childLogicalElementId', childLogicalElementId);
-
-                if (childLogicalElementId !== null) {
-                  console.log('-------- has child filter structure --------');
-
-                  let childLogicalElement = logicalStructureElements[childLogicalElementId];
-                  console.log('childLogicalElement', childLogicalElement);
-
-                  let pathCheck = false;
-
-                  for (const pathObj of path) {
-                    if (checkObjType(childLogicalElement.objType, pathObj.objType) === true) {
-                      pathCheck = true;
-                    };
-                  };
-
-                  if (pathCheck) {
-
-                    if (logicalElementsStructure.nextLogicalElementId === null) {
-
-                      //* delete level of objType
-                      let checkChild = false;
-                      for (const objType of PATHCONSTANCES.objTypes) {
-                        if (checkObjType(objType, childLogicalElement.objType) === true) {
-                          if (!childLogicalElement.hasOwnProperty('childLogicalElementId')) {
-
-                            // let childSchema = await getObjectSchema.getObjSchemaS3(
-                            let childSchema = await getObjectSchema.getObjSchemaS3WithoutHierarchy(
-                              childLogicalElement.objType
-                            );
-                            console.log('childSchema: ', childSchema);
-
-                            if (childSchema.hasOwnProperty('extendObjType')) {
-                              if (checkObjType(requiredObjType, childSchema.extendObjType) === true) {
-                                checkChild = false;
-                                break;
-                              };
-                            };
-                          };
-                          checkChild = true;
-                          break;
-                        };
-                      };
-
-                      if (checkChild) {
-
-                        delete filtersStructure.logicalElements[initialLogicalElementId];
-                        console.log('filtersStructure: ', filtersStructure);
-
-                        filtersStructure.objType = childLogicalElement.objType;
-                        filtersStructure.initialLogicalElementId = childLogicalElementId;
-                        filtersStructure.logicalElements[childLogicalElementId].previousLogicalElementId = null;
-                        console.log('after filtersStructure: ', filtersStructure);
-
-                        logicalElements = filtersStructure.logicalElements;
-
-                        continue;
-
-                      };
-                    };
-                  };
-
-                  currentLogicalElementId = uuidV4();
-                  console.log('currentLogicalElementId: ', currentLogicalElementId)
-
-                  currentLogicalElement = {
-                    logicalElementType: 'childComplexFilter',
-                    previousLogicalElementId: null,
-                    nextLogicalElementId: null,
-                    childLogicalElementId: filtersStructure.initialLogicalElementId,
-
-                    objType: pathObject.pathLinkType.objType,
-                    pathLinkType: {
-                      objType: pathObject.objType,
-                      relType: pathObject.pathLinkType.relType,
-                      direction: pathObject.pathLinkType.direction
-                    }
-                  };
-                  console.log('currentLogicalElement', currentLogicalElement);
-
-                  let logicalStructure = {};
-                  [previousLogicalElementId, previousLogicalElement, logicalStructure, errorsFound] = createChildComplexFilterStructure(
-                    _izContext,
-                    logicalElements,
-                    previousLogicalElementId,
-                    previousLogicalElement,
-                    currentLogicalElementId,
-                    currentLogicalElement,
-                    filtersStructure
-                  )
-                  console.log('return create child', {
-                    previousLogicalElementId,
-                    previousLogicalElement,
-                    logicalStructure,
-                    errorsFound
-                  });
-
-                  logicalElements = logicalStructure;
-                  console.log('logicalElements: ', logicalElements);
-
-                  // if (logicalElementsStructure.nextLogicalElementId !== null) {
-                  //  console.log("-------- no child filter structure --------", vvv);
-                  // }
-
-                } else {
-                  console.log('-------- no child filter structure --------', vvv);
-
-                }
-
-              } else {
-
-                currentLogicalElementId = uuidV4();
-                console.log('currentLogicalElementId: ', currentLogicalElementId);
-
-                currentLogicalElement = {
-                  logicalElementType: 'childComplexFilter',
-                  previousLogicalElementId: null,
-                  nextLogicalElementId: null,
-                  childLogicalElementId: filtersStructure.initialLogicalElementId,
-
-                  objType: pathObject.pathLinkType.objType,
-                  pathLinkType: {
-                    objType: pathObject.objType,
-                    relType: pathObject.pathLinkType.relType,
-                    direction: pathObject.pathLinkType.direction
-                  }
-                };
-                console.log('currentLogicalElement', currentLogicalElement);
-
-                let logicalStructure = {};
-                // change function name ==> set logicalElementId
-                [previousLogicalElementId, previousLogicalElement, logicalStructure, errorsFound] = createChildComplexFilterStructure(
-                  _izContext,
-                  logicalElements,
-                  previousLogicalElementId,
-                  previousLogicalElement,
-                  currentLogicalElementId,
-                  currentLogicalElement,
-                  filtersStructure
-                )
-                console.log('return create child', {
-                  previousLogicalElementId,
-                  previousLogicalElement,
-                  logicalStructure,
-                  errorsFound
-                });
-                logicalElements = logicalStructure;
-              };
-            };
-          };
-        };
-      } else {
-        console.log('------------ path euals 1 -----------');
-        console.log('pathObject', path[0]);
-
-        if (checkObjType(requiredObjType, filtersStructure.objType) === true) {
-          filterLogicalStructure = filtersStructure;
-        } else {
-          errorsObject = {
-            [requiredObjType.objectType]: `is not equals objType in filter structure: objType: ${filtersStructure.objType.objectType}`
-          };
-          errorsFound.push(`${requiredObjType.objectType} is not equals objType in filter structure: objType: ${filtersStructure.objType.objectType}`);
-          return [filterLogicalStructure, errorsObject, errorsFound];
-        };
-      };
-    };
-
-    console.log('before return filterLogicalStructure: ', {
-      path,
-      filterLogicalStructure,
-      errorsObject,
-      errorsFound
-    });
-    return [filterLogicalStructure, errorsObject, errorsFound];
-
-  } catch (err) {
-    _izContext.logger.error('error ValidateSearchTypeFilterType: ', err)
-    throw (err);
-  };
-
-};
-//###################################################################################################################################################################################
-
-function createChildComplexFilterStructure(
-  logicalElements,
-  previousLogicalElementId,
-  previousLogicalElement,
-  currentLogicalElementId,
-  currentLogicalElement,
-  filtersStructure
-) {
-  console.log('createChildComplexFilterStructure: ', {
-    logicalElements,
-    previousLogicalElementId,
-    previousLogicalElement,
-    currentLogicalElementId,
-    currentLogicalElement,
-    filtersStructure
-  });
-
-  let errorsFound = [];
-
-  if (!currentLogicalElement) {
-    errorsFound.push('no current logical element to process');
-    return [previousLogicalElementId, previousLogicalElement, logicalElements, errorsFound];
-  };
-
-  if (!previousLogicalElement) {
-    filtersStructure.logicalElements[filtersStructure.initialLogicalElementId].previousLogicalElementId = currentLogicalElementId;
-    logicalElements = Object.assign({ [currentLogicalElementId]: currentLogicalElement }, logicalElements, filtersStructure.logicalElements);
-  } else {
-
-    currentLogicalElement.childLogicalElementId = previousLogicalElementId;
-    console.log('currentLogicalElement', currentLogicalElement);
-
-    logicalElements[previousLogicalElementId].previousLogicalElementId = currentLogicalElementId;
-    console.log('logicalElements', logicalElements);
-
-    logicalElements = Object.assign({ [currentLogicalElementId]: currentLogicalElement }, logicalElements);
-    console.log('after logicalElements', logicalElements);
-
-  };
-
-  previousLogicalElementId = currentLogicalElementId;
-  previousLogicalElement = currentLogicalElement;
-
-  return [previousLogicalElementId, previousLogicalElement, logicalElements, errorsFound];
-};
-
-async function findObjTypePathToAnotherObjType(
-  fromObjType,
-  toObjType,
-  PATHCONSTANCES
-) {
-  console.log('----- function findObjTypePathToAnotherObjType -----', {
-    fromObjType,
-    toObjType
-  });
-
-  let [path, errorsObject, errorsFound] = await recursiveFindObjTypeTypePathToAnotherObjType(
-    PATHCONSTANCES,
-    fromObjType,
-    toObjType,
-  );
-  console.log('return path', {
-    path,
-    errorsObject,
-    errorsFound
-  });
-
-  if (path !== null) {
-    console.log('--------------- will return -----------------');
-    return [path, errorsObject, errorsFound];
-  };
-
-  return [path, errorsObject, errorsFound];
-
-};
-
-async function recursiveFindObjTypeTypePathToAnotherObjType(
-  PATHCONSTANCES,
-  fromObjType,
-  toObjType,
-  iter = 1
-) {
-  console.log('----- function recursiveFindObjTypeTypePathToAnotherObjType -----', {
-    PATHCONSTANCES,
-    fromObjType,
-    toObjType,
-    iter
-  });
-
-  let errorsObject = {};
-  let errorsFound = [];
-
-  let continueProcess = false;
-
-  for (const objType of PATHCONSTANCES.objTypes) {
-    console.log('objType: ', objType);
-    if (checkObjType(fromObjType, objType) === true) {
-      // if (hash(fromObjType) === hash(objType)) {
-      continueProcess = true;
-    };
-  };
-
-  if (continueProcess) {
-    console.log('------------ continue to find path --------------');
-
-    if (checkObjType(fromObjType, toObjType) === true) {
-      // if (hash(fromObjType) === hash(toObjType)) {
-      return [[{ objType: toObjType }], errorsObject, errorsFound];
-    };
-
-    if (iter >= MAX_ITER) {
-      return [null, errorsObject, errorsFound];
-    };
-
-    // let objectRelationship = await getObjectSchema.getObjectRelationshipWithCache(
-    const objectRelationship = await getObjectSchema.getObjectRelationship(
-      fromObjType
-    );
-    console.log("objectRelationship: ", { fromObjType, objectRelationship });
-
-    let path = null;
-    let previousNextPath = null;
-    let currentNextPath = null;
-
-    for (const relationshipObject of objectRelationship) {
-      console.log('relationshipObject: ', relationshipObject);
-
-      let relType = relationshipObject.relType;
-      console.log('relType: ', relType);
-
-      let otherObjType = relationshipObject.other.objType;
-      console.log('otherObjType: ', otherObjType);
-
-      let relCheck = false;
-
-      for (const relPath of PATHCONSTANCES.relTypes) {
-        if (hash(relType) === hash(relPath)) {
-          relCheck = true;
-          break;
-        };
-      };
-
-      if (!relCheck) {
-        //* no relationshipTag in constance
-        continue;
-      };
-
-      // const objectSchema = await getObjectSchema.getObjSchemaS3WithCache(
-      const objectSchema = await getObjectSchema.getObjSchemaS3WithoutHierarchy(
-        toObjType,
-      );
-      console.log('objectSchema: ', objectSchema);
-      console.log('before relationshipObject: ', {
-        from: fromObjType,
-        to: toObjType,
-        next: otherObjType,
-        relationshipObject
-      });
-
-      if (objectSchema.hasOwnProperty('extendObjType')) {
-        if (checkObjType(otherObjType, objectSchema.extendObjType) === true) {
-          // if (hash(nextObjType) === hash(objectSchema.extendObjType)) {
-          otherObjType = toObjType;
-        };
-      };
-      console.log('after relationshipObject: ', {
-        from: fromObjType,
-        to: toObjType,
-        next: otherObjType,
-        relationshipObject
-      });
-
-      let pathErrorsObject;
-      let pathErrorsFound;
-
-      //* recurvsive path
-      [currentNextPath, pathErrorsObject, pathErrorsFound] = await recursiveFindObjTypeTypePathToAnotherObjType(
-        PATHCONSTANCES,
-        otherObjType,
-        toObjType,
-        iter + 1
-      );
-      console.log('return recursive path: ', {
-        currentNextPath,
-        pathErrorsObject,
-        pathErrorsFound
-      });
-
-      if (currentNextPath !== null) {
-
-        previousNextPath = currentNextPath;
-
-        let addPath = {
-          objType: fromObjType,
-          pathLinkType: {
-            objType: otherObjType,
-            relType: relType,
-            direction: relationshipObject.other.direction
-          }
-        };
-        console.log('addPath: ', addPath);
-
-        previousNextPath.unshift(addPath);
-        console.log('path: ', path);
-
-      } else {
-        continue;
-      };
-
-      if (previousNextPath !== null) {
-        if (path !== null) {
-          if (path.length > previousNextPath.length) {
-            path = previousNextPath;
-          };
-          console.log('path: ', path);
-          return [path, errorsObject, errorsFound];
-        } else {
-          path = previousNextPath;
-        };
-      };
-    };// end iterate relType
-
-    // if (previousNextPath !== null) {
-    if (path !== null) {
-      if (path.length > previousNextPath.length) {
-        path = previousNextPath;
-      };
-      console.log('path: ', path);
-      return [path, errorsObject, errorsFound];
-    };
-
-  } else {
-    errorsObject = {
-      [fromObjType.objectType]: 'cannot found this objType that can process in path'
-    };
-    errorsFound.push(`${fromObjType.objectType}: cannot found objType that can process in path`);
-  };
-
-  return [null, errorsObject, errorsFound];
-
-};
-
-
-export default {
-  changeObjTypePath,
-  findObjTypePathToAnotherObjType
-}