@amityco/ts-sdk 0.0.1-beta.37 → 0.0.1-beta.39

package/src/report/api/tests/deleteReport.test.ts

@@ -0,0 +1,93 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  flaggedUser as unflaggedUser,
+  flaggedUserQueryResponse as unflaggedUserQueryResponse,
+} from '~/utils/tests';
+import { ASCApiError } from '~/core/errors';
+
+import { onUserUnflagged } from '~/user/events';
+
+import { deleteReport } from '..';
+import REFERENCE_TYPES from '../../constants/referenceTypes';
+
+describe('deleteReport', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  // integration_test_id: fddf1d63-98e2-4296-ab3a-4e2b55044f89
+  test('it should unflag user with userId', async () => {
+    const expected = true;
+    client.http.delete = jest.fn().mockResolvedValue(unflaggedUserQueryResponse);
+
+    const received = await deleteReport('user', unflaggedUser.userId);
+
+    expect(received).toBe(expected);
+  });
+
+  // integration_test_id: a95a0784-56ce-4b17-ac1b-0f1c50a361ef
+  test('it should throw error with 400400 when sending invalid userId', async () => {
+    client.http.delete = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('unauthorized', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(deleteReport('user', unflaggedUser.userId)).rejects.toThrow('400400');
+  });
+
+  test('it should fire event for user', async () => {
+    let dispose;
+    const expected = unflaggedUser;
+
+    client.http.delete = jest.fn().mockResolvedValue(unflaggedUserQueryResponse);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onUserUnflagged(resolve);
+    }).finally(dispose);
+
+    const recieved = await deleteReport('user', unflaggedUser.userId);
+
+    expect(recieved).toBe(true);
+    await expect(callbackPromise).resolves.toEqual(expect.objectContaining(expected));
+  });
+
+  test.todo('it should fire event for unflagging message');
+  test.todo('it should fire event for unflagging delete');
+
+  const tests: [keyof typeof REFERENCE_TYPES, string, string][] = [
+    ['user', 'userId', `/api/v4/me/flags/${encodeURIComponent('userId')}`],
+    ['post', 'postId', `/api/v3/posts/${encodeURIComponent('postId')}/unflag`],
+    ['message', 'messageId', `/api/v5/messages/${encodeURIComponent('messageId')}/flags`],
+  ];
+
+  test.each(tests)(
+    'it should call the appropriate api for %s',
+    async (referenceType, referenceId, expected) => {
+      const apimock = jest.fn();
+
+      client.http.delete = apimock.mockResolvedValue({ data: {} });
+
+      await deleteReport(referenceType, referenceId);
+
+      const received = apimock.mock.lastCall[0];
+
+      expect(received).toBe(expected);
+    },
+  );
+
+  test('it should add data to cache', async () => {
+    enableCache();
+    const expected = unflaggedUser;
+    client.http.delete = jest.fn().mockResolvedValue(unflaggedUserQueryResponse);
+
+    await deleteReport('user', unflaggedUser.userId);
+    const recieved = pullFromCache(['user', 'get', unflaggedUser.userId]);
+
+    expect(recieved?.data).toBe(expected);
+
+    disableCache();
+  });
+});

package/src/stream/api/tests/createStream.test.ts

@@ -1,15 +1,10 @@
 import { getActiveClient } from '~/client/api';
-import {
-  client,
-  connectClient,
-  disconnectClient,
-  streamResponse,
-} from '~/utils/tests';
+import { client, connectClient, disconnectClient, streamResponse } from '~/utils/tests';
 import { createStream } from '../createStream';
 
 const bundle: Parameters<typeof createStream>[0] = {
   title: 'my stream',
-  'thumbnailFileId': streamResponse.data.videoStreamings[0].thumbnailFileId,
+  thumbnailFileId: streamResponse.data.videoStreamings[0].thumbnailFileId,
 };
 
 describe('createStream', () => {
@@ -21,10 +16,7 @@ describe('createStream', () => {
 
     const created = await createStream(bundle);
 
-    expect(getActiveClient().http.post).toHaveBeenCalledWith(
-      `/api/v3/video-streaming`,
-      bundle
-    );
+    expect(getActiveClient().http.post).toHaveBeenCalledWith(`/api/v3/video-streaming`, bundle);
     expect(created.data).toEqual(streamResponse.data.videoStreamings[0]);
   });
 });

