@amityco/ts-sdk 1.0.0-8aae813.0 → 6.0.0-beta01

package/src/channelRepsitory/channelMembership/api/queryChannelMembers.ts

@@ -0,0 +1,131 @@
+import { prepareChannelPayload } from '~/channelRepsitory/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'
+ * const channelMembers = await queryChannelMembers({ channelId: 'foo' })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.ChannelUser} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.ChannelUser} objects
+ *
+ * @category Channel API
+ * @async
+ * */
+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, ...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 } = queryPayload;
+  const preparedPayload = await prepareChannelPayload(payload);
+  const { channelUsers } = preparedPayload;
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) {
+    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,
+  };
+};
+/* end_public_function */
+
+/**
+ * ```js
+ * import { queryChannelMembers } from '@amityco/ts-sdk'
+ * const channelMembers = await queryChannelMembers(query)
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Post} objects from cache
+ *
+ * @param query The query parameters
+ * @returns posts
+ *
+ * @category Post API
+ */
+queryChannelMembers.locally = (
+  query: Parameters<typeof queryChannelMembers>[0],
+): Amity.Cached<Amity.Paged<Amity.Membership<'channel'>>> | undefined => {
+  const client = getActiveClient();
+  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);
+
+  return channelUsers.length === data?.channelUsers?.length
+    ? { data: channelUsers, cachedAt, prevPage, nextPage }
+    : undefined;
+};

package/src/channelRepsitory/channelMembership/api/removeMembers.ts

