@amityco/ts-sdk-react-native 6.14.2-5d7d534.0 → 6.15.1-fee6c8f.0

package/src/analytic/service/analytic/AnalyticsEventSyncer.ts

@@ -1,18 +1,24 @@
 import { pullFromCache } from '~/cache/api/pullFromCache';
 import { dropFromCache } from '~/cache/api/dropFromCache';
-import { MINUTE } from '~/utils/constants';
-import { ANALYTIC_CACHE_KEY } from '../../constant';
+import { MINUTE, SECOND } from '~/utils/constants';
+import { ANALYTIC_CACHE_KEY, HIGH_PRIORITY_ANALYTIC_CACHE_KEY } from '../../constant';
 import { syncEvent } from '../../api/syncEvent';
 
 export class AnalyticsEventSyncer {
   _timer: NodeJS.Timeout | undefined = undefined;
 
+  _high_priority_timer: NodeJS.Timeout | undefined = undefined;
+
   start() {
     this.syncCapturedEvent();
 
     this._timer = setInterval(() => {
       this.syncCapturedEvent();
     }, 1 * MINUTE);
+
+    this._high_priority_timer = setInterval(() => {
+      this.syncHighPriorityCapturedEvent();
+    }, 10 * SECOND);
   }
 
   stop() {
@@ -23,10 +29,10 @@ export class AnalyticsEventSyncer {
 
   async syncCapturedEvent() {
     try {
-      // Must query only objects that has same userId with current logged-in user.
+      // Must query only objects that have same userId with current logged-in user.
       // Query captured event with maximum of 1000
       // Order by latest first
-      // e.g. If there is 2000 events we will query 1000-2000 first
+      // e.g., If there are 2000 events we will query 1000-2000 first
       const cache = pullFromCache<{ event: Amity.AnalyticEventModel[] }>(ANALYTIC_CACHE_KEY);
       if (!cache?.data) return;
       if (cache.data.event.length === 0) return;
@@ -42,4 +48,28 @@ export class AnalyticsEventSyncer {
       dropFromCache(ANALYTIC_CACHE_KEY);
     }
   }
+
+  async syncHighPriorityCapturedEvent() {
+    try {
+      // Must query only objects that have same userId with current logged-in user.
+      // Query captured event with maximum of 1000
+      // Order by latest first
+      // e.g., If there are 2000 events we will query 1000-2000 first
+      const cache = pullFromCache<{ event: Amity.AnalyticEventModel[] }>(
+        HIGH_PRIORITY_ANALYTIC_CACHE_KEY,
+      );
+      if (!cache?.data) return;
+      if (cache.data.event.length === 0) return;
+
+      const capturedEvents = cache.data.event;
+
+      await syncEvent(capturedEvents);
+
+      dropFromCache(HIGH_PRIORITY_ANALYTIC_CACHE_KEY);
+    } catch (error) {
+      // stop and destroy all events
+      this.stop();
+      dropFromCache(HIGH_PRIORITY_ANALYTIC_CACHE_KEY);
+    }
+  }
 }

package/src/categoryRepository/internalApi/queryCategories.ts

@@ -1,6 +1,6 @@
 import { getActiveClient } from '~/client/api/activeClient';
 
-import { toToken, toPage } from '~/core/query';
+import { toPage } from '~/core/query';
 
 import { pullFromCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
@@ -10,11 +10,18 @@ import { inferIsDeleted } from '~/utils/inferIsDeleted';
 
 export const queryCategories = async (
   query?: Amity.QueryCategories,
-): Promise<Amity.Cached<Amity.Paged<Amity.InternalCategory, Amity.Page>>> => {
+): Promise<Amity.Cached<Amity.PageToken<Amity.InternalCategory>>> => {
   const client = getActiveClient();
   client.log('category/queryCategories', query);
 
-  const { page = { limit: 10 }, includeDeleted, ...params } = query ?? {};
+  const { page, limit, includeDeleted, ...params } = query ?? {};
+
+  const options = (() => {
+    if (page) return { token: page };
+    if (limit) return { limit };
+
+    return undefined;
+  })();
 
   const { data } = await client.http.get<Amity.CategoryPayload & Amity.Pagination>(
     `/api/v3/community-categories`,
@@ -22,9 +29,7 @@ export const queryCategories = async (
       params: {
         ...params,
         isDeleted: inferIsDeleted(includeDeleted),
-        options: {
-          token: toToken(page, 'skiplimit'),
-        },
+        options,
       },
     },
   );
@@ -40,33 +45,36 @@ export const queryCategories = async (
     const cacheKey = [
       'category',
       'query',
-      { ...params, includeDeleted, options: { ...page } } as Amity.Serializable,
+      { ...params, includeDeleted, options } as Amity.Serializable,
     ];
     pushToCache(cacheKey, { categories: categories.map(getResolver('category')), paging });
   }
 
-  const nextPage = toPage(paging.next);
-  const prevPage = toPage(paging.previous);
-
   return {
     data: categories,
     cachedAt,
-    prevPage,
-    nextPage,
+    paging,
   };
 };
 
 queryCategories.locally = (
   query: Parameters<typeof queryCategories>[0],
-): Amity.Cached<Amity.Paged<Amity.InternalCategory, Amity.Page>> | undefined => {
+): Amity.Cached<Amity.PageToken<Amity.InternalCategory>> | undefined => {
   const client = getActiveClient();
   client.log('category/queryCategories.locally', query);
 
   if (!client.cache) return;
 
-  const { page = { limit: 10 }, ...params } = query ?? {};
+  const { page, limit = 10, ...params } = query ?? {};
+
+  const options = (() => {
+    if (page) return { token: page };
+    if (limit) return { limit };
+
+    return undefined;
+  })();
 
-  const queryKey = ['category', 'query', { ...params, options: { ...page } } as Amity.Serializable];
+  const queryKey = ['category', 'query', { ...params, options } as Amity.Serializable];
   const { data, cachedAt } =
     pullFromCache<{ categories: Pick<Amity.InternalCategory, 'categoryId'>[] } & Amity.Pagination>(
       queryKey,
@@ -79,10 +87,9 @@ queryCategories.locally = (
     .filter(Boolean)
     .map(({ data }) => data);
 
-  const prevPage = toPage(data?.paging.previous);
-  const nextPage = toPage(data?.paging.next);
+  const { paging } = data;
 
   return categories.length === data?.categories?.length
-    ? { data: categories, cachedAt, prevPage, nextPage }
+    ? { data: categories, cachedAt, paging }
     : undefined;
 };

package/src/categoryRepository/observers/getCategories.ts

@@ -109,16 +109,17 @@ export const getCategories = (
 
     const query = createQuery(queryCategories, {
       ...queryParams,
-      page: (!initial ? collection?.params.page : undefined) ?? { limit },
+      limit: initial ? limit : undefined,
+      page: !initial ? collection?.params.page : undefined,
     });
 
     runQuery(
       query,
-      ({ data: result, error, loading, nextPage: page }) => {
+      ({ data: result, error, loading, paging }) => {
         const data = {
           loading,
           error,
-          params: { page },
+          params: { page: paging?.next },
           data: categories,
         };
 

package/src/channelRepository/api/createChannel.ts

@@ -24,7 +24,7 @@ import { prepareChannelPayload } from '../utils';
 export const createChannel = async <T extends Amity.ChannelType>(
   bundle: { type: T; userIds?: Amity.InternalUser['userId'][] } & Pick<
     Amity.Channel<T>,
-    'displayName' | 'avatarFileId' | 'tags' | 'metadata'
+    'displayName' | 'avatarFileId' | 'tags' | 'metadata' | 'isPublic'
   >,
 ): Promise<Amity.Cached<Amity.InternalChannel>> => {
   const client = getActiveClient();
@@ -38,9 +38,13 @@ export const createChannel = async <T extends Amity.ChannelType>(
       isDistinct: true,
     });
   } else {
-    payload = await client.http.post<Amity.ChannelPayload>('/api/v3/channels', bundle);
-  }
+    const { isPublic, ...restParams } = bundle;
 
+    payload = await client.http.post<Amity.ChannelPayload>('/api/v3/channels', {
+      ...restParams,
+      isPublic: bundle?.type === 'community' ? isPublic : undefined,
+    });
+  }
   const data = await prepareChannelPayload(payload.data);
 
   const cachedAt = client.cache && Date.now();

package/src/channelRepository/channelMembership/observers/getMembers.ts

@@ -1,32 +1,14 @@
 /* eslint-disable no-use-before-define */
-import { getResolver } from '~/core/model';
-import { pullFromCache, pushToCache } from '~/cache/api';
 import { getActiveClient } from '~/client/api';
 import {
-  createQuery,
   filterByPropIntersection,
   filterBySearchTerm,
-  queryOptions,
-  runQuery,
   sortByFirstCreated,
   sortByLastCreated,
 } from '~/core/query';
-import {
-  COLLECTION_DEFAULT_CACHING_POLICY,
-  COLLECTION_DEFAULT_PAGINATION_LIMIT,
-  ENABLE_CACHE_MESSAGE,
-} from '~/utils/constants';
-import {
-  onChannelJoined,
-  onChannelLeft,
-  onChannelMemberAdded,
-  onChannelMemberBanned,
-  onChannelMemberRemoved,
-  onChannelMemberRoleAdded,
-  onChannelMemberRoleRemoved,
-  onChannelMemberUnbanned,
-} from '../../events';
-import { queryChannelMembers } from '../api/queryChannelMembers';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { ChannelMemberLiveCollectionController } from './liveCollection/ChannelMemberLiveCollectionController';
+import { dropFromCache } from '~/cache/api';
 
 /*
  * Exported for testing
@@ -109,110 +91,14 @@ export const getMembers = (
   const timestamp = Date.now();
   log(`getMembers(tmpid: ${timestamp}) > listen`);
 
-  const { limit: queryLimit, ...queryParams } = params;
-
-  const limit = queryLimit ?? COLLECTION_DEFAULT_PAGINATION_LIMIT;
-  const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
-
-  const disposers: Amity.Unsubscriber[] = [];
-
-  // Put all overlap field to unknown type before convert again to Amity.Serializable
-  const cacheKey = ['channelUsers', 'collection', queryParams as unknown as Amity.Serializable];
-  const cacheByChannelKey = ['channelUsers', 'collection', { channelId: queryParams.channelId }];
-
-  const responder = (data: Amity.ChannelMembersLiveCollectionCache, isEventModel = false) => {
-    const channelMembers: Amity.Membership<'channel'>[] =
-      data.data
-        .map(id => pullFromCache<Amity.Membership<'channel'>>(['channelUsers', 'get', id])!)
-        .filter(Boolean)
-        .map(({ data }) => data) ?? [];
-
-    callback({
-      onNextPage: onFetch,
-      /*
-       * Only apply filter to RTE Model
-       */
-      data: isEventModel ? applyFilter(channelMembers, params) : channelMembers,
-      hasNextPage: !!data.params?.page,
-      loading: data.loading,
-      error: data.error,
-    });
-  };
-
-  const realtimeRouter =
-    (action: Amity.ChannelMemberActionType) =>
-    (channel: Amity.InternalChannel, channelMember: Amity.Membership<'channel'>) => {
-      if (params.channelId !== channelMember.channelId) {
-        return;
-      }
-
-      const collection = pullFromCache<Amity.ChannelMembersLiveCollectionCache>(cacheKey)?.data;
-      if (!collection) return;
-
-      const channelMemberCacheId = getResolver('channelUsers')({
-        channelId: params.channelId,
-        userId: channelMember.userId,
-      });
-
-      if (channelMember.membership === 'none') {
-        collection.data = collection.data.filter(m => m !== channelMemberCacheId);
-      } else if (!collection.data.includes(channelMemberCacheId)) {
-        collection.data = [channelMemberCacheId, ...collection.data];
-      }
+  const channelMemberLiveCollection = new ChannelMemberLiveCollectionController(params, callback);
+  const disposers = channelMemberLiveCollection.startSubscription();
 
-      pushToCache(cacheKey, collection);
-      pushToCache(cacheByChannelKey, collection);
-
-      responder(collection, true);
-    };
-
-  const onFetch = (initial = false) => {
-    const collection = pullFromCache<Amity.ChannelMembersLiveCollectionCache>(cacheKey)?.data;
-
-    const channelMembers = collection?.data ?? [];
-
-    if (!initial && channelMembers.length > 0 && !collection?.params.page) return;
-
-    const query = createQuery(queryChannelMembers, {
-      ...queryParams,
-      page: (!initial ? collection?.params.page : undefined) ?? { limit },
-    });
-
-    runQuery(
-      query,
-      ({ data: result, error, loading, nextPage: page }) => {
-        const data = {
-          loading,
-          error,
-          params: { page },
-          data: channelMembers,
-        };
-
-        if (result) {
-          data.data = [...new Set([...channelMembers, ...result.map(getResolver('channelUsers'))])];
-        }
-
-        pushToCache(cacheKey, data);
-        pushToCache(cacheByChannelKey, data);
-
-        responder(data);
-      },
-      queryOptions(policy),
-    );
-  };
-
-  disposers.push(
-    onChannelJoined(realtimeRouter('onJoin')),
-    onChannelLeft(realtimeRouter('onLeft')),
-    onChannelMemberAdded(realtimeRouter('onMemberAdded')),
-    onChannelMemberRemoved(realtimeRouter('onMemberRemoved')),
-    onChannelMemberBanned(realtimeRouter('onChannelMemberBanned')),
-    onChannelMemberUnbanned(realtimeRouter('onChannelMemberUnbanned')),
-    onChannelMemberRoleAdded(realtimeRouter('onChannelMemberRoleAdded')),
-    onChannelMemberRoleRemoved(realtimeRouter('onChannelMemberRoleRemoved')),
-  );
+  const cacheKey = channelMemberLiveCollection.getCacheKey();
 
-  onFetch(true);
+  disposers.push(() => {
+    dropFromCache(cacheKey);
+  });
 
   return () => {
     log(`getMembers(tmpid: ${timestamp}) > dispose`);

package/src/channelRepository/channelMembership/observers/liveCollection/ChannelMemberLiveCollectionController.ts

@@ -0,0 +1,154 @@
+/* eslint-disable no-use-before-define */
+import hash from 'object-hash';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ChannelMemberPaginationController } from './ChannelMemberPaginationController';
+import { ChannelMemberQueryStreamController } from './ChannelMemberQueryStreamController';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import {
+  onChannelJoined,
+  onChannelLeft,
+  onChannelMemberAdded,
+  onChannelMemberRemoved,
+  onChannelMemberBanned,
+  onChannelMemberUnbanned,
+  onChannelMemberRoleAdded,
+  onChannelMemberRoleRemoved,
+} from '~/channelRepository/events';
+import {
+  filterByPropEquality,
+  filterByPropIntersection,
+  filterBySearchTerm,
+  sortByFirstCreated,
+  sortByLastCreated,
+} from '~/core/query';
+import { prepareChannelPayload } from '~/channelRepository/utils';
+
+export class ChannelMemberLiveCollectionController extends LiveCollectionController<
+  'channelUser',
+  Amity.ChannelMembersLiveCollection,
+  Amity.Membership<'channel'>,
+  ChannelMemberPaginationController
+> {
+  private queryStreamController: ChannelMemberQueryStreamController;
+
+  private query: Amity.ChannelMembersLiveCollection;
+
+  constructor(
+    query: Amity.ChannelMembersLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.Membership<'channel'>>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['channelUsers', 'collection', queryStreamId];
+    const paginationController = new ChannelMemberPaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new ChannelMemberQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      prepareChannelPayload,
+    );
+
+    this.callback = callback.bind(this);
+    this.loadPage(true);
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.ChannelMembersLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        params: {},
+      });
+    }
+  }
+
+  protected async persistModel(queryPayload: Amity.ChannelMembershipPayload & Amity.Pagination) {
+    await this.queryStreamController.saveToMainDB(queryPayload);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'channelUser'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
+
+  startSubscription() {
+    return this.queryStreamController.subscribeRTE([
+      { fn: onChannelJoined, action: 'onJoin' },
+      { fn: onChannelLeft, action: 'onLeft' },
+      { fn: onChannelMemberAdded, action: 'onMemberAdded' },
+      { fn: onChannelMemberRemoved, action: 'onMemberRemoved' },
+      { fn: onChannelMemberBanned, action: 'onChannelMemberBanned' },
+      { fn: onChannelMemberUnbanned, action: 'onChannelMemberUnbanned' },
+      { fn: onChannelMemberRoleAdded, action: 'onChannelMemberRoleAdded' },
+      { fn: onChannelMemberRoleRemoved, action: 'onChannelMemberRoleRemoved' },
+    ]);
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.ChannelMembersLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) return;
+
+    const data = this.applyFilter(
+      collection.data
+        .map(id => pullFromCache<Amity.Membership<'channel'>>(['channelUsers', 'get', id])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [],
+    );
+
+    if (!this.shouldNotify(data) && origin === 'event') return;
+
+    this.callback({
+      onNextPage: () => this.loadPage(false, Amity.LiveCollectionPageDirection.NEXT),
+      data,
+      hasNextPage: !!this.paginationController.getNextToken(),
+      loading,
+      error,
+    });
+  }
+
+  applyFilter(data: Amity.Membership<'channel'>[]) {
+    let channelMembers = filterByPropIntersection(data, 'roles', this.query.roles);
+
+    if (this.query.memberships) {
+      /*
+       * even though membership includes muted as a possible value
+       * when querying the server.
+       * Muted is specified under seperarte property namely isMuted
+       * Hence why I've seperately checked for it's equality
+       */
+      channelMembers = channelMembers.filter(member => {
+        if (this.query.memberships?.includes('muted') && member.isMuted) {
+          return true;
+        }
+
+        if (member.membership !== 'none') {
+          return this.query.memberships?.includes(member.membership);
+        }
+
+        return false;
+      });
+    }
+
+    if (this.query.search) {
+      // eslint-disable-next-line no-console
+      console.warn(
+        '`search` param will be deprecated in the next major release. If you want to search channel members by displayName, Please use `searchMembers()` instead.',
+      );
+      channelMembers = filterBySearchTerm(channelMembers, this.query.search);
+    }
+
+    // sort, 'lastCreated' is the default sort order
+    const sortBy = this.query.sortBy ? this.query.sortBy : 'lastCreated';
+    channelMembers = channelMembers.sort(
+      sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated,
+    );
+
+    return channelMembers;
+  }
+}

package/src/channelRepository/channelMembership/observers/liveCollection/ChannelMemberPaginationController.ts

@@ -0,0 +1,28 @@
+/* eslint-disable no-use-before-define */
+
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+
+/**
+ * TODO: handle cache receive cache option, and cache policy
+ * TODO: check if querybyIds is supported
+ */
+export class ChannelMemberPaginationController extends PaginationController<
+  'channelUser',
+  Amity.ChannelMembersLiveCollection
+> {
+  async getRequest(queryParams: Amity.ChannelMembersLiveCollection, token: string | undefined) {
+    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, ...params } = queryParams;
+    const options = token ? { token } : { limit };
+
+    const { data: queryResponse } = await this.http.get<
+      Amity.ChannelMembershipPayload & Amity.Pagination
+    >(`/api/v4/channels/${encodeURIComponent(params.channelId)}/users`, {
+      params: {
+        ...params,
+        options,
+      },
+    });
+    return queryResponse;
+  }
+}

package/src/channelRepository/channelMembership/observers/liveCollection/ChannelMemberQueryStreamController.ts

@@ -0,0 +1,109 @@
+/* eslint-disable no-use-before-define */
+import { QueryStreamController } from '~/core/liveCollection/QueryStreamController';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getResolver } from '~/core/model';
+import { getActiveClient } from '~/client';
+
+export class ChannelMemberQueryStreamController extends QueryStreamController<
+  Amity.ChannelMembershipPayload,
+  Amity.ChannelMembersLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (
+    response: Amity.ChannelMembershipPayload,
+  ) => Promise<Amity.ProcessedChannelPayload>;
+
+  constructor(
+    query: Amity.ChannelMembersLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    preparePayload: (
+      response: Amity.ChannelMembershipPayload,
+    ) => Promise<Amity.ProcessedChannelPayload>,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.preparePayload = preparePayload;
+  }
+
+  async saveToMainDB(response: Amity.ChannelMembershipPayload) {
+    const processedPayload = await this.preparePayload(response);
+
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    if (client.cache) {
+      ingestInCache(processedPayload, { cachedAt });
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.ChannelPayload & Partial<Amity.Pagination>,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: response.channelUsers.map(({ channelId, userId }) =>
+          getResolver('channelUsers')({ channelId, userId }),
+        ),
+      });
+    } else {
+      const collection = pullFromCache<Amity.ChannelMembersLiveCollectionCache>(
+        this.cacheKey,
+      )?.data;
+
+      const channelUsers = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data: [
+          ...new Set([
+            ...channelUsers,
+            ...response.channelUsers.map(({ channelId, userId }) =>
+              getResolver('channelUsers')({ channelId, userId }),
+            ),
+          ]),
+        ],
+      });
+    }
+  }
+
+  reactor(action: string) {
+    return (channel: Amity.Channel, channelMember: Amity.Membership<'channel'>) => {
+      if (this.query.channelId !== channelMember.channelId) return;
+
+      const collection = pullFromCache<Amity.ChannelMembersLiveCollectionCache>(
+        this.cacheKey,
+      )?.data;
+      if (!collection) return;
+
+      const channelMemberCacheId = getResolver('channelUsers')({
+        channelId: this.query.channelId,
+        userId: channelMember.userId,
+      });
+
+      if (channelMember.membership === 'none') {
+        collection.data = collection.data.filter(m => m !== channelMemberCacheId);
+      } else if (!collection.data.includes(channelMemberCacheId)) {
+        collection.data = [channelMemberCacheId, ...collection.data];
+      }
+
+      pushToCache(this.cacheKey, collection);
+      this.notifyChange({ origin: Amity.LiveDataOrigin.EVENT, loading: false });
+    };
+  }
+
+  subscribeRTE(
+    createSubscriber: {
+      fn: (
+        reactor: (channel: Amity.Channel, channelMember: Amity.Membership<'channel'>) => void,
+      ) => Amity.Unsubscriber;
+      action: string;
+    }[],
+  ) {
+    return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+  }
+}

package/src/channelRepository/channelMembership/observers/tests/getMembers.test.ts

@@ -149,7 +149,9 @@ describe('getMembers', () => {
     );
   });
 
-  test('it should apply filter on RTE only', async () => {
+  // skip because new live collection do apply filter before notify
+  // TODO: check if it should do filtering only on RTE event or not
+  test.skip('it should apply filter on RTE only', async () => {
     const callback = jest.fn();
     const applyFilterSpy = jest.spyOn(getMembersModule, 'applyFilter');