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

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.8",
   "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

@@ -35,7 +35,7 @@ async function createRequiredData(
   requiredDataLinkStepObjects,
   requiredDataLinkSteps,
   values,
-  // getSchemaFn
+  getSchemaFn
 ) {
   console.log('createRequiredData: ', {
     objType,
@@ -44,7 +44,7 @@ async function createRequiredData(
     perParentCombinations,
     requiredDataLinkStepObjects,
     values,
-    // getSchemaFn
+    getSchemaFn
   });
 
   let errorsObject = {};
@@ -75,7 +75,6 @@ async function createRequiredData(
       perParentCombinations,
       complexFilterCombinations,
       values,
-      // getSchemaFn,
       errorsObject,
       errorsFound
     );
@@ -86,12 +85,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 +113,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 +129,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 +151,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 +173,8 @@ async function createRequiredData(
         requiredDataObject[requiredDataFieldNameId] = setObject;
       };
 
+      Object.assign(linkPathObjects, { [pathId]: pathObject });
+
     } else {
       console.log("------- requiredData has only fieldName ---------");
 
@@ -269,7 +270,6 @@ async function createLinkPath(
   perParentCombinations,
   complexFilterCombinations,
   values,
-  // getSchemaFn,
   errorsObject,
   errorsFound,
   index = 0,
@@ -291,17 +291,6 @@ 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 linkStepId = linkSteps[index];
   console.log('linkStepId: ', linkStepId);
@@ -329,7 +318,6 @@ async function createLinkPath(
       linkSteps,
       requiredDataLinkStepObjects,
       requiredDataLinkSteps,
-      // getSchemaFn,
       errorsObject,
       errorsFound
     );
@@ -341,7 +329,6 @@ async function createLinkPath(
       perParentCombinations,
       complexFilterCombinations,
       values,
-      // getSchemaFn,
       errorsObject,
       errorsFound,
       index + 1
@@ -354,6 +341,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 +352,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 +404,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 +444,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 +552,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 +575,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);
@@ -582,7 +609,6 @@ async function checkConditionsLink(
   linkSteps,
   requiredDataLinkStepObjects,
   requiredDataLinkSteps,
-  // getSchemaFn,
   errorsObject,
   errorsFound
 ) {
@@ -595,7 +621,6 @@ async function checkConditionsLink(
     linkSteps,
     requiredDataLinkStepObjects,
     requiredDataLinkSteps,
-    // getSchemaFn,
     errorsObject,
     errorsFound
   });
@@ -621,7 +646,8 @@ async function checkConditionsLink(
 
     if (filterErrorsFound.length > 0) {
       Object.assign(errorsObject, filterErrorsObject)
-      errorsFound = errorsFound.concat(filterErrorsFound)
+      errorsFound = errorsFound.concat(filterErrorsFound);
+      return [null, errorsObject, errorsFound]
     };
     conditionLinkObject.filterElements = complexFilterRequest.filterElements;
     console.log('conditionLinkObject in condition link: ', conditionLinkObject);
@@ -630,7 +656,9 @@ async function checkConditionsLink(
   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 +696,6 @@ async function checkConditionsLink(
         perParentCombinations,
         complexFilterCombinations,
         values,
-        // getSchemaFn,
         errorsObject,
         errorsFound
       );
@@ -679,6 +706,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
@@ -764,7 +797,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 +924,10 @@ async function checkConditionsLink(
       };
     };
 
+    if (errorsFound.length > 0) {
+      return [null, errorsObject, errorsFound]
+    }
+
     console.log('perParentCombinations: ', {
       perParentCombinationIds,
       perParentCombinationObjects,
@@ -906,6 +945,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

@@ -20,6 +20,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 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 complexFilterShared from '@izara_project/izara-core-library-complex-filter';
 
 function validateFilterElement(
   filterElements,
@@ -1151,43 +1152,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;
     };

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(getObjSchemaS3WithoutHierarchy, getObjectRelationship) { //getObjectLinks
+  return LogicalStructureSharedLib.initSchemaFn(getObjSchemaS3WithoutHierarchy, getObjectRelationship);
+}
+
+export default {
+  initSchemaFn
+}

package/src/LogicalStructureSharedLib.js

@@ -22,10 +22,19 @@ import { objectHash as hash } from '@izara_project/izara-shared-core';  //const
 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 { getObjectSchema } from '@izara_project/izara-core-library-service-schemas';
 const MAX_ITER = 4;
 
+let getObjectSchema = {};
+
+function initSchemaFn(getObjSchemaS3WithoutHierarchy, getObjectRelationship) { //getObjectLinks
+  getObjectSchema = {
+    getObjSchemaS3WithoutHierarchy,
+    getObjectRelationship: getObjectRelationship // getObjectRelationship: getObjectLinks
+  }
+
+  return getObjectSchema;
+}
 
 function combineLogicalStructure(
   objType,
@@ -594,15 +603,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 +752,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.getObjSchemaS3WithoutHierarchyV2(
                                 childLogicalElement.objType
                               );
-                              // let childSchema = await getObjectSchema.getObjSchemaWithoutHierarchy(
-                              //   getSchemaFn,
-                              //   childLogicalElement.objType
-                              // );
                               console.log('childSchema: ', childSchema);
 
                               if (childSchema.hasOwnProperty('extendObjType')) {
@@ -768,7 +770,7 @@ async function changeObjTypePath(
                         };
                       } else {
                         checkChild = true;
-                      };
+                      }
 
                       if (checkChild) {
 
@@ -808,6 +810,7 @@ async function changeObjTypePath(
 
                   let logicalStructure = {};
                   [previousLogicalElementId, previousLogicalElement, logicalStructure, errorsFound] = createChildComplexFilterStructure(
+                    _izContext,
                     logicalElements,
                     previousLogicalElementId,
                     previousLogicalElement,
@@ -857,6 +860,7 @@ async function changeObjTypePath(
                 let logicalStructure = {};
                 // change function name ==> set logicalElementId
                 [previousLogicalElementId, previousLogicalElement, logicalStructure, errorsFound] = createChildComplexFilterStructure(
+                  _izContext,
                   logicalElements,
                   previousLogicalElementId,
                   previousLogicalElement,
@@ -907,6 +911,9 @@ async function changeObjTypePath(
 };
 //###################################################################################################################################################################################
 
+
+
+
 function createChildComplexFilterStructure(
   logicalElements,
   previousLogicalElementId,
@@ -956,21 +963,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 +994,12 @@ async function recursiveFindObjTypeTypePathToAnotherObjType(
   PATHCONSTANCES,
   fromObjType,
   toObjType,
-  // getSchemaFn,
   iter = 1
 ) {
   console.log('----- function recursiveFindObjTypeTypePathToAnotherObjType -----', {
     PATHCONSTANCES,
     fromObjType,
     toObjType,
-    // getSchemaFn,
     iter
   });
 
@@ -1032,10 +1033,6 @@ async function recursiveFindObjTypeTypePathToAnotherObjType(
       {},  //_izContext maybe delete
       fromObjType
     );
-    // const objectRelationship = await getObjectSchema.getObjectRelationship(
-    //   getSchemaFn,
-    //   fromObjType
-    // )
     console.log("objectRelationship: ", { fromObjType, objectRelationship });
 
     let path = null;
@@ -1070,10 +1067,6 @@ async function recursiveFindObjTypeTypePathToAnotherObjType(
         {}, //_izContext maybe delete
         toObjType,
       );
-      // const objectSchema = await getObjectSchema.getObjSchemaWithoutHierarchy(
-      //   getSchemaFn,
-      //   toObjType,
-      // )
       console.log('objectSchema: ', objectSchema);
       console.log('before relationshipObject: ', {
         from: fromObjType,
@@ -1103,7 +1096,6 @@ async function recursiveFindObjTypeTypePathToAnotherObjType(
         PATHCONSTANCES,
         otherObjType,
         toObjType,
-        // getSchemaFn,
         iter + 1
       );
       console.log('return recursive path: ', {
@@ -1168,15 +1160,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

@@ -23,7 +23,7 @@ import lodash from 'lodash';
 const { isEmpty } = lodash;
 import filtersSharedLib from './FiltersSharedLib.js'; //const filtersSharedLib = require('./FiltersSharedLib');
 import dataFieldsSharedLib from './DataFieldsSharedLib.js';
-
+import LogicalStructureSharedLib from './LogicalStructureSharedLib.js';
 
 async function createSearchRequest(
   objType,
@@ -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,
@@ -103,18 +105,16 @@ async function createSearchRequest(
   let requiredData = await requiredDataPromise;
   console.log('return create requiredData: ', requiredData);
 
-  if (requiredData.status === 'invalid' || requiredData.errorsFound.length > 0) {
-    Object.assign(errorsObject, requiredData.errorsObject)
-    errorsFound.push('requiredData cannot create');
-    errorsFound = errorsFound.concat(requiredData.errorsFound);
-  }
+  // if (requiredData.status === 'invalid' || requiredData.errorsFound.length > 0) {
+  //   Object.assign(errorsObject, requiredData.errorsObject)
+  //   errorsFound.push('requiredData cannot create');
+  //   errorsFound = errorsFound.concat(requiredData.errorsFound);
+  // }
 
   if (errorsFound.length > 0) {
     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 = {
-
-// }
+}