@amityco/ts-sdk 0.0.1-003998f.0

package/src/channel/api/getChannels.ts

@@ -0,0 +1,80 @@
+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'
+ * const channels = await getChannels(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Channel} objects
+ *
+ * @param channelIds the IDs of the {@link Amity.Channel} to fetch
+ * @returns the associated collection of {@link Amity.Channel} objects
+ *
+ * @category Channel API
+ * @async
+ */
+export const getChannels = async (
+  channelIds: Amity.Channel['channelId'][],
+): Promise<Amity.Cached<Amity.Channel[]>> => {
+  const client = getActiveClient();
+  client.log('channel/getChannels', channelIds);
+
+  const encodedChannelIds = channelIds.map(channelId => encodeURIComponent(channelId));
+
+  // API-FIX: endpoint should not be /list, parameters should be querystring.
+  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 });
+
+  return {
+    data: data.channels,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { getChannels } from '@amityco/ts-sdk'
+ * const channels = getChannels.locally(['foo', 'bar']) ?? []
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Channel} objects from cache
+ *
+ * @param channelIds the IDs of the {@link Amity.Channel} to fetch
+ * @returns the associated collection of {@link Amity.Channel} objects
+ *
+ * @category Channel API
+ */
+getChannels.locally = (
+  channelIds: Amity.Channel['channelId'][],
+): Amity.Cached<Amity.Channel[]> | undefined => {
+  const client = getActiveClient();
+  client.log('channel/getChannels.locally', channelIds);
+
+  if (!client.cache) return;
+
+  const cached = channelIds
+    .map(channelId => pullFromCache<Amity.Channel>(['channel', 'get', channelId])!)
+    .filter(Boolean);
+
+  const channels = cached.map(({ data }) => data);
+  const oldest = cached.sort((a, b) => (a.cachedAt! < b.cachedAt! ? -1 : 1))?.[0];
+
+  if (cached?.length < channelIds.length) return;
+
+  return {
+    data: channels,
+    cachedAt: oldest.cachedAt,
+  };
+};

package/src/channel/api/index.ts

@@ -0,0 +1,21 @@
+export * from './queryChannels';
+export * from './getChannels';
+export * from './getChannel';
+
+export * from './createChannel';
+export * from './updateChannel';
+export * from './deleteChannel';
+
+export * from './joinChannel';
+export * from './leaveChannel';
+
+export * from './queryChannelMembers';
+
+export * from './addChannelMembers';
+export * from './removeChannelMembers';
+
+export * from './addChannelMembersRole';
+export * from './removeChannelMembersRole';
+
+export * from './banChannelMembers';
+export * from './unbanChannelMembers';

package/src/channel/api/joinChannel.ts

@@ -0,0 +1,38 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { joinChannel } from '@amityco/ts-sdk'
+ * const isJoined = await joinChannel('foobar')
+ * ```
+ *
+ * Joins a {@link Amity.Channel} object
+ *
+ * @param channelId the {@link Amity.Channel} to join
+ * @returns A success boolean if the {@link Amity.Channel} was joined
+ *
+ * @category Channel API
+ * @async
+ */
+export const joinChannel = async (channelId: Amity.Channel['channelId']): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('channel/joinChannel', channelId);
+
+  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;
+
+  return !!channelUsers.find(
+    channelUser => channelUser.channelId === channelId && channelUser.membership === 'member',
+  );
+};

package/src/channel/api/leaveChannel.ts

@@ -0,0 +1,38 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { leaveChannel } from '@amityco/ts-sdk'
+ * const isLeft = await leaveChannel('foobar')
+ * ```
+ *
+ * Leave a {@link Amity.Channel} object
+ *
+ * @param channelId the {@link Amity.Channel} to leave
+ * @returns A success boolean if the {@link Amity.Channel} was left
+ *
+ * @category Channel API
+ * @async
+ */
+export const leaveChannel = async (channelId: Amity.Channel['channelId']): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('channel/leaveChannel', channelId);
+
+  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;
+
+  return !!channelUsers.find(
+    channelUser => channelUser.channelId === channelId && channelUser.membership !== 'member',
+  );
+};

package/src/channel/api/queryChannelMembers.ts

