@amityco/ts-sdk 0.0.1-beta.25 → 0.0.1-beta.28

package/src/channel/api/getChannels.ts

@@ -3,6 +3,8 @@ import { getActiveClient } from '~/client/api';
 import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
  * import { getChannels } from '@amityco/ts-sdk'
@@ -26,10 +28,12 @@ export const getChannels = async (
   const encodedChannelIds = channelIds.map(channelId => encodeURIComponent(channelId));
 
   // API-FIX: endpoint should not be /list, parameters should be querystring.
-  const { data } = await client.http.get<Amity.ChannelPayload>(`/api/v3/channels/list`, {
+  const { data: payload } = await client.http.get<Amity.ChannelPayload>(`/api/v3/channels/list`, {
     params: { channelIds: encodedChannelIds },
   });
 
+  const data = prepareChannelPayload(payload);
+
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 

package/src/channel/api/index.ts

@@ -16,3 +16,6 @@ export * from './removeChannelMembers';
 
 export * from './addChannelMembersRole';
 export * from './removeChannelMembersRole';
+
+export * from './banChannelMembers';
+export * from './unbanChannelMembers';

package/src/channel/api/joinChannel.ts

@@ -2,6 +2,8 @@ import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
  * import { joinChannel } from '@amityco/ts-sdk'
@@ -20,10 +22,12 @@ export const joinChannel = async (channelId: Amity.Channel['channelId']): Promis
   const client = getActiveClient();
   client.log('channel/joinChannel', channelId);
 
-  const { data } = await client.http.post<Amity.ChannelMembershipPayload>(
+  const { data: payload } = await client.http.post<Amity.ChannelMembershipPayload>(
     `/api/v3/channels/${encodeURIComponent(channelId)}/join`,
   );
 
+  const data = prepareChannelPayload(payload);
+
   if (client.cache) ingestInCache(data);
 
   const { channelUsers } = data;

package/src/channel/api/leaveChannel.ts

@@ -2,6 +2,8 @@ import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
  * import { leaveChannel } from '@amityco/ts-sdk'
@@ -20,10 +22,12 @@ export const leaveChannel = async (channelId: Amity.Channel['channelId']): Promi
   const client = getActiveClient();
   client.log('channel/leaveChannel', channelId);
 
-  const { data } = await client.http.delete<Amity.ChannelMembershipPayload>(
+  const { data: payload } = await client.http.delete<Amity.ChannelMembershipPayload>(
     `/api/v3/channels/${encodeURIComponent(channelId)}/leave`,
   );
 
+  const data = prepareChannelPayload(payload);
+
   if (client.cache) ingestInCache(data);
 
   const { channelUsers } = data;

package/src/channel/api/queryChannelMembers.ts

@@ -3,6 +3,8 @@ import { getActiveClient } from '~/client/api';
 import { toPage, toToken } from '~/core/query';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
  * import { queryChannelMembers } from '@amityco/ts-sdk'
@@ -30,24 +32,26 @@ export const queryChannelMembers = async (query: {
 
   const { page, channelId, ...params } = query ?? {};
 
-  const { data } = await client.http.get<Amity.ChannelMembershipPayload & Amity.Pagination>(
-    `/api/v4/channels/${encodeURIComponent(channelId)}/users`,
-    {
-      params: {
-        ...params,
-        options: {
-          token: toToken(page, 'skiplimit'),
-        },
+  const { data: queryPayload } = await client.http.get<
+    Amity.ChannelMembershipPayload & Amity.Pagination
+  >(`/api/v4/channels/${encodeURIComponent(channelId)}/users`, {
+    params: {
+      ...params,
+      options: {
+        token: toToken(page, 'skiplimit'),
       },
     },
-  );
+  });
+
+  const { paging, ...payload } = queryPayload;
+
+  const data = prepareChannelPayload(payload);
 
-  const { paging, ...payload } = data;
-  const { channelUsers } = payload;
+  const { channelUsers } = data;
 
   const cachedAt = client.cache && Date.now();
   if (client.cache) {
-    ingestInCache(payload as Amity.ChannelMembershipPayload);
+    ingestInCache(data as Amity.ChannelMembershipPayload);
   }
 
   const nextPage = toPage(paging.next);

package/src/channel/api/queryChannels.ts

@@ -5,6 +5,8 @@ import { pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
  * import { queryChannels } from '@amityco/ts-sdk'
@@ -39,7 +41,7 @@ export const queryChannels = async (query?: {
   // API-FIX: parameters should be querystring.
   // API-FIX: backend doesnt answer Amity.Response
   // const { data } = await client.http.get<Amity.Response<Amity.Paged<ChannelPayload>>>(
-  const { data } = await client.http.get<Amity.ChannelPayload & Amity.Pagination>(
+  const { data: queryPayload } = await client.http.get<Amity.ChannelPayload & Amity.Pagination>(
     `/api/v3/channels`,
     {
       params: {
@@ -53,13 +55,16 @@ export const queryChannels = async (query?: {
     },
   );
 
-  const { paging, ...payload } = data;
-  const { channels } = payload;
+  const { paging, ...payload } = queryPayload;
+
+  const data = prepareChannelPayload(payload);
+
+  const { channels } = data;
 
   const cachedAt = client.cache && Date.now();
 
   if (client.cache) {
-    ingestInCache(payload as Amity.ChannelPayload, { cachedAt });
+    ingestInCache(data as Amity.ChannelPayload, { cachedAt });
 
     const cacheKey = [
       'channel',

package/src/channel/api/removeChannelMembers.ts

@@ -3,6 +3,8 @@ import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
  * import { removeChannelMembers } from '@amityco/ts-sdk'
@@ -25,17 +27,16 @@ export const removeChannelMembers = async (
   const client = getActiveClient();
   client.log('channel/removeChannelMembers', channelId, userIds);
 
-  const { data } = await client.http.delete<Amity.ChannelMembershipPayload>(
+  const { data: payload } = await client.http.delete<Amity.ChannelMembershipPayload>(
     `/api/v3/channels/${encodeURIComponent(channelId)}/users`,
     { data: { channelId, userIds } },
   );
 
+  const data = prepareChannelPayload(payload);
+
   if (client.cache) ingestInCache(data);
 
-  fireEvent('v3.channel.didRemoveUsers', {
-    channels: data.channels,
-    channelUsers: data.channelUsers,
-  });
+  fireEvent('v3.channel.didRemoveUsers', data);
 
   const { channelUsers } = data;
   return !!channelUsers.find(

package/src/channel/api/removeChannelMembersRole.ts

@@ -2,6 +2,8 @@ import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
  * import { removeChannelMembersRole } from '@amityco/ts-sdk'
@@ -26,11 +28,13 @@ export const removeChannelMembersRole = async (
   const client = getActiveClient();
   client.log('channel/removeChannelMembersRole', channelId, roleId, userIds);
 
-  const { data } = await client.http.delete<Amity.ChannelMembershipPayload>(
+  const { data: payload } = await client.http.delete<Amity.ChannelMembershipPayload>(
     `/api/v3/channels/${encodeURIComponent(channelId)}/users/roles`,
     { data: { channelId, role: roleId, userIds } },
   );
 
+  const data = prepareChannelPayload(payload);
+
   if (client.cache) ingestInCache(data);
 
   const { channelUsers } = data;

package/src/channel/api/unbanChannelMembers.ts

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

package/src/channel/api/updateChannel.ts

@@ -2,6 +2,8 @@ import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
  * import { updateChannel } from '@amityco/ts-sdk'
@@ -24,11 +26,13 @@ export const updateChannel = async (
   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 });
 

package/src/channel/events/index.ts

@@ -1,3 +1,4 @@
+export * from './onChannelCreated';
 export * from './onChannelUpdated';
 export * from './onChannelDeleted';
 export * from './onChannelJoined';

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,8 +24,10 @@ 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);

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,8 +24,10 @@ 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);

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,8 +24,10 @@ 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);

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,8 +24,10 @@ 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);

package/src/channel/events/onChannelMemberAdded.ts

@@ -3,6 +3,8 @@ import { createEventSubscriber } from '~/core/events';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
  * import { onChannelMemberAdded } from '@amityco/ts-sdk'
@@ -24,8 +26,10 @@ export const onChannelMemberAdded = (
   const client = getActiveClient();
 
   const filter = (payload: Amity.ChannelMembershipPayload) => {
-    ingestInCache(payload);
-    callback(payload.channels[0], payload.channelUsers[0]);
+    const data = prepareChannelPayload(payload);
+
+    ingestInCache(data);
+    callback(data.channels[0], data.channelUsers[0]);
   };
 
   return createEventSubscriber(client, 'onChannelMemberAdded', 'v3.channel.didAddUsers', filter);

package/src/channel/events/onChannelMemberRemoved.ts

@@ -3,6 +3,8 @@ import { createEventSubscriber } from '~/core/events';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
  * import { onChannelMemberRemoved } from '@amityco/ts-sdk'
@@ -24,8 +26,10 @@ export const onChannelMemberRemoved = (
   const client = getActiveClient();
 
   const filter = (payload: Amity.ChannelMembershipPayload) => {
-    ingestInCache(payload);
-    callback(payload.channels[0], payload.channelUsers[0]);
+    const data = prepareChannelPayload(payload);
+
+    ingestInCache(data);
+    callback(data.channels[0], data.channelUsers[0]);
   };
 
   return createEventSubscriber(

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,8 +24,10 @@ 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);

package/src/channel/observers/index.ts

@@ -1 +1,2 @@
 export * from './observeChannel';
+export * from './observeChannels';

package/src/channel/observers/observeChannel.ts

@@ -29,17 +29,7 @@ import {
  *
  * @category Channel Observer
  */
-export const observeChannel = <
-  Events extends [
-    'onFetch',
-    'onUpdate',
-    'onDelete',
-    'onJoin',
-    'onLeft',
-    'onMemberAdded',
-    'onMemberRemoved',
-  ],
->(
+export const observeChannel = <Events extends [Exclude<Amity.ChannelActionType, 'onCreate'>]>(
   channelId: string,
   callback: Amity.ObjectListener<Amity.Snapshot<Amity.Channel>, Events>,
 ): Amity.Unsubscriber => {

package/src/channel/observers/observeChannels.ts

@@ -0,0 +1,59 @@
+import { getActiveClient } from '~/client/api';
+
+import {
+  onChannelCreated,
+  onChannelUpdated,
+  onChannelDeleted,
+  onChannelJoined,
+  onChannelLeft,
+  onChannelMemberAdded,
+  onChannelMemberRemoved,
+} from '../events';
+
+/**
+ * ```js
+ * import { observeChannels } from '@amityco/ts-sdk'
+ *
+ * let channels = []
+ * const unsub = observeChannels(channel => merge(channels, channel))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Channel} for a current user
+ *
+ * @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 channels
+ *
+ * @category Channel Observer
+ */
+export const observeChannels = (
+  callback: Amity.ObjectListener<Amity.Channel, [Exclude<Amity.ChannelActionType, 'onFetch'>]>,
+): Amity.Unsubscriber => {
+  const { log } = getActiveClient();
+
+  const timestamp = Date.now();
+  log(`observeChannels(tmpid: ${timestamp}) > listen`);
+
+  const disposers: Amity.Unsubscriber[] = [];
+
+  const router = (channel: Amity.Channel, action: Exclude<Amity.ChannelActionType, 'onFetch'>) => {
+    if (callback instanceof Function) return callback(channel);
+
+    callback.onEvent?.(action, channel);
+    callback[action]?.(channel);
+  };
+
+  disposers.push(
+    onChannelCreated(data => router(data, 'onCreate')),
+    onChannelUpdated(data => router(data, 'onUpdate')),
+    onChannelDeleted(data => router(data, 'onDelete')),
+    onChannelJoined(data => router(data, 'onJoin')),
+    onChannelLeft(data => router(data, 'onLeft')),
+    onChannelMemberAdded(data => router(data, 'onMemberAdded')),
+    onChannelMemberRemoved(data => router(data, 'onMemberRemoved')),
+  );
+
+  return () => {
+    log(`observeChannels(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/channel/tests/utils/prepareChannelPayload.test.ts

@@ -0,0 +1,120 @@
+import {
+  connectClient,
+  disconnectClient,
+  channel11,
+  channel12,
+  channelRaw1,
+  channelRaw2,
+  channelUser1,
+  channelUser2,
+} from '~/utils/tests';
+
+import { prepareChannelPayload } from '../../utils';
+
+beforeAll(async () => {
+  await connectClient();
+});
+
+afterAll(async () => {
+  await disconnectClient();
+});
+
+const responseSchema = {
+  channels: [],
+  channelUsers: [],
+  files: [],
+  users: [],
+};
+
+const tests = [
+  {
+    id: 1,
+    desc: 'hasMention: false, unreadCount: 0, if channelUsers is empty',
+    before: {
+      ...responseSchema,
+      channels: [channelRaw1],
+    },
+    after: {
+      ...responseSchema,
+      channels: [channel11],
+    },
+  },
+  {
+    id: 2,
+    desc: 'hasMention: false, if channelUser.readToSegment >= channelUser.lastMentionedSegment',
+    before: {
+      ...responseSchema,
+      channels: [channelRaw1],
+      channelUsers: [channelUser1],
+    },
+    after: {
+      ...responseSchema,
+      channels: [channel11],
+      channelUsers: [channelUser1],
+    },
+  },
+  {
+    id: 3,
+    desc: 'unreadCount: 0, if channelUser.readToSegment = channel.messageCount',
+    before: {
+      ...responseSchema,
+      channels: [channelRaw1],
+      channelUsers: [channelUser1],
+    },
+    after: {
+      ...responseSchema,
+      channels: [channel11],
+      channelUsers: [channelUser1],
+    },
+  },
+  {
+    id: 4,
+    desc: 'hasMention: true, if channelUser.readToSegment < channelUser.lastMentionedSegment',
+    before: {
+      ...responseSchema,
+      channels: [channelRaw2],
+      channelUsers: [channelUser2],
+    },
+    after: {
+      ...responseSchema,
+      channels: [channel12],
+      channelUsers: [channelUser2],
+    },
+  },
+  {
+    id: 5,
+    desc: 'unreadCount: > 0, if channelUser.readToSegment < channel.messageCount',
+    before: {
+      ...responseSchema,
+      channels: [channelRaw2],
+      channelUsers: [channelUser2],
+    },
+    after: {
+      ...responseSchema,
+      channels: [channel12],
+      channelUsers: [channelUser2],
+    },
+  },
+  {
+    id: 4,
+    desc: 'hasMention: true, unreadCount: > 0, if 4 / 5 ',
+    before: {
+      ...responseSchema,
+      channels: [channelRaw2],
+      channelUsers: [channelUser2],
+    },
+    after: {
+      ...responseSchema,
+      channels: [channel12],
+      channelUsers: [channelUser2],
+    },
+  },
+];
+
+describe('channel/utils/prepareChannelPayload', () => {
+  tests.forEach(({ id, desc, before, after }) => {
+    test(`${id} - ${desc}`, () => {
+      expect(prepareChannelPayload(before)).toEqual(after);
+    });
+  });
+});

package/src/channel/utils/index.ts

@@ -0,0 +1 @@
+export * from './prepareChannelPayload';