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

package/src/channel/events/onChannelMemberRemoved.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,16 +27,13 @@ export const onChannelMemberRemoved = (
   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[0]);
   };
 
-  return createEventSubscriber(
-    client,
-    'onChannelMemberRemoved',
-    'v3.channel.didRemoveUsers',
-    filter,
-  );
+  return createEventSubscriber(client, 'onChannelMemberRemoved', 'channel.membersRemoved', filter);
 };

package/src/channel/events/onChannelMemberUnbanned.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 onChannelMemberUnbanned = (
   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 === 'none')!);
+    ingestInCache(preparedPayload);
+    callback(channels[0], channelUsers.find(cu => cu.membership === 'none')!);
   };
 
-  return createEventSubscriber(client, 'onChannelMemberBanned', 'v3.channel.didUnban', filter);
+  return createEventSubscriber(client, 'onChannelMemberUnbanned', 'channel.unbanned', filter);
 };

package/src/channel/events/onChannelMuted.ts

@@ -0,0 +1,34 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { onChannelMuted } from '@amityco/ts-sdk'
+ * const dispose = onChannelMuted(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 onChannelMuted = (callback: Amity.Listener<Amity.Channel>) => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.ChannelPayload) => {
+    const data = prepareChannelPayload(payload);
+
+    ingestInCache(data);
+    callback(data.channels[0]);
+  };
+
+  return createEventSubscriber(client, 'onChannelMuted', 'channel.setMuted', filter);
+};

package/src/channel/events/onChannelUpdated.ts

@@ -30,5 +30,14 @@ export const onChannelUpdated = (callback: Amity.Listener<Amity.Channel>) => {
     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();
+  });
+});

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

