feat: allow to keep channels in certain matching paginators and not in other matching paginators

Author: MartinCupela

src/ChannelPaginatorsOrchestrator.ts

@@ -294,6 +294,8 @@ export class ChannelPaginatorsOrchestrator extends WithSubscriptions {
     EventHandlerPipeline<EventHandlerContext>
   >();
   protected ownershipResolver?: PaginatorOwnershipResolver;
+  /** Track paginators already wrapped with ownership-aware filtering */
+  protected _wrappedForOwnership = new WeakSet<ChannelPaginator>();
 
   protected static readonly defaultEventHandlers: ChannelPaginatorsOrchestratorEventHandlers =
     {
@@ -330,6 +332,8 @@ export class ChannelPaginatorsOrchestrator extends WithSubscriptions {
     for (const [type, handlers] of Object.entries(finalEventHandlers)) {
       if (handlers) this.ensurePipeline(type).replaceAll(handlers);
     }
+    // Ensure ownership rules are applied to initial paginators' query results
+    this.paginators.forEach((p) => this.wrapPaginatorFiltering(p));
   }
 
   get paginators(): ChannelPaginator[] {
@@ -369,6 +373,46 @@ export class ChannelPaginatorsOrchestrator extends WithSubscriptions {
     return new Set(this.ownershipResolver?.({ channel, matchingPaginators }) ?? []);
   }
 
+  /**
+   * Filter a page of query results for a specific paginator according to ownership rules.
+   * If no owners are specified by the resolver, all matching paginators keep the item.
+   */
+  protected filterItemsByOwnership({
+    paginator,
+    items,
+  }: {
+    paginator: ChannelPaginator;
+    items: Channel[];
+  }): Channel[] {
+    if (!items.length) return items;
+    const result: Channel[] = [];
+    for (const ch of items) {
+      const matchingPaginators = this.paginators.filter((p) => p.matchesFilter(ch));
+      const ownerIds = this.resolveOwnership(ch, matchingPaginators);
+      const noOwnersOrPaginatorIsOwner =
+        ownerIds.size === 0 || ownerIds.has(paginator.id);
+
+      if (noOwnersOrPaginatorIsOwner) {
+        result.push(ch);
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Wrap paginator.filterQueryResults so that ownership rules are applied whenever
+   * the paginator ingests results from a server query (first page and subsequent pages).
+   */
+  protected wrapPaginatorFiltering(paginator: ChannelPaginator) {
+    if (this._wrappedForOwnership.has(paginator)) return;
+    const original = paginator.filterQueryResults.bind(paginator);
+    paginator.filterQueryResults = (items: Channel[]) => {
+      const filtered = original(items) as Channel[];
+      return this.filterItemsByOwnership({ paginator, items: filtered });
+    };
+    this._wrappedForOwnership.add(paginator);
+  }
+
   getPaginatorById(id: string) {
     return this.paginators.find((p) => p.id === id);
   }
@@ -392,6 +436,8 @@ export class ChannelPaginatorsOrchestrator extends WithSubscriptions {
     );
     paginators.splice(validIndex, 0, paginator);
     this.state.partialNext({ paginators });
+    // Wrap newly inserted paginator to enforce ownership on query results
+    this.wrapPaginatorFiltering(paginator);
   }
 
   addEventHandler({

src/pagination/ChannelPaginator.ts

@@ -99,7 +99,11 @@ const hasUnreadFilterResolver: FieldToDataResolver<Channel> = {
   matchesField: (field) => field === 'has_unread',
   resolve: (channel) => {
     const ownUserId = channel.getClient().user?.id;
-    return ownUserId && channel.state.read[ownUserId].unread_messages > 0;
+    return (
+      ownUserId &&
+      channel.state.read[ownUserId] &&
+      channel.state.read[ownUserId].unread_messages > 0
+    );
   },
 };
 

test/unit/ChannelPaginatorsOrchestrator.test.ts

@@ -165,6 +165,51 @@ describe('ChannelPaginatorsOrchestrator', () => {
         expect(p3.items).toBeUndefined();
       });
     });
+
+    it('applies ownership rules to paginators when they paginate', async () => {
+      const ch1 = makeChannel('messaging:101');
+      const ch2 = makeChannel('messaging:102');
+      const queryChannelSpy = vi.spyOn(client, 'queryChannels').mockResolvedValue([ch1]);
+      const p1 = new ChannelPaginator({
+        client,
+        filters: { type: 'messaging' },
+        id: 'p1',
+        paginatorOptions: { pageSize: 1 },
+      });
+      const p2 = new ChannelPaginator({
+        client,
+        filters: { type: 'messaging' },
+        id: 'p2',
+        paginatorOptions: { pageSize: 1 },
+      });
+      new ChannelPaginatorsOrchestrator({
+        client,
+        paginators: [p1, p2],
+        ownershipResolver: [p2.id],
+      });
+
+      await Promise.all([p1, p2].map((p) => p.next()));
+
+      await vi.waitFor(() => {
+        expect(p1.items).toHaveLength(0);
+        // even though ownership claimed by p2, it is still possible to request next page.
+        expect(p1.hasNext).toBe(true);
+        expect(p2.items).toHaveLength(1);
+        expect(p2.items).toStrictEqual([ch1]);
+        expect(p2.hasNext).toBe(true);
+      });
+
+      queryChannelSpy.mockResolvedValue([ch2]);
+      await Promise.all([p1, p2].map((p) => p.next()));
+
+      await vi.waitFor(() => {
+        expect(p1.items).toHaveLength(0);
+        expect(p1.hasNext).toBe(true);
+        expect(p2.items).toHaveLength(2);
+        expect(p2.items).toStrictEqual([ch1, ch2]);
+        expect(p2.hasNext).toBe(true);
+      });
+    });
   });
 
   describe('constructor', () => {