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

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

@@ -0,0 +1,106 @@
+import { getResolver } from '~/core/model';
+import { pullFromCache, enableCache, disableCache } from '~/cache/api';
+
+import {
+  client,
+  pause,
+  channelUserQueryResponse,
+  rawChannelUser,
+  rawChannelUser3,
+  channel1,
+  channelUser,
+  channelUser3,
+  connectClient,
+  disconnectClient,
+} from '~/utils/tests';
+
+import { onChannelMemberRemoved } from '~/channel/events';
+
+import { removeChannelMembers } from '../removeChannelMembers';
+
+describe('removeChannelMembers', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  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 recievedCache = pullFromCache<Amity.Membership<'channel'>>([
+      'channelUsers',
+      'get',
+      channelUserCacheKey,
+    ])?.data;
+
+    expect(recieved).toBe(true);
+    expect(recievedCache).toBeDefined();
+    expect(recievedCache).toEqual(channelUser);
+
+    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, channelUser);
+    expect(callback).toHaveBeenNthCalledWith(2, channel1, 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,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

@@ -0,0 +1,50 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '../utils';
+
+/* begin_public_function
+  id: channel.moderation.unban_members
+*/
+/**
+ * ```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 preparedPayload = prepareChannelPayload(payload);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(preparedPayload, { cachedAt });
+
+  const { channelUsers } = preparedPayload;
+
+  return {
+    data: channelUsers?.filter(user => user.membership === 'member')!,
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/channel/api/updateChannel.ts

@@ -2,6 +2,11 @@ import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { prepareChannelPayload } from '../utils';
+
+/* begin_public_function
+  id: channel.update
+*/
 /**
  * ```js
  * import { updateChannel } from '@amityco/ts-sdk'
@@ -19,16 +24,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 });
 
@@ -39,3 +46,4 @@ export const updateChannel = async (
     cachedAt,
   };
 };
+/* end_public_function */

package/src/channel/events/index.ts

@@ -1,6 +1,13 @@
+export * from './onChannelCreated';
 export * from './onChannelUpdated';
 export * from './onChannelDeleted';
+
 export * from './onChannelJoined';
 export * from './onChannelLeft';
-export * from './onMemberAdded';
-export * from './onMemberRemoved';
+export * from './onChannelMuted';
+
+export * from './onChannelMemberAdded';
+export * from './onChannelMemberRemoved';
+
+export * from './onChannelMemberBanned';
+export * from './onChannelMemberUnbanned';

package/src/channel/events/onChannelCreated.ts

@@ -3,6 +3,8 @@ import { createEventSubscriber } from '~/core/events';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
  * import { onChannelCreated } from '@amityco/ts-sdk'
@@ -22,9 +24,11 @@ export const onChannelCreated = (callback: Amity.Listener<Amity.Channel>) => {
   const client = getActiveClient();
 
   const filter = (payload: Amity.ChannelPayload) => {
-    ingestInCache(payload);
-    callback(payload.channels[0]);
+    const data = prepareChannelPayload(payload);
+
+    ingestInCache(data);
+    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

@@ -3,6 +3,8 @@ import { createEventSubscriber } from '~/core/events';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
  * import { onChannelDeleted } from '@amityco/ts-sdk'
@@ -22,9 +24,11 @@ export const onChannelDeleted = (callback: Amity.Listener<Amity.Channel>) => {
   const client = getActiveClient();
 
   const filter = (payload: Amity.ChannelPayload) => {
-    ingestInCache(payload);
-    callback(payload.channels[0]);
+    const data = prepareChannelPayload(payload);
+
+    ingestInCache(data);
+    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,10 +3,12 @@ import { createEventSubscriber } from '~/core/events';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
  * import { onChannelJoined } from '@amityco/ts-sdk'
- * const dispose = onChannelJoined(channel => {
+ * const dispose = onChannelJoined((channel, member) => {
  *   // ...
  * })
  * ```
@@ -18,13 +20,18 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  *
  * @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) => {
-    ingestInCache(payload);
-    callback(payload.channels[0]);
+  const filter = (payload: Amity.ChannelMembershipPayload) => {
+    const preparedPayload = prepareChannelPayload(payload);
+    const { channels, channelUsers } = preparedPayload;
+
+    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,10 +3,12 @@ import { createEventSubscriber } from '~/core/events';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
  * import { onChannelLeft } from '@amityco/ts-sdk'
- * const dispose = onChannelLeft(channel => {
+ * const dispose = onChannelLeft((channel, member) => {
  *   // ...
  * })
  * ```
@@ -18,13 +20,18 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  *
  * @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) => {
-    ingestInCache(payload);
-    callback(payload.channels[0]);
+  const filter = (payload: Amity.ChannelMembershipPayload) => {
+    const preparedPayload = prepareChannelPayload(payload);
+    const { channels, channelUsers } = preparedPayload;
+
+    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

@@ -0,0 +1,36 @@
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { prepareChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { onChannelMemberAdded } from '@amityco/ts-sdk'
+ * const dispose = onChannelMemberAdded((channel, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.User} has been added to any {@link Amity.Channel}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onChannelMemberAdded = (
+  callback: (channel: Amity.Channel, member: Amity.Membership<'channel'>) => void,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.ChannelMembershipPayload) => {
+    const preparedPayload = prepareChannelPayload(payload);
+    const { channels, channelUsers } = preparedPayload;
+
+    ingestInCache(preparedPayload);
+    callback(channels[0], channelUsers.find(cu => cu.membership === 'member')!);
+  };
+
+  return createEventSubscriber(client, 'onChannelMemberAdded', 'channel.membersAdded', filter);
+};

package/src/channel/events/onChannelMemberBanned.ts

@@ -0,0 +1,37 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { onChannelMemberBanned } from '@amityco/ts-sdk'
+ * const dispose = onChannelMemberBanned((channel, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.User} has been banned from any {@link Amity.Channel}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onChannelMemberBanned = (
+  callback: (channel: Amity.Channel, member: Amity.Membership<'channel'>) => void,
+) => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.ChannelMembershipPayload) => {
+    const preparedPayload = prepareChannelPayload(payload);
+    const { channels, channelUsers } = preparedPayload;
+
+    ingestInCache(preparedPayload);
+    callback(channels[0], channelUsers.find(cu => cu.membership === 'banned')!);
+  };
+
+  return createEventSubscriber(client, 'onChannelMemberBanned', 'channel.banned', filter);
+};

package/src/channel/events/onChannelMemberRemoved.ts

@@ -0,0 +1,37 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { onChannelMemberRemoved } from '@amityco/ts-sdk'
+ * const dispose = onChannelMemberRemoved((channel, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.User} has been removed from any {@link Amity.Channel}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onChannelMemberRemoved = (
+  callback: (channel: Amity.Channel, member: Amity.Membership<'channel'>) => void,
+) => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.ChannelMembershipPayload) => {
+    const preparedPayload = prepareChannelPayload(payload);
+    const { channels, channelUsers } = preparedPayload;
+
+    ingestInCache(preparedPayload);
+    callback(channels[0], channelUsers[0]);
+  };
+
+  return createEventSubscriber(client, 'onChannelMemberRemoved', 'channel.membersRemoved', filter);
+};

package/src/channel/events/onChannelMemberUnbanned.ts

@@ -0,0 +1,37 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { onChannelMemberUnbanned } from '@amityco/ts-sdk'
+ * const dispose = onChannelMemberUnbanned((channel, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.User} has been unbanned from any {@link Amity.Channel}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onChannelMemberUnbanned = (
+  callback: (channel: Amity.Channel, member: Amity.Membership<'channel'>) => void,
+) => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.ChannelMembershipPayload) => {
+    const preparedPayload = prepareChannelPayload(payload);
+    const { channels, channelUsers } = preparedPayload;
+
+    ingestInCache(preparedPayload);
+    callback(channels[0], channelUsers.find(cu => cu.membership === 'none')!);
+  };
+
+  return createEventSubscriber(client, 'onChannelMemberUnbanned', 'channel.unbanned', filter);
+};

package/src/channel/events/{onMemberAdded.ts → onChannelMuted.ts}

@@ -3,28 +3,32 @@ import { createEventSubscriber } from '~/core/events';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
- * import { onMemberAdded } from '@amityco/ts-sdk'
- * const dispose = onMemberAdded(channel => {
+ * import { onChannelMuted } from '@amityco/ts-sdk'
+ * const dispose = onChannelMuted(channel => {
  *   // ...
  * })
  * ```
  *
- * Fired when any {@link Amity.User} has been added to any {@link Amity.Channel}
+ * Fired when any {@link Amity.Channel} have been muted
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category Channel Events
  */
-export const onMemberAdded = (callback: Amity.Listener<Amity.Channel>) => {
+export const onChannelMuted = (callback: Amity.Listener<Amity.Channel>) => {
   const client = getActiveClient();
 
   const filter = (payload: Amity.ChannelPayload) => {
-    ingestInCache(payload);
-    callback(payload.channels[0]);
+    const data = prepareChannelPayload(payload);
+
+    ingestInCache(data);
+    callback(data.channels[0]);
   };
 
-  return createEventSubscriber(client, 'onMemberAdded', 'v3.channel.didAddUsers', filter);
+  return createEventSubscriber(client, 'onChannelMuted', 'channel.setMuted', filter);
 };

package/src/channel/events/onChannelUpdated.ts

@@ -3,6 +3,8 @@ import { createEventSubscriber } from '~/core/events';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
  * import { onChannelUpdated } from '@amityco/ts-sdk'
@@ -22,9 +24,20 @@ export const onChannelUpdated = (callback: Amity.Listener<Amity.Channel>) => {
   const client = getActiveClient();
 
   const filter = (payload: Amity.ChannelPayload) => {
-    ingestInCache(payload);
-    callback(payload.channels[0]);
+    const data = prepareChannelPayload(payload);
+
+    ingestInCache(data);
+    callback(data.channels[0]);
   };
 
-  return createEventSubscriber(client, 'onChannelUpdated', 'v3.channel.didUpdate', filter);
+  const disposers = [
+    createEventSubscriber(client, 'onChannelUpdated', 'channel.updated', filter),
+    createEventSubscriber(client, 'local.channel.updated', 'local.channel.updated', payload =>
+      callback(payload.channels[0]),
+    ),
+  ];
+
+  return () => {
+    disposers.forEach(fn => fn());
+  };
 };

package/src/channel/events/tests/onChannelCreated.test.ts

@@ -0,0 +1,55 @@
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  channel1,
+  channelRaw1,
+  client,
+  connectClient,
+  disconnectClient,
+  rawChannelUser,
+  user11,
+} from '~/utils/tests';
+import { onChannelCreated } from '../onChannelCreated';
+
+describe('onChannelCreated event', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  const channelPayload: Amity.ChannelMembershipPayload = {
+    channelUsers: [rawChannelUser],
+    channels: [channelRaw1],
+    files: [],
+    users: [user11],
+  };
+
+  test('it should call callback when channel have created', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelCreated(callback);
+    client.emitter.emit('channel.created', channelPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(channel1);
+  });
+
+  test('it should return an unsubscriber', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelCreated(callback);
+    unsub();
+
+    client.emitter.emit('channel.created', channelPayload);
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+});