@amityco/ts-sdk 0.0.1-cb052d5.0 → 0.0.1-cbf10e4.0

package/src/channel/api/tests/createChannel.test.ts

@@ -0,0 +1,52 @@
+import { pullFromCache, enableCache, disableCache } from '~/cache/api';
+
+import { client, channelPayload } from '~/utils/tests';
+
+import { createChannel } from '../createChannel';
+
+const resPayload = { data: channelPayload };
+
+describe('createChannel', () => {
+  test('it should create a channel', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce(resPayload);
+
+    const res = await createChannel({ type: 'community' });
+
+    expect(res).toBeDefined();
+    expect(res.data).toStrictEqual(channelPayload.channels[0]);
+  });
+
+  test('it should add channel to cache', async () => {
+    enableCache();
+
+    client.http.post = jest.fn().mockResolvedValueOnce(resPayload);
+    const { channelId } = channelPayload.channels[0];
+
+    await createChannel({ type: 'community' });
+    const data = pullFromCache(['channel', 'get', channelId]);
+
+    expect(data).toBeDefined();
+    expect(data?.data).toStrictEqual(channelPayload.channels[0]);
+
+    disableCache();
+  });
+
+  test('it should call conversation channel with /conversation api', async () => {
+    const mockFn = jest.fn();
+    client.http.post = mockFn.mockResolvedValueOnce(resPayload);
+    const expected = '/api/v3/channels/conversation';
+    const expectedPayload = { type: 'conversation', isDistinct: true };
+
+    await createChannel({ type: 'conversation' });
+    const [recieved, recievedPayload] = mockFn.mock.lastCall;
+
+    expect(recieved).toBe(expected);
+    expect(recievedPayload).toStrictEqual(expectedPayload);
+  });
+
+  test('it should return an error', async () => {
+    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(createChannel({ type: 'conversation' })).rejects.toThrow('error');
+  });
+});

package/src/channel/api/tests/getChannel.test.ts

@@ -0,0 +1,108 @@
+import { ASCApiError } from '~/core/errors';
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import { client, channelQueryResponse } from '~/utils/tests';
+
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+import { isInTombstone } from '~/cache/api/isInTombstone';
+
+import { getChannel } from '../getChannel';
+
+const { channelId } = channelQueryResponse.data.channels[0];
+const channel = channelQueryResponse.data.channels[0];
+
+describe('getChannel', () => {
+  test('it should return a channel', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(channelQueryResponse);
+
+    const expected = channel;
+    const { data: received } = await getChannel(channelId);
+
+    expect(received).toStrictEqual(expected);
+  });
+
+  test('it should update cache after fetch from server', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
+    await getChannel(channelId);
+
+    expect(getChannel.locally(channelId)).toBeDefined();
+
+    disableCache();
+  });
+
+  test('it should return an error', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(getChannel(channelId)).rejects.toThrow('error');
+  });
+
+  test('it should return an error if channel in cache but api throws not found', async () => {
+    enableCache();
+    pushToCache(['channel', 'get', channelId], channel, { cachedAt: Date.now() });
+
+    client.http.get = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(getChannel(channelId)).rejects.toThrow();
+    expect(getChannel.locally(channelId)).toBeUndefined();
+
+    disableCache();
+  });
+});
+
+describe('getChannel locally', () => {
+  test('it should return data from cache', () => {
+    enableCache();
+
+    const cachedAt = Date.now();
+
+    pushToCache(['channel', 'get', channelId], channel, { cachedAt });
+
+    const data = getChannel.locally(channelId);
+
+    expect(data).toBeDefined();
+    expect(data?.data).toEqual(channel);
+    expect(data?.cachedAt).toEqual(cachedAt);
+
+    disableCache();
+  });
+
+  test('should return undefined if channel not in cache', () => {
+    expect(getChannel.locally('non-existent-channel')).toBeUndefined();
+  });
+
+  test('should return undefined if cache not enabled', () => {
+    expect(getChannel.locally(channelId)).toBeUndefined();
+  });
+});
+
+describe('getChannel tombostone', () => {
+  test('it should add channel to tombostone if 404', async () => {
+    enableCache();
+
+    client.http.get = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(getChannel(channelId)).rejects.toThrow();
+    expect(() => {
+      isInTombstone('channel', channelId);
+    }).toThrow();
+
+    disableCache();
+  });
+
+  test('it should throw error if channel not found in tombostone', async () => {
+    enableCache();
+
+    pushToTombstone('channel', channelId);
+    await expect(getChannel(channelId)).rejects.toThrow();
+
+    disableCache();
+  });
+});

