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

package/index.js

@@ -20,10 +20,12 @@ import SearchSortSharedLib from './src/SearchSortSharedLib.js';
 import FiltersSharedLib from './src/FiltersSharedLib.js'
 import DataFieldsSharedLib from './src/DataFieldsSharedLib.js'
 import LogicalStructureSharedLib from './src/LogicalStructureSharedLib.js';
+import InitialSchemaLib from './src/InitialSchemaLib.js';
 
 export {
   SearchSortSharedLib,
   FiltersSharedLib,
   DataFieldsSharedLib,
-  LogicalStructureSharedLib
+  LogicalStructureSharedLib,
+  InitialSchemaLib
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-shared-search-and-sort",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "Shared Libraries frontend/backend for Search and Sort stack",
   "main": "index.js",
   "scripts": {
@@ -21,12 +21,7 @@
   },
   "type": "module",
   "dependencies": {
-    "@izara_project/izara-core-library-complex-filter": "^1.0.8",
-    "@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-core-library-core": "^1.0.31",
     "@izara_project/izara-shared-service-schemas": "^1.0.35",
     "object-hash": "^3.0.0"
   }

package/src/DataFieldsSharedLib.js

@@ -22,29 +22,33 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // 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 { objectHash as hash } from '@izara_project/izara-shared-core';
 import lodash from 'lodash';
 const { isEmpty } = lodash;
-import filtersSharedLib from './FiltersSharedLib.js'; //const filtersSharedLib = require('./FiltersSharedLib');
+import filtersSharedLib from './FiltersSharedLib.js';
+import LogicalStructureSharedLib from './LogicalStructureSharedLib'
 
 async function createRequiredData(
   objType,
+  initialLogicalElementId,
+  logicalElements,
   requiredDataFields,
   complexFilterCombinations,
   perParentCombinations,
   requiredDataLinkStepObjects,
   requiredDataLinkSteps,
   values,
-  // getSchemaFn
 ) {
   console.log('createRequiredData: ', {
     objType,
+    initialLogicalElementId,
+    logicalElements,
     requiredDataFields,
     complexFilterCombinations,
     perParentCombinations,
     requiredDataLinkStepObjects,
+    requiredDataLinkSteps,
     values,
-    // getSchemaFn
   });
 
   let errorsObject = {};
@@ -75,7 +79,6 @@ async function createRequiredData(
       perParentCombinations,
       complexFilterCombinations,
       values,
-      // getSchemaFn,
       errorsObject,
       errorsFound
     );
@@ -86,12 +89,9 @@ async function createRequiredData(
       linkPathErrorsFound
     });
 
-    if (linkPathErrorsFound.length > 0) {
+    if (linkPathErrorsFound.length > 0 || fieldName === null) {
       Object.assign(errorsObject, linkPathErrorObject);
       errorsFound = errorsFound.concat(linkPathErrorsFound);
-    };
-
-    if (fieldName === null) {
       return {
         requiredDataHash: null,
         requiredDataObject: requiredDataObject,
@@ -117,6 +117,8 @@ async function createRequiredData(
         Object.assign(linkPathObjects, returnValue.sortFieldLinkPathObjects.linkPathObjects);
       }
 
+      console.log('returnValue.linkStepObjects: ', returnValue.linkStepObjects);
+
       let pathObject = {
         initialObjType: objType,
         linkSteps: returnValue.linkSteps
@@ -131,16 +133,17 @@ async function createRequiredData(
         linkPathObjectId: pathId
       };
 
-      Object.assign(linkPathObjects, { [pathId]: pathObject });
-
       let requiredFieldNameObject = {
-        fieldName: fieldName,
-        linkPathObjects: linkPathObjects,
-        linkPathSteps: linkPathSteps
+        // fieldName: fieldName,
+        fieldName: setObject,
+        linkPathObjects: {
+          [pathId]: pathObject
+        },
+        linkPathSteps: returnValue.linkStepObjects
       };
 
       if (returnValue.hasOwnProperty('complexFilterCombinations')) {
-        requiredFieldNameObject.complexFilterCombinations = returnValue.complexFilterCombinations;
+        // requiredFieldNameObject.complexFilterCombinations = returnValue.complexFilterCombinations;
         Object.assign(setComplexFilterCombinations, returnValue.complexFilterCombinations);
 
         setObject.complexFilterCombinationIds = []
@@ -152,12 +155,12 @@ async function createRequiredData(
       };
 
       if (returnValue.hasOwnProperty('perParentCombinations')) {
-        requiredFieldNameObject.perParentCombinations = returnValue.perParentCombinations;
+        // requiredFieldNameObject.perParentCombinations = returnValue.perParentCombinations;
         Object.assign(setPerParentCombinations, returnValue.perParentCombinations);
       };
 
       if (returnValue.hasOwnProperty('filterElements')) {
-        requiredFieldNameObject.filterElements = returnValue.filterElements;
+        // requiredFieldNameObject.filterElements = returnValue.filterElements;
         Object.assign(setFilterElementsLink, returnValue.filterElements);
       };
       console.log('requiredFieldNameObject: ', requiredFieldNameObject);
@@ -174,6 +177,8 @@ async function createRequiredData(
         requiredDataObject[requiredDataFieldNameId] = setObject;
       };
 
+      Object.assign(linkPathObjects, { [pathId]: pathObject });
+
     } else {
       console.log("------- requiredData has only fieldName ---------");
 
@@ -269,7 +274,8 @@ async function createLinkPath(
   perParentCombinations,
   complexFilterCombinations,
   values,
-  // getSchemaFn,
+  filtersStructure,
+  path,
   errorsObject,
   errorsFound,
   index = 0,
@@ -283,6 +289,8 @@ async function createLinkPath(
     perParentCombinations,
     complexFilterCombinations,
     values,
+    filtersStructure,
+    path,
     errorsObject,
     errorsFound,
     index,
@@ -291,17 +299,8 @@ async function createLinkPath(
   });
   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 sortObj = null;
 
   let linkStepId = linkSteps[index];
   console.log('linkStepId: ', linkStepId);
@@ -313,12 +312,32 @@ async function createLinkPath(
     // last link that has only fieldName
     console.log('---------- is final link ----------', { index, linkStep });
 
-    return [linkStep.fieldName, returnValue, errorsObject, errorsFound]
+    let sortValueObj = null;
+
+    if (linkStep.hasOwnProperty("dataType")) {
+
+      sortValueObj = {
+        dataType: linkStep.dataType,
+        value: linkStep.value
+      }
+
+    }
+
+    return [linkStep.fieldName, returnValue, errorsObject, errorsFound, sortValueObj]
 
   } else {
     // has nextLink
     console.log('---------- is next link ----------', { index, linkStep });
 
+    if (linkStep.hasOwnProperty("pathLinkType")) {
+      path.push({
+        objType: objType,
+        pathLinkType: linkStep.pathLinkType
+      });
+      console.log("path", path);
+      // console.log('---------- is next link ----------', hhhh);
+    }
+
     let conditionsPromise = checkConditionsLink(
       // let [conditions, conditionErrObject, conditionErrFound] = await this.checkConditionsLink(
       linkStep.pathLinkType.objType,
@@ -329,19 +348,20 @@ async function createLinkPath(
       linkSteps,
       requiredDataLinkStepObjects,
       requiredDataLinkSteps,
-      // getSchemaFn,
+      path,
       errorsObject,
       errorsFound
     );
 
-    [fieldName, returnValue, errorsObject, errorsFound] = await createLinkPath(
+    [fieldName, returnValue, errorsObject, errorsFound, sortObj] = await createLinkPath(
       linkSteps,
       requiredDataLinkStepObjects,
       requiredDataLinkSteps,
       perParentCombinations,
       complexFilterCombinations,
       values,
-      // getSchemaFn,
+      filtersStructure,
+      path,
       errorsObject,
       errorsFound,
       index + 1
@@ -354,6 +374,10 @@ async function createLinkPath(
       index
     });
 
+    if (errorsFound.length > 0) {
+      return [null, null, errorsObject, errorsFound]
+    }
+
     console.log('linkStep', linkStep);
 
     let [conditions, conditionErrObject, conditionErrFound] = await conditionsPromise;
@@ -361,6 +385,8 @@ async function createLinkPath(
     if (conditionErrFound.length > 0) {
       Object.assign(errorsObject, conditionErrObject);
       errorsFound = errorsFound.concat(conditionErrFound);
+
+      return [null, null, errorsObject, errorsFound]
     };
 
     if (!isEmpty(returnValue)) {
@@ -411,15 +437,37 @@ async function createLinkPath(
           if (conditions.hasOwnProperty("setFilterCombinations") && !isEmpty(conditions.setFilterCombinations)) {
 
             if (conditions.setFilterCombinations.hasOwnProperty('filterElements')) {
-              Object.assign(returnValue["filterElements"], conditions.setFilterCombinations.filterElements.filterElements);
+
+              if (returnValue.hasOwnProperty("filterElements")) {
+                Object.assign(returnValue["filterElements"], conditions.setFilterCombinations.filterElements.filterElements);
+              } else {
+                returnValue.filterElements = {};
+                Object.assign(returnValue["filterElements"], conditions.setFilterCombinations.filterElements.filterElements);
+              }
+
             }
 
             if (conditions.setFilterCombinations.hasOwnProperty('perParentCombinations')) {
-              Object.assign(returnValue["perParentCombinations"], conditions.setFilterCombinations.perParentCombinations);
+
+              if (returnValue.hasOwnProperty("perParentCombinations")) {
+                Object.assign(returnValue["perParentCombinations"], conditions.setFilterCombinations.perParentCombinations);
+              } else {
+                returnValue.perParentCombinations = {};
+                Object.assign(returnValue["perParentCombinations"], conditions.setFilterCombinations.perParentCombinations);
+              }
+
             };
 
             if (conditions.setFilterCombinations.hasOwnProperty('complexFilterCombinations')) {
-              Object.assign(returnValue['complexFilterCombinations'], conditions.setFilterCombinations.complexFilterCombinations);
+
+              if (returnValue.hasOwnProperty("complexFilterCombinations")) {
+                Object.assign(returnValue['complexFilterCombinations'], conditions.setFilterCombinations.complexFilterCombinations);
+              } else {
+                returnValue.complexFilterCombinations = {};
+                Object.assign(returnValue["complexFilterCombinations"], conditions.setFilterCombinations.complexFilterCombinations);
+              }
+
+
             };
           }
 
@@ -429,6 +477,7 @@ async function createLinkPath(
           //* error
           errorsObject[linkStepId] = `has linkPathObject but no data`;
           errorsFound.push(`${linkStepId} no data in linkPathObject`)
+          return [null, null, errorsObject, errorsFound]
         }
       }
 
@@ -536,7 +585,8 @@ async function createLinkPath(
         } else {
           //* error
           errorsObject[linkStepId] = `has linkPathObject but no data`;
-          errorsFound.push(`${linkStepId} no data in linkPathObject`)
+          errorsFound.push(`${linkStepId} no data in linkPathObject`);
+          return [null, null, errorsObject, errorsFound]
         }
       }
 
@@ -558,6 +608,16 @@ async function createLinkPath(
         };
       };
 
+      if (conditions.hasOwnProperty("comparison")) {
+        if (conditions.hasOwnProperty("comparisonSortField")) {
+          if (conditions.hasOwnProperty("comparisonValue")) {
+            linkStepObject.comparison = conditions.comparison;
+            linkStepObject.comparisonSortField = conditions.comparisonSortField;
+            linkStepObject.comparisonValue = conditions.comparisonValue;
+          }
+        }
+      }
+
       console.log('linkStepObject', linkStepObject);
       let linkStepId = hash(linkStepObject);
       console.log('linkStepId', linkStepId);
@@ -579,10 +639,11 @@ async function checkConditionsLink(
   perParentCombinations,
   complexFilterCombinations,
   values,
+  filtersStructure,
   linkSteps,
   requiredDataLinkStepObjects,
   requiredDataLinkSteps,
-  // getSchemaFn,
+  path,
   errorsObject,
   errorsFound
 ) {
@@ -592,24 +653,76 @@ async function checkConditionsLink(
     perParentCombinations,
     complexFilterCombinations,
     values,
+    filtersStructure,
     linkSteps,
     requiredDataLinkStepObjects,
     requiredDataLinkSteps,
-    // getSchemaFn,
+    path,
     errorsObject,
     errorsFound
   });
 
 
-  let conditionLinkObject = {}
+  let conditionLinkObject = {};
+  let filterMainRequest = null
+
+  if (linkStepObject.hasOwnProperty("addFilterMain") && linkStepObject.addFilterMain === true) {
+
+    path.push({ objType: objType });
+    console.log('path', path);
+
+    let [filterStructureCurrent, filterErrorObject, filterErrorFound] = await LogicalStructureSharedLib.changeObjTypePath(
+      objType,
+      filtersStructure,
+      path
+    );
+
+    console.log('changeObjTypePath', {
+      filterStructureCurrent,
+      filterErrorObject,
+      filterErrorFound
+    });
+
+    if (filterErrorFound.length > 0) {
+      Object.assign(errorsObject, filterErrorObject);
+      errorsFound = errorsFound.concat('filterErrorFound');
+    } else {
+      filterMainRequest = filterStructureCurrent;
+    }
+
+  }
 
   if (linkStepObject.hasOwnProperty('filterElements')) {
     console.log('------------ has filterElements ------------');
 
+    let filters = {};
+
+    if (filterMainRequest !== null) {
+      if (hash(filterMainRequest.objType) !== hash(linkStepObject.filterElements.objType)) {
+        errorsObject[linkStepObject.filterElements.objType.objectType] = 'this linkStep has error when combine filterMain in link';
+        errorsFound.push(`${linkStepObject.filterElements.objType.objectType}: this linkStep has error when combine filterMain in link`);
+        return [null, errorsObject, errorsFound];
+      }
+
+      filters = filtersSharedLib.combineLogicalElements(
+        filterMainRequest,
+        linkStepObject.filterElements
+      );
+
+
+    } else {
+      filters = {
+        objType: linkStepObject.filterElements.objType,
+        initialLogicalElementId: linkStepObject.filterElements.initialLogicalElementId,
+        logicalElements: linkStepObject.filterElements.logicalElements,
+      }
+    }
+    console.log('filters: ', filters);
+
     let [complexFilterRequest, status, filterErrorsObject, filterErrorsFound] = filtersSharedLib.createFiltersRequest(
-      linkStepObject.filterElements.objType,
-      linkStepObject.filterElements.initialLogicalElementId,
-      linkStepObject.filterElements.logicalElements,
+      filters.objType,
+      filters.initialLogicalElementId,
+      filters.logicalElements,
       values
     );
     console.log('return complexFilter for filterElements: ', {
@@ -623,14 +736,44 @@ async function checkConditionsLink(
       Object.assign(errorsObject, filterErrorsObject)
       errorsFound = errorsFound.concat(filterErrorsFound)
     };
+
     conditionLinkObject.filterElements = complexFilterRequest.filterElements;
     console.log('conditionLinkObject in condition link: ', conditionLinkObject);
+
   }
 
+
+  // if (linkStepObject.hasOwnProperty('filterElements')) {
+  //   console.log('------------ has filterElements ------------');
+
+  //   let [complexFilterRequest, status, filterErrorsObject, filterErrorsFound] = filtersSharedLib.createFiltersRequest(
+  //     linkStepObject.filterElements.objType,
+  //     linkStepObject.filterElements.initialLogicalElementId,
+  //     linkStepObject.filterElements.logicalElements,
+  //     values
+  //   );
+  //   console.log('return complexFilter for filterElements: ', {
+  //     complexFilterRequest,
+  //     status,
+  //     filterErrorsObject,
+  //     filterErrorsFound
+  //   });
+
+  //   if (filterErrorsFound.length > 0) {
+  //     Object.assign(errorsObject, filterErrorsObject)
+  //     errorsFound = errorsFound.concat(filterErrorsFound);
+  //     return [null, errorsObject, errorsFound]
+  //   };
+  //   conditionLinkObject.filterElements = complexFilterRequest.filterElements;
+  //   console.log('conditionLinkObject in condition link: ', conditionLinkObject);
+  // }
+
   if (linkStepObject.hasOwnProperty('aggregate')) {
     console.log('------------ has aggregate ------------');
     if (!linkStepObject.hasOwnProperty('sortFields')) {
+      errorsObject[objType.objectType] = 'if has aggregate need to has sortFields, too';
       errorsFound.push('if has aggregate need to has sortFields, too');
+      return [null, errorsObject, errorsFound]
     };
     conditionLinkObject.aggregate = linkStepObject.aggregate;
     conditionLinkObject.sortFields = [];
@@ -668,7 +811,8 @@ async function checkConditionsLink(
         perParentCombinations,
         complexFilterCombinations,
         values,
-        // getSchemaFn,
+        filtersStructure,
+        [],
         errorsObject,
         errorsFound
       );
@@ -679,6 +823,12 @@ async function checkConditionsLink(
         linkErrorsFound
       });
 
+      if (linkErrorsFound > 0) {
+        Object.assign(errorsObject, linkErrorsObject);
+        errorsFound = errorsFound.concat(linkErrorsFound);
+        return [null, errorsObject, errorsFound]
+      }
+
       if (!isEmpty(childLinkStep)) {
 
         //* create linkPathObject from child
@@ -733,10 +883,19 @@ async function checkConditionsLink(
         });
       };
 
-      sortFieldObjects.push({
+      let sortObject = {
         fieldName: fieldName,
-        dataType: sortField.dataType
-      });
+        // dataType: sortField.dataType
+      }
+
+      if (sortObj !== null) {
+        if (sortObj.dataType === "array") {
+          sortObject.dataType = sortObj.dataType
+          sortObject.values = sortObj.value;
+        }
+      }
+
+      sortFieldObjects.push(sortObject);
       console.log('sortFieldObjects: ', sortFieldObjects);
 
     };
@@ -764,7 +923,9 @@ async function checkConditionsLink(
 
   } else {
     if (linkStepObject.hasOwnProperty('combine')) {
-      errorsFound.push('this link set combine must set aggregate and sortFields, too');
+      errorsObject[objType.objectType] = 'must set aggregate and sortFields';
+      errorsFound = errorsFound.concat('must set aggregate and sortFields')
+      return [null, errorsObject, errorsFound]
     }
   };
 
@@ -889,6 +1050,10 @@ async function checkConditionsLink(
       };
     };
 
+    if (errorsFound.length > 0) {
+      return [null, errorsObject, errorsFound]
+    }
+
     console.log('perParentCombinations: ', {
       perParentCombinationIds,
       perParentCombinationObjects,
@@ -906,6 +1071,22 @@ async function checkConditionsLink(
     };
     console.log('conditionLinkObject: ', conditionLinkObject);
   }
+
+  if (linkStepObject.hasOwnProperty("comparison")) {
+    console.log('------------ link has comparison ------------');
+
+    if (!linkStepObject.hasOwnProperty("comparisonSortField") || !linkStepObject.hasOwnProperty("comparisonValue")) {
+      errorsObject[objType.objectType] = 'no comparisonSortField | comparisonValue';
+      errorsFound.push(`${objType.objectType}: no comparisonSortField | comparisonValue`);
+      return [null, errorsObject, errorsFound]
+    }
+
+    conditionLinkObject.comparison = linkStepObject.comparison;
+    conditionLinkObject.comparisonSortField = linkStepObject.comparisonSortField;
+    conditionLinkObject.comparisonValue = values[linkStepObject.comparisonValue].value;
+
+  }
+
   console.log('conditionLinkObject', conditionLinkObject);
   return [conditionLinkObject, errorsObject, errorsFound];
 }

package/src/FiltersSharedLib.js

@@ -17,7 +17,7 @@ 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 { objectHash as hash } from '@izara_project/izara-shared-core';
 import lodash from 'lodash';
 const { isEmpty } = lodash;
 
@@ -161,18 +161,6 @@ function createFiltersRequest(
   };
   console.log('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,
@@ -1004,7 +992,6 @@ function filterLogicalElements(
 
   if (lastNextLogicalElementId !== null) {
 
-    // [runningFilterMainId, runningFilterObject, operation, operationErrorsFound] = complexFilterShared.validateOperation(
     [runningFilterMainId, runningFilterObject, operation, operationErrorsFound] = validateOperation(
       objType,
       runningFilterMainId,
@@ -1151,43 +1138,43 @@ function splitFilterElements(
   //   || runningFilterObject.filterElement.filterType === 'traversal'
   // ) {}
 
-  if (runningFilterObject.filterElement.filterType === 'operation') {
+  if (runningFilterObject.logicalElementType === 'operation') {
     console.log('-------- operation ----------');
 
     Object.assign(filterElements, runningFilterObject.filterElement.filterElements);
-    delete runningFilterObject.filterElement.filterElements;
+    // delete runningFilterObject.filterElement.filterElements;
     filterElements[runningFilterMainId] = runningFilterObject;
 
-  } else if (runningFilterObject.filterElement.filterType === 'childComplexFilter') {
+  } else if (runningFilterObject.logicalElementType === 'childComplexFilter') {
     console.log('-------- childComplexFilter ----------');
 
     Object.assign(filterElements, runningFilterObject.filterElement.filterElements);
-    delete runningFilterObject.filterElement.filterElements;
+    // delete runningFilterObject.filterElement.filterElements;
     filterElements[runningFilterMainId] = runningFilterObject;
 
   } else {
-    console.log(` -------- ${runningFilterObject.filterElement.filterType} ----------`);
+    console.log(` -------- ${runningFilterObject.logicalElementType} ----------`);
     //'logical'| 'identifiers'|'translateIds'|'traversal'
     filterElements[runningFilterMainId] = runningFilterObject;
   };
 
   if (currentFilterObject !== null) {
-    if (currentFilterObject.filterElement.filterType === 'operation') {
+    if (currentFilterObject.logicalElementType === 'operation') {
       console.log('-------- operation ----------');
 
       Object.assign(filterElements, currentFilterObject.filterElement.filterElements);
-      delete currentFilterObject.filterElement.filterElements;
+      // delete currentFilterObject.filterElement.filterElements;
       filterElements[currentFilterMainId] = currentFilterObject;
 
-    } else if (currentFilterObject.filterElement.filterType === 'childComplexFilter') {
+    } else if (currentFilterObject.logicalElementType === 'childComplexFilter') {
       console.log('-------- childComplexFilter ----------');
 
       Object.assign(filterElements, currentFilterObject.filterElement.filterElements);
-      delete currentFilterObject.filterElement.filterElements;
+      // delete currentFilterObject.filterElement.filterElements;
       filterElements[currentFilterMainId] = currentFilterObject;
 
     } else {
-      console.log(` -------- ${currentFilterObject.filterElement.filterType} ----------`);
+      console.log(` -------- ${currentFilterObject.logicalElementType} ----------`);
       //'logical'| 'identifiers'|'translateIds'|'traversal'
       filterElements[currentFilterMainId] = currentFilterObject;
     };
@@ -1202,7 +1189,7 @@ export default {
   //* create filter
   createFiltersRequest,
   validateCombinationStructure,
-  // validateOperation,
   filterLogicalElements,
+  // validateOperation,
   // splitFilterElements,
 }

package/src/InitialSchemaLib.js

@@ -0,0 +1,27 @@
+/*
+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 LogicalStructureSharedLib from './LogicalStructureSharedLib.js';
+
+function initSchemaFn(getObjSchemaS3WithHierarchyShared, getObjectLinksShared) {
+  return LogicalStructureSharedLib.initSchemaFn(getObjSchemaS3WithHierarchyShared, getObjectLinksShared);
+}
+
+export default {
+  initSchemaFn
+}

package/src/LogicalStructureSharedLib.js

@@ -18,14 +18,22 @@ 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 { objectHash as hash } from '@izara_project/izara-shared-core';
 import lodash from 'lodash';
 const { isEmpty } = lodash;
-import { v4 as uuidV4 } from 'uuid'; //const { v4: uuidv4 } = require('uuid');
-import { getObjectSchema } from '@izara_project/izara-core-library-service-schemas';
-// import { getObjectSchema } from '@izara_project/izara-shared-service-schemas';
+import { v4 as uuidV4 } from 'uuid';
 const MAX_ITER = 4;
 
+let getObjectSchema = {};
+
+function initSchemaFn(getObjSchemaS3WithHierarchyShared, getObjectLinksShared) {
+  getObjectSchema = {
+    getObjSchemaS3WithHierarchyShared,
+    getObjectLinksShared
+  }
+  return getObjectSchema;
+}
+
 
 function combineLogicalStructure(
   objType,
@@ -594,15 +602,13 @@ async function changeObjTypePath(
   requiredObjType,
   filtersStructure,
   path = null,
-  // getSchemaFn,
-  PATHCONSTANCES = null,
+  PATHCONSTANCES = null
 ) {
   try {
     console.log('----- function validateSearchTypeFilterType -----', {
       requiredObjType,
       filtersStructure,
-      path,
-      // getSchemaFn,
+      path
     });
 
     let filterLogicalStructure = {};
@@ -745,14 +751,9 @@ async function changeObjTypePath(
                             if (!childLogicalElement.hasOwnProperty('childLogicalElementId')) {
 
                               // let childSchema = await getObjectSchema.getObjSchemaS3WithCache(
-                              let childSchema = await getObjectSchema.getObjSchemaS3WithoutHierarchy(
-                                {},// _izContext, maybe delete
+                              let childSchema = await getObjectSchema.getObjSchemaS3WithHierarchyShared(
                                 childLogicalElement.objType
                               );
-                              // let childSchema = await getObjectSchema.getObjSchemaWithoutHierarchy(
-                              //   getSchemaFn,
-                              //   childLogicalElement.objType
-                              // );
                               console.log('childSchema: ', childSchema);
 
                               if (childSchema.hasOwnProperty('extendObjType')) {
@@ -768,7 +769,7 @@ async function changeObjTypePath(
                         };
                       } else {
                         checkChild = true;
-                      };
+                      }
 
                       if (checkChild) {
 
@@ -907,6 +908,9 @@ async function changeObjTypePath(
 };
 //###################################################################################################################################################################################
 
+
+
+
 function createChildComplexFilterStructure(
   logicalElements,
   previousLogicalElementId,
@@ -956,21 +960,17 @@ function createChildComplexFilterStructure(
 async function findObjTypePathToAnotherObjType(
   fromObjType,
   toObjType,
-  PATHCONSTANCES,
-  // getSchemaFn
+  PATHCONSTANCES
 ) {
   console.log('----- function findObjTypePathToAnotherObjType -----', {
     fromObjType,
-    toObjType,
-    PATHCONSTANCES,
-    // getSchemaFn
+    toObjType
   });
 
   let [path, errorsObject, errorsFound] = await recursiveFindObjTypeTypePathToAnotherObjType(
     PATHCONSTANCES,
     fromObjType,
     toObjType,
-    // getSchemaFn
   );
   console.log('return path', {
     path,
@@ -991,14 +991,12 @@ async function recursiveFindObjTypeTypePathToAnotherObjType(
   PATHCONSTANCES,
   fromObjType,
   toObjType,
-  // getSchemaFn,
   iter = 1
 ) {
   console.log('----- function recursiveFindObjTypeTypePathToAnotherObjType -----', {
     PATHCONSTANCES,
     fromObjType,
     toObjType,
-    // getSchemaFn,
     iter
   });
 
@@ -1027,15 +1025,9 @@ async function recursiveFindObjTypeTypePathToAnotherObjType(
       return [null, errorsObject, errorsFound];
     };
 
-    // let objectRelationship = await getObjectSchema.getObjectRelationshipWithCache(
-    const objectRelationship = await getObjectSchema.getObjectRelationship(
-      {},  //_izContext maybe delete
+    const objectRelationship = await getObjectSchema.getObjectLinksShared(
       fromObjType
     );
-    // const objectRelationship = await getObjectSchema.getObjectRelationship(
-    //   getSchemaFn,
-    //   fromObjType
-    // )
     console.log("objectRelationship: ", { fromObjType, objectRelationship });
 
     let path = null;
@@ -1066,14 +1058,9 @@ async function recursiveFindObjTypeTypePathToAnotherObjType(
       };
 
       // const objectSchema = await getObjectSchema.getObjSchemaS3WithCache(
-      const objectSchema = await getObjectSchema.getObjSchemaS3WithoutHierarchy(
-        {}, //_izContext maybe delete
+      const objectSchema = await getObjectSchema.getObjSchemaS3WithHierarchyShared(
         toObjType,
       );
-      // const objectSchema = await getObjectSchema.getObjSchemaWithoutHierarchy(
-      //   getSchemaFn,
-      //   toObjType,
-      // )
       console.log('objectSchema: ', objectSchema);
       console.log('before relationshipObject: ', {
         from: fromObjType,
@@ -1103,7 +1090,6 @@ async function recursiveFindObjTypeTypePathToAnotherObjType(
         PATHCONSTANCES,
         otherObjType,
         toObjType,
-        // getSchemaFn,
         iter + 1
       );
       console.log('return recursive path: ', {
@@ -1168,15 +1154,14 @@ async function recursiveFindObjTypeTypePathToAnotherObjType(
 
 
 export default {
-  //* front-end
-  changeObjTypePath,
-  findObjTypePathToAnotherObjType,
-
+  initSchemaFn,
 
-  //* use in back-end
   combineLogicalStructure,
+  // combineOperation,
+  // combineLogicalElements,
+
   checkAndCreateBracket,
-  // changeObjTypePath,
-  // findObjTypePathToAnotherObjType,
 
+  changeObjTypePath,
+  findObjTypePathToAnotherObjType
 }

package/src/SearchSortSharedLib.js

@@ -18,10 +18,10 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 "use strict";
 
 //* searchResultMain record
-import { objectHash as hash } from '@izara_project/izara-shared-core';  //const hash = require('@izara_project/izara-shared-core').objectHash;
+import { objectHash as hash } from '@izara_project/izara-shared-core';
 import lodash from 'lodash';
 const { isEmpty } = lodash;
-import filtersSharedLib from './FiltersSharedLib.js'; //const filtersSharedLib = require('./FiltersSharedLib');
+import filtersSharedLib from './FiltersSharedLib.js';
 import dataFieldsSharedLib from './DataFieldsSharedLib.js';
 
 
@@ -35,7 +35,7 @@ async function createSearchRequest(
   requiredDataLinkStepObjects,
   requiredDataLinkSteps,
   values,
-  // getSchemaFn
+  getSchemaFn
 ) {
   console.log('createSearchResult: ', {
     objType,
@@ -46,8 +46,7 @@ async function createSearchRequest(
     perParentCombinations,
     requiredDataLinkStepObjects,
     requiredDataLinkSteps,
-    values,
-    // getSchemaFn
+    values
   });
 
   let filterElements = {};
@@ -55,6 +54,7 @@ async function createSearchRequest(
   let errorsObject = {};
   let errorsFound = [];
 
+
   let requiredDataPromise = dataFieldsSharedLib.createRequiredData(
     objType,
     requiredDataFields,
@@ -63,7 +63,7 @@ async function createSearchRequest(
     requiredDataLinkStepObjects,
     requiredDataLinkSteps,
     values,
-    // getSchemaFn
+    getSchemaFn
   );
 
   //* create complexFilter normalize to send backend
@@ -91,6 +91,8 @@ async function createSearchRequest(
     Object.assign(errorsObject, complexErrorsObject);
   }
 
+  filterElements = complexFilterRequest.filterElements;
+
   // let requiredData = dataFieldsSharedLib.createRequiredData(
   //   objType,
   //   requiredDataFields,
@@ -113,8 +115,6 @@ async function createSearchRequest(
     return [null, 'invalid', errorsObject, errorsFound]
   }
 
-  filterElements = complexFilterRequest.filterElements;
-
   if (!isEmpty(requiredData.perParentCombinations)) {
     for (const filterObject of Object.values(requiredData.perParentCombinations)) {
       Object.assign(filterElements, filterObject.filterElements);
@@ -166,7 +166,6 @@ async function createSortRequest(
   requiredDataLinkSteps,
   sortFields,
   values,
-  // getSchemaFn
 ) {
   console.log('createSortResult: ', {
     objType,
@@ -178,8 +177,7 @@ async function createSortRequest(
     requiredDataLinkStepObjects,
     requiredDataLinkSteps,
     sortFields,
-    values,
-    // getSchemaFn
+    values
   });
 
   let sortFieldMain = []
@@ -222,8 +220,7 @@ async function createSortRequest(
     perParentCombinations,
     requiredDataLinkStepObjects,
     requiredDataLinkSteps,
-    values,
-    // getSchemaFn
+    values
   );
   console.log('SearchResultRequest: ', {
     searchResultRequest,
@@ -233,7 +230,7 @@ async function createSortRequest(
   });
 
   if (errorsFound.length > 0) {
-    return [null, 'invalid', errorsObject, errorsFound]
+    return [null, null, 'invalid', errorsObject, errorsFound]
   }
 
   let searchResultId = searchResultRequest.searchResultId;
@@ -274,9 +271,4 @@ export default {
   //* create request to backend to sort and search
   createSearchRequest,
   createSortRequest
-}
-
-
-// getSchemaFn = {
-
-// }
+}