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

package/src/channel/api/queryChannelMembers.ts

@@ -1,8 +1,15 @@
+import { prepareChannelPayload } from '~/channel/utils';
 import { getActiveClient } from '~/client/api';
 
 import { toPage, toToken } from '~/core/query';
+import { getResolver } from '~/core/model';
+
+import { pullFromCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+/* begin_public_function
+  id: channel.member.query, channel.member.search
+*/
 /**
  * ```js
  * import { queryChannelMembers } from '@amityco/ts-sdk'
@@ -17,44 +24,59 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * @category Channel API
  * @async
  * */
-export const queryChannelMembers = async (query: {
-  channelId: string;
-  membership?: 'all' | 'muted' | 'banned' | 'member&banned';
-  roles?: string[];
-  sortBy?: 'firstCreated' | 'lastCreated';
-  page?: Amity.Page;
-}): Promise<Amity.Cached<Amity.Paged<Amity.Membership<'channel'>>>> => {
+export const queryChannelMembers = async (
+  query: Amity.QueryChannelMembers,
+): Promise<Amity.Cached<Amity.Paged<Amity.Membership<'channel'>>>> => {
   const client = getActiveClient();
   client.log('channel/queryChannelMembers', query);
 
-  const { page, channelId, membership, ...params } = query ?? {};
-
-  const { data } = await client.http.get<Amity.ChannelMembershipPayload & Amity.Pagination>(
-    `/api/v3/channels/${encodeURIComponent(channelId)}/users`,
-    {
-      params: {
-        ...params,
-        filter: membership,
-        options: {
-          token: toToken(page, 'skiplimit'),
-        },
+  const { page, ...params } = query ?? {};
+
+  const { data: queryPayload } = await client.http.get<
+    Amity.ChannelMembershipPayload & Amity.Pagination
+  >(`/api/v4/channels/${encodeURIComponent(params.channelId)}/users`, {
+    params: {
+      ...params,
+      options: {
+        token: toToken(page, 'skiplimit'),
       },
     },
-  );
+  });
 
-  const { paging, ...payload } = data;
-  const { channelUsers } = payload;
+  const { paging, ...payload } = queryPayload;
+  const preparedPayload = prepareChannelPayload(payload);
+  const { channelUsers } = preparedPayload;
 
   const cachedAt = client.cache && Date.now();
+
   if (client.cache) {
-    ingestInCache(payload as Amity.ChannelMembershipPayload);
+    ingestInCache(preparedPayload);
+
+    const cacheKey = [
+      'channelUsers',
+      'query',
+      { ...params, options: { ...page } } as Amity.Serializable,
+    ];
+
+    pushToCache(cacheKey, {
+      channelUsers: channelUsers.map(({ channelId, userId }) =>
+        getResolver('channelUsers')({ channelId, userId }),
+      ),
+      paging,
+    });
   }
 
   const nextPage = toPage(paging.next);
   const prevPage = toPage(paging.previous);
 
-  return { data: channelUsers, cachedAt, nextPage, prevPage };
+  return {
+    data: channelUsers,
+    cachedAt,
+    nextPage,
+    prevPage,
+  };
 };
+/* end_public_function */
 
 /**
  * ```js
@@ -69,9 +91,41 @@ export const queryChannelMembers = async (query: {
  *
  * @category Post API
  */
-queryChannelMembers.locally = (query: Parameters<typeof queryChannelMembers>[0]) => {
+queryChannelMembers.locally = (
+  query: Parameters<typeof queryChannelMembers>[0],
+): Amity.Cached<Amity.Paged<Amity.Membership<'channel'>>> | undefined => {
   const client = getActiveClient();
-  client.log('channel/queryChannelMembers', query);
+  client.log('channel/queryChannelMembers.locally', query);
+
+  if (!client.cache) return;
+
+  const { page, ...params } = query;
+
+  const cacheKey = [
+    'channelUsers',
+    'query',
+    { ...params, options: { ...page } } as Amity.Serializable,
+  ];
+
+  const { data, cachedAt } =
+    pullFromCache<
+      {
+        channelUsers: Pick<Amity.Membership<'channel'>, 'channelId' | 'userId'>[];
+      } & Amity.Pagination
+    >(cacheKey) ?? {};
+
+  if (!data?.channelUsers.length) return;
+
+  const channelUsers: Amity.Membership<'channel'>[] = data.channelUsers
+    // ck -> cacheKey, abbrevated to avoid confusion from the above cache key
+    .map(ck => pullFromCache<Amity.Membership<'channel'>>(['channelUsers', 'get', ck])!)
+    .filter(Boolean)
+    .map(({ data }) => data);
+
+  const prevPage = toPage(data?.paging.previous);
+  const nextPage = toPage(data?.paging.next);
 
-  // TODO
+  return channelUsers.length === data?.channelUsers?.length
+    ? { data: channelUsers, cachedAt, prevPage, nextPage }
+    : undefined;
 };

package/src/channel/api/queryChannels.ts

@@ -1,10 +1,16 @@
 import { getActiveClient } from '~/client/api';
 
 import { toPage, toToken } from '~/core/query';
-import { pushToCache } from '~/cache/api';
-import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
 
+import { pushToCache, pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '../utils';
+
+/* begin_public_function
+  id: channel.query
+*/
 /**
  * ```js
  * import { queryChannels } from '@amityco/ts-sdk'
@@ -20,15 +26,9 @@ import { getResolver } from '~/core/model';
  * @category Channel API
  * @async
  */
-export const queryChannels = async (query?: {
-  displayName?: string;
-  membership?: 'all' | 'member' | 'notMember';
-  sortBy?: 'displayName' | 'firstCreated' | 'lastCreated';
-  types?: Amity.ChannelType;
-  tags?: Amity.Taggable['tags'];
-  excludeTags?: Amity.Taggable['tags'];
-  page?: Amity.Page;
-}): Promise<Amity.Cached<Amity.Paged<Amity.Channel>>> => {
+export const queryChannels = async (
+  query?: Amity.QueryChannels,
+): Promise<Amity.Cached<Amity.Paged<Amity.Channel>>> => {
   const client = getActiveClient();
   client.log('channel/queryChannels', query);
 
@@ -38,7 +38,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: {
@@ -52,13 +52,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, { cachedAt });
 
     const cacheKey = [
       'channel',
@@ -73,6 +76,7 @@ export const queryChannels = async (query?: {
 
   return { data: channels, cachedAt, prevPage, nextPage };
 };
+/* end_public_function */
 
 /**
  * ```js
@@ -87,9 +91,35 @@ export const queryChannels = async (query?: {
  *
  * @category Channel API
  */
-queryChannels.locally = (query: Parameters<typeof queryChannels>[0]) => {
+queryChannels.locally = (
+  query?: Parameters<typeof queryChannels>[0],
+): Amity.Cached<Amity.Paged<Amity.Channel>> | undefined => {
   const client = getActiveClient();
   client.log('channel/queryChannels.locally', query);
 
-  // TODO
+  const { page = { limit: 10 }, ...params } = query ?? {};
+
+  const cacheKey = ['channel', 'query', { ...params, options: { ...page } } as Amity.Serializable];
+
+  const { data, cachedAt } =
+    pullFromCache<
+      {
+        channels: Pick<Amity.Channel, 'channelId'>[];
+      } & Amity.Pagination
+    >(cacheKey) ?? {};
+
+  if (!data?.channels.length) return;
+
+  const channels: Amity.Channel[] = data.channels
+    // ck -> cacheKey, abbrevated to avoid confusion from the above cache key
+    .map(ck => pullFromCache<Amity.Channel>(['channel', 'get', ck])!)
+    .filter(Boolean)
+    .map(({ data }) => data);
+
+  const prevPage = toPage(data?.paging.previous);
+  const nextPage = toPage(data?.paging.next);
+
+  return channels.length === data?.channels?.length
+    ? { data: channels, cachedAt, prevPage, nextPage }
+    : undefined;
 };

package/src/channel/api/removeChannelMembers.ts

@@ -3,6 +3,11 @@ import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
 
+import { prepareChannelPayload } from '../utils';
+
+/* begin_public_function
+  id: channel.member.remove
+*/
 /**
  * ```js
  * import { removeChannelMembers } from '@amityco/ts-sdk'
@@ -25,19 +30,28 @@ 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 } },
   );
 
-  if (client.cache) ingestInCache(data);
+  /*
+   * should fire event for each user that was removed
+   */
+  userIds.forEach(id =>
+    fireEvent('channel.membersRemoved', {
+      ...payload,
+      channelUsers: payload.channelUsers.filter(u => u.userId === id),
+    }),
+  );
 
-  fireEvent('v3.channel.didRemoveUsers', {
-    channels: data.channels!,
-  });
+  const data = prepareChannelPayload(payload);
+
+  if (client.cache) ingestInCache(data);
 
   const { channelUsers } = data;
   return !!channelUsers.find(
     channelUser => channelUser.channelId === channelId && channelUser.membership !== 'member',
   );
 };
+/* end_public_function */

package/src/channel/api/removeChannelMembersRole.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.moderation.remove_roles
+*/
 /**
  * ```js
  * import { removeChannelMembersRole } from '@amityco/ts-sdk'
@@ -12,7 +17,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  *
  * @param channelId The ID of the {@link Amity.Channel} to perform
  * @param roleId The ID of the {@link Amity.Role} to apply
- * @param userId Array of IDs of the {@link Amity.User} to perform
+ * @param userIds Array of IDs of the {@link Amity.User} to perform
  * @returns A success boolean if the {@link Amity.Role} were removed from list of {@link Amity.User} in the {@link Amity.Channel}
  *
  * @category Channel API
@@ -26,11 +31,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;
@@ -38,3 +45,4 @@ export const removeChannelMembersRole = async (
     channelUser => channelUser.channelId === channelId && !channelUser.roles.includes(roleId),
   );
 };
+/* end_public_function */

package/src/channel/api/startReading.ts

@@ -0,0 +1,57 @@
+import { getActiveClient } from '~/client/api';
+import { synchronousWSCall } from '~/core/transports';
+import { pullFromCache, pushToCache } from '~/cache/api';
+
+/* begin_public_function
+  id: channel.start_reading
+*/
+/**
+ * ```js
+ * import { startReading } from '@amityco/ts-sdk'
+ * const success = await startReading('foo')
+ * ```
+ *
+ * Mark all messages as read and start reading message inside channel
+ *
+ * @param subChannelId - The channel ID to start reading.
+ * @param userId - The user ID of channel member.
+ * @return A success boolean if the channel reading of the sub channel had begun.
+ *
+ * @category Message API
+ * @async
+ */
+export const startReading = async (subChannelId: string, userId = getActiveClient().userId) => {
+  const client = getActiveClient();
+  client.log('message/startReading', { subChannelId });
+
+  const subChannel = pullFromCache<Amity.SubChannel>(['subChannel', 'get', subChannelId]);
+
+  if (!subChannel) {
+    return;
+  }
+
+  const { channelId } = subChannel.data;
+  const channel = pullFromCache<Amity.Channel>(['channel', 'get', channelId]);
+
+  if (!channel || channel.data.defaultSubChannelId !== subChannelId) {
+    return;
+  }
+
+  const update: Amity.Channel = {
+    ...channel.data,
+    // @ts-ignore
+    localReading: true,
+    defaultSubChannelUnreadCount: 0,
+    defaultSubChannelHasUnreadMention: false,
+  };
+
+  pushToCache(['channel', 'get', channelId], update);
+  client.emitter.emit('local.channel.updated', { channels: [update] });
+
+  const result = await synchronousWSCall<Record<never, never>>(client, 'channel.startReading', {
+    channelId,
+  });
+
+  return !!result;
+};
+/* end_public_function */

package/src/channel/api/stopReading.ts

@@ -0,0 +1,53 @@
+import { getActiveClient } from '~/client/api';
+import { synchronousWSCall } from '~/core/transports';
+import { pullFromCache, pushToCache } from '~/cache/api';
+
+/* begin_public_function
+  id: channel.stop_reading
+*/
+/**
+ * ```js
+ * import { stopReading } from '@amityco/ts-sdk'
+ * const success = await stopReading('foo')
+ * ```
+ *
+ * Stop reading message inside channel
+ *
+ * @param subChannelId - The channel ID to stop reading.
+ * @return A success boolean if the sub channel reading was halted.
+ *
+ * @category Message API
+ * @async
+ */
+export const stopReading = async (subChannelId: string) => {
+  const client = getActiveClient();
+  client.log('message/stopReading', { subChannelId });
+
+  const subChannel = pullFromCache<Amity.SubChannel>(['subChannel', 'get', subChannelId]);
+
+  if (!subChannel) {
+    return;
+  }
+
+  const { channelId } = subChannel.data;
+  const channel = pullFromCache<Amity.Channel>(['channel', 'get', channelId]);
+
+  if (!channel || channel.data.defaultSubChannelId !== subChannelId) {
+    return;
+  }
+
+  const update: Amity.Channel = {
+    ...channel.data,
+    // @ts-ignore
+    localReading: false,
+  };
+
+  pushToCache(['channel', 'get', channelId], update);
+
+  const result = await synchronousWSCall<Record<never, never>>(client, 'channel.stopReading', {
+    channelId,
+  });
+
+  return !!result;
+};
+/* end_public_function */

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

@@ -0,0 +1,124 @@
+import { getResolver } from '~/core/model';
+import { pullFromCache, enableCache, disableCache } from '~/cache/api';
+
+import {
+  client,
+  pause,
+  channelUserQueryResponse,
+  rawChannelUser,
+  rawChannelUser3,
+  channel1,
+  user11,
+  channelUser,
+} from '~/utils/tests';
+
+import { onChannelMemberAdded } from '~/channel/events';
+import { addChannelMembers } from '../addChannelMembers';
+
+describe('addChannelMembers', () => {
+  const { channelId } = channelUserQueryResponse.data.channels[0];
+  const { userId } = rawChannelUser;
+
+  test('it should add channel members in channel', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const recieved = await addChannelMembers(channelId, [userId]);
+
+    expect(recieved).toBe(true);
+  });
+
+  test('it should update cache with channel members', async () => {
+    enableCache();
+
+    client.http.post = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const channelUserCacheKey = getResolver('channelUsers')({
+      channelId,
+      userId,
+    });
+
+    const recieved = await addChannelMembers(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 new members added', async () => {
+    expect.assertions(1);
+
+    client.http.post = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+    let dispose;
+
+    const callback = new Promise(resolve => {
+      dispose = onChannelMemberAdded(resolve);
+    }).finally(dispose);
+
+    await addChannelMembers(channelId, [userId]);
+
+    return expect(callback).resolves.not.toThrow();
+  });
+
+  test('it should fire event with all new members', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const callback = jest.fn();
+    const { userId: userId2 } = rawChannelUser3;
+    const unsub = onChannelMemberAdded(callback);
+
+    const recieved = await addChannelMembers(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 }, { ...rawChannelUser });
+
+    unsub();
+  });
+
+  test('it should fire event with all new members by attaching a user', async () => {
+    enableCache();
+    client.http.post = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const callback = jest.fn();
+    const { userId: userId2 } = rawChannelUser3;
+    const unsub = onChannelMemberAdded(callback);
+
+    const recieved = await addChannelMembers(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 },
+      { ...rawChannelUser, user: user11 },
+    );
+
+    unsub();
+    disableCache();
+  });
+
+  test('it should return an error', async () => {
+    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(addChannelMembers('channelId', [])).rejects.toThrow('error');
+  });
+});

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

@@ -0,0 +1,79 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import {
+  channelPayload,
+  client,
+  conversationChannelPayload,
+  liveChannelPayload,
+  rawChannelPayload,
+} from '~/utils/tests';
+import { prepareChannelPayload } from '~/channel/utils';
+
+import { createChannel } from '../createChannel';
+
+const resPayload = { data: rawChannelPayload };
+
+describe('createChannel', () => {
+  // integration_test_id: 9d80fd54-9e6d-454d-8344-6f9436b8e495
+  test('it should create a channel for community', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce(resPayload);
+
+    const res = await createChannel({ type: 'community' });
+
+    expect(res).toBeDefined();
+    expect(res.data).toStrictEqual(prepareChannelPayload(rawChannelPayload).channels[0]);
+  });
+
+  // integration_test_id: cef520ab-027d-4c5b-836c-a7f63ddc5146
+  test('it should create a channel for live', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce({ data: liveChannelPayload });
+
+    const res = await createChannel({ type: 'live' });
+
+    expect(res).toBeDefined();
+    expect(res.data).toStrictEqual(prepareChannelPayload(liveChannelPayload).channels[0]);
+  });
+
+  // integration_test_id: 11a43612-ff6f-4262-874c-4419d342cff1
+  test('it should create a channel for conversation', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce({ data: conversationChannelPayload });
+
+    const res = await createChannel({ type: 'conversation' });
+
+    expect(res).toBeDefined();
+    expect(res.data).toStrictEqual(prepareChannelPayload(conversationChannelPayload).channels[0]);
+  });
+
+  test('it should add channel to cache', async () => {
+    enableCache();
+
+    client.http.post = jest.fn().mockResolvedValueOnce(resPayload);
+    const { channelId } = channelPayload.channels[0];
+
+    await createChannel({ type: 'community' });
+    const data = pullFromCache(['channel', 'get', channelId]);
+
+    expect(data).toBeDefined();
+    expect(data?.data).toStrictEqual(prepareChannelPayload(rawChannelPayload).channels[0]);
+
+    disableCache();
+  });
+
+  test('it should call conversation channel with /conversation api', async () => {
+    const mockFn = jest.fn();
+    client.http.post = mockFn.mockResolvedValueOnce(resPayload);
+    const expected = '/api/v3/channels/conversation';
+    const expectedPayload = { type: 'conversation', isDistinct: true };
+
+    await createChannel({ type: 'conversation' });
+    const [recieved, recievedPayload] = mockFn.mock.lastCall;
+
+    expect(recieved).toBe(expected);
+    expect(recievedPayload).toStrictEqual(expectedPayload);
+  });
+
+  test('it should return an error', async () => {
+    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(createChannel({ type: 'conversation' })).rejects.toThrow('error');
+  });
+});