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

package/src/subChannelRepository/observers/liveCollection/SubChannelLiveCollectionController.ts

@@ -0,0 +1,274 @@
+/* eslint-disable no-use-before-define */
+import hash from 'object-hash';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { SubChannelPaginationController } from './SubChannelPaginationController';
+import { SubChannelQueryStreamController } from './SubChannelQueryStreamController';
+import {
+  onSubChannelCreated,
+  onSubChannelDeleted,
+  onSubChannelUpdated,
+} from '~/subChannelRepository/events';
+import { onMessageCreated, onMessageUpdated, onMessageDeleted } from '~/messageRepository/events';
+import { onSubChannelMarkerFetched, onSubChannelMarkerUpdated } from '~/marker/events';
+import { convertEventPayload } from '~/utils/event';
+import { filterByPropEquality, sortByLastActivity } from '~/core/query';
+import { getActiveClient } from '~/client';
+import {
+  getSubChannelMessagePreview,
+  getSubChannelMessagePreviewWithUser,
+  handleMessageCreated,
+  handleMessageUpdated,
+} from '~/messagePreview/utils';
+import { getSubChannel } from '~/subChannelRepository/api/getSubChannel';
+import { updateSubChannelCache } from '~/subChannelRepository/utils/updateSubChannelCache';
+import { prepareSubChannelPayload } from '~/subChannelRepository/utils';
+import { onSubChannelFetched } from '~/subChannelRepository/events/onSubChannelFetched';
+
+export class SubChannelLiveCollectionController extends LiveCollectionController<
+  'subChannel',
+  Amity.SubChannelLiveCollection,
+  Amity.SubChannel,
+  SubChannelPaginationController
+> {
+  private queryStreamController: SubChannelQueryStreamController;
+
+  private query: Amity.SubChannelLiveCollection;
+
+  constructor(
+    query: Amity.SubChannelLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.SubChannel>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['subChannel', 'collection', queryStreamId];
+    const paginationController = new SubChannelPaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new SubChannelQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      prepareSubChannelPayload,
+    );
+    this.callback = callback.bind(this);
+    this.loadPage(true);
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.SubChannelLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+      });
+    }
+  }
+
+  protected async persistModel(response: Amity.SubChannelPayload & Amity.Pagination) {
+    await this.queryStreamController.saveToMainDB(response);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'subChannel'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
+
+  startSubscription() {
+    return this.queryStreamController.subscribeRTE([
+      { fn: onSubChannelFetched, action: 'onCreate' },
+      { fn: onSubChannelCreated, action: 'onCreate' },
+      { fn: onSubChannelDeleted, action: 'onDelete' },
+      {
+        fn: callback => {
+          return onSubChannelUpdated(async (subChannel: Amity.SubChannel) => {
+            const collection = pullFromCache<Amity.SubChannelLiveCollectionCache>(
+              this.cacheKey,
+            )?.data;
+
+            if (!collection || !collection.data.includes(subChannel.subChannelId)) return;
+
+            const client = getActiveClient();
+            const messagePreviewSetting = await client.getMessagePreviewSetting(false);
+
+            if (messagePreviewSetting !== Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW) {
+              const messagePreview = getSubChannelMessagePreview(subChannel.subChannelId);
+
+              if (messagePreview?.subChannelId === subChannel.subChannelId) {
+                pushToCache(['messagePreviewSubChannel', 'get', subChannel.subChannelId], {
+                  ...messagePreview,
+                  subChannelName: subChannel.displayName,
+                  subChannelUpdatedAt: subChannel.updatedAt,
+                });
+              }
+            }
+
+            callback(subChannel);
+          });
+        },
+        action: 'onUpdate',
+      },
+      {
+        fn: callback => {
+          return onMessageCreated(async message => {
+            const cacheData = pullFromCache<Amity.SubChannel>([
+              'subChannel',
+              'get',
+              message.subChannelId,
+            ]);
+
+            if (!cacheData) return;
+
+            const collection = pullFromCache<Amity.SubChannelLiveCollectionCache>(
+              this.cacheKey,
+            )?.data;
+
+            if (!collection || !collection.data.includes(message.subChannelId)) return;
+
+            const client = getActiveClient();
+            const messagePreviewSetting = await client.getMessagePreviewSetting(false);
+
+            if (messagePreviewSetting === Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW) return;
+
+            handleMessageCreated(message);
+
+            const subChannelCache = pullFromCache<Amity.SubChannel>([
+              'subChannel',
+              'get',
+              message.subChannelId,
+            ])?.data;
+            if (!subChannelCache) return;
+
+            updateSubChannelCache(message.subChannelId, subChannelCache, {
+              lastActivity: message.createdAt,
+              messagePreviewId: message.messageId,
+            });
+
+            callback({
+              ...cacheData.data,
+              messagePreviewId: message.messageId,
+              subChannelId: message.subChannelId,
+              lastActivity: message.createdAt,
+            });
+          });
+        },
+        action: 'onUpdate',
+      },
+      {
+        fn: callback => {
+          return onSubChannelMarkerUpdated((subChannelMarkers: Amity.SubChannelMarker[]) => {
+            const subChannelWithMarkerUpdated =
+              subChannelMarkers
+                .map(
+                  ({ feedId }) => pullFromCache<Amity.SubChannel>(['subChannel', 'get', feedId])!,
+                )
+                .filter(Boolean)
+                .map(({ data }) => data) ?? [];
+
+            if (subChannelWithMarkerUpdated.length === 0) return;
+            callback(subChannelWithMarkerUpdated);
+          });
+        },
+        action: 'onUpdate',
+      },
+      {
+        fn: convertEventPayload(
+          (callback: Amity.Listener<Amity.Message>) => {
+            const updateMessagePreview = async (message: Amity.Message) => {
+              const client = getActiveClient();
+              const messagePreviewSetting = await client.getMessagePreviewSetting(false);
+
+              if (messagePreviewSetting === Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW) return;
+
+              const collection = pullFromCache<Amity.SubChannelLiveCollectionCache>(
+                this.cacheKey,
+              )?.data;
+
+              if (!collection || !collection.data.includes(message.subChannelId)) return;
+
+              handleMessageUpdated(message);
+
+              callback(message);
+            };
+            return onMessageUpdated(updateMessagePreview);
+          },
+          'subChannelId',
+          'subChannel',
+        ),
+        action: 'onUpdate',
+      },
+      {
+        fn: convertEventPayload(
+          (callback: Amity.Listener<Amity.Message>) => {
+            const updateMessagePreview = async (message: Amity.Message) => {
+              const client = getActiveClient();
+              const messagePreviewSetting = await client.getMessagePreviewSetting(false);
+
+              if (messagePreviewSetting === Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW) return;
+
+              const collection = pullFromCache<Amity.SubChannelLiveCollectionCache>(
+                this.cacheKey,
+              )?.data;
+
+              if (!collection || !collection.data.includes(message.subChannelId)) return;
+
+              if (
+                messagePreviewSetting ===
+                Amity.MessagePreviewSetting.MESSAGE_PREVIEW_NOT_INCLUDE_DELETED
+              ) {
+                await getSubChannel(message.subChannelId);
+              } else {
+                await handleMessageUpdated(message);
+              }
+
+              callback(message);
+            };
+
+            return onMessageDeleted(updateMessagePreview);
+          },
+          'subChannelId',
+          'subChannel',
+        ),
+        action: 'onUpdate',
+      },
+    ]);
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.SubChannelLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) return;
+
+    const data = this.applyFilter(
+      collection.data
+        .map(subChannelId => pullFromCache<Amity.SubChannel>(['subChannel', 'get', subChannelId])!)
+        .filter(Boolean)
+        .map(({ data }) => data)
+        .map(getSubChannelMessagePreviewWithUser) ?? [],
+    );
+
+    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.SubChannel[]) {
+    let subChannels = data;
+
+    if (!this.query.includeDeleted) {
+      subChannels = filterByPropEquality(data, 'isDeleted', false);
+    }
+
+    subChannels.sort(sortByLastActivity);
+
+    return subChannels;
+  }
+}

package/src/subChannelRepository/observers/liveCollection/SubChannelPaginationController.ts

@@ -0,0 +1,35 @@
+/* eslint-disable no-use-before-define */
+
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+import { convertQueryParams } from '~/subChannelRepository/utils';
+import { inferIsDeleted } from '~/utils/inferIsDeleted';
+
+/**
+ * TODO: handle cache receive cache option, and cache policy
+ * TODO: check if querybyIds is supported
+ */
+export class SubChannelPaginationController extends PaginationController<
+  'subChannel',
+  Amity.SubChannelLiveCollection
+> {
+  async getRequest(queryParams: Amity.SubChannelLiveCollection, token: string | undefined) {
+    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, ...params } = queryParams;
+    const { channelId, includeDeleted, ...restProcessedParams } = convertQueryParams(params) ?? {};
+
+    const options = token ? { token } : { limit };
+
+    const { data: queryResponse } = await this.http.get<Amity.SubChannelPayload & Amity.Pagination>(
+      `/api/v5/message-feeds/channel/${channelId}`,
+      {
+        params: {
+          ...restProcessedParams,
+          isDeleted: inferIsDeleted(includeDeleted),
+          options,
+        },
+      },
+    );
+
+    return queryResponse;
+  }
+}

package/src/subChannelRepository/observers/liveCollection/SubChannelQueryStreamController.ts