package/src/channel/api/tests/joinChannel.test.ts

@@ -0,0 +1,52 @@
+import { pullFromCache, enableCache, disableCache } from '~/cache/api';
+import { getResolver } from '~/core/model';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  channel11,
+  user11,
+  channelUser1,
+  channelUserQueryResponse,
+} from '~/utils/tests';
+
+import { joinChannel } from '../joinChannel';
+
+describe('joinChannel', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  const { channelId } = channel11;
+
+  test('it should return channelUser', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const recieved = await joinChannel(channelId);
+
+    expect(recieved).toBe(true);
+  });
+
+  test('it should update cache', async () => {
+    enableCache();
+
+    const expected = channelUser1;
+    client.http.post = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const didJoinChannel = await joinChannel(channelId);
+
+    const resolverId = getResolver('channelUsers')({ channelId, userId: user11.userId });
+    const recieved = pullFromCache(['channelUsers', 'get', resolverId]);
+
+    expect(didJoinChannel).toBe(true);
+    expect(recieved?.data).toStrictEqual(expected);
+
+    disableCache();
+  });
+
+  test('it should throw error', async () => {
+    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(joinChannel(channelId)).rejects.toThrow('error');
+  });
+});

package/src/channel/api/tests/queryChannelMembers.test.ts

@@ -0,0 +1,131 @@
+import { getResolver } from '~/core/model';
+
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '~/channel/utils';
+import { prepareMembershipPayload } from '~/group/utils';
+import { client, channelUserQueryResponse, channelUserModel } from '~/utils/tests';
+
+import { queryChannelMembers } from '../queryChannelMembers';
+
+describe('queryChannelMembers', () => {
+  const { channelId } = channelUserQueryResponse.data.channels[0];
+
+  test('it should return channel members', async () => {
+    const expected = channelUserQueryResponse.data.channelUsers;
+    client.http.get = jest.fn().mockResolvedValue(channelUserQueryResponse);
+
+    const { data } = await queryChannelMembers({ channelId });
+    expect(data).toEqual(expected);
+  });
+
+  test('it should return channel members by attaching a user', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(channelUserQueryResponse);
+
+    const { data } = await queryChannelMembers({ channelId });
+
+    expect(data).toEqual(channelUserModel);
+
+    disableCache();
+  });
+
+  test('it should throw error', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(queryChannelMembers({ channelId })).rejects.toThrow('error');
+  });
+
+  test('it should update cache upon fetching data from server', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(channelUserQueryResponse);
+
+    const { data: got } = await queryChannelMembers({ channelId });
+    const { data } = queryChannelMembers.locally({ channelId })!;
+
+    expect(data).toBeDefined();
+    expect(got).toEqual(data);
+
+    disableCache();
+  });
+});
+
+describe('queryChannelMembers.locally', () => {
+  const { channelId } = channelUserQueryResponse.data.channels[0];
+  const cacheKey = [
+    'channelUsers',
+    'query',
+    { channelId, options: { limit: 10, after: undefined } },
+  ];
+
+  test('it should fetch query locally if present in cache', () => {
+    enableCache();
+
+    const { paging, ...payload } = channelUserQueryResponse.data;
+    const channelPayload = prepareChannelPayload(payload);
+    const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+    const { channelUsers } = preparedPayload;
+
+    ingestInCache(preparedPayload);
+
+    pushToCache(cacheKey, {
+      channelUsers: channelUsers.map(({ channelId, userId }) =>
+        getResolver('channelUsers')({ channelId, userId }),
+      ),
+      paging,
+    });
+
+    const got = queryChannelMembers.locally({
+      channelId,
+      page: { limit: 10, after: undefined },
+    })?.data;
+
+    expect(got).toBeDefined();
+    expect(got).toEqual(channelUsers);
+
+    disableCache();
+  });
+
+  test('it should return undefined if only partial data in cache', () => {
+    enableCache();
+
+    const { paging, ...payload } = channelUserQueryResponse.data;
+    const channelPayload = prepareChannelPayload(payload);
+    const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+    const { channelUsers } = preparedPayload;
+
+    // ingest incomplete data
+    ingestInCache({
+      ...preparedPayload,
+      channelUsers: [preparedPayload.channelUsers[0]],
+    } as Amity.ChannelMembershipPayload);
+
+    pushToCache(cacheKey, {
+      channelUsers: channelUsers.map(({ channelId, userId }) =>
+        getResolver('channelUsers')({ channelId, userId }),
+      ),
+      paging,
+    });
+
+    const got = queryChannelMembers.locally({ channelId })!;
+
+    expect(got).toBeUndefined();
+
+    disableCache();
+  });
+
+  test('it should return undefined if data not in cache', () => {
+    enableCache();
+
+    const got = queryChannelMembers.locally({ channelId });
+
+    expect(got).toBeUndefined();
+
+    disableCache();
+  });
+
+  test('it should return undefined if cache disabled', () => {
+    expect(queryChannelMembers.locally({ channelId })).toBeUndefined();
+  });
+});

