fix: working signalstore sort & filter

Author: Gérard Collin

libs/xt-store/projects/store/src/store-entity/store-entity-feature.spec.ts

@@ -8,7 +8,7 @@ import { withXtStoreProvider, XtSignalStore } from './store-entity-feature';
 import { XtMemoryStoreProvider } from '../store-provider/xt-memory-store-provider';
 import { ManagedData, xtTypeManager } from 'xt-type';
 import { StoreTestBed } from '../test/store-test-bed';
-import { XtStoreCriteria } from '../xt-store-parameters';
+import { XtSortByDirection, XtStoreCriteria } from '../xt-store-parameters';
 import { firstValueFrom } from 'rxjs';
 
 describe('StoreEntityFeature', () => {
@@ -153,6 +153,116 @@ describe('StoreEntityFeature', () => {
     expect(loadedProvenanceBook.author._id).toEqual(annLeckieAuthor._id);
   });
 
+  it('should support sorted & filtered store', async () => {
+    StoreTestBed.ensureMemoryProviderOnly();
+    const typeMgr = xtTypeManager();
+    typeMgr.addRootType('AuthorType2', {
+      name: 'string',
+      birthDate: 'date',
+      birthCity: 'string'
+    });
+    typeMgr.addRootType('BookType2', {
+      children: {
+        title: 'string',
+        author: {
+          toType: 'AuthorType2',
+          field: 'name',
+          referenceType: 'MANY-TO-ONE'
+        },
+        genre: 'string',
+        cost: 'number'
+      }
+    });
+
+    const storeMgr = xtStoreManager();
+
+    const philipKDickAuthor = await storeMgr.getProviderSafe<AuthorType>('AuthorType2').storeEntity('AuthorType2', {
+      name: 'Philip K. Dick',
+      birthCity: 'Chicago',
+      birthDate: new Date(1928, 12, 16)
+    });
+
+    const annLeckieAuthor = await storeMgr.getProviderSafe<AuthorType>('AuthorType2').storeEntity('AuthorType2', {
+      name: 'Ann Leckie',
+      birthCity: 'Toledo',
+      birthDate: new Date(1966, 3, 2)
+
+    });
+
+    await storeMgr.getProviderSafe<StoredBookType2>('BookType2').storeEntity('BookType2', {
+      title: 'Ubik',
+      author: 'Philip K. Dick',
+      genre: 'SF',
+      cost:50
+    });
+
+    await storeMgr.getProviderSafe<StoredBookType2>('BookType2').storeEntity('BookType2', {
+      title: 'Ancillaire',
+      author: 'Ann Leckie',
+      genre: 'Space Opera',
+      cost:70
+    });
+
+    await storeMgr.getProviderSafe<StoredBookType2>('BookType2').storeEntity('BookType2', {
+      title: 'Sheep',
+      author: 'Philip K. Dick',
+      genre: 'SF',
+      cost:40
+    });
+
+    // Let's try first the simple sort / filter
+    const storeType = signalStore(withXtStoreProvider<BookType2>("BookType2", undefined, storeMgr, typeMgr, {
+      sort: [{
+        by: 'title',
+        direction:XtSortByDirection.Ascending
+      } ],
+      filter: [new XtStoreCriteria('genre', 'SF', '=')
+      ]
+    }));
+    const store = new storeType() as unknown as XtSignalStore<BookType2>;
+    await store.fetchEntities();
+    let result = store.entities();
+    expect(result.length).toEqual(2);
+    expect(result[0].title).toEqual('Sheep');
+
+    // Now adds an item, and ensure it is put at the right place, and genre is automatically filled
+    let added = await store.storeEntity({
+        title: 'Tad Book',
+        author: annLeckieAuthor,
+        cost: 40
+      } as BookType2);
+    expect(added.genre).toBe('SF');
+    result = store.entities();
+    expect(result.length).toEqual(3);
+    expect(result[1].title).toEqual(added.title);
+
+    let error=false;
+    // Storing an entity that doesn't match the filter should not update the list
+      const notAdded = await store.storeEntity({
+        title: 'Tad Book',
+        author: annLeckieAuthor,
+        cost: 40,
+        genre:'NotGood'
+      });
+    result = store.entities();
+    expect(result).toHaveLength(3);
+
+    // Updating an element should re-trigger sort
+    added.title='Aaaa';
+    const addedId=added._id;
+    added = await store.storeEntity(added);
+    expect(added._id).toBe(addedId);
+    result = store.entities();
+    expect(result.map(val => val.title)).toEqual(['Aaaa', 'Sheep', 'Ubik']);
+
+    // If the updated element is not in the filter anymore, it should be removed from the list
+    added.genre='Other';
+    added = await store.storeEntity(added);
+    result = store.entities();
+    expect(result.length).toBe(2);
+    expect(result.map(val => val.title)).toEqual(['Sheep', 'Ubik']);
+
+  });
 });
 
 type AuthorType=ManagedData&{
@@ -167,8 +277,16 @@ type BookType =ManagedData&{
   genre:string
 }
 
+type BookType2 = BookType & {
+  cost:number
+}
+
 type StoredBookType =ManagedData&{
   title:string,
   author:string,
   genre:string
 }
+
+type StoredBookType2 = StoredBookType & {
+  cost:number
+}

libs/xt-store/projects/store/src/store-entity/store-entity-feature.ts

@@ -16,6 +16,7 @@ import { ManagedData, XtTypeResolver } from 'xt-type';
 import { XtStoreManager } from '../store-manager/xt-store-manager';
 import { XtSortBy, XtStoreCriteria } from '../xt-store-parameters';
 import { XtStoreProviderHelper } from '../store-provider/xt-store-provider-helper';
+import { XtStoreSortBy } from '../xt-reporting';
 
 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 });
