@amityco/ts-sdk 0.0.1-beta.36 → 0.0.1-beta.38

package/src/utils/tests/dummy/channel.ts

@@ -54,7 +54,13 @@ export const mockPage = {
   },
 };
 
-export const channelRaw1: Amity.ChannelRaw = generateRawChannel();
+export const channelRaw1: Amity.ChannelRaw = generateRawChannel({ type: 'community' });
+
+export const channelRawLive1: Amity.ChannelRaw = generateRawChannel({ type: 'live' });
+
+export const channelRawConversation1: Amity.ChannelRaw = generateRawChannel({
+  type: 'conversation',
+});
 
 export const channelRaw2: Amity.ChannelRaw = generateRawChannel({
   channelId: 'channelId12',
@@ -132,6 +138,16 @@ export const channelQueryResponse = {
   },
 };
 
+export const getChannelsResponse = {
+  data: {
+    channels: [channelRaw1, channelRaw2, channelRaw3],
+    channelUsers: [],
+    files: [],
+    users: [],
+    ...mockPage,
+  },
+};
+
 export const channelQueryResponsePage2 = {
   data: {
     channels: [channelRaw3],
@@ -142,6 +158,26 @@ export const channelQueryResponsePage2 = {
   },
 };
 
+export const channelTagQueryResponse = {
+  data: {
+    channels: [channelRaw2],
+    channelUsers: [],
+    files: [],
+    users: [],
+    ...mockPage,
+  },
+};
+
+export const channelExcludeTagQueryResponse = {
+  data: {
+    channels: [channelRaw1, channelRaw3],
+    channelUsers: [],
+    files: [],
+    users: [],
+    ...mockPage,
+  },
+};
+
 export const channelUserQueryResponse = {
   data: {
     channels: [channelRaw1],
@@ -191,3 +227,17 @@ export const channelPayload = {
   users: [user14, user11],
   files: [file11],
 };
+
+export const liveChannelPayload = {
+  channels: [channelRawLive1],
+  channelUsers: [rawChannelUserWithRole, rawMutedChannelUser],
+  users: [user14, user11],
+  files: [file11],
+};
+
+export const conversationChannelPayload = {
+  channels: [channelRawConversation1],
+  channelUsers: [rawChannelUserWithRole, rawMutedChannelUser],
+  users: [user14, user11],
+  files: [file11],
+};

package/src/utils/tests/dummy/community.ts

@@ -106,3 +106,97 @@ export const communityUserModel = [
   { ...communityUser11, user: user11 },
   { ...communityUser12, user: user12 },
 ];
+
+export const communityRaw1 = {
+  path: '631f16be1e440400da5663b0/social/community/63c8e023d2474637568ece5e',
+  isOfficial: false,
+  isPublic: true,
+  onlyAdminCanPost: false,
+  postsCount: 0,
+  membersCount: 1,
+  moderatorMemberCount: 1,
+  updatedAt: '2023-01-19T06:16:03.818Z',
+  createdAt: '2023-01-19T06:16:03.818Z',
+  isDeleted: true,
+  needApprovalOnPostCreation: false,
+  displayName: 'community 1',
+  tags: ['test-community-tag'],
+  metadata: {},
+  hasFlaggedComment: false,
+  hasFlaggedPost: true,
+  communityId: '63c8e023d2474637568ece5e',
+  channelId: '63c8e023d2474637568ece5e',
+  userId: user11.userId,
+  isJoined: true,
+  avatarFileId: '',
+  categoryIds: ['test-category-id'],
+};
+
+export const communityRaw2 = {
+  path: '631f16be1e440400da5663b0/social/community/63c8cd098309f85d2ec7dad7',
+  isOfficial: false,
+  isPublic: true,
+  onlyAdminCanPost: false,
+  postsCount: 0,
+  membersCount: 1,
+  moderatorMemberCount: 1,
+  updatedAt: '2023-01-19T04:54:57.078Z',
+  createdAt: '2023-01-19T04:54:33.716Z',
+  isDeleted: false,
+  needApprovalOnPostCreation: false,
+  displayName: 'new community ....1',
+  tags: [],
+  metadata: {},
+  hasFlaggedComment: false,
+  hasFlaggedPost: false,
+  communityId: '63c8cd098309f85d2ec7dad7',
+  channelId: '63c8cd098309f85d2ec7dad7',
+  userId: user12.userId,
+  isJoined: false,
+  avatarFileId: '',
+  categoryIds: [],
+};
+
+export const communityQueryResponse = {
+  data: {
+    communities: [communityRaw1, communityRaw2],
+    communityUsers: [communityUser11],
+    categories: [
+      {
+        name: '$testing category',
+        metadata: {},
+        updatedAt: '2022-11-25T03:56:06.238Z',
+        createdAt: '2022-11-25T03:56:06.238Z',
+        isDeleted: false,
+        categoryId: '88d175da65cbfeb39b81e722b322430d',
+      },
+    ],
+    users: [user11, user12],
+    feeds: [],
+    paging: {
+      next: 'eyJza2lwIjoxMCwibGltaXQiOjEwfQ==',
+    },
+  },
+};
+
+export const communityQueryResponsePage2 = {
+  data: {
+    communities: [communityRaw1],
+    communityUsers: [communityUser11],
+    categories: [
+      {
+        name: '$testing category',
+        metadata: {},
+        updatedAt: '2022-11-25T03:56:06.238Z',
+        createdAt: '2022-11-25T03:56:06.238Z',
+        isDeleted: false,
+        categoryId: '88d175da65cbfeb39b81e722b322430d',
+      },
+    ],
+    users: [user11, user12],
+    feeds: [],
+    paging: {
+      next: 'eyJza2lwIjoxMCwibGltaXQiOjEwfQ==',
+    },
+  },
+};

package/src/utils/tests/dummy/file.ts

@@ -1,3 +1,5 @@
+import MockFormData from 'form-data';
+
 export const file11: Amity.File<'image'> = {
   fileId: 'file-Id',
   fileUrl: 'https://fileUrl.com/test-file',
@@ -18,3 +20,33 @@ export const file11: Amity.File<'image'> = {
     },
   },
 };
+
+export const file12: Amity.File<'video'> = {
+  fileId: 'file-Id-12',
+  feedType: 'post',
+  status: 'uploaded',
+  fileUrl: 'https://fileUrl.com/test-file',
+  type: 'video',
+  createdAt: '2023-01-20T18:37:19.583Z',
+  updatedAt: '2023-01-20T18:37:19.583Z',
+  attributes: {
+    name: 'test.mp4',
+    extension: 'mp4',
+    size: '3652304',
+    mimeType: 'video/mp4',
+    metadata: {},
+  },
+};
+
+export const createFileFormData = () => {
+  const fd = new MockFormData() as unknown as FormData;
+  fd.append('files', 'file');
+  fd.getAll = jest.fn().mockImplementation(() => ['file']);
+  return fd;
+};
+
+export const createEmptyFormData = () => {
+  const fd = new MockFormData() as unknown as FormData;
+  fd.getAll = jest.fn().mockImplementation(() => []);
+  return fd;
+};

package/src/utils/tests/dummy/index.ts

@@ -15,5 +15,9 @@ export * from './channel';
 export * from './subChannel';
 
 export * from './message';
+export * from './token';
 export * from './member';
 export * from './community';
+export * from './category';
+
+export * from './stream';

package/src/utils/tests/dummy/post.ts

@@ -1,52 +1,63 @@
 import { user11, file11, communityUser11, date } from '.';
 import { encodeJson } from '..';
 
-export const post11: Amity.Post = {
-  path: '',
-  feedId: '',
-  children: [],
-  comments: [],
-  flagCount: 0,
-  reactions: {},
-  hashFlag: null,
-  editedAt: date,
-  createdAt: date,
-  commentsCount: 0,
-  reactionsCount: 0,
-  postId: 'postId11',
-  targetType: 'user',
-  parentId: 'postId12',
-  data: { text: 'post11' },
-  targetId: user11.userId,
-  hasFlaggedComment: false,
-  hasFlaggedChildren: false,
-  postedUserId: user11.userId,
-};
+export function generatePost(params?: Partial<Amity.Post>): Amity.Post {
+  return {
+    children: [],
+    comments: [],
+    commentsCount: 0,
+    createdAt: date,
+    data: { text: 'post11' },
+    editedAt: date,
+    feedId: '',
+    flagCount: 0,
+    hashFlag: null,
+    hasFlaggedComment: false,
+    hasFlaggedChildren: false,
+    parentId: 'postId12',
+    path: '',
+    postedUserId: user11.userId,
+    postId: 'postId11',
+    reactions: {},
+    reactionsCount: 0,
+    targetId: user11.userId,
+    targetType: 'user',
+    updatedAt: date,
+    ...params,
+  };
+}
 
-export const comment11: Amity.Comment = {
-  path: '',
-  referenceType: 'post',
-  dataType: 'text',
-  rootId: 'test',
-  data: {
-    text: 'yellow new world',
-  },
-  childrenNumber: 0,
-  isDeleted: false,
-  editedAt: '2022-10-31T05:57:45.661Z',
-  updatedAt: '2022-10-31T05:57:45.670Z',
-  createdAt: '2022-10-31T05:57:45.661Z',
-  segmentNumber: 2,
-  commentId: 'comment11',
-  userId: 'test',
-  referenceId: post11.postId,
-  flagCount: 0,
-  hashFlag: null,
-  children: [],
-  mentionees: [],
-  reactions: {},
-  reactionsCount: 0,
-};
+export function generateComment(params?: Partial<Amity.Comment>): Amity.Comment {
+  return {
+    path: '',
+    referenceType: 'post',
+    dataType: 'text',
+    rootId: 'test',
+    data: {
+      text: 'yellow new world',
+    },
+    childrenNumber: 0,
+    isDeleted: false,
+    editedAt: '2022-10-31T05:57:45.661Z',
+    updatedAt: '2022-10-31T05:57:45.670Z',
+    createdAt: '2022-10-31T05:57:45.661Z',
+    segmentNumber: 2,
+    commentId: 'comment11',
+    userId: 'test',
+    referenceId: 'postId11',
+    flagCount: 0,
+    hashFlag: null,
+    children: [],
+    mentionees: [],
+    reactions: {},
+    reactionsCount: 0,
+    ...params,
+  };
+}
+
+export const post11: Amity.Post = generatePost();
+
+export const comment11: Amity.Comment = generateComment();
 
 export const post12: Amity.Post = {
   ...post11,

package/src/utils/tests/dummy/stream.ts

@@ -0,0 +1,86 @@
+export const streamResponse = {
+  data: {
+    videoStreamings: [
+      {
+        streamId: '123',
+        userId: '123',
+        thumbnailFileId: '123',
+        title: 'Test Stream',
+        status: 'idle',
+        isLive: true,
+        isDeleted: true,
+        description: 'Test Stream Description',
+        platform: {
+          name: 'x86',
+          version: '123',
+        },
+        startedAt: '2023-01-17T07:19:06.414Z',
+        endedAt: '2023-01-17T07:19:06.414Z',
+        createdAt: '2023-01-17T07:19:06.414Z',
+        updatedAt: '2023-01-17T07:19:06.414Z',
+        metadata: {},
+        resolution: 'SD',
+        streamerUrl: {
+          url: 'https://test-stream.test',
+          components: {
+            origin: 'origin',
+            appName: 'stream app',
+            streamName: 'stream name',
+            query: '123',
+          },
+        },
+        recordings: [
+          {
+            flv: {
+              url: 'https://test-stream-flv.test',
+              duration: 0,
+              startTime: 0,
+              stopTime: 0,
+            },
+            mp4: {
+              url: 'https://test-stream-mp4.test',
+              duration: 0,
+              startTime: 0,
+              stopTime: 0,
+            },
+            m3u8: {
+              url: 'https://test-stream-m3u8.test',
+              duration: 0,
+              startTime: 0,
+              stopTime: 0,
+            },
+          },
+        ],
+        watcherUrl: {
+          flv: {
+            url: 'https://test-stream-flv.test',
+            components: {
+              origin: '1',
+              appName: '2',
+              streamName: '3',
+              query: '4',
+            },
+          },
+          hls: {
+            url: 'https://test-stream-hls.test',
+            components: {
+              origin: '1',
+              appName: '2',
+              streamName: '3',
+              query: '4',
+            },
+          },
+          rtmp: {
+            url: 'https://test-stream-rtmp.test',
+            components: {
+              origin: '1',
+              appName: '2',
+              streamName: '3',
+              query: '4',
+            },
+          },
+        },
+      },
+    ],
+  },
+};

package/src/utils/tests/dummy/token.ts

@@ -0,0 +1,12 @@
+import { user11 } from '.';
+
+export const sessionResponse = {
+  data: {
+    accessToken: 'test-access-token',
+    refreshToken: 'test-refresh-token',
+    issuedAt: new Date(),
+    expiresAt: new Date(),
+    users: [user11],
+    files: [],
+  },
+};

package/src/utils/tests/dummy/user.ts

@@ -36,6 +36,27 @@ export const userQueryResponse = {
     },
   },
 };
+
+export const userUpdateResponse = {
+  data: {
+    users: [
+      {
+        isDeleted: false,
+        displayName: 'updated-display-name',
+        userId: 'test-user',
+        metadata: {},
+        roles: [],
+        permissions: [],
+        flagCount: 0,
+        hashFlag: null,
+        avatarCustomUrl: 'updated-avatarUrl',
+        avatarFileId: null,
+        isGlobalBan: false,
+      },
+    ],
+    files: [],
+  },
+};
 export const users = [user11, user12, user13, user14];
 
 // user payload with file

package/src/utils/tests/liveObject.test.ts

@@ -0,0 +1,172 @@
+import { generatePost } from '~/utils/tests/dummy';
+import { pause } from '~/utils/tests/utils';
+import { connectClient, disconnectClient } from '~/utils/tests/client';
+import { disableCache, enableCache } from '~/cache/api';
+import { getFutureDate, getPastDate } from '~/core/model';
+import { LIVE_OBJECT_ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { liveObject } from '../liveObject';
+
+describe('liveObject', () => {
+  let post: Amity.Post;
+  let fetcher: jest.Mock;
+  let callback: jest.Mock;
+  let eventCallback: Amity.Listener<Amity.Post>;
+  let eventUnsubscriber: jest.Mock;
+  const onEvent = (fn: Amity.Listener<Amity.Post>) => {
+    eventCallback = fn;
+    eventUnsubscriber = jest.fn();
+
+    return eventUnsubscriber;
+  };
+  let unsubscribe: Amity.Unsubscriber;
+
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(() => {
+    enableCache();
+
+    callback = jest.fn();
+    post = generatePost({ postId: 'my-post-id' });
+    fetcher = jest.fn().mockResolvedValue(post);
+  });
+
+  afterEach(() => {
+    disableCache();
+    unsubscribe();
+  });
+
+  test('it should show message if cache not enabled', () => {
+    /*
+     * NOTE: at the time of writing this test cache is disabled by default, but
+     * there is a proposal to enable cache by default. So I'm disabling cache
+     * here to ensure cache is disabled
+     */
+    disableCache();
+    jest.spyOn(global.console, 'log');
+
+    unsubscribe = liveObject<Amity.Post, 'postId'>(post.postId, callback, 'postId', fetcher, []);
+
+    expect(console.log).toBeCalledWith(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
+  });
+
+  it('should fetch the model', async () => {
+    unsubscribe = liveObject<Amity.Post, 'postId'>(post.postId, callback, 'postId', fetcher, []);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({ data: undefined, loading: true }),
+    );
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        data: post,
+        loading: false,
+      }),
+    );
+  });
+
+  it('should provide the error if fetch is failed', async () => {
+    const error = new Error('can not fetch');
+
+    unsubscribe = liveObject<Amity.Post, 'postId'>(
+      post.postId,
+      callback,
+      'postId',
+      () => {
+        return Promise.reject(error);
+      },
+      [onEvent],
+    );
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({ data: undefined, loading: true }),
+    );
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        data: undefined,
+        error,
+        loading: false,
+      }),
+    );
+    expect(eventUnsubscriber).toHaveBeenCalledTimes(1);
+  });
+
+  it('should update the model on the event', async () => {
+    const update = {
+      ...post,
+      data: { text: 'new-text' },
+      updatedAt: getFutureDate(post.updatedAt),
+    };
+
+    unsubscribe = liveObject<Amity.Post, 'postId'>(post.postId, callback, 'postId', fetcher, [
+      onEvent,
+    ]);
+    await pause();
+    eventCallback(update);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(3);
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: update,
+        loading: false,
+      }),
+    );
+  });
+
+  it('should not update the model on the event if the model is already the latest', async () => {
+    const update = {
+      ...post,
+      data: { text: 'new-text' },
+      updatedAt: getPastDate(post.updatedAt),
+    };
+
+    unsubscribe = liveObject<Amity.Post, 'postId'>(post.postId, callback, 'postId', fetcher, [
+      onEvent,
+    ]);
+    await pause();
+    eventCallback(update);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+  });
+
+  it('should not update the model on the event if the model has different id', async () => {
+    const post2 = generatePost({
+      postId: 'my-post-id-2',
+      updatedAt: getFutureDate(post.updatedAt),
+    });
+
+    unsubscribe = liveObject<Amity.Post, 'postId'>(post.postId, callback, 'postId', fetcher, [
+      onEvent,
+    ]);
+    await pause();
+    eventCallback(post2);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+  });
+
+  it('should unsubscribe from events on liveObject disposing', async () => {
+    unsubscribe = liveObject<Amity.Post, 'postId'>(post.postId, callback, 'postId', fetcher, [
+      onEvent,
+    ]);
+    await pause();
+    unsubscribe();
+
+    expect(eventUnsubscriber).toHaveBeenCalledTimes(1);
+  });
+});