package/src/channel/api/tests/queryChannels.test.ts

@@ -0,0 +1,121 @@
+import { getResolver } from '~/core/model';
+
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '~/channel/utils';
+import { client, channelQueryResponse } from '~/utils/tests';
+
+import { queryChannels } from '../queryChannels';
+
+describe('queryChannels', () => {
+  test('it should return channels', async () => {
+    const expected = prepareChannelPayload(channelQueryResponse.data).channels;
+    client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
+
+    const { data } = await queryChannels();
+
+    expect(data).toEqual(expected);
+  });
+
+  test('it should throw error', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(queryChannels()).rejects.toThrow('error');
+  });
+
+  test('it should update cache upon fetching data from server', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
+
+    const { data: got } = await queryChannels();
+    const { data } = queryChannels.locally()!;
+
+    expect(data).toBeDefined();
+    expect(got).toEqual(data);
+
+    disableCache();
+  });
+});
+
+describe('queryChannels.locally', () => {
+  const cacheKey = ['channel', 'query', { options: { limit: 10, after: undefined } }];
+
+  test('it should fetch query locally if present in cache', () => {
+    enableCache();
+
+    const { paging, ...payload } = channelQueryResponse.data;
+    const data = prepareChannelPayload(payload);
+    const { channels } = data;
+
+    ingestInCache(data as Amity.ChannelMembershipPayload);
+
+    pushToCache(cacheKey, { channels: channels.map(getResolver('channel')), paging });
+
+    const { data: got } = queryChannels.locally()!;
+
+    expect(got).toBeDefined();
+    expect(got).toEqual(channels);
+
+    disableCache();
+  });
+
+  test('it should return undefined if only partial data in cache', () => {
+    enableCache();
+
+    const { paging, ...payload } = channelQueryResponse.data;
+    const data = prepareChannelPayload(payload);
+    const { channels } = data;
+
+    // ingest incomplete data
+    ingestInCache({
+      ...data,
+      channels: [data.channels[0]],
+    } as Amity.ChannelPayload);
+
+    pushToCache(cacheKey, {
+      channels: channels.map(getResolver('channel')),
+      paging,
+    });
+
+    const got = queryChannels.locally()!;
+
+    expect(got).toBeUndefined();
+
+    disableCache();
+  });
+
+  test('it should return undefined if params do not match', () => {
+    enableCache();
+
+    const { data } = channelQueryResponse;
+    const { channels: expected, paging } = data;
+
+    ingestInCache(data as Amity.ChannelPayload);
+
+    pushToCache(cacheKey, { channels: expected.map(getResolver('channel')), paging });
+
+    const { data: received } = queryChannels.locally()!;
+    const received2 = queryChannels.locally({ displayName: 'test' })!;
+
+    expect(received).toBeDefined();
+    expect(received).toEqual(expected);
+    expect(received2).toBeUndefined();
+
+    disableCache();
+  });
+
+  test('it should return undefined if data not in cache', () => {
+    enableCache();
+
+    const got = queryChannels.locally();
+
+    expect(got).toBeUndefined();
+
+    disableCache();
+  });
+
+  test('it should return undefined if cache disabled', () => {
+    expect(queryChannels.locally()).toBeUndefined();
+  });
+});

