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

package/index.js

@@ -19,9 +19,13 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 import SearchSortSharedLib from './src/SearchSortSharedLib.js';
 import FiltersSharedLib from './src/FiltersSharedLib.js'
 import DataFieldsSharedLib from './src/DataFieldsSharedLib.js'
+import ChangeLevelSharedLib from './src/ChangeLevelSharedLib.js';
+import LogicalStructureSharedLib from './src/LogicalStructureSharedLib.js';
 
 export {
   SearchSortSharedLib,
   FiltersSharedLib,
-  DataFieldsSharedLib
+  DataFieldsSharedLib,
+  ChangeLevelSharedLib,
+  LogicalStructureSharedLib
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-shared-search-and-sort",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Shared Libraries frontend/backend for Search and Sort stack",
   "main": "index.js",
   "scripts": {
@@ -25,7 +25,9 @@
     "@izara_project/izara-core-library-core": "^1.0.13",
     "@izara_project/izara-core-library-external-request": "^1.0.13",
     "@izara_project/izara-core-library-search-result": "^1.0.6",
+    "@izara_project/izara-core-library-service-schemas": "^1.0.105",
     "@izara_project/izara-shared": "^1.0.109",
+    "@izara_project/izara-shared-service-schemas": "^1.0.35",
     "object-hash": "^3.0.0"
   }
 }

package/src/ChangeLevelSharedLib.js

@@ -0,0 +1,610 @@
+/*
+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
+}