@izara_project/izara-shared-search-and-sort 1.0.6 → 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.6",
+  "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,6 +35,7 @@ async function createRequiredData(
   requiredDataLinkStepObjects,
   requiredDataLinkSteps,
   values,
+  getSchemaFn
 ) {
   console.log('createRequiredData: ', {
     objType,
@@ -43,6 +44,7 @@ async function createRequiredData(
     perParentCombinations,
     requiredDataLinkStepObjects,
     values,
+    getSchemaFn
   });
 
   let errorsObject = {};
@@ -83,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,
@@ -114,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
@@ -128,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 = []
@@ -149,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);
@@ -171,6 +173,8 @@ async function createRequiredData(
         requiredDataObject[requiredDataFieldNameId] = setObject;
       };
 
+      Object.assign(linkPathObjects, { [pathId]: pathObject });
+
     } else {
       console.log("------- requiredData has only fieldName ---------");
 
@@ -287,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);
@@ -348,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;
@@ -355,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)) {
@@ -405,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);
+              }
+
+
             };
           }
 
@@ -423,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]
         }
       }
 
@@ -530,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]
         }
       }
 
@@ -552,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);
@@ -613,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);
@@ -622,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 = [];
@@ -670,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
@@ -755,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]
     }
   };
 
@@ -880,6 +924,10 @@ async function checkConditionsLink(
       };
     };
 
+    if (errorsFound.length > 0) {
+      return [null, errorsObject, errorsFound]
+    }
+
     console.log('perParentCombinations: ', {
       perParentCombinationIds,
       perParentCombinationObjects,
@@ -897,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

@@ -1152,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,9 +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-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,
@@ -593,6 +603,7 @@ async function changeObjTypePath(
   requiredObjType,
   filtersStructure,
   path = null,
+  PATHCONSTANCES = null
 ) {
   try {
     console.log('----- function validateSearchTypeFilterType -----', {
@@ -733,28 +744,33 @@ async function changeObjTypePath(
 
                       //* 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(
-                              {},  //_izContext maybe delete
-                              childLogicalElement.objType
-                            );
-                            console.log('childSchema: ', childSchema);
-
-                            if (childSchema.hasOwnProperty('extendObjType')) {
-                              if (checkObjType(requiredObjType, childSchema.extendObjType) === true) {
-                                checkChild = false;
-                                break;
+
+                      if (PATHCONSTANCES != null) {
+
+                        for (const objType of PATHCONSTANCES.objTypes) {
+                          if (checkObjType(objType, childLogicalElement.objType) === true) {
+                            if (!childLogicalElement.hasOwnProperty('childLogicalElementId')) {
+
+                              // let childSchema = await getObjectSchema.getObjSchemaS3WithCache(
+                              let childSchema = await getObjectSchema.getObjSchemaS3WithoutHierarchyV2(
+                                childLogicalElement.objType
+                              );
+                              console.log('childSchema: ', childSchema);
+
+                              if (childSchema.hasOwnProperty('extendObjType')) {
+                                if (checkObjType(requiredObjType, childSchema.extendObjType) === true) {
+                                  checkChild = false;
+                                  break;
+                                };
                               };
                             };
+                            checkChild = true;
+                            break;
                           };
-                          checkChild = true;
-                          break;
                         };
-                      };
+                      } else {
+                        checkChild = true;
+                      }
 
                       if (checkChild) {
 
@@ -888,13 +904,16 @@ async function changeObjTypePath(
     return [filterLogicalStructure, errorsObject, errorsFound];
 
   } catch (err) {
-    _izContext.logger.error('error ValidateSearchTypeFilterType: ', err)
+    console.log('error ValidateSearchTypeFilterType: ', err)
     throw (err);
   };
 
 };
 //###################################################################################################################################################################################
 
+
+
+
 function createChildComplexFilterStructure(
   logicalElements,
   previousLogicalElementId,
@@ -1141,6 +1160,8 @@ async function recursiveFindObjTypeTypePathToAnotherObjType(
 
 
 export default {
+  initSchemaFn,
+
   combineLogicalStructure,
   // combineOperation,
   // combineLogicalElements,

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,
@@ -34,7 +34,8 @@ async function createSearchRequest(
   perParentCombinations,
   requiredDataLinkStepObjects,
   requiredDataLinkSteps,
-  values
+  values,
+  getSchemaFn
 ) {
   console.log('createSearchResult: ', {
     objType,
@@ -53,6 +54,7 @@ async function createSearchRequest(
   let errorsObject = {};
   let errorsFound = [];
 
+
   let requiredDataPromise = dataFieldsSharedLib.createRequiredData(
     objType,
     requiredDataFields,
@@ -61,6 +63,7 @@ async function createSearchRequest(
     requiredDataLinkStepObjects,
     requiredDataLinkSteps,
     values,
+    getSchemaFn
   );
 
   //* create complexFilter normalize to send backend
@@ -88,6 +91,8 @@ async function createSearchRequest(
     Object.assign(errorsObject, complexErrorsObject);
   }
 
+  filterElements = complexFilterRequest.filterElements;
+
   // let requiredData = dataFieldsSharedLib.createRequiredData(
   //   objType,
   //   requiredDataFields,
@@ -100,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);
@@ -162,7 +165,7 @@ async function createSortRequest(
   requiredDataLinkStepObjects,
   requiredDataLinkSteps,
   sortFields,
-  values
+  values,
 ) {
   console.log('createSortResult: ', {
     objType,
@@ -227,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;