package/src/channel/api/tests/removeChannelMembers.test.ts

@@ -0,0 +1,95 @@
+import { getResolver } from '~/core/model';
+import { pullFromCache, enableCache, disableCache } from '~/cache/api';
+
+import {
+  client,
+  pause,
+  channelUserQueryResponse,
+  channelUser1,
+  channelUser3,
+  channel11,
+} from '~/utils/tests';
+
+import { onChannelMemberRemoved } from '~/channel/events';
+import { removeChannelMembers } from '../removeChannelMembers';
+
+describe('removeChannelMembers', () => {
+  const { channelId } = channelUserQueryResponse.data.channels[0];
+  const { userId } = channelUser1;
+
+  test('it should remove channel members from channel', async () => {
+    client.http.delete = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const recieved = await removeChannelMembers(channelId, [userId]);
+
+    expect(recieved).toBe(true);
+  });
+
+  test('it should update cache with removed channel members', async () => {
+    enableCache();
+
+    client.http.delete = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const channelUserCacheKey = getResolver('channelUsers')({
+      channelId,
+      userId,
+    });
+
+    const recieved = await removeChannelMembers(channelId, [userId]);
+    const channelUser = pullFromCache<Amity.Membership<'channel'>>([
+      'channelUsers',
+      'get',
+      channelUserCacheKey,
+    ])?.data;
+
+    expect(recieved).toBe(true);
+    expect(channelUser).toBeDefined();
+    expect(channelUser).toBe(channelUser1);
+
+    disableCache();
+  });
+
+  test('it should fire event when members are removed', async () => {
+    expect.assertions(1);
+
+    client.http.delete = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+    let dispose;
+
+    const callback = new Promise(resolve => {
+      dispose = onChannelMemberRemoved(resolve);
+    }).finally(dispose);
+
+    await removeChannelMembers(channelId, [userId]);
+
+    return expect(callback).resolves.not.toThrow();
+  });
+
+  test('it should fire event with all removed members', async () => {
+    client.http.delete = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const callback = jest.fn();
+    const { userId: userId2 } = channelUser3;
+    const unsub = onChannelMemberRemoved(callback);
+
+    const recieved = await removeChannelMembers(channelId, [userId, userId2]);
+
+    expect(recieved).toBe(true);
+
+    await pause();
+
+    /*
+     * Assertion below is required to check if the event handler is called with the right
+     * params. It's not enough to check if the handler does not throw
+     */
+    expect(callback).toHaveBeenNthCalledWith(1, channel11, channelUser1);
+    expect(callback).toHaveBeenNthCalledWith(2, channel11, channelUser3);
+
+    unsub();
+  });
+
+  test('it should return an error', async () => {
+    client.http.delete = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(removeChannelMembers('channelId', [])).rejects.toThrow('error');
+  });
+});

package/src/channel/api/tests/startReading.test.ts