@@ -0,0 +1,56 @@
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  channel1,
+  channelRaw1,
+  channelUser,
+  client,
+  connectClient,
+  disconnectClient,
+  rawChannelUser,
+  user11,
+} from '~/utils/tests';
+import { onChannelJoined } from '../onChannelJoined';
+
+describe('onChannelJoined 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 have someone joined channel', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelJoined(callback);
+    client.emitter.emit('channel.joined', channelPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(channel1, channelUser);
+  });
+
+  test('it should return an unsubscriber', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelJoined(callback);
+    unsub();
+
+    client.emitter.emit('channel.joined', channelPayload);
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,56 @@
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  channel1,
+  user11,
+  rawChannelUser,
+  channelRaw1,
+  channelUser,
+} from '~/utils/tests';
+import { onChannelMemberAdded } from '../onChannelMemberAdded';
+
+describe('onChannelMemberAdded 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 have someone add member to channel', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelMemberAdded(callback);
+    client.emitter.emit('channel.membersAdded', channelPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(channel1, channelUser);
+  });
+
+  test('it should return an unsubscriber', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelMemberAdded(callback);
+    unsub();
+
+    client.emitter.emit('channel.membersAdded', channelPayload);
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

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

@@ -4,9 +4,12 @@ import {
   client,
   connectClient,
   disconnectClient,
-  channel11,
-  channelUser1,
-  channelUser5,
+  channel1,
+  rawChannelUser,
+  rawBannedChannelUser,
+  user11,
+  user13,
+  channelRaw1,
 } from '~/utils/tests';
 
 import { onChannelMemberBanned } from '../onChannelMemberBanned';
@@ -20,29 +23,27 @@ describe('onChannelMemberBanned event', () => {
     await disconnectClient();
   });
 
-  beforeEach(async () => {
-    enableCache();
-  });
+  beforeEach(enableCache);
 
   afterEach(disableCache);
 
   const channelPayload: Amity.ChannelMembershipPayload = {
-    channelUsers: [channelUser1, channelUser5],
-    channels: [channel11],
+    channelUsers: [rawChannelUser, rawBannedChannelUser],
+    channels: [channelRaw1],
     files: [],
-    users: [],
+    users: [user11, user13],
   };
 
   test('it should call callback with channel and banned member', () => {
     const callback = jest.fn();
 
     const unsub = onChannelMemberBanned(callback);
-    client.emitter.emit('v3.channel.didBan', channelPayload);
+    client.emitter.emit('channel.banned', channelPayload);
 
     unsub();
 
     expect(callback).toHaveBeenCalled();
-    expect(callback).toHaveBeenCalledWith(channel11, channelUser5);
+    expect(callback).toHaveBeenCalledWith(channel1, { ...rawBannedChannelUser, user: user13 });
   });
 
   test('it should return an unsubscriber', () => {
@@ -51,7 +52,7 @@ describe('onChannelMemberBanned event', () => {
     const unsub = onChannelMemberBanned(callback);
     unsub();
 
-    client.emitter.emit('v3.channel.didBan', channelPayload);
+    client.emitter.emit('channel.unbanned', channelPayload);
 
     expect(callback).not.toHaveBeenCalled();
   });

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

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

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

@@ -4,9 +4,12 @@ import {
   client,
   connectClient,
   disconnectClient,
-  channel11,
-  channelUser1,
-  channelUser3,
+  channel1,
+  rawChannelUser,
+  rawChannelUser3,
+  user11,
+  user12,
+  channelRaw1,
 } from '~/utils/tests';
 
 import { onChannelMemberUnbanned } from '../onChannelMemberUnbanned';
@@ -20,29 +23,27 @@ describe('onChannelMemberBanned event', () => {
     await disconnectClient();
   });
 
-  beforeEach(async () => {
-    enableCache();
-  });
+  beforeEach(enableCache);
 
   afterEach(disableCache);
 
   const channelPayload: Amity.ChannelMembershipPayload = {
-    channelUsers: [channelUser1, channelUser3],
-    channels: [channel11],
+    channelUsers: [rawChannelUser, rawChannelUser3],
+    channels: [channelRaw1],
     files: [],
-    users: [],
+    users: [user11, user12],
   };
 
   test('it should call callback with channel and unbanned member', () => {
     const callback = jest.fn();
 
     const unsub = onChannelMemberUnbanned(callback);
-    client.emitter.emit('v3.channel.didUnban', channelPayload);
+    client.emitter.emit('channel.unbanned', channelPayload);
 
     unsub();
 
     expect(callback).toHaveBeenCalled();
-    expect(callback).toHaveBeenCalledWith(channel11, channelUser3);
+    expect(callback).toHaveBeenCalledWith(channel1, { ...rawChannelUser3, user: user12 });
   });
 
   test('it should return an Unsubscriber', () => {
@@ -51,7 +52,7 @@ describe('onChannelMemberBanned event', () => {
     const unsub = onChannelMemberUnbanned(callback);
     unsub();
 
-    client.emitter.emit('v3.channel.didUnban', channelPayload);
+    client.emitter.emit('channel.unbanned', channelPayload);
 
     expect(callback).not.toHaveBeenCalled();
   });

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

@@ -0,0 +1,55 @@
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  channel1,
+  channelRaw1,
+  client,
+  connectClient,
+  disconnectClient,
+  rawChannelUser,
+  user11,
+} from '~/utils/tests';
+import { onChannelUpdated } from '../onChannelUpdated';
+
+describe('onChannelUpdated 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 updated', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelUpdated(callback);
+    client.emitter.emit('channel.updated', channelPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(channel1);
+  });
+
+  test('it should return an unsubscriber', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelUpdated(callback);
+    unsub();
+
+    client.emitter.emit('channel.updated', channelPayload);
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/channel/observers/index.ts

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

package/src/channel/observers/liveChannel.ts

@@ -0,0 +1,108 @@
+import { ASCApiError } from '~/core/errors';
+import { getActiveClient } from '~/client/api';
+import { createQuery, runQuery } from '~/core/query';
+import {
+  LIVE_OBJECT_ENABLE_CACHE_MESSAGE,
+  UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
+  UNSYNCED_OBJECT_CACHED_AT_VALUE,
+} from '~/utils/constants';
+import { hasUpdates } from '~/core/model';
+import { onMessageCreated } from '~/message/events';
+import { getChannel } from '../api';
+import { onChannelDeleted, onChannelJoined, onChannelMuted, onChannelUpdated } from '../events';
+
+/**
+ * ```js
+ * import { liveChannel } from '@amityco/ts-sdk';
+ *
+ * let channel;
+ *
+ * const unsubscribe = liveChannel(channelId, response => {
+ *   channel = response.data;
+ * });
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.Channel}
+ *
+ * @param channelId the ID of the channel to observe
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the channel
+ *
+ * @category Message Live Object
+ */
+export const liveChannel = (
+  channelId: Amity.Channel['channelId'],
+  callback: Amity.LiveObjectCallback<Amity.Channel>,
+): Amity.Unsubscriber => {
+  const { log, cache } = getActiveClient();
+  const timestamp = Date.now();
+  log(`liveChannel(tmpid: ${timestamp}) > listen`);
+
+  if (!cache) {
+    console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
+  }
+
+  let channel: Amity.Channel;
+  let isUnsyncedObject = false;
+  const disposers: Amity.Unsubscriber[] = [];
+
+  const dispatcher = (data: Amity.LiveObject<Amity.Channel>) => {
+    channel = data.data;
+    callback(data);
+  };
+
+  const realtimeRouter = (eventChannel: Amity.Channel) => {
+    if (channelId !== eventChannel.channelId) {
+      return;
+    }
+
+    if (channel && !hasUpdates(channel, eventChannel)) {
+      return;
+    }
+
+    dispatcher({ loading: false, data: eventChannel, origin: 'event' });
+  };
+
+  const onFetch = () => {
+    const query = createQuery(getChannel, channelId);
+
+    runQuery(query, ({ loading, data, error, origin, cachedAt }) => {
+      if (cachedAt === UNSYNCED_OBJECT_CACHED_AT_VALUE) {
+        dispatcher({
+          data,
+          origin,
+          loading: false,
+          error: new ASCApiError(
+            UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
+            Amity.ClientError.DISALOOW_UNSYNCED_OBJECT,
+            Amity.ErrorLevel.ERROR,
+          ),
+        });
+
+        isUnsyncedObject = true;
+        disposers.forEach(fn => fn());
+      } else if (!isUnsyncedObject) {
+        dispatcher({ loading, data, origin, error });
+      }
+
+      if (error) {
+        disposers.forEach(fn => fn());
+      }
+    });
+  };
+
+  disposers.push(
+    onChannelUpdated(realtimeRouter),
+    onChannelDeleted(realtimeRouter),
+    onChannelJoined(realtimeRouter),
+    onChannelMuted(realtimeRouter),
+    onMessageCreated(() => null), // watch unread count
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveChannel(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};