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

package/src/channel/events/index.ts

@@ -1,6 +1,15 @@
+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';
+
+export * from './onChannelMemberRead';

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,6 +3,8 @@ import { createEventSubscriber } from '~/core/events';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
  * import { onChannelJoined } from '@amityco/ts-sdk'
@@ -22,9 +24,11 @@ export const onChannelJoined = (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, 'onChannelJoined', 'v3.channel.didJoin', filter);
+  return createEventSubscriber(client, 'onChannelJoined', 'channel.joined', filter);
 };

package/src/channel/events/onChannelLeft.ts

@@ -3,6 +3,8 @@ import { createEventSubscriber } from '~/core/events';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
  * import { onChannelLeft } from '@amityco/ts-sdk'
@@ -22,9 +24,11 @@ export const onChannelLeft = (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, 'onChannelLeft', 'v3.channel.didLeave', filter);
+  return createEventSubscriber(client, 'onChannelLeft', 'channel.leave', filter);
 };

package/src/channel/events/onChannelMemberAdded.ts

@@ -0,0 +1,38 @@
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+import { prepareMembershipPayload } from '~/group/utils';
+
+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 channelPayload = prepareChannelPayload(payload);
+    const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+    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,39 @@
+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';
+
+/**
+ * ```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 channelPayload = prepareChannelPayload(payload);
+    const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+    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/onChannelMemberRead.ts

@@ -0,0 +1,38 @@
+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';
+
+/**
+ * ```js
+ * import { onChannelMemberRead } from '@amityco/ts-sdk'
+ * const dispose = onChannelMemberRead((channel, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.User} has been read 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 onChannelMemberRead = (
+  callback: (channel: Amity.Channel, member: Amity.Membership<'channel'>) => void,
+) => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.ChannelPayload) => {
+    const channelPayload = prepareChannelPayload(payload);
+    const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+
+    ingestInCache(preparedPayload);
+    callback(preparedPayload.channels[0], preparedPayload.channelUsers[0]);
+  };
+
+  return createEventSubscriber(client, 'onChannelMemberRead', 'v3.channel.didMarkSeen', filter);
+};

package/src/channel/events/onChannelMemberRemoved.ts

@@ -0,0 +1,39 @@
+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';
+
+/**
+ * ```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 channelPayload = prepareChannelPayload(payload);
+    const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+    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,39 @@
+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';
+
+/**
+ * ```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 channelPayload = prepareChannelPayload(payload);
+    const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+    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,11 @@ 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);
+  return createEventSubscriber(client, 'onChannelUpdated', 'channel.updated', filter);
 };

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

@@ -0,0 +1,60 @@
+import { disableCache, enableCache } from '~/cache/api';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  channel11,
+  channelUser1,
+  channelUser5,
+  user11,
+  user13,
+} from '~/utils/tests';
+
+import { onChannelMemberBanned } from '../onChannelMemberBanned';
+
+describe('onChannelMemberBanned event', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(async () => {
+    enableCache();
+  });
+
+  afterEach(disableCache);
+
+  const channelPayload: Amity.ChannelMembershipPayload = {
+    channelUsers: [channelUser1, channelUser5],
+    channels: [channel11],
+    files: [],
+    users: [user11, user13],
+  };
+
+  test('it should call callback with channel and banned member', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelMemberBanned(callback);
+    client.emitter.emit('channel.banned', channelPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(channel11, { ...channelUser5, user: user13 });
+  });
+
+  test('it should return an unsubscriber', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelMemberBanned(callback);
+    unsub();
+
+    client.emitter.emit('channel.unbanned', channelPayload);
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,56 @@
+import { disableCache, enableCache } from '~/cache/api';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  channel11,
+  channelUser1,
+  user11,
+} from '~/utils/tests';
+
+import { onChannelMemberRead } from '../onChannelMemberRead';
+
+describe('onChannelMemberRead event', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  const channelPayload: Amity.ChannelPayload = {
+    channelUsers: [channelUser1],
+    channels: [channel11],
+    files: [],
+    users: [user11],
+  };
+
+  test('it should call callback with channel and read member', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelMemberRead(callback);
+    client.emitter.emit('v3.channel.didMarkSeen', channelPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(channel11, { ...channelUser1, user: user11 });
+  });
+
+  test('it should return an unsubscriber', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelMemberRead(callback);
+    unsub();
+
+    client.emitter.emit('v3.channel.didMarkSeen', channelPayload);
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,60 @@
+import { disableCache, enableCache } from '~/cache/api';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  channel11,
+  channelUser1,
+  channelUser3,
+  user11,
+  user12,
+} from '~/utils/tests';
+
+import { onChannelMemberUnbanned } from '../onChannelMemberUnbanned';
+
+describe('onChannelMemberBanned event', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(async () => {
+    enableCache();
+  });
+
+  afterEach(disableCache);
+
+  const channelPayload: Amity.ChannelMembershipPayload = {
+    channelUsers: [channelUser1, channelUser3],
+    channels: [channel11],
+    files: [],
+    users: [user11, user12],
+  };
+
+  test('it should call callback with channel and unbanned member', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelMemberUnbanned(callback);
+    client.emitter.emit('channel.unbanned', channelPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(channel11, { ...channelUser3, user: user12 });
+  });
+
+  test('it should return an Unsubscriber', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelMemberUnbanned(callback);
+    unsub();
+
+    client.emitter.emit('channel.unbanned', channelPayload);
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/channel/observers/index.ts

@@ -1 +1,4 @@
 export * from './observeChannel';
+export * from './observeChannels';
+export * from './liveChannels';
+export * from './liveChannelMembers';