@@ -0,0 +1,24 @@
+import { channel11, client } from '~/utils/tests';
+
+import { startReading } from '../startReading';
+
+const resolvedSuccessValue = { status: 'success', data: {} };
+const resolvedErrorValue = { status: 'error', message: 'error', code: 500000 };
+
+describe('startReading', () => {
+  test('should resolves true value', async () => {
+    client.ws.emit = jest
+      .fn()
+      .mockImplementationOnce((event, data, callback) => callback(resolvedSuccessValue));
+
+    await expect(startReading(channel11.channelId)).resolves.toEqual(true);
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.ws.emit = jest
+      .fn()
+      .mockImplementationOnce((event, data, callback) => callback(resolvedErrorValue));
+
+    await expect(startReading(channel11.channelId)).rejects.toThrow(resolvedErrorValue.message);
+  });
+});

package/src/channel/api/tests/stopReading.test.ts

@@ -0,0 +1,24 @@
+import { channel11, client } from '~/utils/tests';
+
+import { stopReading } from '../stopReading';
+
+const resolvedSuccessValue = { status: 'success', data: {} };
+const resolvedErrorValue = { status: 'error', message: 'error', code: 500000 };
+
+describe('stopReading', () => {
+  test('should resolves true value', async () => {
+    client.ws.emit = jest
+      .fn()
+      .mockImplementationOnce((event, data, callback) => callback(resolvedSuccessValue));
+
+    await expect(stopReading(channel11.channelId)).resolves.toEqual(true);
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.ws.emit = jest
+      .fn()
+      .mockImplementationOnce((event, data, callback) => callback(resolvedErrorValue));
+
+    await expect(stopReading(channel11.channelId)).rejects.toThrow(resolvedErrorValue.message);
+  });
+});

package/src/channel/api/unbanChannelMembers.ts

@@ -0,0 +1,48 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareMembershipPayload, withUsers } from '~/group/utils';
+
+import { prepareChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { unbanChannelMembers } from '@amityco/ts-sdk'
+ *
+ * await unbanChannelMembers('channel-id-1', ['userId1', 'userId2'])
+ * ```
+ *
+ * @param channelId of {@link Amity.Channel} where the users should be unbanned
+ * @param userIds of the {@link Amity.User}'s to be unbanned
+ * @returns the updated {@link Amity.Membership}'s object
+ *
+ * @category Channel API
+ * @async
+ * */
+export const unbanChannelMembers = async (
+  channelId: Amity.Channel['channelId'],
+  userIds: Amity.User['userId'][],
+): Promise<Amity.Cached<Amity.Membership<'channel'>[]>> => {
+  const client = getActiveClient();
+  client.log('channel/unbanChannelMembers', { userIds, channelId });
+
+  const { data: payload } = await client.http.put<Amity.ChannelPayload>(
+    `/api/v3/channels/${encodeURIComponent(channelId)}/users/unban`,
+    {
+      userIds,
+    },
+  );
+
+  const channelPayload = prepareChannelPayload(payload);
+  const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(preparedPayload, { cachedAt });
+
+  const { channelUsers } = preparedPayload;
+
+  return {
+    data: channelUsers?.filter(user => user.membership === 'member')!,
+    cachedAt,
+  };
+};

package/src/channel/api/updateChannel.ts

@@ -2,6 +2,8 @@ import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
  * import { updateChannel } from '@amityco/ts-sdk'
@@ -19,16 +21,18 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  */
 export const updateChannel = async (
   channelId: Amity.Channel['channelId'],
-  patch: Patch<Amity.Channel, 'displayName' | 'description' | 'avatarFileId' | 'metadata'>,
+  patch: Patch<Amity.Channel, 'displayName' | 'avatarFileId' | 'tags' | 'metadata'>,
 ): Promise<Amity.Cached<Amity.Channel>> => {
   const client = getActiveClient();
   client.log('channel/updateChannel', channelId, patch);
 
-  const { data } = await client.http.put<Amity.ChannelPayload>(
+  const { data: payload } = await client.http.put<Amity.ChannelPayload>(
     `/api/v3/channels/${encodeURIComponent(channelId)}`,
     patch,
   );
 
+  const data = prepareChannelPayload(payload);
+
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });