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

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());
+  };
+};

package/src/channel/observers/liveChannelMembers.ts

@@ -4,12 +4,11 @@ import { pullFromCache, pushToCache } from '~/cache/api';
 import { getActiveClient } from '~/client/api';
 import {
   createQuery,
-  runQuery,
-  queryOptions,
   filterByPropEquality,
-  sortByLastCreated,
+  queryOptions,
+  runQuery,
   sortByFirstCreated,
-  filterByPropInclusion,
+  sortByLastCreated,
 } from '~/core/query';
 import {
   COLLECTION_DEFAULT_CACHING_POLICY,
@@ -17,9 +16,11 @@ import {
   ENABLE_CACHE_MESSAGE,
 } from '~/utils/constants';
 import {
+  onChannelJoined,
+  onChannelLeft,
   onChannelMemberAdded,
-  onChannelMemberRemoved,
   onChannelMemberBanned,
+  onChannelMemberRemoved,
   onChannelMemberUnbanned,
 } from '../events';
 import { queryChannelMembers } from '../api';
@@ -80,13 +81,15 @@ export const liveChannelMembers = (
        * Muted is specified under seperarte property namely isMuted
        * Hence why I've seperately checked for it's equality
        */
-      if (params.memberships.some(m => ['member', 'banned'].includes(m))) {
-        channelMembers = filterByPropInclusion(channelMembers, 'membership', params.memberships);
-      }
+      channelMembers = channelMembers.filter(member => {
+        // @ts-ignore
+        if (params.memberships.includes('muted') && member.isMuted) {
+          return true;
+        }
 
-      if (params.memberships.includes('muted')) {
-        channelMembers = filterByPropEquality(channelMembers, 'isMuted', true);
-      }
+        // @ts-ignore
+        return params.memberships.includes(member.membership);
+      });
     }
 
     if (params.search) {
@@ -109,29 +112,30 @@ export const liveChannelMembers = (
     });
   };
 
-  const realtimeRouter = (
-    channelMember: Amity.Membership<'channel'>,
-    action: Amity.ChannelMemberActionType,
-  ) => {
-    const collection = pullFromCache<Amity.ChannelMembersLiveCollectionCache>(cacheKey)?.data;
-    if (!collection) return;
+  const realtimeRouter =
+    (action: Amity.ChannelMemberActionType) =>
+    (channel: Amity.Channel, channelMember: Amity.Membership<'channel'>) => {
+      if (params.channelId !== channelMember.channelId) {
+        return;
+      }
 
-    const channelMemberCacheId = getResolver('channelUsers')({
-      channelId: params.channelId,
-      userId: channelMember.userId,
-    });
+      const collection = pullFromCache<Amity.ChannelMembersLiveCollectionCache>(cacheKey)?.data;
+      if (!collection) return;
 
-    if (action === 'onMemberAdded') {
-      collection.data = [...new Set([channelMemberCacheId, ...collection.data])];
-    }
+      const channelMemberCacheId = getResolver('channelUsers')({
+        channelId: params.channelId,
+        userId: channelMember.userId,
+      });
 
-    if (action === 'onMemberRemoved') {
-      collection.data = collection.data.filter(m => m !== channelMemberCacheId);
-    }
+      if (channelMember.membership === 'none') {
+        collection.data = collection.data.filter(m => m !== channelMemberCacheId);
+      } else if (!collection.data.includes(channelMemberCacheId)) {
+        collection.data = [channelMemberCacheId, ...collection.data];
+      }
 
-    pushToCache(cacheKey, collection);
-    responder(collection);
-  };
+      pushToCache(cacheKey, collection);
+      responder(collection);
+    };
 
   const onFetch = () => {
     const collection = pullFromCache<Amity.ChannelMembersLiveCollectionCache>(cacheKey)?.data;
@@ -168,10 +172,12 @@ export const liveChannelMembers = (
   };
 
   disposers.push(
-    onChannelMemberAdded((_, member) => realtimeRouter(member, 'onMemberAdded')),
-    onChannelMemberRemoved((_, member) => realtimeRouter(member, 'onMemberRemoved')),
-    onChannelMemberBanned((_, member) => realtimeRouter(member, 'onChannelMemberBanned')),
-    onChannelMemberUnbanned((_, member) => realtimeRouter(member, 'onChannelMemberUnbanned')),
+    onChannelJoined(realtimeRouter('onJoin')),
+    onChannelLeft(realtimeRouter('onLeft')),
+    onChannelMemberAdded(realtimeRouter('onMemberAdded')),
+    onChannelMemberRemoved(realtimeRouter('onMemberRemoved')),
+    onChannelMemberBanned(realtimeRouter('onChannelMemberBanned')),
+    onChannelMemberUnbanned(realtimeRouter('onChannelMemberUnbanned')),
   );
 
   onFetch();

package/src/channel/observers/liveChannels.ts

@@ -12,14 +12,23 @@ import {
   sortByDisplayName,
   sortByFirstCreated,
 } from '~/core/query';
-import { onChannelCreated, onChannelDeleted, onChannelUpdated } from '../events';
-import { queryChannels } from '../api';
-
 import {
   COLLECTION_DEFAULT_CACHING_POLICY,
   COLLECTION_DEFAULT_PAGINATION_LIMIT,
   ENABLE_CACHE_MESSAGE,
 } from '~/utils/constants';
+import { onMessageCreated } from '~/message/events';
+import {
+  onChannelCreated,
+  onChannelDeleted,
+  onChannelUpdated,
+  onChannelMuted,
+  onChannelJoined,
+  onChannelLeft,
+  onChannelMemberAdded,
+  onChannelMemberRemoved,
+} from '../events';
+import { queryChannels } from '../api';
 
 /**
  * ```js
@@ -117,18 +126,14 @@ export const liveChannels = (
     });
   };
 
-  const realtimeRouter = (channel: Amity.Channel, action: Amity.ChannelActionType) => {
+  const realtimeRouter = (action: Amity.ChannelActionType) => (channel: Amity.Channel) => {
     const collection = pullFromCache<Amity.ChannelLiveCollectionCache>(cacheKey)?.data;
     if (!collection) return;
 
-    if (action === 'onCreate') {
-      collection.data = [...new Set([channel.channelId, ...collection.data])];
-      /*
-       * if the filter isDeleted is set, only collection item must be updated and not
-       * the collection
-       */
-    } else if (action === 'onDelete' && !params.isDeleted) {
+    if (action === 'onDelete' && params.isDeleted === false) {
       collection.data = collection.data.filter(c => c !== channel.channelId);
+    } else {
+      collection.data = [...new Set([channel.channelId, ...collection.data])];
     }
 
     pushToCache(cacheKey, collection);
@@ -170,9 +175,15 @@ export const liveChannels = (
   };
 
   disposers.push(
-    onChannelCreated(channel => realtimeRouter(channel, 'onCreate')),
-    onChannelDeleted(channel => realtimeRouter(channel, 'onDelete')),
-    onChannelUpdated(channel => realtimeRouter(channel, 'onUpdate')),
+    onChannelCreated(realtimeRouter('onCreate')),
+    onChannelDeleted(realtimeRouter('onDelete')),
+    onChannelUpdated(realtimeRouter('onUpdate')),
+    onChannelMuted(realtimeRouter('onMute')),
+    onChannelJoined(realtimeRouter('onJoin')),
+    onChannelLeft(realtimeRouter('onLeft')),
+    onChannelMemberAdded(realtimeRouter('onMemberAdded')),
+    onChannelMemberRemoved(realtimeRouter('onMemberRemoved')),
+    onMessageCreated(() => null), // watch unread count
   );
 
   onFetch();

package/src/channel/observers/observeChannel.ts

@@ -9,6 +9,7 @@ import {
   onChannelDeleted,
   onChannelJoined,
   onChannelLeft,
+  onChannelMuted,
   onChannelMemberAdded,
   onChannelMemberRemoved,
 } from '../events';
@@ -57,6 +58,7 @@ export const observeChannel = <Events extends [Exclude<Amity.ChannelActionType,
     onChannelDeleted(data => router({ data, loading: false, origin: 'event' }, 'onDelete')),
     onChannelJoined(data => router({ data, loading: false, origin: 'event' }, 'onJoin')),
     onChannelLeft(data => router({ data, loading: false, origin: 'event' }, 'onLeft')),
+    onChannelMuted(data => router({ data, loading: false, origin: 'event' }, 'onMute')),
     onChannelMemberAdded(data =>
       router({ data, loading: false, origin: 'event' }, 'onMemberAdded'),
     ),

package/src/channel/observers/observeChannels.ts

@@ -6,6 +6,7 @@ import {
   onChannelDeleted,
   onChannelJoined,
   onChannelLeft,
+  onChannelMuted,
   onChannelMemberAdded,
   onChannelMemberRemoved,
 } from '../events';
@@ -48,6 +49,7 @@ export const observeChannels = (
     onChannelDeleted(data => router(data, 'onDelete')),
     onChannelJoined(data => router(data, 'onJoin')),
     onChannelLeft(data => router(data, 'onLeft')),
+    onChannelMuted(data => router(data, 'onMute')),
     onChannelMemberAdded(data => router(data, 'onMemberAdded')),
     onChannelMemberRemoved(data => router(data, 'onMemberRemoved')),
   );