@amityco/ts-sdk 7.5.4-2d34fd5f.0 → 7.5.4-54f750e3.0

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/feedRepository/api/getCustomRankingGlobalFeed.ts

@@ -23,7 +23,7 @@ import { LinkedObject } from '~/utils/linkedObject';
  * @async
  * */
 export const getCustomRankingGlobalFeed = async (query?: {
-  dataTypes?: ('video' | 'image' | 'file' | 'liveStream' | 'clip')[];
+  dataTypes?: ('video' | 'image' | 'file' | 'liveStream')[];
   limit?: number;
   queryToken?: string;
 }): Promise<

package/src/feedRepository/api/queryGlobalFeed.ts

@@ -32,7 +32,7 @@ export const queryGlobalFeed = async (
   const client = getActiveClient();
   client.log('feed/queryGlobalFeed', query);
 
-  const { queryToken, dataTypes, resolveParent, ...params } = query ?? {};
+  const { queryToken, ...params } = query ?? {};
 
   const options = (() => {
     if (queryToken) return { token: queryToken };
@@ -44,8 +44,6 @@ export const queryGlobalFeed = async (
     {
       params: {
         ...params,
-        dataTypes,
-        resolveParent: resolveParent ?? true,
         options,
       },
     },

package/src/fileRepository/api/index.ts

@@ -5,4 +5,3 @@ export * from './fileUrlWithSize';
 export * from './uploadVideo';
 export * from './uploadImage';
 export * from './updateAltText';
-export * from './uploadClip';

package/src/postRepository/api/index.ts

@@ -13,5 +13,3 @@ export * from './declinePost';
 export * from './flagPost';
 export * from './unflagPost';
 export * from './isPostFlaggedByMe';
-
-export * from './createClipPost';

package/src/postRepository/api/queryPosts.ts

@@ -43,7 +43,7 @@ export const queryPosts = async (
   // API-FIX: parameters should be querystring. (1)
   // API-FIX: backend should answer Amity.Response (2)
   // const { data } = await client.http.get<Amity.Response<Amity.PagedResponse<Amity.PostPayload>>>(
-  const { data } = await client.http.get<Amity.PostPayload & Amity.Pagination>(`/api/v5/posts`, {
+  const { data } = await client.http.get<Amity.PostPayload & Amity.Pagination>(`/api/v4/posts`, {
     params: {
       ...params,
       isDeleted: inferIsDeleted(includeDeleted),

package/src/postRepository/observers/getPosts/PostPaginationController.ts

@@ -23,7 +23,7 @@ export class PostPaginationController extends PaginationController<
     const options = token ? { ...baseOptions, token } : { ...baseOptions, limit };
 
     const { data: queryResponse } = await this.http.get<Amity.PostPayload & Amity.Pagination>(
-      `/api/v5/posts`,
+      `/api/v4/posts`,
       {
         params: {
           ...params,

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,
 };

package/src/utils/linkedObject/invitationLinkedObject.ts

@@ -22,8 +22,10 @@ export const invitationLinkedObject = (invitation: Amity.InternalInvitation): Am
           'get',
           invitation.targetId,
         ]);
-        if (cacheData?.data) return cacheData.data;
-        return undefined;
+        return {
+          community: cacheData?.data,
+          communityId: invitation.communityId,
+        };
       }
       return undefined;
     },

package/src/utils/linkedObject/postLinkedObject.ts

@@ -2,12 +2,7 @@ import { pullFromCache } from '~/cache/api';
 import { commentLinkedObject } from '~/utils/linkedObject/commentLinkedObject';
 import AnalyticsEngine from '../../analytic/service/analytic/AnalyticsEngine';
 import { userLinkedObject } from './userLinkedObject';
-import {
-  isAmityClipPost,
-  isAmityFilePost,
-  isAmityImagePost,
-  isAmityVideoPost,
-} from '../postTypePredicate';
+import { isAmityFilePost, isAmityImagePost, isAmityVideoPost } from '../postTypePredicate';
 
 export const postLinkedObject = (post: Amity.InternalPost): Amity.Post => {
   return {
@@ -69,11 +64,5 @@ export const postLinkedObject = (post: Amity.InternalPost): Amity.Post => {
         ? pullFromCache<Amity.File<'file'>>(['file', 'get', post?.data?.fileId])?.data
         : undefined;
     },
-
-    getClipInfo(): Amity.File<'clip'> | undefined {
-      return isAmityClipPost(post)
-        ? pullFromCache<Amity.File<'clip'>>(['file', 'get', post?.data?.fileId])?.data
-        : undefined;
-    },
   };
 };

package/src/utils/postTypePredicate.ts

@@ -25,13 +25,3 @@ export function isAmityVideoPost(post: Amity.InternalPost): post is Amity.Post<'
     post.dataType === 'video'
   );
 }
-
-export function isAmityClipPost(post: Amity.InternalPost): post is Amity.Post<'clip'> {
-  return !!(
-    post.data &&
-    typeof post.data !== 'string' &&
-    'fileId' in post.data &&
-    'thumbnailFileId' in post.data &&
-    post.dataType === 'clip'
-  );
-}

package/dist/fileRepository/api/uploadClip.d.ts

@@ -1,17 +0,0 @@
-/**
- * ```js
- * import { FileRepository } from '@amityco/ts-sdk'
- * const created = await FileRepository.uploadClip(formData)
- * ```
- *
- * Creates an {@link Amity.File}
- *
- * @param formData The data necessary to create a new {@link Amity.File}
- * @param onProgress The callback to track the upload progress
- * @returns The newly created {@link Amity.File}
- *
- * @category File API
- * @async
- */
-export declare const uploadClip: (formData: FormData, feedType?: Amity.ContentFeedType, onProgress?: ((percent: number) => void) | undefined) => Promise<Amity.Cached<Amity.File<'clip'>[]>>;
-//# sourceMappingURL=uploadClip.d.ts.map

package/dist/fileRepository/api/uploadClip.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"uploadClip.d.ts","sourceRoot":"","sources":["../../../src/fileRepository/api/uploadClip.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,UAAU,aACX,QAAQ,aACP,MAAM,eAAe,0BACT,MAAM,KAAK,IAAI,kBACrC,QAAQ,MAAM,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC,CA2C5C,CAAC"}

package/dist/postRepository/api/createClipPost.d.ts

@@ -1,32 +0,0 @@
-/**
- * ```js
- * import { PostRepository } from '@amityco/ts-sdk'
- * const created = await PostRepository.createClipPost({
- *   targetType: 'user',
- *   targetId: 'foobar',
- *   dataType: 'clip',
- *   data: { text: 'hello world' },
- *   attachments: [{ type: 'clip', fileId: 'fileId123', displayMode: 'fill', isMuted: false }]
- * }))
- * ```
- *
- * Creates an {@link Amity.Post}
- *
- * @param bundle The data necessary to create a new {@link Amity.Post}
- * @returns The newly created {@link Amity.Post}
- *
- * @category Post API
- * @async
- */
-export declare const createClipPost: <T extends string>(bundle: Pick<Amity.Post<T>, "targetType" | "targetId"> & Partial<Pick<Amity.Post<T>, "metadata" | "tags" | "mentionees">> & {
-    data: {
-        [k: string]: any;
-    };
-    attachments: {
-        type: T;
-        fileId: Amity.File['fileId'];
-        displayMode?: Amity.ClipDisplayMode | undefined;
-        isMuted?: boolean | undefined;
-    }[];
-}) => Promise<Amity.Cached<Amity.Post>>;
-//# sourceMappingURL=createClipPost.d.ts.map

package/dist/postRepository/api/createClipPost.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createClipPost.d.ts","sourceRoot":"","sources":["../../../src/postRepository/api/createClipPost.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,cAAc;;;;;;gBAMX,UAAU,CAAC,QAAQ,CAAC;;;;MAKjC,QAAQ,MAAM,MAAM,CAAC,MAAM,IAAI,CAAC,CAmBlC,CAAC"}

package/src/fileRepository/api/uploadClip.ts

@@ -1,71 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient';
-import { ingestInCache } from '~/cache/api/ingestInCache';
-import GlobalFileAccessType from '~/client/utils/GlobalFileAccessType';
-
-/* begin_public_function
-  id: file.upload.clip
-*/
-/**
- * ```js
- * import { FileRepository } from '@amityco/ts-sdk'
- * const created = await FileRepository.uploadClip(formData)
- * ```
- *
- * Creates an {@link Amity.File}
- *
- * @param formData The data necessary to create a new {@link Amity.File}
- * @param onProgress The callback to track the upload progress
- * @returns The newly created {@link Amity.File}
- *
- * @category File API
- * @async
- */
-export const uploadClip = async (
-  formData: FormData,
-  feedType?: Amity.ContentFeedType,
-  onProgress?: (percent: number) => void,
-): Promise<Amity.Cached<Amity.File<'clip'>[]>> => {
-  const client = getActiveClient();
-  client.log('file/uploadClip', formData);
-
-  const file = formData.get('files');
-
-  if (!file) throw new Error('The formData object must have a `files` key.');
-
-  const accessType = GlobalFileAccessType.getInstance().getFileAccessType();
-  formData.append('accessType', accessType);
-
-  formData.append('preferredFilename', (file as File).name);
-
-  if (feedType) {
-    formData.append('feedType', feedType);
-  }
-
-  const headers =
-    'getHeaders' in formData
-      ? (formData as any).getHeaders()
-      : { 'content-type': 'multipart/form-data' };
-
-  const { data } = await client.upload.post<Amity.CreateFilePayload<'clip'>>(
-    '/api/v4/clips',
-    formData,
-    {
-      headers,
-      onUploadProgress({ loaded, total = 100 }) {
-        onProgress && onProgress(Math.round((loaded * 100) / total));
-      },
-    },
-  );
-
-  // API-FIX: payload should be serialized properly
-  // const { files } = data
-
-  const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache({ files: data }, { cachedAt });
-
-  return {
-    data,
-    cachedAt,
-  };
-};
-/* end_public_function */

package/src/postRepository/api/createClipPost.ts

@@ -1,62 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient';
-
-import { ingestInCache } from '~/cache/api/ingestInCache';
-import { fireEvent } from '~/core/events';
-import { prepareMembershipPayload } from '~/group/utils';
-import { LinkedObject } from '~/utils/linkedObject';
-
-/* begin_public_function
-  id: post.create.clip_post
-*/
-/**
- * ```js
- * import { PostRepository } from '@amityco/ts-sdk'
- * const created = await PostRepository.createClipPost({
- *   targetType: 'user',
- *   targetId: 'foobar',
- *   dataType: 'clip',
- *   data: { text: 'hello world' },
- *   attachments: [{ type: 'clip', fileId: 'fileId123', displayMode: 'fill', isMuted: false }]
- * }))
- * ```
- *
- * Creates an {@link Amity.Post}
- *
- * @param bundle The data necessary to create a new {@link Amity.Post}
- * @returns The newly created {@link Amity.Post}
- *
- * @category Post API
- * @async
- */
-export const createClipPost = async <T extends Amity.PostContentType | string>(
-  bundle: Pick<Amity.Post<T>, 'targetType' | 'targetId'> &
-    Partial<Pick<Amity.Post<T>, 'metadata' | 'mentionees' | 'tags'>> & {
-      data: { [k: string]: any };
-      attachments: {
-        type: T;
-        fileId: Amity.File['fileId'];
-        displayMode?: Amity.ClipDisplayMode;
-        isMuted?: boolean;
-      }[];
-    },
-): Promise<Amity.Cached<Amity.Post>> => {
-  const client = getActiveClient();
-  client.log('post/createPost', bundle);
-
-  const { data: payload } = await client.http.post<Amity.PostPayload>('/api/v4/posts', bundle);
-
-  fireEvent('post.created', payload);
-
-  const data = prepareMembershipPayload(payload, 'communityUsers');
-  const cachedAt = client.cache && Date.now();
-
-  if (client.cache) ingestInCache(data, { cachedAt });
-
-  const { posts } = data;
-
-  return {
-    data: LinkedObject.post(posts[0]),
-    cachedAt,
-  };
-};
-/* end_public_function */