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

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

@@ -5,9 +5,10 @@ import {
   client,
   pause,
   channelUserQueryResponse,
-  channelUser1,
-  channelUser3,
-  channel11,
+  rawChannelUser,
+  rawChannelUser3,
+  channel1,
+  user11,
 } from '~/utils/tests';
 
 import { onChannelMemberAdded } from '~/channel/events';
@@ -15,7 +16,7 @@ import { addChannelMembers } from '../addChannelMembers';
 
 describe('addChannelMembers', () => {
   const { channelId } = channelUserQueryResponse.data.channels[0];
-  const { userId } = channelUser1;
+  const { userId } = rawChannelUser;
 
   test('it should add channel members in channel', async () => {
     client.http.post = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
@@ -44,7 +45,7 @@ describe('addChannelMembers', () => {
 
     expect(recieved).toBe(true);
     expect(channelUser).toBeDefined();
-    expect(channelUser).toBe(channelUser1);
+    expect(channelUser).toBe(rawChannelUser);
 
     disableCache();
   });
@@ -68,7 +69,7 @@ describe('addChannelMembers', () => {
     client.http.post = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
 
     const callback = jest.fn();
-    const { userId: userId2 } = channelUser3;
+    const { userId: userId2 } = rawChannelUser3;
     const unsub = onChannelMemberAdded(callback);
 
     const recieved = await addChannelMembers(channelId, [userId, userId2]);
@@ -81,12 +82,39 @@ describe('addChannelMembers', () => {
      * 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 });
+    expect(callback).toHaveBeenNthCalledWith(1, { ...channel1 }, { ...rawChannelUser });
 
     unsub();
   });
 
+  test('it should fire event with all new members by attaching a user', async () => {
+    enableCache();
+    client.http.post = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const callback = jest.fn();
+    const { userId: userId2 } = rawChannelUser3;
+    const unsub = onChannelMemberAdded(callback);
+
+    const recieved = await addChannelMembers(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,
+      { ...channel1 },
+      { ...rawChannelUser, user: user11 },
+    );
+
+    unsub();
+    disableCache();
+  });
+
   test('it should return an error', async () => {
     client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
 

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

@@ -0,0 +1,53 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { channelPayload, client } from '~/utils/tests';
+import { prepareChannelPayload } from '~/channel/utils';
+import { createChannel } from '../createChannel';
+
+const resPayload = { data: channelPayload };
+
+describe('createChannel', () => {
+  const channel = prepareChannelPayload(channelPayload).channels[0];
+
+  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(channel);
+  });
+
+  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(channel);
+
+    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

@@ -6,9 +6,10 @@ import { pushToTombstone } from '~/cache/api/pushToTombstone';
 import { isInTombstone } from '~/cache/api/isInTombstone';
 
 import { getChannel } from '../getChannel';
+import { prepareChannelPayload } from '~/channel/utils';
 
 const { channelId } = channelQueryResponse.data.channels[0];
-const channel = channelQueryResponse.data.channels[0];
+const channel = prepareChannelPayload(channelQueryResponse.data).channels[0];
 
 describe('getChannel', () => {
   test('it should return a channel', async () => {
@@ -82,7 +83,7 @@ describe('getChannel locally', () => {
 describe('getChannel tombostone', () => {
   test('it should add channel to tombostone if 404', async () => {
     enableCache();
-    
+
     client.http.get = jest
       .fn()
       .mockRejectedValueOnce(

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,
+  channel1,
+  user11,
+  rawChannelUser,
+  channelUserQueryResponse,
+} from '~/utils/tests';
+
+import { joinChannel } from '../joinChannel';
+
+describe('joinChannel', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  const { channelId } = channel1;
+
+  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 = rawChannelUser;
+    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

@@ -4,7 +4,8 @@ import { disableCache, enableCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
 import { prepareChannelPayload } from '~/channel/utils';
-import { client, channelUserQueryResponse } from '~/utils/tests';
+import { prepareMembershipPayload } from '~/group/utils';
+import { client, channelUserQueryResponse, channelUserModel } from '~/utils/tests';
 
 import { queryChannelMembers } from '../queryChannelMembers';
 
@@ -16,10 +17,20 @@ describe('queryChannelMembers', () => {
     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'));
 
@@ -52,10 +63,11 @@ describe('queryChannelMembers.locally', () => {
     enableCache();
 
     const { paging, ...payload } = channelUserQueryResponse.data;
-    const data = prepareChannelPayload(payload);
-    const { channelUsers } = data;
+    const channelPayload = prepareChannelPayload(payload);
+    const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+    const { channelUsers } = preparedPayload;
 
-    ingestInCache(data as Amity.ChannelMembershipPayload);
+    ingestInCache(preparedPayload);
 
     pushToCache(cacheKey, {
       channelUsers: channelUsers.map(({ channelId, userId }) =>
@@ -64,7 +76,10 @@ describe('queryChannelMembers.locally', () => {
       paging,
     });
 
-    const { data: got } = queryChannelMembers.locally({ channelId })!;
+    const got = queryChannelMembers.locally({
+      channelId,
+      page: { limit: 10, after: undefined },
+    })?.data;
 
     expect(got).toBeDefined();
     expect(got).toEqual(channelUsers);
@@ -76,14 +91,15 @@ describe('queryChannelMembers.locally', () => {
     enableCache();
 
     const { paging, ...payload } = channelUserQueryResponse.data;
-    const data = prepareChannelPayload(payload);
-    const { channelUsers } = data;
+    const channelPayload = prepareChannelPayload(payload);
+    const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+    const { channelUsers } = preparedPayload;
 
     // ingest incomplete data
     ingestInCache({
-      ...data,
-      channelUsers: [data.channelUsers[0]],
-    } as Amity.ChannelMembershipPayload);
+      ...preparedPayload,
+      channelUsers: [preparedPayload.channelUsers[0]],
+    });
 
     pushToCache(cacheKey, {
       channelUsers: channelUsers.map(({ channelId, userId }) =>

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

@@ -48,7 +48,7 @@ describe('queryChannels.locally', () => {
     const data = prepareChannelPayload(payload);
     const { channels } = data;
 
-    ingestInCache(data as Amity.ChannelMembershipPayload);
+    ingestInCache(data);
 
     pushToCache(cacheKey, { channels: channels.map(getResolver('channel')), paging });
 
@@ -71,7 +71,7 @@ describe('queryChannels.locally', () => {
     ingestInCache({
       ...data,
       channels: [data.channels[0]],
-    } as Amity.ChannelPayload);
+    });
 
     pushToCache(cacheKey, {
       channels: channels.map(getResolver('channel')),

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,
+  rawChannelUser,
+  rawChannelUser3,
+  channel1,
+} from '~/utils/tests';
+
+import { onChannelMemberRemoved } from '~/channel/events';
+import { removeChannelMembers } from '../removeChannelMembers';
+
+describe('removeChannelMembers', () => {
+  const { channelId } = channelUserQueryResponse.data.channels[0];
+  const { userId } = rawChannelUser;
+
+  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(rawChannelUser);
+
+    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 } = rawChannelUser3;
+    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, channel1, rawChannelUser);
+    expect(callback).toHaveBeenNthCalledWith(2, channel1, rawChannelUser3);
+
+    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,25 @@
+import { channel1, client } from '~/utils/tests';
+
+import { startReading } from '../startReading';
+
+const resolvedSuccessValue = { status: 'success', data: {} };
+const resolvedErrorValue = { status: 'error', message: 'error', code: 500000 };
+
+// FIXME: wait for marker service
+xdescribe('startReading', () => {
+  test('should resolves true value', async () => {
+    client.ws.emit = jest
+      .fn()
+      .mockImplementationOnce((event, data, callback) => callback(resolvedSuccessValue));
+
+    await expect(startReading(channel1.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(channel1.channelId)).rejects.toThrow(resolvedErrorValue.message);
+  });
+});

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

@@ -0,0 +1,25 @@
+import { channel1, client } from '~/utils/tests';
+
+import { stopReading } from '../stopReading';
+
+const resolvedSuccessValue = { status: 'success', data: {} };
+const resolvedErrorValue = { status: 'error', message: 'error', code: 500000 };
+
+// FIXME: wait for marker service
+xdescribe('stopReading', () => {
+  test('should resolves true value', async () => {
+    client.ws.emit = jest
+      .fn()
+      .mockImplementationOnce((event, data, callback) => callback(resolvedSuccessValue));
+
+    await expect(stopReading(channel1.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(channel1.channelId)).rejects.toThrow(resolvedErrorValue.message);
+  });
+});

package/src/channel/api/unbanChannelMembers.ts

@@ -1,6 +1,7 @@
 import { getActiveClient } from '~/client/api/activeClient';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareMembershipPayload, withUsers } from '~/group/utils';
 
 import { prepareChannelPayload } from '../utils';
 
@@ -32,12 +33,14 @@ export const unbanChannelMembers = async (
     },
   );
 
-  const data = prepareChannelPayload(payload);
+  const channelPayload = prepareChannelPayload(payload);
+  const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
 
   const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(data, { cachedAt });
+  if (client.cache) ingestInCache(preparedPayload, { cachedAt });
+
+  const { channelUsers } = preparedPayload;
 
-  const { channelUsers } = data;
   return {
     data: channelUsers?.filter(user => user.membership === 'member')!,
     cachedAt,

package/src/channel/events/index.ts

@@ -4,6 +4,7 @@ export * from './onChannelDeleted';
 
 export * from './onChannelJoined';
 export * from './onChannelLeft';
+export * from './onChannelMuted';
 
 export * from './onChannelMemberAdded';
 export * from './onChannelMemberRemoved';

package/src/channel/events/onChannelCreated.ts

@@ -30,5 +30,5 @@ export const onChannelCreated = (callback: Amity.Listener<Amity.Channel>) => {
     callback(data.channels[0]);
   };
 
-  return createEventSubscriber(client, 'onChannelCreated', 'v3.channel.didCreate', filter);
+  return createEventSubscriber(client, 'onChannelCreated', 'channel.created', filter);
 };

package/src/channel/events/onChannelDeleted.ts

@@ -30,5 +30,5 @@ export const onChannelDeleted = (callback: Amity.Listener<Amity.Channel>) => {
     callback(data.channels[0]);
   };
 
-  return createEventSubscriber(client, 'onChannelDeleted', 'v3.channel.didDelete', filter);
+  return createEventSubscriber(client, 'onChannelDeleted', 'channel.deleted', filter);
 };

package/src/channel/events/onChannelJoined.ts

@@ -3,12 +3,13 @@ import { createEventSubscriber } from '~/core/events';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { prepareMembershipPayload } from '~/group/utils';
 import { prepareChannelPayload } from '../utils';
 
 /**
  * ```js
  * import { onChannelJoined } from '@amityco/ts-sdk'
- * const dispose = onChannelJoined(channel => {
+ * const dispose = onChannelJoined((channel, member) => {
  *   // ...
  * })
  * ```
@@ -20,15 +21,19 @@ import { prepareChannelPayload } from '../utils';
  *
  * @category Channel Events
  */
-export const onChannelJoined = (callback: Amity.Listener<Amity.Channel>) => {
+export const onChannelJoined = (
+  callback: (channel: Amity.Channel, member: Amity.Membership<'channel'>) => void,
+) => {
   const client = getActiveClient();
 
-  const filter = (payload: Amity.ChannelPayload) => {
-    const data = prepareChannelPayload(payload);
+  const filter = (payload: Amity.ChannelMembershipPayload) => {
+    const channelPayload = prepareChannelPayload(payload);
+    const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+    const { channels, channelUsers } = preparedPayload;
 
-    ingestInCache(data);
-    callback(data.channels[0]);
+    ingestInCache(preparedPayload);
+    callback(channels[0], channelUsers[0]);
   };
 
-  return createEventSubscriber(client, 'onChannelJoined', 'v3.channel.didJoin', filter);
+  return createEventSubscriber(client, 'onChannelJoined', 'channel.joined', filter);
 };

package/src/channel/events/onChannelLeft.ts

@@ -3,12 +3,13 @@ import { createEventSubscriber } from '~/core/events';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { prepareMembershipPayload } from '~/group/utils';
 import { prepareChannelPayload } from '../utils';
 
 /**
  * ```js
  * import { onChannelLeft } from '@amityco/ts-sdk'
- * const dispose = onChannelLeft(channel => {
+ * const dispose = onChannelLeft((channel, member) => {
  *   // ...
  * })
  * ```
@@ -20,15 +21,19 @@ import { prepareChannelPayload } from '../utils';
  *
  * @category Channel Events
  */
-export const onChannelLeft = (callback: Amity.Listener<Amity.Channel>) => {
+export const onChannelLeft = (
+  callback: (channel: Amity.Channel, member: Amity.Membership<'channel'>) => void,
+) => {
   const client = getActiveClient();
 
-  const filter = (payload: Amity.ChannelPayload) => {
-    const data = prepareChannelPayload(payload);
+  const filter = (payload: Amity.ChannelMembershipPayload) => {
+    const channelPayload = prepareChannelPayload(payload);
+    const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+    const { channels, channelUsers } = preparedPayload;
 
-    ingestInCache(data);
-    callback(data.channels[0]);
+    ingestInCache(preparedPayload);
+    callback(channels[0], channelUsers[0]);
   };
 
-  return createEventSubscriber(client, 'onChannelLeft', 'v3.channel.didLeave', filter);
+  return createEventSubscriber(client, 'onChannelLeft', 'channel.left', filter);
 };

package/src/channel/events/onChannelMemberAdded.ts

@@ -1,7 +1,7 @@
+import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getActiveClient } from '~/client/api';
 import { createEventSubscriber } from '~/core/events';
-
-import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareMembershipPayload } from '~/group/utils';
 
 import { prepareChannelPayload } from '../utils';
 
@@ -26,11 +26,13 @@ export const onChannelMemberAdded = (
   const client = getActiveClient();
 
   const filter = (payload: Amity.ChannelMembershipPayload) => {
-    const data = prepareChannelPayload(payload);
+    const channelPayload = prepareChannelPayload(payload);
+    const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+    const { channels, channelUsers } = preparedPayload;
 
-    ingestInCache(data);
-    callback(data.channels[0], data.channelUsers[0]);
+    ingestInCache(preparedPayload);
+    callback(channels[0], channelUsers.find(cu => cu.membership === 'member')!);
   };
 
-  return createEventSubscriber(client, 'onChannelMemberAdded', 'v3.channel.didAddUsers', filter);
+  return createEventSubscriber(client, 'onChannelMemberAdded', 'channel.membersAdded', filter);
 };

package/src/channel/events/onChannelMemberBanned.ts

@@ -2,6 +2,7 @@ import { getActiveClient } from '~/client/api';
 import { createEventSubscriber } from '~/core/events';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareMembershipPayload } from '~/group/utils';
 
 import { prepareChannelPayload } from '../utils';
 
@@ -26,11 +27,13 @@ export const onChannelMemberBanned = (
   const client = getActiveClient();
 
   const filter = (payload: Amity.ChannelMembershipPayload) => {
-    const data = prepareChannelPayload(payload);
+    const channelPayload = prepareChannelPayload(payload);
+    const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+    const { channels, channelUsers } = preparedPayload;
 
-    ingestInCache(data);
-    callback(data.channels[0], data.channelUsers.find(cu => cu.membership === 'banned')!);
+    ingestInCache(preparedPayload);
+    callback(channels[0], channelUsers.find(cu => cu.membership === 'banned')!);
   };
 
-  return createEventSubscriber(client, 'onChannelMemberBanned', 'v3.channel.didBan', filter);
+  return createEventSubscriber(client, 'onChannelMemberBanned', 'channel.banned', filter);
 };