@@ -0,0 +1,94 @@
+/* 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 { getActiveClient } from '~/client';
+
+export class SubChannelQueryStreamController extends QueryStreamController<
+  Amity.SubChannelPayload,
+  Amity.SubChannelLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (
+    response: Amity.SubChannelPayload,
+  ) => Promise<Amity.ProcessedSubChannelPayload>;
+
+  constructor(
+    query: Amity.SubChannelLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    preparePayload: (
+      response: Amity.SubChannelPayload,
+    ) => Promise<Amity.ProcessedSubChannelPayload>,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.preparePayload = preparePayload;
+  }
+
+  async saveToMainDB(response: Amity.SubChannelPayload) {
+    const processedPayload = await this.preparePayload(response);
+
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    if (client.cache) {
+      ingestInCache(processedPayload, { cachedAt });
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.SubChannelPayload & Partial<Amity.Pagination>,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: response.messageFeeds.map(({ messageFeedId }) => messageFeedId),
+      });
+    } else {
+      const collection = pullFromCache<Amity.SubChannelLiveCollectionCache>(this.cacheKey)?.data;
+
+      const subChannels = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data: [
+          ...new Set([
+            ...subChannels,
+            ...response.messageFeeds.map(({ messageFeedId }) => messageFeedId),
+          ]),
+        ],
+      });
+    }
+  }
+
+  reactor(action: string) {
+    return (payload: Amity.SubChannel | Amity.SubChannel[]) => {
+      const collection = pullFromCache<Amity.SubChannelLiveCollectionCache>(this.cacheKey)?.data;
+      if (!collection) return;
+
+      if (!Array.isArray(payload)) {
+        if (this.query.channelId !== payload.channelId) return;
+
+        if (action === 'onCreate') {
+          collection.data = [...new Set([payload.subChannelId, ...collection.data])];
+        }
+
+        pushToCache(this.cacheKey, collection);
+      }
+
+      this.notifyChange({ origin: Amity.LiveDataOrigin.EVENT, loading: false });
+    };
+  }
+
+  subscribeRTE(
+    createSubscriber: {
+      fn: (reactor: Amity.Listener<Amity.SubChannel | Amity.SubChannel[]>) => Amity.Unsubscriber;
+      action: string;
+    }[],
+  ) {
+    return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+  }
+}

package/src/subChannelRepository/observers/tests/getSubChannels.test.ts

@@ -160,24 +160,24 @@ describe('getSubChannels', () => {
 
   test('when querying two subchannel collections with same channelId but different params, pagination remains functional', async () => {
     const subChannelCase1Page1 = [
-      generateRawSubChannel({ channelPublicId: 'channel1', name: '1' }),
-      generateRawSubChannel({ channelPublicId: 'channel1', name: '2' }),
+      generateRawSubChannel({ channelPublicId: 'channel1', name: '1', messageFeedId: '1' }),
+      generateRawSubChannel({ channelPublicId: 'channel1', name: '2', messageFeedId: '2' }),
     ];
     const subChannelCase1Page2 = [
-      generateRawSubChannel({ channelPublicId: 'channel1', name: '3' }),
-      generateRawSubChannel({ channelPublicId: 'channel1', name: '4' }),
+      generateRawSubChannel({ channelPublicId: 'channel1', name: '3', messageFeedId: '3' }),
+      generateRawSubChannel({ channelPublicId: 'channel1', name: '4', messageFeedId: '4' }),
     ];
     const subChannelCase2Page1 = [
-      generateRawSubChannel({ channelPublicId: 'channel1', name: 'x6' }),
-      generateRawSubChannel({ channelPublicId: 'channel1', name: 'x5' }),
+      generateRawSubChannel({ channelPublicId: 'channel1', name: 'x6', messageFeedId: 'x6' }),
+      generateRawSubChannel({ channelPublicId: 'channel1', name: 'x5', messageFeedId: 'x5' }),
     ];
     const subChannelCase2Page2 = [
-      generateRawSubChannel({ channelPublicId: 'channel1', name: 'x4' }),
-      generateRawSubChannel({ channelPublicId: 'channel1', name: 'x3' }),
+      generateRawSubChannel({ channelPublicId: 'channel1', name: 'x4', messageFeedId: 'x4' }),
+      generateRawSubChannel({ channelPublicId: 'channel1', name: 'x3', messageFeedId: 'x3' }),
     ];
     const subChannelCase2Page3 = [
-      generateRawSubChannel({ channelPublicId: 'channel1', name: 'x2' }),
-      generateRawSubChannel({ channelPublicId: 'channel1', name: 'x1' }),
+      generateRawSubChannel({ channelPublicId: 'channel1', name: 'x2', messageFeedId: 'x2' }),
+      generateRawSubChannel({ channelPublicId: 'channel1', name: 'x1', messageFeedId: 'x1' }),
     ];
 
     const callback = jest.fn();
@@ -185,7 +185,7 @@ describe('getSubChannels', () => {
 
     client.http.get = jest.fn().mockImplementation((url, params) => {
       if (params.params?.excludeDefaultMessageFeed === true) {
-        if (params?.params.options.token === 'eyJiZWZvcmUiOjU1LCJsaW1pdCI6NX0=') {
+        if (params?.params?.options?.token === 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=') {
           return Promise.resolve({
             data: {
               messageFeeds: subChannelCase2Page2,
@@ -194,13 +194,13 @@ describe('getSubChannels', () => {
               files: [],
               paging: {
                 previous: 'eyJiZWZvcmUiOjQ1LCJsYXN0IjoxMH0=',
-                next: 'eyJiZWZvcmUiOjQ1LCJsYXN0IjoxMH0=',
+                next: 'eyJiZWZvcmUiOjQ1LCJsaW1pdCI6NX0=',
               },
             },
           });
         }
 
-        if (params?.params.options.token === 'eyJiZWZvcmUiOjQ1LCJsaW1pdCI6NX0=') {
+        if (params?.params?.options?.token === 'eyJiZWZvcmUiOjQ1LCJsaW1pdCI6NX0=') {
           return Promise.resolve({
             data: {
               messageFeeds: subChannelCase2Page3,
@@ -227,7 +227,7 @@ describe('getSubChannels', () => {
           },
         });
       }
-      if (params?.params.options.token === 'eyJiZWZvcmUiOjU1LCJsaW1pdCI6NX0=') {
+      if (params?.params?.options?.token === 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=') {
         return Promise.resolve({
           data: {
             messageFeeds: subChannelCase1Page2,
@@ -261,34 +261,37 @@ describe('getSubChannels', () => {
 
     await pause();
 
-    expect(callback).toHaveBeenCalledTimes(4);
+    expect(callback).toHaveBeenCalledTimes(2);
     expect(callback).lastCalledWith(
       expect.objectContaining({
-        data: [
-          getSubChannelMessagePreviewWithUser(convertSubChannelFromRaw(subChannelCase1Page1[0])),
-        ],
+        data: subChannelCase1Page1
+          .map(convertSubChannelFromRaw)
+          .map(getSubChannelMessagePreviewWithUser),
         loading: false,
         hasNextPage: true,
         error: undefined,
       }),
     );
 
-    expect(callback2).toHaveBeenCalledTimes(4);
+    expect(callback2).toHaveBeenCalledTimes(2);
 
+    /**
+     * not have been called with subChannelCase1Page1
+     */
     expect(callback2).not.toHaveBeenCalledWith(
       expect.objectContaining({
-        data: [
-          getSubChannelMessagePreviewWithUser(convertSubChannelFromRaw(subChannelCase1Page1[0])),
-        ],
+        data: subChannelCase1Page1
+          .map(convertSubChannelFromRaw)
+          .map(getSubChannelMessagePreviewWithUser),
         loading: false,
       }),
     );
 
     expect(callback2).lastCalledWith(
       expect.objectContaining({
-        data: [
-          getSubChannelMessagePreviewWithUser(convertSubChannelFromRaw(subChannelCase2Page1[0])),
-        ],
+        data: subChannelCase2Page1
+          .map(convertSubChannelFromRaw)
+          .map(getSubChannelMessagePreviewWithUser),
         loading: false,
         hasNextPage: true,
         error: undefined,
@@ -303,10 +306,15 @@ describe('getSubChannels', () => {
 
     await pause();
 
-    expect(callback2).toHaveBeenCalledTimes(10);
+    /**
+     * calling callback 2 times so, callback2 should have been called 6 times with 3 pages of data
+     */
+    expect(callback2).toHaveBeenCalledTimes(6);
     expect(callback2).lastCalledWith(
       expect.objectContaining({
-        data: [convertSubChannelFromRaw(subChannelCase2Page3[0])],
+        data: [...subChannelCase2Page1, ...subChannelCase2Page2, ...subChannelCase2Page3]
+          .map(convertSubChannelFromRaw)
+          .map(getSubChannelMessagePreviewWithUser),
         loading: false,
       }),
     );
@@ -315,25 +323,40 @@ describe('getSubChannels', () => {
 
     await pause();
 
-    expect(callback).toHaveBeenCalledTimes(9);
+    // /**
+    //  * calling nextPage 1 times so, callback2 should have been called 4 times;
+    //  */
+    expect(callback).toHaveBeenCalledTimes(4);
     expect(callback).lastCalledWith(
       expect.objectContaining({
-        data: [convertSubChannelFromRaw(subChannelCase1Page2[0])],
+        data: [...subChannelCase1Page1, ...subChannelCase1Page2]
+          .map(convertSubChannelFromRaw)
+          .map(getSubChannelMessagePreviewWithUser),
         loading: false,
       }),
     );
 
     expect(callback).not.toHaveBeenCalledWith(
       expect.objectContaining({
-        data: [convertSubChannelFromRaw(subChannelCase2Page3[0])],
+        data: [...subChannelCase2Page1, ...subChannelCase2Page2, ...subChannelCase2Page3]
+          .map(convertSubChannelFromRaw)
+          .map(getSubChannelMessagePreviewWithUser),
         loading: false,
       }),
     );
   });
 
+  /**
+   * TODO: change this test to use with event
+   * and add test to check if query params is converted correct for includeDeleted
+   */
   describe('when querying the subchannel collection with specific sort and filter options, results sort correctly', () => {
-    const subChannel1 = generateRawSubChannel({ channelId: 'aaaaa' });
-    const deletedRawSubChannel = generateRawSubChannel({ channelId: 'aaaaa', isDeleted: true });
+    const subChannel1 = generateRawSubChannel({ channelId: 'aaaaa', messageFeedId: 'aaaa-1' });
+    const deletedRawSubChannel = generateRawSubChannel({
+      channelId: 'aaaaa',
+      messageFeedId: 'aaaa-2',
+      isDeleted: true,
+    });
 
     const filterCases: [
       string,
@@ -345,12 +368,12 @@ describe('getSubChannels', () => {
         'includeDeleted = true',
         { channelId: 'aaaaa', includeDeleted: true },
         [deletedRawSubChannel, subChannel1],
-        [subChannel1],
+        [deletedRawSubChannel, subChannel1],
       ],
       [
         'includeDeleted = false',
         { channelId: 'aaaaa', includeDeleted: false },
-        [deletedRawSubChannel, subChannel1],
+        [subChannel1],
         [subChannel1],
       ],
     ];
@@ -386,14 +409,19 @@ describe('getSubChannels', () => {
   test('when querying two subchannel collections with the same channelId but different params, results are distinct', async () => {
     const callback = jest.fn();
     const callback2 = jest.fn();
-    const subChannel = generateRawSubChannel({ channelPublicId: 'channel1' });
+    const subChannel = generateRawSubChannel({
+      channelPublicId: 'channel1',
+      messageFeedId: 'channel1-subChannel1',
+    });
     const subChannel2 = generateRawSubChannel({
       channelPublicId: 'channel1',
       lastMessageId: 'thisissubchannelforanothercase',
+      messageFeedId: 'channel1-subChannel2',
     });
     const defaultSubChannel = generateRawSubChannel({
       channelPublicId: 'channel1',
       lastMessageId: 'thisisdefault',
+      messageFeedId: 'channel1',
     });
 
     client.http.get = jest.fn().mockImplementation((url, params) => {
@@ -433,18 +461,18 @@ describe('getSubChannels', () => {
 
     await pause(100);
 
-    expect(callback.mock.calls.length).toBe(3);
+    expect(callback.mock.calls.length).toBe(2);
+    /**
+     * excludeDefaultSubChannel: false
+     * should return [defaultSubChannel, subChannel];
+     */
     expect(callback).toHaveBeenCalledWith(
       expect.objectContaining({
-        data: [convertSubChannelFromRaw(subChannel)],
-        error: undefined,
-        loading: false,
-      }),
-    );
-    expect(callback).lastCalledWith(
-      expect.objectContaining({
-        data: [convertSubChannelFromRaw(defaultSubChannel)],
+        data: [defaultSubChannel, subChannel]
+          .map(convertSubChannelFromRaw)
+          .map(getSubChannelMessagePreviewWithUser),
         error: undefined,
+        hasNextPage: false,
         loading: false,
       }),
     );
@@ -452,7 +480,7 @@ describe('getSubChannels', () => {
     expect(callback2.mock.calls.length).toBe(2);
     expect(callback2).lastCalledWith(
       expect.objectContaining({
-        data: [convertSubChannelFromRaw(subChannel2)],
+        data: [{ ...convertSubChannelFromRaw(subChannel2), messagePreview: null }],
         error: undefined,
         loading: false,
       }),