@@ -0,0 +1,124 @@
+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';
+
+import { prepareChannelPayload } from '../utils';
+
+/**
+ * ```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 = { limit: 10 }, ...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 data = prepareChannelPayload(payload);
+
+  const { channelUsers } = data;
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) {
+    ingestInCache(data as Amity.ChannelMembershipPayload);
+
+    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 };
+};
+
+/**
+ * ```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 = { limit: 10 }, ...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/channel/api/queryChannels.ts

@@ -0,0 +1,121 @@
+import { getActiveClient } from '~/client/api';
+
+import { toPage, toToken } from '~/core/query';
+import { getResolver } from '~/core/model';
+
+import { pushToCache, pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { queryChannels } from '@amityco/ts-sdk'
+ * const channels = await queryChannels()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Channel} objects
+ * Search is performed by displayName such as `.startsWith(search)`
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Channel} objects
+ *
+ * @category Channel API
+ * @async
+ */
+export const queryChannels = async (
+  query?: Amity.QueryChannels,
+): Promise<Amity.Cached<Amity.Paged<Amity.Channel>>> => {
+  const client = getActiveClient();
+  client.log('channel/queryChannels', query);
+
+  // safe decapsulation
+  const { page = { limit: 10 }, displayName, membership, ...params } = 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: queryPayload } = await client.http.get<Amity.ChannelPayload & Amity.Pagination>(
+    `/api/v3/channels`,
+    {
+      params: {
+        ...params,
+        keyword: displayName,
+        filter: membership,
+        options: {
+          token: toToken(page, 'skiplimit'),
+        },
+      },
+    },
+  );
+
+  const { paging, ...payload } = queryPayload;
+
+  const data = prepareChannelPayload(payload);
+
+  const { channels } = data;
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) {
+    ingestInCache(data as Amity.ChannelPayload, { cachedAt });
+
+    const cacheKey = [
+      'channel',
+      'query',
+      { ...params, options: { ...page } } as Amity.Serializable,
+    ];
+    pushToCache(cacheKey, { channels: channels.map(getResolver('channel')), paging });
+  }
+
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
+
+  return { data: channels, cachedAt, prevPage, nextPage };
+};
+
+/**
+ * ```js
+ * import { queryChannels } from '@amityco/ts-sdk'
+ * const channels = queryChannels.locally()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Channel} objects from cache
+ *
+ * @param query The query parameters
+ * @returns channels
+ *
+ * @category Channel API
+ */
+queryChannels.locally = (
+  query?: Parameters<typeof queryChannels>[0],
+): Amity.Cached<Amity.Paged<Amity.Channel>> | undefined => {
+  const client = getActiveClient();
+  client.log('channel/queryChannels.locally', query);
+
+  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

@@ -0,0 +1,45 @@
+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'
+ * const updated = await removeChannelMembers(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 removeChannelMembers = async (
+  channelId: Amity.Channel['channelId'],
+  userIds: Amity.User['userId'][],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('channel/removeChannelMembers', channelId, userIds);
+
+  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('channel.membersRemoved', data);
+
+  const { channelUsers } = data;
+  return !!channelUsers.find(
+    channelUser => channelUser.channelId === channelId && channelUser.membership !== 'member',
+  );
+};

package/src/channel/api/removeChannelMembersRole.ts

@@ -0,0 +1,44 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { removeChannelMembersRole } from '@amityco/ts-sdk'
+ * const updated = await removeChannelMembersRole(channelId, 'foo', ['bar'])
+ * ```
+ *
+ * Removes an {@link Amity.Role} from a list of {@link Amity.User} on a {@link Amity.Channel}
+ *
+ * @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
+ * @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
+ * @async
+ */
+export const removeChannelMembersRole = async (
+  channelId: Amity.Channel['channelId'],
+  roleId: Amity.Role['roleId'],
+  userIds: Amity.User['userId'][],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('channel/removeChannelMembersRole', channelId, roleId, userIds);
+
+  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;
+  return !!channelUsers.find(
+    channelUser => channelUser.channelId === channelId && !channelUser.roles.includes(roleId),
+  );
+};

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

@@ -0,0 +1,95 @@
+import { getResolver } from '~/core/model';
+import { pullFromCache, enableCache, disableCache } from '~/cache/api';
+
+import {
+  client,
+  pause,
+  channelUserQueryResponse,
+  channelUser1,
+  channelUser3,
+  channel11,
+} from '~/utils/tests';
+
+import { onChannelMemberAdded } from '~/channel/events';
+import { addChannelMembers } from '../addChannelMembers';
+
+describe('addChannelMembers', () => {
+  const { channelId } = channelUserQueryResponse.data.channels[0];
+  const { userId } = channelUser1;
+
+  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 channelUser = pullFromCache<Amity.Membership<'channel'>>([
+      'channelUsers',
+      'get',
+      channelUserCacheKey,
+    ])?.data;
+
+    expect(recieved).toBe(true);
+    expect(channelUser).toBeDefined();
+    expect(channelUser).toBe(channelUser1);
+
+    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 } = channelUser3;
+    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, { ...channel11 }, { ...channelUser1 });
+    expect(callback).toHaveBeenNthCalledWith(2, { ...channel11 }, { ...channelUser3 });
+
+    unsub();
+  });
+
+  test('it should return an error', async () => {
+    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(addChannelMembers('channelId', [])).rejects.toThrow('error');
+  });
+});