@@ -62,9 +63,9 @@ export type XtSignalStore<T> = {
  * @param storeMgr
  * @param typeRegistry
  */
-export function withXtStoreProvider<T extends ManagedData = ManagedData> (entityName:string, storeProvider?:XtStoreProvider<T>, storeMgr?:XtStoreManager, typeRegistry?: XtTypeResolver) {
+export function withXtStoreProvider<T extends ManagedData = ManagedData> (entityName:string, storeProvider?:XtStoreProvider<T>, storeMgr?:XtStoreManager, typeRegistry?: XtTypeResolver, options?: XtStoreEntityFeatureOptions) {
   return signalStoreFeature(
-    withState ({ entityName, loading:false} as StoreState),
+    withState ({ entityName, loading:false, sort:options?.sort, filter:options?.filter} as StoreState),
     withEntities(xtStoreEntityConfig<T> ()),
     withProps ( () => ({
       _storeProvider:storeProvider??storeMgr!.getProviderSafe<T>(entityName),
@@ -100,21 +101,6 @@ export function withXtStoreProvider<T extends ManagedData = ManagedData> (entity
         })));
       },
 
-      _callProviderSearchEntities ():Observable<T[]> {
-        const sort=this._safeSort();
-        if( sort.length>0) {
-            // We call the full function but only needs the sorted & filtered data (no need for grouping)
-          return store._storeProvider.searchAndPrepareEntities(entityName, this._safeSort(),undefined,undefined,...this._safeFilter()).pipe(
-            map((value) => {
-              return value.sortedData;
-            })
-          )
-        } else {
-            // If we don't need sorting, then a simpler function can be called
-          return store._storeProvider.searchEntities(entityName, ...this._safeFilter());
-        }
-      },
-
     /*  listEntities (): Observable<ManagedData[]> {
         patchState(store, {loading:true});
         return store._storeProvider.searchEntities(entityName).pipe (map( (entities: ManagedData[]) => {
@@ -169,7 +155,7 @@ export function withXtStoreProvider<T extends ManagedData = ManagedData> (entity
           const listEntities = store.entities();
           const ret = new Array<T>();
           for (const entity of listEntities) {
-            if (this._isPassingFilter(entity, criteria)){
+            if (this._isPassingFilter(entity, false, criteria)){
                 ret.push(entity);
             }
           }
@@ -238,7 +224,7 @@ export function withXtStoreProvider<T extends ManagedData = ManagedData> (entity
 
       _patchStateSetEntity (stored:T) {
         // Ensure the entity is still part of the list
-        if (this._isPassingFilter (stored)) {
+        if (this._isPassingFilter (stored, true)) {
           // 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
@@ -258,15 +244,20 @@ export function withXtStoreProvider<T extends ManagedData = ManagedData> (entity
         }
 
       },
-      _isPassingFilter (element:T, criteria?:XtStoreCriteria<T>[]):boolean {
+      _isPassingFilter (element:T, applyFilters:boolean=false, criteria?:XtStoreCriteria<T>[]):boolean {
         if (criteria===undefined) {
           criteria=this._safeFilter();
         }
         for (const crit of criteria) {
           if (!crit.filter(element)) {
-            return false;
+            // One filter is not met, but we may be allowed to set it automatically
+            if ((applyFilters)&& (crit.operator=='=') && (element[crit.name]==null)) {
+              // We enforce the criteria
+              element[crit.name]=crit.value;
+            }else {
+              return false;
+            }
           }
-
         }
         return true;
       },
@@ -283,8 +274,27 @@ export function withXtStoreProvider<T extends ManagedData = ManagedData> (entity
           return ret;
         }
         return [];
+      },
+      _callProviderSearchEntities ():Observable<T[]> {
+        const sort=this._safeSort();
+        if( sort.length>0) {
+          // We call the full function but only needs the sorted & filtered data (no need for grouping)
+          return store._storeProvider.searchAndPrepareEntities(entityName, this._safeSort(),undefined,undefined,...this._safeFilter()).pipe(
+            map((value) => {
+              return value.sortedData;
+            })
+          )
+        } else {
+          // If we don't need sorting, then a simpler function can be called
+          return store._storeProvider.searchEntities(entityName, ...this._safeFilter());
+        }
       }
     })
   )
 );
 }
+
+export type XtStoreEntityFeatureOptions<T extends ManagedData=ManagedData>= {
+  sort?:XtSortBy<T>[];
+  filter?:XtStoreCriteria<T>[];
+}