feat: support for multisort

Gérard Collin · Gérard Collin · commit b8eedd0ccd8e · 2026-05-17T10:47:34.000+02:00
diff --git a/libs/xt-store/projects/store/src/store-entity/store-entity-feature.ts b/libs/xt-store/projects/store/src/store-entity/store-entity-feature.ts
@@ -3,7 +3,7 @@ import {
   EntityId,
   EntityMap,
   removeEntity,
-  SelectEntityId,
+  SelectEntityId, setAllEntities,
   setEntities,
   setEntity,
   withEntities
@@ -14,7 +14,8 @@ import { finalize, firstValueFrom, lastValueFrom, map, mergeMap, Observable, of
 import { Signal } from '@angular/core';
 import { ManagedData, XtTypeResolver } from 'xt-type';
 import { XtStoreManager } from '../store-manager/xt-store-manager';
-import { XtStoreCriteria } from '../xt-store-parameters';
+import { XtSortBy, XtStoreCriteria } from '../xt-store-parameters';
+import { XtStoreProviderHelper } from '../store-provider/xt-store-provider-helper';
 
 export function selectId<T extends ManagedData=ManagedData>(): SelectEntityId<T> { return (data) => {
     if (data._id==null) throw new Error("ManagedData with no entity Id used in the store.", { cause: data });
@@ -30,9 +31,11 @@ export function xtStoreEntityConfig<T extends ManagedData=ManagedData> () {
 };
 
 
-export type StoreState = {
+export type StoreState<T extends ManagedData=ManagedData> = {
   entityName: string,
-  loading:boolean
+  loading:boolean,
+  sort?: XtSortBy<T>[],
+  filter?: XtStoreCriteria<T>[]
 };
 
 export type XtSignalStore<T> = {
@@ -72,14 +75,14 @@ export function withXtStoreProvider<T extends ManagedData = ManagedData> (entity
     withMethods ((store) => ({
       async storeEntity (toStore:T): Promise<T> {
         patchState(store, {loading:true});
-          return this.clearReferences(toStore).then((valAndRef) => {
+          return this._clearReferences(toStore).then((valAndRef) => {
             return store._storeProvider.storeEntity(entityName, valAndRef.newValue).then((stored) => {
               return { newValue: stored, references: valAndRef.references };
             });
           }).then((valAndRef) => {
-            return this.applyReferences(valAndRef.newValue, valAndRef.references);
+            return this._applyReferences(valAndRef.newValue, valAndRef.references);
           }).then((stored) => {
-          patchState(store, setEntity(stored, store._entityConfig));
+            this._patchStateSetEntity (stored);
           return stored;
         }).finally(() => {
           patchState(store, {loading:false});
@@ -89,7 +92,7 @@ export function withXtStoreProvider<T extends ManagedData = ManagedData> (entity
       fetchEntities (): Promise<void> {
         patchState(store, {loading:true});
         return lastValueFrom(store._storeProvider.searchEntities(entityName).pipe ( mergeMap((entities:T[]) => {
-          return this.resolveReferences(entities);
+          return this._resolveReferences(entities);
         }),map( (entities: T[]) => {
           patchState(store, setEntities (entities, store._entityConfig));
         }),finalize(() => {
@@ -111,7 +114,7 @@ export function withXtStoreProvider<T extends ManagedData = ManagedData> (entity
         patchState(store, {loading:true});
         return store._storeProvider.loadEntity(entityName, id).then((loaded) => {
           if (loaded != null)
-            return this.resolveReferences([loaded]).then((results) => results[0]);
+            return this._resolveReferences([loaded]).then((results) => results[0]);
           return loaded;
         }).then ( (loaded)=> {
           if( loaded != null)
@@ -149,17 +152,11 @@ export function withXtStoreProvider<T extends ManagedData = ManagedData> (entity
         patchState(store, { loading: true });
         try {
           const listEntities = store.entities();
-          let toAdd=true;
           const ret = new Array<T>();
           for (const entity of listEntities) {
-            toAdd=true;
-            for (const crit of criteria) {
-              if (!crit.filter(entity)) {
-                toAdd=false;
-                break;
-              }
+            if (!this._isFiltered(entity, criteria)){
+                ret.push(entity);
             }
-            if (toAdd) ret.push(entity);
           }
           return of(ret);
         } finally {
@@ -171,7 +168,7 @@ export function withXtStoreProvider<T extends ManagedData = ManagedData> (entity
        * Detects and replace all referenced objects by the key value that will be stored.
        * @param toClear
        */
-      async clearReferences(toClear: T): Promise<{ newValue: T, references: any }> {
+      async _clearReferences(toClear: T): Promise<{ newValue: T, references: any }> {
         if( typeRegistry==null) return  { newValue:toClear, references:{}};
 
         const refs = typeRegistry.listReferences(entityName);
@@ -190,7 +187,7 @@ export function withXtStoreProvider<T extends ManagedData = ManagedData> (entity
        * From the key values, assign the relevant referenced object so that it's transparent to the caller
        * @param values
        */
-      async resolveReferences(values: T[]): Promise<T[]> {
+      async _resolveReferences(values: T[]): Promise<T[]> {
         if ((typeRegistry==null)||(storeMgr==null)) return values;
 
         const refs = typeRegistry.listReferences(entityName);
@@ -217,11 +214,60 @@ export function withXtStoreProvider<T extends ManagedData = ManagedData> (entity
        * @param newValue
        * @param references
        */
-      async applyReferences(newValue: T, references: ManagedData): Promise<T> {
+      async _applyReferences(newValue: T, references: ManagedData): Promise<T> {
         if (references != null) {
           // Override the values with the references
           return { ...newValue, ...references } as T;
         } else return newValue;
+      },
+
+      _patchStateSetEntity (stored:T) {
+        // Ensure the entity is still part of the list
+        if (this._isFiltered (stored)==false) {
+          // It's still in the list, now check if sort needs to be applied
+          if (this._safeSort().length>0) {
+              // We remove it from the old sort
+            if (stored._id!=null)
+              patchState(store, removeEntity (stored._id));
+
+              // And find it's right position
+            const newList = XtStoreProviderHelper.insertInSortedList(stored, store.entities(), this._safeSort());
+            patchState (store, setAllEntities (newList, store._entityConfig));
+          } else {
+            patchState(store, setEntity(stored, store._entityConfig));
+          }
+        } else {
+          // Maybe it was in the list and it is no more due to the modification. Let's make sure by removing it
+          if (stored._id!=null)
+            patchState(store, removeEntity (stored._id));
+        }
+
+      },
+      _isFiltered (element:T, criteria?:XtStoreCriteria<T>[]):boolean {
+        if (criteria===undefined) {
+          criteria=this._safeFilter();
+        }
+        for (const crit of criteria) {
+          if (crit.filter(element)) {
+            return true;
+          }
+
+        }
+        return false;
+      },
+      _safeFilter (): XtStoreCriteria<T>[] {
+        const ret=store.filter?store.filter():null;
+        if ((ret!=null) && (ret.length>0)) {
+          return ret;
+        }
+        return [];
+      },
+      _safeSort (): XtSortBy<T>[] {
+        const ret=store.sort?store.sort():null;
+        if ((ret!=null) && (ret.length>0)) {
+          return ret;
+        }
+        return [];
       }
     })
   )
diff --git a/libs/xt-store/projects/store/src/store-provider/xt-store-provider-helper.spec.ts b/libs/xt-store/projects/store/src/store-provider/xt-store-provider-helper.spec.ts
@@ -1,6 +1,6 @@
 import {XtStoreProviderHelper} from './xt-store-provider-helper';
 import { XtStoreGroupByAggregate, XtStoreGroupBy } from '../xt-reporting';
-import { XtGroupByOperation } from '../xt-store-parameters';
+import { XtGroupByOperation, XtSortByDirection } from '../xt-store-parameters';
 import { ManagedData, ManagedDataHandler, SpecialFields, xtTypeManager } from 'xt-type';
 import { describe, expect, it } from 'vitest';
 
@@ -236,5 +236,80 @@ describe('Store Provider Helper', () => {
       }
     }
   )
+
+  it ('should support simple sorting correctly', () => {
+    const testArray=[{
+      name: 'cTest',
+      value: 4,
+      date: new Date (1970,10,5)
+    },{
+      name:'aTest',
+      value:1,
+      date: new Date(1960, 5,10)
+    },{
+      name:'bTest',
+      value: 10,
+      date: new Date(2010,8,4)
+    }];
+
+    const byNameSort = XtStoreProviderHelper.multiSortArray([...testArray], [{
+      by:'name',
+      direction:XtSortByDirection.Ascending
+    }]);
+
+    expect(byNameSort.map((val)=> val.name)).toEqual(['aTest','bTest', 'cTest']);
+
+    const byValueSort= XtStoreProviderHelper.multiSortArray([...testArray], [{
+      by:'value',
+      direction:XtSortByDirection.Descending
+    }]);
+
+    expect(byValueSort.map((val)=> val.value)).toEqual([10,4, 1]);
+
+    const byDateSort= XtStoreProviderHelper.multiSortArray([...testArray], [{
+      by:'date',
+      direction:XtSortByDirection.None
+    }]);
+
+    expect(byDateSort.map((val)=> val.date)).toEqual([testArray[1].date, testArray[0].date, testArray[2].date]);
+
+    const byMultipleValueSort= XtStoreProviderHelper.multiSortArray([...testArray], [{
+      by:'value',
+      direction:XtSortByDirection.Descending
+    }, {
+      by:'name',
+      direction:XtSortByDirection.Ascending
+    }]);
+
+    expect(byMultipleValueSort.map((val)=> val.value)).toEqual([10,4, 1]);
+  })
+
+
+    it ('should support multiple sort correctly', () => {
+      const testArray=[{
+        name: 'cTest',
+        value: 4,
+        date: new Date (1970,10,5)
+      },{
+        name:'aTest',
+        value:1,
+        date: new Date(1960, 5,10)
+      },{
+        name:'cTest',
+        value: 10,
+        date: new Date(2010,8,4)
+      }];
+
+      const byNameSort = XtStoreProviderHelper.multiSortArray([...testArray], [{
+        by:'name',
+        direction:XtSortByDirection.Descending
+      }, {
+        by:'value',
+        direction:XtSortByDirection.Ascending
+      }]);
+
+      expect(byNameSort.map((val)=> val.name+val.value)).toEqual(['cTest4','cTest10', 'aTest1']);
+
+    })
   }
 );
diff --git a/libs/xt-store/projects/store/src/store-provider/xt-store-provider-helper.ts b/libs/xt-store/projects/store/src/store-provider/xt-store-provider-helper.ts
@@ -1,5 +1,12 @@
 import { Counters, ManagedData, XtTypeHandler, xtTypeManager } from 'xt-type';
-import { XtGroupBy, XtGroupByAggregate, XtGroupByOperation, XtSortBy, XtStoreCriteria } from '../xt-store-parameters';
+import {
+  XtGroupBy,
+  XtGroupByAggregate,
+  XtGroupByOperation,
+  XtSortBy,
+  XtSortByDirection,
+  XtStoreCriteria
+} from '../xt-store-parameters';
 
 /**
  * Helps handle metadata information about loaded items
@@ -121,10 +128,52 @@ export class XtStoreProviderHelper {
    * @param toSort
    * @param sortOptions
    */
-  static multiSortArray<T>(toSort: T[], sortOptions?: XtSortBy<T>): T[] {
+  static multiSortArray<T>(toSort: T[], sortOptions?: XtSortBy<T>[]): T[] {
     if( sortOptions==null)
       return toSort;
-    return toSort;
+    return toSort.sort(this.compareFunction(sortOptions));
+  }
+
+  /**
+   * Quickly insert an element in an already sorted list
+   * @param toInsert
+   * @param list
+   * @param sortOptions
+   */
+  static insertInSortedList<T>(toInsert: T, list:T[], sortOptions?:XtSortBy<T>[]): T[] {
+    if ((sortOptions==null) || (sortOptions.length==0)) {
+      list.push(toInsert);
+      return list;
+    } else {
+      const compareFunction=this.compareFunction(sortOptions);
+      for (let index=0;index<list.length;index++) {
+        if (list[index]>toInsert) {
+          return list.splice(index, 0, toInsert);
+        }
+      }
+      list.push(toInsert);
+      return list;
+    }
+  }
+
+  /**
+   * Returns a compare function based on the sort options given
+   * @param sortOptions
+   */
+  static compareFunction<T> (sortOptions:XtSortBy<T>[]): (a:T, b:T) => number {
+    return (a:T, b:T):number => {
+      for (const sortOption of sortOptions) {
+        const aVal=a[sortOption.by];
+        const bVal=b[sortOption.by];
+        let factor=1;
+        if (sortOption.direction==XtSortByDirection.Descending) factor=-1;
+        if (aVal < bVal) return -1*factor;
+        if (aVal > bVal) return 1*factor;
+        // If aVal == bVal, then it will loop to the lower sort
+      }
+        // Couldn't find any difference, then let's say they are equals
+      return 0;
+    }
   }
 
   /**
diff --git a/libs/xt-store/projects/store/src/store-provider/xt-store-provider.ts b/libs/xt-store/projects/store/src/store-provider/xt-store-provider.ts
@@ -111,7 +111,11 @@ export abstract class AbstractXtStoreProvider<T extends ManagedData = ManagedDat
       map (value => {
         let groupedByValues:DontCodeStoreGroupedByEntities<T>|undefined;
         if((sort!=null) || (groupBy?.atLeastOneGroupIsRequested()===true)) {
-          value = XtStoreProviderHelper.multiSortArray(value, this.calculateSortHierarchy(sort, groupBy)) as T[];
+          if (sort!=null) {
+            const sortHierarchy=this.calculateSortHierarchy(sort, groupBy);
+            if (sortHierarchy!=null)
+              value = XtStoreProviderHelper.multiSortArray(value, [sortHierarchy]) as T[];
+          }
           if (groupBy!=null) {
             groupedByValues = XtStoreProviderHelper.calculateGroupedByValues(name, value, groupBy);
           }