package/src/stream/api/tests/deleteStream.test.ts

@@ -39,9 +39,11 @@ describe('deleteStream', () => {
     await deleteStream(STREAM_ID);
     const recieved = pullFromCache(['stream', 'get', STREAM_ID])?.data;
 
-    expect(recieved).toEqual(expect.objectContaining({
-      isDeleted: true
-    }));
+    expect(recieved).toEqual(
+      expect.objectContaining({
+        isDeleted: true,
+      }),
+    );
 
     disableCache();
   });

package/src/subChannel/api/tests/createSubChannel.test.ts

@@ -1,14 +1,10 @@
 import { createSubChannel } from '../createSubChannel';
-import {
-  client,
-  generateRawSubChannel,
-  createSubChannelError400301,
-  createSubChannelError400400,
-} from '~/utils/tests';
+import { client, generateRawSubChannel } from '~/utils/tests';
 
 import { onSubChannelCreated } from '~/subChannel/events';
 
-import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
 
 const subChannelId = 'channelId11--sub-channel-id';
 
@@ -38,37 +34,48 @@ describe('createSubChannel', () => {
 
   // integration_test_id: f5b376b7-32b6-47f3-a5a1-553221340d17
   test('it should return error 400400 when try to create subChannel from wrong parent channel Id', async () => {
+    const apiError = new ASCApiError(
+      'Channel not found.',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+
     client.http.post = jest.fn().mockRejectedValue({
       status: 404,
-      data: createSubChannelError400400,
+      data: apiError,
     });
 
     try {
       await createSubChannel({
-        channelId: createSubChannelError400400.data.detail.channelId,
+        channelId: 'invalid_channel_id',
         displayName: 'sub channel name',
       });
     } catch ({ status = null, data = null }) {
       expect(status).toEqual(404);
-      expect(data).toEqual(createSubChannelError400400);
+      expect(data).toEqual(apiError);
     }
   });
 
   // integration_test_id: 73b59e57-2330-4ed3-95bd-241c9e7a2c43
-  test('it should return error 400301 when try to create subChannel from channel Id', async () => {
+  test('it should return error 400301 when try to create subChannel from channel Id which current user is not member', async () => {
+    const apiError = new ASCApiError(
+      'You are not a member of this channel.',
+      Amity.ServerError.PERMISSION_DENIED,
+      Amity.ErrorLevel.ERROR,
+    );
     client.http.post = jest.fn().mockRejectedValue({
       status: 403,
-      data: createSubChannelError400301,
+      data: apiError,
     });
 
     try {
       await createSubChannel({
-        channelId: createSubChannelError400301.data.detail.channelId,
+        channelId: 'invalid_channel_id',
         displayName: 'sub channel name',
       });
     } catch ({ status = null, data = null }) {
       expect(status).toEqual(403);
-      expect(data).toEqual(createSubChannelError400301);
+      expect(data).toEqual(apiError);
     }
   });
 

package/src/subChannel/api/tests/deleteSubChannel.test.ts

@@ -0,0 +1,112 @@
+import { deleteSubChannel } from '../deleteSubChannel';
+import { onSubChannelDeleted } from '../../events';
+
+import { client, generateRawSubChannel } from '~/utils/tests';
+
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
+
+const subChannelId = 'channelId11--sub-channel-id';
+
+describe('createSubChannel', () => {
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  // integration_test_id: 43ba1273-4560-4cea-93ce-cf5728b2a475
+  test('it should delete sub channel', async () => {
+    const rawSubChannel = generateRawSubChannel();
+    const rawDeleteSubChannel = generateRawSubChannel({ isDeleted: true });
+
+    // Mock for getSubChannel
+    client.http.get = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    client.http.delete = jest.fn().mockResolvedValue({
+      data: {
+        messageFeeds: [rawDeleteSubChannel],
+        messages: [],
+        users: [],
+        files: [],
+      },
+    });
+
+    const result = await deleteSubChannel(subChannelId);
+    expect(result.isDeleted).toEqual(true);
+  });
+
+  // integration_test_id: 57ba785f-484b-4f19-aa38-18e0bd4ec433
+  test('it should return error 400400 when try to delete subChannel from invalid subChannelId', async () => {
+    const apiError = new ASCApiError(
+      'Feed not found',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.get = jest.fn().mockRejectedValue({
+      status: 404,
+      data: apiError,
+    });
+
+    try {
+      await deleteSubChannel(subChannelId);
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(404);
+      expect(data).toEqual(apiError);
+    }
+  });
+
+  test('it should return a valid sub channel from cache', async () => {
+    const rawSubChannel = generateRawSubChannel();
+    const rawDeleteSubChannel = generateRawSubChannel({ isDeleted: true });
+
+    // Mock for getSubChannel
+    client.http.get = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    client.http.delete = jest.fn().mockResolvedValue({
+      data: {
+        messageFeeds: [rawDeleteSubChannel],
+        messages: [],
+        users: [],
+        files: [],
+      },
+    });
+
+    await deleteSubChannel(subChannelId);
+
+    const cache = pullFromCache(['subChannel', 'get', subChannelId]);
+
+    expect(cache?.data).toEqual(expect.objectContaining({ isDeleted: true }));
+  });
+
+  test('should fire event `onChannelDeleted`', async () => {
+    let dispose;
+    const rawSubChannel = generateRawSubChannel();
+    const rawDeleteSubChannel = generateRawSubChannel({ isDeleted: true });
+
+    // Mock for getSubChannel
+    client.http.get = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    client.http.delete = jest.fn().mockResolvedValue({
+      data: {
+        messageFeeds: [rawDeleteSubChannel],
+        messages: [],
+        users: [],
+        files: [],
+      },
+    });
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onSubChannelDeleted(resolve);
+    }).finally(dispose);
+
+    await deleteSubChannel(subChannelId);
+
+    await expect(callbackPromise).resolves.toEqual(expect.objectContaining({ isDeleted: true }));
+  });
+});

package/src/subChannel/api/tests/getSubChannel.test.ts

@@ -0,0 +1,97 @@
+import { getSubChannel } from '../getSubChannel';
+import { client, generateRawSubChannel } from '~/utils/tests';
+
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
+import { onSubChannelFetched } from '../../events/onSubChannelFetched';
+
+const subChannelId = 'channelId11--sub-channel-id';
+
+const subChannelPayload = {
+  channelId: 'channelId11',
+  displayName: 'sub channel name',
+};
+
+describe('createSubChannel', () => {
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  // integration_test_id: 6f019056-921e-43e2-a426-dd5a96f2fdcf
+  test('it should return a valid sub channel', async () => {
+    const rawSubChannel = generateRawSubChannel();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    const { data } = await getSubChannel(subChannelId);
+
+    expect(data.channelId).toEqual(subChannelPayload.channelId);
+    expect(data.displayName).toEqual(subChannelPayload.displayName);
+    expect(data.subChannelId).toEqual(subChannelId);
+  });
+
+  // integration_test_id: 0dc440b6-b2bb-41fb-bbe8-1b2a4c71bffc
+  test('it should return error 400400 when try to get subChannel from invalid subChannelId', async () => {
+    const apiError = new ASCApiError(
+      'Feed not found',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.put = jest.fn().mockRejectedValue({
+      status: 404,
+      data: apiError,
+    });
+
+    try {
+      await getSubChannel(subChannelId);
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(404);
+      expect(data).toEqual(apiError);
+    }
+  });
+
+  test('it should return a valid sub channel from cache', async () => {
+    const rawSubChannel = generateRawSubChannel();
+    client.http.put = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    const { data } = await getSubChannel(subChannelId);
+
+    const cache = pullFromCache(['subChannel', 'get', subChannelId]);
+
+    expect(cache?.data).toEqual(data);
+  });
+
+  test('it should return a valid sub channel from locally cache', async () => {
+    const rawSubChannel = generateRawSubChannel();
+    client.http.put = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    await getSubChannel(subChannelId);
+
+    const cache = pullFromCache(['subChannel', 'get', subChannelId]);
+    const locallyData = await getSubChannel.locally(subChannelId);
+
+    expect(cache?.data).toEqual(locallyData?.data);
+  });
+
+  test('should fire event `onSubChannelFetched`', async () => {
+    let dispose;
+    const rawSubChannel = generateRawSubChannel();
+    client.http.put = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onSubChannelFetched(resolve);
+    }).finally(dispose);
+
+    const { data } = await getSubChannel(subChannelId);
+
+    await expect(callbackPromise).resolves.toMatchObject(data);
+  });
+});

package/src/subChannel/api/tests/getSubChannels.test.ts

@@ -0,0 +1,97 @@
+import { getSubChannels } from '../getSubChannels';
+import { client, generateRawSubChannel } from '~/utils/tests';
+
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
+import { onSubChannelFetched } from '../../events/onSubChannelFetched';
+
+const subChannelId = 'channelId11--sub-channel-id';
+
+const subChannelPayload = {
+  channelId: 'channelId11',
+  displayName: 'sub channel name',
+};
+
+describe('createSubChannel', () => {
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  // integration_test_id: dc771f42-14b9-420e-999d-858151e8ce41
+  test('it should return a valid sub channel', async () => {
+    const rawSubChannel = generateRawSubChannel();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    const { data } = await getSubChannels([subChannelId]);
+
+    expect(data[0].channelId).toEqual(subChannelPayload.channelId);
+    expect(data[0].displayName).toEqual(subChannelPayload.displayName);
+    expect(data[0].subChannelId).toEqual(subChannelId);
+  });
+
+  // integration_test_id: 28710df0-e5b6-4e46-b1aa-440d5ea01995
+  test('it should return error 400400 when try to get subChannel from invalid subChannelId', async () => {
+    const apiError = new ASCApiError(
+      'Feed not found',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.get = jest.fn().mockRejectedValue({
+      status: 404,
+      data: apiError,
+    });
+
+    try {
+      await getSubChannels([subChannelId]);
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(404);
+      expect(data).toEqual(apiError);
+    }
+  });
+
+  test('it should return a valid sub channel from cache', async () => {
+    const rawSubChannel = generateRawSubChannel();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    const { data } = await getSubChannels([subChannelId]);
+
+    const cache = pullFromCache(['subChannel', 'get', subChannelId]);
+
+    expect(cache?.data).toEqual(data[0]);
+  });
+
+  test('it should return a valid sub channel from locally cache', async () => {
+    const rawSubChannel = generateRawSubChannel();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    await getSubChannels([subChannelId]);
+
+    const cache = pullFromCache(['subChannel', 'get', subChannelId]);
+    const locallyData = await getSubChannels.locally([subChannelId]);
+
+    expect(cache?.data).toEqual(locallyData?.data[0]);
+  });
+
+  test('should fire event `onSubChannelFetched`', async () => {
+    let dispose;
+    const rawSubChannel = generateRawSubChannel();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onSubChannelFetched(resolve);
+    }).finally(dispose);
+
+    const { data } = await getSubChannels([subChannelId]);
+
+    await expect(callbackPromise).resolves.toMatchObject(data[0]);
+  });
+});

package/src/subChannel/api/tests/updateSubChannel.test.ts

@@ -0,0 +1,86 @@
+import { updateSubChannel } from '../updateSubChannel';
+import { client, generateRawSubChannel } from '~/utils/tests';
+
+import { onSubChannelUpdated } from '~/subChannel/events';
+
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
+
+const subChannelId = 'channelId11--sub-channel-id';
+
+const subChannelPayload = {
+  channelId: 'channelId11',
+  displayName: 'sub channel name',
+};
+
+describe('createSubChannel', () => {
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  // integration_test_id: 9f50fa02-c26c-4666-8e8b-2d9076a3edd3
+  test('it should return a valid sub channel', async () => {
+    const rawSubChannel = generateRawSubChannel();
+    client.http.put = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    const { data } = await updateSubChannel(subChannelId, subChannelPayload);
+
+    expect(data.channelId).toEqual(subChannelPayload.channelId);
+    expect(data.displayName).toEqual(subChannelPayload.displayName);
+    expect(data.subChannelId).toEqual(subChannelId);
+  });
+
+  // integration_test_id: 118f410c-5476-4c4e-9199-ac166da30840
+  test('it should return error 400400 when try to update subChannel from wrong sub channel Id', async () => {
+    const apiError = new ASCApiError(
+      'Feed not found',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.put = jest.fn().mockRejectedValue({
+      status: 404,
+      data: apiError,
+    });
+
+    try {
+      await updateSubChannel(subChannelId, {
+        displayName: 'sub channel name',
+      });
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(404);
+      expect(data).toEqual(apiError);
+    }
+  });
+
+  test('it should return a valid sub channel from cache', async () => {
+    const rawSubChannel = generateRawSubChannel();
+    client.http.put = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    const { data } = await updateSubChannel(subChannelId, subChannelPayload);
+
+    const cache = pullFromCache(['subChannel', 'get', subChannelId]);
+
+    expect(cache?.data).toEqual(data);
+  });
+
+  test('should fire event `onSubChannelUpdated`', async () => {
+    let dispose;
+    const rawSubChannel = generateRawSubChannel();
+    client.http.put = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onSubChannelUpdated(resolve);
+    }).finally(dispose);
+
+    const { data } = await updateSubChannel(subChannelId, subChannelPayload);
+
+    await expect(callbackPromise).resolves.toMatchObject(data);
+  });
+});

package/src/subChannel/observers/liveSubChannel.ts

@@ -1,7 +1,4 @@
-import { getActiveClient } from '~/client/api';
-import { createQuery, runQuery } from '~/core/query';
-import { LIVE_OBJECT_ENABLE_CACHE_MESSAGE } from '~/utils/constants';
-import { hasUpdates } from '~/core/model';
+import { liveObject } from '~/utils/liveObject';
 import { getSubChannel } from '../api';
 import { onSubChannelDeleted, onSubChannelUpdated } from '../events';
 import { onSubChannelFetched } from '../events/onSubChannelFetched';
@@ -29,56 +26,9 @@ export const liveSubChannel = (
   subChannelId: Amity.SubChannel['subChannelId'],
   callback: Amity.LiveObjectCallback<Amity.SubChannel>,
 ): Amity.Unsubscriber => {
-  const { log, cache } = getActiveClient();
-  const timestamp = Date.now();
-  log(`liveSubChannel(tmpid: ${timestamp}) > listen`);
-
-  if (!cache) {
-    console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
-  }
-
-  let subChannel: Amity.SubChannel;
-  const disposers: Amity.Unsubscriber[] = [];
-
-  const dispatcher = (data: Amity.LiveObject<Amity.SubChannel>) => {
-    subChannel = data.data;
-    callback(data);
-  };
-
-  const realtimeRouter = (eventSubChannel: Amity.SubChannel) => {
-    if (subChannelId !== eventSubChannel.subChannelId) {
-      return;
-    }
-
-    if (subChannel && !hasUpdates(subChannel, eventSubChannel)) {
-      return;
-    }
-
-    dispatcher({ loading: false, data: eventSubChannel, origin: 'event' });
-  };
-
-  const onFetch = () => {
-    const query = createQuery(getSubChannel, subChannelId);
-
-    runQuery(query, ({ error, data, loading, origin }) => {
-      dispatcher({ error, data, loading, origin });
-
-      if (error) {
-        disposers.forEach(fn => fn());
-      }
-    });
-  };
-
-  disposers.push(
-    onSubChannelFetched(realtimeRouter),
-    onSubChannelUpdated(realtimeRouter),
-    onSubChannelDeleted(realtimeRouter),
-  );
-
-  onFetch();
-
-  return () => {
-    log(`liveSubChannel(tmpid: ${timestamp}) > dispose`);
-    disposers.forEach(fn => fn());
-  };
+  return liveObject(subChannelId, callback, 'subChannelId', getSubChannel, [
+    onSubChannelFetched,
+    onSubChannelUpdated,
+    onSubChannelDeleted,
+  ]);
 };