@amityco/ts-sdk 7.5.4-db55aa2.0 → 7.6.0

package/dist/utils/linkedObject/channelLinkedObject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"channelLinkedObject.d.ts","sourceRoot":"","sources":["../../../src/utils/linkedObject/channelLinkedObject.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,mBAAmB,YAAa,MAAM,eAAe,KAAG,MAAM,OAI1E,CAAC"}
+{"version":3,"file":"channelLinkedObject.d.ts","sourceRoot":"","sources":["../../../src/utils/linkedObject/channelLinkedObject.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,mBAAmB,YAAa,MAAM,eAAe,KAAG,MAAM,OAqB1E,CAAC"}

package/dist/utils/linkedObject/channelMemberLinkedObject.d.ts

@@ -0,0 +1,2 @@
+export declare const channelMemberLinkedObject: (channelMember: Amity.Membership<'channel'>) => Amity.Membership<'channel'>;
+//# sourceMappingURL=channelMemberLinkedObject.d.ts.map

package/dist/utils/linkedObject/channelMemberLinkedObject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channelMemberLinkedObject.d.ts","sourceRoot":"","sources":["../../../src/utils/linkedObject/channelMemberLinkedObject.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,yBAAyB,kBACrB,MAAM,UAAU,CAAC,SAAS,CAAC,KACzC,MAAM,UAAU,CAAC,SAAS,CAc5B,CAAC"}

package/dist/utils/linkedObject/index.d.ts

@@ -15,5 +15,6 @@ export declare const LinkedObject: {
     community: (community: Amity.InternalCommunity) => Amity.Community;
     invitation: (invitation: Amity.InternalInvitation) => Amity.Invitation;
     joinRequest: (joinRequest: Amity.InternalJoinRequest) => Amity.JoinRequest;
+    channelMember: (channelMember: Amity.Membership<"channel">) => Amity.Membership<"channel">;
 };
 //# sourceMappingURL=index.d.ts.map

package/dist/utils/linkedObject/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/linkedObject/index.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;CAiBxB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/linkedObject/index.ts"],"names":[],"mappings":"AAkBA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;CAkBxB,CAAC"}

package/dist/utils/tests/dummy/community.d.ts

@@ -55,6 +55,8 @@ export declare const communityUserModel: {
     muteTimeout: string;
     lastActivity: string;
     userId: string;
+    userInternalId: string;
+    userPublicId: string;
     communityId: string;
     communityMembership: Amity.GroupMembership;
     createdAt: string;

package/dist/utils/tests/dummy/community.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"community.d.ts","sourceRoot":"","sources":["../../../../src/utils/tests/dummy/community.ts"],"names":[],"mappings":"AAqBA,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,SAajC,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,SAoB/B,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,SAI/B,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,aAAa,CAAC,WAAW,CAa5D,CAAC;AAEF,eAAO,MAAM,uBAAuB,+BAAuD,CAAC;AAE5F,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,aAAa,CAAC,WAAW,CAO5D,CAAC;AAEF,eAAO,MAAM,uBAAuB,+BAAuD,CAAC;AAE5F,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,aAAa,CAAC,WAAW,CAO5D,CAAC;AAEF,eAAO,MAAM,uBAAuB,+BAAuD,CAAC;AAE5F,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,aAAa,CAAC,WAAW,CAM5D,CAAC;AAEF,eAAO,MAAM,qBAAqB,+BAAuD,CAAC;AAE1F,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,aAAa,CAAC,WAAW,CAK5D,CAAC;AAEF,eAAO,MAAM,mBAAmB,+BAAuD,CAAC;AAExF,eAAO,MAAM,qBAAqB;;;;;;;CAOjC,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,KAAK,CAAC,gBAOpC,CAAC;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;CAUtC,CAAC;AAEF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;CAU3C,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;GAG9B,CAAC;AAEF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;CAuBzB,CAAC;AAEF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;CAuBzB,CAAC;AAEF,eAAO,MAAM,sBAAsB;;CAqBlC,CAAC;AAEF,eAAO,MAAM,2BAA2B;;CAqBvC,CAAC"}
+{"version":3,"file":"community.d.ts","sourceRoot":"","sources":["../../../../src/utils/tests/dummy/community.ts"],"names":[],"mappings":"AAqBA,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,SAajC,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,SAoB/B,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,SAI/B,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,aAAa,CAAC,WAAW,CAa5D,CAAC;AAEF,eAAO,MAAM,uBAAuB,+BAAuD,CAAC;AAE5F,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,aAAa,CAAC,WAAW,CAO5D,CAAC;AAEF,eAAO,MAAM,uBAAuB,+BAAuD,CAAC;AAE5F,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,aAAa,CAAC,WAAW,CAO5D,CAAC;AAEF,eAAO,MAAM,uBAAuB,+BAAuD,CAAC;AAE5F,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,aAAa,CAAC,WAAW,CAM5D,CAAC;AAEF,eAAO,MAAM,qBAAqB,+BAAuD,CAAC;AAE1F,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,aAAa,CAAC,WAAW,CAK5D,CAAC;AAEF,eAAO,MAAM,mBAAmB,+BAAuD,CAAC;AAExF,eAAO,MAAM,qBAAqB;;;;;;;CAOjC,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,KAAK,CAAC,gBAOpC,CAAC;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;CAUtC,CAAC;AAEF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;CAU3C,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;GAG9B,CAAC;AAEF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;CAuBzB,CAAC;AAEF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;CAuBzB,CAAC;AAEF,eAAO,MAAM,sBAAsB;;CAqBlC,CAAC;AAEF,eAAO,MAAM,2BAA2B;;CAqBvC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amityco/ts-sdk",
-  "version": "7.5.4-db55aa2.0",
+  "version": "7.6.0",
   "license": "CC-BY-ND-4.0",
   "author": "amity.co <developers@amity.co> (https://amity.co)",
   "description": "Amity Social Cloud Typescript SDK",
@@ -63,6 +63,7 @@
     "debug": "^4.3.4",
     "hls.js": "^1.4.10",
     "js-base64": "^3.7.2",
+    "jwt-decode": "^3.1.2",
     "mitt": "^3.0.0",
     "mqtt": "^4.3.7",
     "object-hash": "^3.0.0",

package/src/@types/domains/channel.ts

@@ -93,6 +93,7 @@ declare global {
     type Channel<T extends ChannelType = any> = InternalChannel<T> & {
       messagePreview?: Amity.MessagePreview | null;
       markAsRead: () => Promise<boolean>;
+      previewMembers: Amity.Membership<'channel'>[];
     };
 
     type QueryChannels = {

package/src/@types/domains/group.ts

@@ -15,6 +15,8 @@ declare global {
 
     type Member<T extends Amity.GroupType> = {
       userId: Amity.InternalUser['userId'];
+      userInternalId: Amity.InternalUser['userInternalId'];
+      userPublicId: Amity.InternalUser['userPublicId'];
     } & (T extends 'channel'
       ? {
           channelId: Amity.Channel['channelId'];

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

@@ -23,6 +23,7 @@ import {
 } from '~/core/query';
 import { prepareChannelPayload } from '~/channelRepository/utils';
 import { onUserDeleted } from '~/channelRepository/events/onUserDeleted';
+import { LinkedObject } from '~/utils/linkedObject';
 
 export class ChannelMemberLiveCollectionController extends LiveCollectionController<
   'channelUser',
@@ -100,7 +101,8 @@ export class ChannelMemberLiveCollectionController extends LiveCollectionControl
       collection.data
         .map(id => pullFromCache<Amity.Membership<'channel'>>(['channelUsers', 'get', id])!)
         .filter(Boolean)
-        .map(({ data }) => data) ?? [],
+        .map(({ data }) => data)
+        .map(LinkedObject.channelMember) ?? [],
     );
 
     if (!this.shouldNotify(data) && origin === 'event') return;

package/src/channelRepository/channelMembership/observers/searchMembers/SearchChannelMemberLiveCollectionController.ts

@@ -17,6 +17,7 @@ import {
 import { filterByPropIntersection, filterBySearchTerm } from '~/core/query';
 import { prepareChannelPayload } from '~/channelRepository/utils';
 import { onUserDeleted } from '~/channelRepository/events/onUserDeleted';
+import { LinkedObject } from '~/utils/linkedObject';
 
 export class SearchChannelMemberLiveCollectionController extends LiveCollectionController<
   'channelUser',
@@ -94,7 +95,7 @@ export class SearchChannelMemberLiveCollectionController extends LiveCollectionC
       collection.data
         .map(id => pullFromCache<Amity.Membership<'channel'>>(['channelUsers', 'get', id])!)
         .filter(Boolean)
-        .map(({ data }) => data) ?? [],
+        .map(({ data }) => LinkedObject.channelMember(data) ?? []),
     );
 
     if (!this.shouldNotify(data) && origin === 'event') return;

package/src/channelRepository/channelMembership/observers/searchMembers/SearchChannelMemberQueryStreamController.ts

@@ -72,7 +72,7 @@ export class SearchChannelMemberQueryStreamController extends QueryStreamControl
   }
 
   reactor(action: string) {
-    return (channel: Amity.InternalChannel, channelMember: Amity.Membership<'channel'>) => {
+    return (channel: Amity.StaticInternalChannel, channelMember: Amity.Membership<'channel'>) => {
       if (this.query.channelId !== channelMember.channelId) return;
 
       const collection = pullFromCache<Amity.ChannelMembersLiveCollectionCache>(
@@ -100,7 +100,7 @@ export class SearchChannelMemberQueryStreamController extends QueryStreamControl
     createSubscriber: {
       fn: (
         reactor: (
-          channel: Amity.InternalChannel,
+          channel: Amity.StaticInternalChannel,
           channelMember: Amity.Membership<'channel'>,
         ) => void,
       ) => Amity.Unsubscriber;

package/src/client/api/index.ts

@@ -6,6 +6,7 @@ export * from './createClient';
 export * from './login';
 export * from './logout';
 export * from './secureLogout';
+export * from './resumeSession';
 
 export * from './isConnected';
 

package/src/client/api/resumeSession.ts

@@ -0,0 +1,282 @@
+import jwtDecode from 'jwt-decode';
+/* eslint-disable no-param-reassign */
+import { modifyMqttConnection } from '~/client/utils/modifyMqttConnection';
+/* eslint-disable require-atomic-updates */
+import { proxyWebsocketEvents } from '~/core/events';
+import { onChannelDeleted } from '~/channelRepository/events/onChannelDeleted';
+import { onChannelMemberBanned } from '~/channelRepository/events/onChannelMemberBanned';
+
+import { markReadEngineOnLoginHandler } from '~/subChannelRepository/utils/markReadEngine';
+import { onUserDeleted } from '~/userRepository/events/onUserDeleted';
+
+import analyticsEngineOnLoginHandler from '~/analytic/utils/analyticsEngineOnLoginHandler';
+import readReceiptSyncEngineOnLoginHandler from '~/client/utils/ReadReceiptSync/readReceiptSyncEngineOnLoginHandler';
+import legacyReadReceiptSyncEngineOnLoginHandler from '~/client/utils/ReadReceiptSync/legacyReadReceiptSyncEngineOnLoginHandler';
+import objectResolverEngineOnLoginHandler from '~/client/utils/ObjectResolver/objectResolverEngineOnLoginHandler';
+import { logout } from './logout';
+
+import { getActiveClient } from './activeClient';
+import { terminateClient } from './terminateClient';
+import { setActiveUser } from './activeUser';
+import { setSessionState } from './setSessionState';
+
+import { onClientBanned } from '../events';
+import { onTokenExpired } from '../events/onTokenExpired';
+import { onTokenTerminated } from '../events/onTokenTerminated';
+
+import { removeChannelMarkerCache } from '../utils/removeChannelMarkerCache';
+import { initializeMessagePreviewSetting } from '../utils/messagePreviewEngine';
+import { ASCError } from '~/core/errors';
+import SessionWatcher from '../utils/SessionWatcher';
+
+/*
+ * declared earlier to accomodate case when logging in with a different user
+ * than the one already connected, in which case the existing subscriptions need
+ * to be cleared
+ */
+let subscriptions: Amity.Unsubscriber[] = [];
+
+async function runMqtt() {
+  await modifyMqttConnection();
+}
+
+interface Params {
+  userId: string;
+  token: {
+    issuedAt: string;
+    expiresAt: string;
+    accessToken: string;
+  };
+}
+
+const isSameUserId = (token: Params['token']['accessToken']) => {
+  const client = getActiveClient();
+
+  const decoded = jwtDecode<{
+    user: {
+      userId: string;
+      publicUserId: string;
+      deviceInfo: Amity.Device['deviceInfo'];
+      networkId: string;
+      displayName: string;
+      refreshToken: string;
+    };
+  }>(token);
+
+  return decoded?.user?.publicUserId === client.userId;
+};
+
+const validateAccessToken = async ({ token, userId }: Params) => {
+  const client = getActiveClient();
+  // begin establishing session
+  setSessionState(Amity.SessionStates.ESTABLISHING);
+
+  const {
+    data: { users },
+  } = await client.http.get(`/api/v3/users/${userId}`, {
+    headers: {
+      Authorization: `Bearer ${token.accessToken}`,
+    },
+  });
+
+  const user = users.find((u: Amity.User) => u.userId === userId);
+
+  client.http.defaults.headers.common.Authorization = `Bearer ${token.accessToken}`;
+
+  client.http.defaults.metadata = {
+    tokenExpiry: token.expiresAt,
+    isGlobalBanned: false,
+    isUserDeleted: false,
+  };
+
+  client.upload.defaults.headers.common.Authorization = `Bearer ${token.accessToken}`;
+
+  client.upload.defaults.metadata = {
+    tokenExpiry: token.expiresAt,
+    isGlobalBanned: false,
+    isUserDeleted: false,
+  };
+
+  // manually setup the token for ws transport
+  if (client.ws) client.ws.io.opts.query = { token: token.accessToken };
+
+  client.token = token;
+
+  setSessionState(Amity.SessionStates.ESTABLISHED);
+
+  return user;
+};
+
+/* begin_public_function
+  id: client.resumeSession
+*/
+/**
+ * ```js
+ * import { resumeSession } from '@amityco/ts-sdk/client/api'
+ * const success = await resumeSession({
+ *   userId: 'XYZ123456789',
+ *   token: { accessToken: 'abc123', issuedAt: '2023-01-01T00:00:00Z', expiresAt: '2023-01-02T00:00:00Z' }
+ * })
+ * ```
+ *
+ * Connects an {@link Amity.Client} instance to ASC servers using an existing access token
+ *
+ * @param params the connect parameters
+ * @param params.userId the user ID for the current session
+ * @param params.token the existing access token with its metadata
+ * @param sessionHandler the session handler for token renewal
+ * @param config optional configuration
+ * @returns a success boolean if connected
+ *
+ * @category Client API
+ * @async
+ */
+export const resumeSession = async (
+  params: Params,
+  sessionHandler: Amity.SessionHandler,
+  config?: Amity.ConnectClientConfig,
+): Promise<boolean> => {
+  const client = getActiveClient();
+  let unsubWatcher: Amity.Unsubscriber;
+
+  client.log('client/api/resumeSession', {
+    apiKey: client.apiKey,
+    sessionState: client.sessionState,
+    ...params,
+  });
+
+  // Handle existing connected user
+  if (client.userId) {
+    if (client.userId === params.userId && isSameUserId(params.token.accessToken)) {
+      // Clear connections and listeners but preserve cache
+      if (client.mqtt && client.mqtt.connected) {
+        client.mqtt.disconnect();
+      }
+      if (client.ws && client.ws.connected) {
+        client.ws.disconnect();
+      }
+
+      // Clear existing subscriptions
+      subscriptions.forEach(fn => fn());
+      subscriptions = [];
+    } else {
+      // Different user - do full logout
+      await logout();
+
+      // Remove subscription to ban and delete
+      subscriptions.forEach(fn => fn());
+      subscriptions = [];
+    }
+  }
+
+  try {
+    const user = await validateAccessToken(params);
+
+    if (user == null) {
+      throw new ASCError(
+        `${params.userId} has not been found`,
+        Amity.ClientError.UNKNOWN_ERROR,
+        Amity.ErrorLevel.ERROR,
+      );
+    }
+
+    if (user.isDeleted) {
+      terminateClient(Amity.TokenTerminationReason.USER_DELETED);
+      return false;
+    }
+
+    if (user.isGlobalBanned) {
+      terminateClient(Amity.TokenTerminationReason.GLOBAL_BAN);
+      return false;
+    }
+
+    // FIXME: events are duplicated if connectClient is called few times without disconnectClient
+    // wire websocket events to our event emitter
+    proxyWebsocketEvents(client.ws, client.emitter);
+
+    client.ws?.open();
+
+    client.userId = user.userId;
+
+    client.sessionHandler = sessionHandler;
+
+    /*
+     * Cannot push to subscriptions as watcher needs to continue working even if
+     * token expires
+     */
+    unsubWatcher = client.accessTokenExpiryWatcher(sessionHandler);
+
+    setActiveUser(user);
+  } catch (error) {
+    /*
+     * if getting token failed session state reverts to initial state when app
+     * is first launched
+     */
+    SessionWatcher.getInstance().setSessionState(Amity.SessionStates.NOT_LOGGED_IN);
+
+    // pass error down tree so the calling function handle it
+    throw error;
+  }
+
+  if (config?.disableRTE !== true) {
+    runMqtt();
+  }
+
+  await initializeMessagePreviewSetting();
+
+  if (subscriptions.length === 0) {
+    subscriptions.push(
+      // GLOBAL_BAN
+      onClientBanned((_: Amity.UserPayload) => {
+        terminateClient(Amity.TokenTerminationReason.GLOBAL_BAN);
+
+        subscriptions.forEach(fn => fn());
+
+        unsubWatcher();
+      }),
+
+      onTokenTerminated(_ => {
+        terminateClient();
+
+        subscriptions.forEach(fn => fn());
+
+        unsubWatcher();
+      }),
+
+      onUserDeleted((user: Amity.InternalUser) => {
+        if (user.userId === client.userId) {
+          terminateClient(Amity.TokenTerminationReason.USER_DELETED);
+
+          subscriptions.forEach(fn => fn());
+
+          unsubWatcher();
+        }
+      }),
+
+      onTokenExpired(state => {
+        SessionWatcher.getInstance().setSessionState(state);
+
+        logout();
+
+        subscriptions.forEach(fn => fn());
+      }),
+
+      // NOTE: This is a temporary solution to handle the channel marker when the user is forced to leave
+      // the channel because currently backend can't handle this, so every time a user is banned from
+      // a channel or the channel is deleted the channel's unread count will not be reset to zero
+      onChannelDeleted(removeChannelMarkerCache),
+      onChannelMemberBanned(removeChannelMarkerCache),
+
+      markReadEngineOnLoginHandler(),
+      analyticsEngineOnLoginHandler(),
+      objectResolverEngineOnLoginHandler(),
+    );
+
+    if (client.useLegacyUnreadCount) {
+      subscriptions.push(readReceiptSyncEngineOnLoginHandler());
+    } else subscriptions.push(legacyReadReceiptSyncEngineOnLoginHandler());
+  }
+
+  return true;
+};
+/* end_public_function */

package/src/client/api/tests/resumeSession.test.ts

@@ -0,0 +1,173 @@
+import { ASCApiError } from '~/core/errors';
+import { user11, disconnectClient } from '~/utils/tests';
+import { resumeSession, createClient } from '..';
+import { setActiveClient } from '../activeClient';
+
+let client: Amity.Client;
+
+const sessionHandler: Amity.SessionHandler = {
+  sessionWillRenewAccessToken(_) {
+    // do nothing
+  },
+};
+
+const mockToken = {
+  accessToken: 'mock-access-token',
+  issuedAt: '2023-01-01T00:00:00Z',
+  expiresAt: '2025-01-01T00:00:00Z',
+};
+
+const mockUserResponse = {
+  data: {
+    users: [user11],
+  },
+};
+
+const onConnect = () =>
+  setTimeout(() => {
+    const CONNECT_PACKET = { type: 0, nsp: client.ws?.nsp };
+
+    client.ws?.emit('connect');
+
+    // simulate a connection ack packet from server
+    client.ws?.io.emit('packet', CONNECT_PACKET);
+  }, 50);
+
+describe('resumeSession', () => {
+  beforeEach(() => {
+    client = createClient('key', 'sg');
+    client.mqtt?.connect && (client.mqtt.connect = jest.fn());
+    client.mqtt?.subscribe && (client.mqtt.subscribe = jest.fn());
+    client.http.get = jest.fn().mockResolvedValueOnce(mockUserResponse);
+
+    setActiveClient(client);
+  });
+
+  afterEach(async () => {
+    if (client.sessionState === Amity.SessionStates.ESTABLISHED) await disconnectClient();
+  });
+
+  test('it should connect client with access token', async () => {
+    onConnect().unref();
+
+    const received = await resumeSession(
+      { userId: user11.userId, token: mockToken },
+      sessionHandler,
+    );
+
+    expect(received).toBe(true);
+  });
+
+  test('it should establish connection', async () => {
+    onConnect().unref();
+
+    await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
+    const { sessionState } = client;
+
+    expect(sessionState).toBe(Amity.SessionStates.ESTABLISHED);
+  });
+
+  test('it should have session state establishing while connecting client', () => {
+    resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
+
+    expect(client.sessionState).toBe(Amity.SessionStates.ESTABLISHING);
+  });
+
+  test('it should have session state notLoggedIn on failure', async () => {
+    client.http.get = jest
+      .fn()
+      .mockRejectedValue(
+        new ASCApiError('unauthorized', Amity.ServerError.UNAUTHORIZED, Amity.ErrorLevel.FATAL),
+      );
+
+    await expect(
+      resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler),
+    ).rejects.toThrow('unauthorized');
+    expect(client.sessionState).toBe(Amity.SessionStates.NOT_LOGGED_IN);
+  });
+
+  test('it should set authorization header with token', async () => {
+    onConnect().unref();
+
+    await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
+
+    expect(client.http.defaults.headers.common.Authorization).toBe(
+      `Bearer ${mockToken.accessToken}`,
+    );
+    expect(client.upload.defaults.headers.common.Authorization).toBe(
+      `Bearer ${mockToken.accessToken}`,
+    );
+  });
+
+  test('it should set token metadata', async () => {
+    onConnect().unref();
+
+    await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
+
+    expect(client.token).toEqual(mockToken);
+    expect(client.http.defaults.metadata).toEqual({
+      tokenExpiry: mockToken.expiresAt,
+      isGlobalBanned: false,
+      isUserDeleted: false,
+    });
+  });
+
+  test('it should call user endpoint to validate token', async () => {
+    onConnect().unref();
+
+    await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
+
+    expect(client.http.get).toHaveBeenCalledWith(`/api/v3/users/${user11.userId}`);
+  });
+
+  test('it should terminate session on ban', async () => {
+    onConnect().unref();
+
+    await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
+
+    // ban user
+    client.emitter.emit('user.didGlobalBan', {} as Amity.UserPayload);
+
+    expect(client.sessionState).toBe(Amity.SessionStates.TERMINATED);
+  });
+
+  test('it should reset client state when user is already connected with same userId', async () => {
+    onConnect().unref();
+
+    // First connection
+    await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
+    expect(client.sessionState).toBe(Amity.SessionStates.ESTABLISHED);
+    expect(client.userId).toBe(user11.userId);
+
+    // Mock the HTTP call for second connection
+    client.http.get = jest.fn().mockResolvedValueOnce(mockUserResponse);
+
+    // Second connection with same userId should treat as token expiry (preserve cache)
+    onConnect().unref();
+    await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
+
+    // Verify that the client is properly reset and reconnected
+    expect(client.sessionState).toBe(Amity.SessionStates.ESTABLISHED);
+    expect(client.userId).toBe(user11.userId);
+  });
+
+  test('it should preserve cache when resuming session with same userId', async () => {
+    onConnect().unref();
+
+    // First connection - set some cache data
+    await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
+    if (client.cache) {
+      client.cache.data = { test: 'data' };
+    }
+
+    // Mock the HTTP call for second connection
+    client.http.get = jest.fn().mockResolvedValueOnce(mockUserResponse);
+
+    // Second connection with same userId
+    onConnect().unref();
+    await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
+
+    // Cache should be preserved when same userId is used
+    expect(client.cache?.data).toEqual({ test: 'data' });
+  });
+});

package/src/utils/linkedObject/channelLinkedObject.ts

@@ -1,8 +1,27 @@
 import { markAsRead } from '~/channelRepository/internalApi/markAsRead';
 import { shallowClone } from '../shallowClone';
+import { queryCache } from '~/cache/api';
+import { channelMemberLinkedObject } from './channelMemberLinkedObject';
 
 export const channelLinkedObject = (channel: Amity.InternalChannel): Amity.Channel => {
+  let previewMembers: Amity.Membership<'channel'>[] = [];
+
+  if (channel.type === 'conversation') {
+    const channelUsers = queryCache<Amity.Membership<'channel'>>(['channelUsers', 'get']);
+    if (channelUsers && channelUsers?.length > 0) {
+      previewMembers = (
+        channelUsers?.filter(({ data }) => data.channelId === channel.channelId) ?? []
+      )
+        // sort in ascending order by userInternalId
+        .sort((a, b) => a.data.userInternalId.localeCompare(b.data.userInternalId))
+        // Select only first 4 members
+        .slice(0, 4)
+        .map(({ data }) => channelMemberLinkedObject(data));
+    }
+  }
+
   return shallowClone(channel, {
     markAsRead: () => markAsRead(channel.channelInternalId),
+    previewMembers,
   });
 };

package/src/utils/linkedObject/channelMemberLinkedObject.ts

@@ -0,0 +1,20 @@
+import { pullFromCache } from '~/cache/api/pullFromCache';
+import { userLinkedObject } from './userLinkedObject';
+
+export const channelMemberLinkedObject = (
+  channelMember: Amity.Membership<'channel'>,
+): Amity.Membership<'channel'> => {
+  const getUser = (): Amity.User | undefined => {
+    const cacheKey = ['user', 'get', channelMember.userId];
+    const internalUser = pullFromCache<Amity.InternalUser>(cacheKey)?.data;
+
+    return internalUser ? userLinkedObject(internalUser) : undefined;
+  };
+
+  return {
+    ...channelMember,
+    get user() {
+      return getUser();
+    },
+  };
+};

package/src/utils/linkedObject/index.ts

@@ -14,6 +14,7 @@ import { notificationTrayLinkedObject } from './notificationTrayLinkedObject';
 import { communityLinkedObject } from './communityLinkedObject';
 import { invitationLinkedObject } from './invitationLinkedObject';
 import { joinRequestLinkedObject } from './joinRequestLinkedObject';
+import { channelMemberLinkedObject } from './channelMemberLinkedObject';
 
 export const LinkedObject = {
   ad: adLinkedObject,
@@ -32,4 +33,5 @@ export const LinkedObject = {
   community: communityLinkedObject,
   invitation: invitationLinkedObject,
   joinRequest: joinRequestLinkedObject,
+  channelMember: channelMemberLinkedObject,
 };