@@ -0,0 +1,57 @@
+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 { removeMembers } from '@amityco/ts-sdk'
+ * const updated = await removeMembers(channelId, ['foo', 'bar'])
+ * ```
+ *
+ * Removes a list of {@link Amity.User} from a {@link Amity.Channel}
+ *
+ * @param channelId The ID of the {@link Amity.Channel} to perform
+ * @param userIds The list of IDs {@link Amity.User} to remove
+ * @returns A success boolean if the list of {@link Amity.User} were removed from the {@link Amity.Channel}
+ *
+ * @category Channel API
+ * @async
+ */
+export const removeMembers = async (
+  channelId: Amity.Channel['channelId'],
+  userIds: Amity.User['userId'][],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('channel/removeMembers', channelId, userIds);
+
+  const { data: payload } = await client.http.delete<Amity.ChannelMembershipPayload>(
+    `/api/v3/channels/${encodeURIComponent(channelId)}/users`,
+    { data: { channelId, userIds } },
+  );
+
+  /*
+   * should fire event for each user that was removed
+   */
+  userIds.forEach(id =>
+    fireEvent('channel.membersRemoved', {
+      ...payload,
+      channelUsers: payload.channelUsers.filter(u => u.userId === id),
+    }),
+  );
+
+  const data = await 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/channelRepsitory/channelMembership/api/tests/addMembers.test.ts

@@ -0,0 +1,152 @@
+import { ASCApiError } from '~/core/errors';
+import { getResolver } from '~/core/model';
+import { pullFromCache, enableCache, disableCache } from '~/cache/api';
+
+import {
+  client,
+  pause,
+  channelUserQueryResponse,
+  rawChannelUser,
+  rawChannelUser3,
+  channel1,
+  user11,
+  channelUser,
+  connectClient,
+  disconnectClient,
+} from '~/utils/tests';
+
+import { onChannelMemberAdded } from '~/channelRepsitory/events';
+import { addMembers } from '../addMembers';
+import * as getChannelMarkers from '~/marker/api/getChannelMarkers';
+
+describe('addMembers', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  const { channelId } = channelUserQueryResponse.data.channels[0];
+  const { userId } = rawChannelUser;
+
+  beforeAll(() => {
+    jest.spyOn(getChannelMarkers, 'getChannelMarkers').mockImplementation(() =>
+      Promise.resolve({
+        data: [],
+        cachedAt: undefined,
+      }),
+    );
+  });
+
+  // integration_test_id: e5bc67d9-7fbe-42ac-8fac-8ee25a6d6da2
+  test('it should add channel members in channel', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const recieved = await addMembers(channelId, [userId]);
+
+    expect(recieved).toBe(true);
+  });
+
+  // integration_test_id: 14286d06-b4c0-4b1d-80b8-c709dd7eac6c
+  test('it should throw error with 400304 when adding a banned member', async () => {
+    client.http.post = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('banned', Amity.ServerError.CHANNEL_BAN, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(addMembers(channelId, [userId])).rejects.toThrow('400304');
+  });
+
+  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 addMembers(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 addMembers(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 addMembers(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 addMembers(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(addMembers('channelId', [])).rejects.toThrow('error');
+  });
+});

package/src/channelRepsitory/channelMembership/api/tests/queryChannelMembers.test.ts

@@ -0,0 +1,138 @@
+import { getResolver } from '~/core/model';
+
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import {
+  client,
+  channelUserQueryResponse,
+  channelUserModel,
+  convertRawChannelPayload,
+  connectClient,
+  disconnectClient,
+} from '~/utils/tests';
+
+import { queryChannelMembers } from '../queryChannelMembers';
+
+describe('queryChannelMembers', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  const { channelId } = channelUserQueryResponse.data.channels[0];
+
+  // integration_test_id: 1e5a4b11-a7f3-496e-a594-22b10ed28a20
+  test('it should return channel members', async () => {
+    const expected = channelUserQueryResponse.data.channelUsers;
+    client.http.get = jest.fn().mockResolvedValue(channelUserQueryResponse);
+
+    const { data } = await queryChannelMembers({ channelId });
+    expect(data).toEqual(expected);
+  });
+
+  test('it should return channel members by attaching a user', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(channelUserQueryResponse);
+
+    const { data } = await queryChannelMembers({ channelId });
+
+    expect(data).toEqual(channelUserModel);
+
+    disableCache();
+  });
+
+  test('it should throw error', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(queryChannelMembers({ channelId })).rejects.toThrow('error');
+  });
+
+  test('it should update cache upon fetching data from server', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(channelUserQueryResponse);
+
+    const { data: got } = await queryChannelMembers({ channelId });
+    const { data } = queryChannelMembers.locally({ channelId })!;
+
+    expect(data).toBeDefined();
+    expect(got).toEqual(data);
+
+    disableCache();
+  });
+});
+
+describe('queryChannelMembers.locally', () => {
+  const { channelId } = channelUserQueryResponse.data.channels[0];
+  const cacheKey = [
+    'channelUsers',
+    'query',
+    { channelId, options: { limit: 10, after: undefined } },
+  ];
+
+  test('it should fetch query locally if present in cache', () => {
+    enableCache();
+
+    const { paging, ...payload } = channelUserQueryResponse.data;
+    const preparedPayload = convertRawChannelPayload(payload);
+    const { channelUsers } = preparedPayload;
+
+    ingestInCache(preparedPayload);
+
+    pushToCache(cacheKey, {
+      channelUsers: channelUsers.map(({ channelId, userId }) =>
+        getResolver('channelUsers')({ channelId, userId }),
+      ),
+      paging,
+    });
+
+    const got = queryChannelMembers.locally({
+      channelId,
+      page: { limit: 10, after: undefined },
+    })?.data;
+
+    expect(got).toBeDefined();
+    expect(got).toEqual(channelUsers);
+
+    disableCache();
+  });
+
+  test('it should return undefined if only partial data in cache', () => {
+    enableCache();
+
+    const { paging, ...payload } = channelUserQueryResponse.data;
+    const preparedPayload = convertRawChannelPayload(payload);
+    const { channelUsers } = preparedPayload;
+
+    // ingest incomplete data
+    ingestInCache({
+      ...preparedPayload,
+      channelUsers: [preparedPayload.channelUsers[0]],
+    });
+
+    pushToCache(cacheKey, {
+      channelUsers: channelUsers.map(({ channelId, userId }) =>
+        getResolver('channelUsers')({ channelId, userId }),
+      ),
+      paging,
+    });
+
+    const got = queryChannelMembers.locally({ channelId })!;
+
+    expect(got).toBeUndefined();
+
+    disableCache();
+  });
+
+  test('it should return undefined if data not in cache', () => {
+    enableCache();
+
+    const got = queryChannelMembers.locally({ channelId });
+
+    expect(got).toBeUndefined();
+
+    disableCache();
+  });
+
+  test('it should return undefined if cache disabled', () => {
+    expect(queryChannelMembers.locally({ channelId })).toBeUndefined();
+  });
+});

package/src/channelRepsitory/channelMembership/api/tests/removeMembers.test.ts

@@ -0,0 +1,112 @@
+import { ASCApiError } from '~/core/errors';
+import { getResolver } from '~/core/model';
+import { pullFromCache, enableCache, disableCache } from '~/cache/api';
+
+import {
+  client,
+  pause,
+  channelUserQueryResponse,
+  rawChannelUser,
+  rawChannelUser3,
+  channel1,
+  channelUser,
+  channelUser3,
+  connectClient,
+  disconnectClient,
+} from '~/utils/tests';
+
+import { onChannelMemberRemoved } from '~/channelRepsitory/events';
+
+import { removeMembers } from '../removeMembers';
+
+describe('removeMembers', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  const { channelId } = channelUserQueryResponse.data.channels[0];
+  const { userId } = rawChannelUser;
+
+  // integration_test_id: fa47f7d9-2b60-4f4e-b65f-f3c3a7999a3f
+  test('it should remove channel members from channel', async () => {
+    client.http.delete = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const recieved = await removeMembers(channelId, [userId]);
+
+    expect(recieved).toBe(true);
+  });
+
+  test('it should update cache with removed channel members', async () => {
+    enableCache();
+
+    client.http.delete = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const channelUserCacheKey = getResolver('channelUsers')({
+      channelId,
+      userId,
+    });
+
+    const recieved = await removeMembers(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 members are removed', async () => {
+    expect.assertions(1);
+
+    client.http.delete = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+    let dispose;
+
+    const callback = new Promise(resolve => {
+      dispose = onChannelMemberRemoved(resolve);
+    }).finally(dispose);
+
+    await removeMembers(channelId, [userId]);
+
+    return expect(callback).resolves.not.toThrow();
+  });
+
+  test('it should fire event with all removed members', async () => {
+    client.http.delete = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const callback = jest.fn();
+    const { userId: userId2 } = rawChannelUser3;
+    const unsub = onChannelMemberRemoved(callback);
+
+    const recieved = await removeMembers(channelId, [userId, userId2]);
+
+    expect(recieved).toBe(true);
+
+    await pause();
+
+    /*
+     * Removed assertion for checking what the callback was called with as it's
+     * impossible to guarantee the order in which the events will be fired
+     */
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    unsub();
+  });
+
+  // integration_test_id: a9d13eff-5e17-4fc5-b20e-43c568aa8c23
+  test('it should return an error', async () => {
+    client.http.delete = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('banned', Amity.ServerError.CHANNEL_BAN, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(removeMembers('channelId', [])).rejects.toThrow('400304');
+  });
+});

package/src/channelRepsitory/channelMembership/index.ts

@@ -0,0 +1,2 @@
+export * from './api';
+export * from './observers';