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

package/src/category/observers/liveCategories.ts

@@ -0,0 +1,143 @@
+/* eslint-disable no-use-before-define */
+import { getResolver } from '~/core/model';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api';
+import {
+  createQuery,
+  runQuery,
+  queryOptions,
+  filterByPropEquality,
+  sortByLastCreated,
+  sortByName,
+  sortByFirstCreated,
+} from '~/core/query';
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+  ENABLE_CACHE_MESSAGE,
+} from '~/utils/constants';
+import { queryCategories } from '../api';
+
+/**
+ * ```js
+ * import { liveCategories } from '@amityco/ts-sdk'
+ *
+ * let categories = []
+ * const unsub = liveCategories({}, response => merge(categories, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Category}s
+ *
+ * @param params for querying categories
+ * @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 categories
+ *
+ * @category Category Live Collection
+ */
+export const liveCategories = (
+  params: Amity.CategoryLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Category>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`liveCategories(tmpid: ${timestamp}) > listen`);
+
+  const { limit: queryLimit, ...queryParams } = params;
+
+  const limit = queryLimit ?? COLLECTION_DEFAULT_PAGINATION_LIMIT;
+  const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
+
+  const disposers: Amity.Unsubscriber[] = [];
+  const cacheKey = ['category', 'collection', {}];
+
+  const responder = (data: Amity.CategoryLiveCollectionCache) => {
+    let categories: Amity.Category[] =
+      data.data
+        .map(categoryId => pullFromCache<Amity.Category>(['category', 'get', categoryId])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    if (params.includeDeleted === false) {
+      categories = filterByPropEquality(categories, 'isDeleted', false);
+    }
+
+    switch (params.sortBy) {
+      case 'firstCreated':
+        categories = categories.sort(sortByFirstCreated);
+        break;
+
+      case 'lastCreated':
+        categories = categories.sort(sortByLastCreated);
+        break;
+
+      default:
+        categories = categories.sort(sortByName);
+    }
+
+    callback({
+      onNextPage: onFetch,
+      data: categories,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  /*
+   * const realtimeRouter = () => {
+   * @TODO: At the time of creating this method category does not have any
+   * observers
+   *};
+   */
+
+  const onFetch = () => {
+    const collection = pullFromCache<Amity.CategoryLiveCollectionCache>(cacheKey)?.data;
+
+    const categories = collection?.data ?? [];
+
+    if (categories.length > 0 && !collection?.params.page) return;
+
+    const query = createQuery(queryCategories, {
+      ...queryParams,
+      page: collection?.params.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, nextPage: page }) => {
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: categories,
+        };
+
+        if (result) {
+          data.data = [...new Set([...categories, ...result.map(getResolver('category'))])];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(() => {
+    // @TODO -> update once observers added
+  });
+
+  onFetch();
+
+  return () => {
+    log(`liveCategories(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/category/observers/tests/liveCategories.test.ts

@@ -0,0 +1,145 @@
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  pause,
+  categoryQueryResponse,
+  categoryQueryResponsePage2,
+  category11,
+  category12,
+} from '~/utils/tests';
+import { sortByName } from '~/core/query';
+
+import { liveCategories } from '../liveCategories';
+
+const getSnapshot = (params?: Record<string, any>) => {
+  return {
+    data: [] as Amity.Category[],
+    loading: true,
+    error: undefined as any,
+    ...params,
+  };
+};
+
+describe('live Caategories', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  const payload = categoryQueryResponse.data;
+  const payloadPage2 = categoryQueryResponsePage2.data;
+
+  test('it should return category collection', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(categoryQueryResponse);
+
+    liveCategories({}, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(1, expect.objectContaining(getSnapshot()));
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining(
+        getSnapshot({
+          data: payload.categories,
+          loading: false,
+        }),
+      ),
+    );
+  });
+
+  test('it should return data from cache', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(categoryQueryResponse);
+
+    liveCategories({}, () => undefined);
+    await pause();
+    liveCategories({}, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining(
+        getSnapshot({
+          data: payload.categories,
+        }),
+      ),
+    );
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining(
+        getSnapshot({
+          data: payload.categories,
+          loading: false,
+        }),
+      ),
+    );
+  });
+
+  const filters: [string, Amity.CategoryLiveCollection, Amity.Category[]][] = [
+    ['not deleted', { includeDeleted: false }, [category11, category12]],
+  ];
+
+  test.each(filters)('it should filter by %s categories', async (filter, params, expected) => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(categoryQueryResponse);
+
+    liveCategories(params, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(getSnapshot()));
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining(
+        getSnapshot({
+          loading: false,
+          data: expected,
+        }),
+      ),
+    );
+  });
+
+  test('it should return method to fetch next page', async () => {
+    const callback = jest.fn();
+    client.http.get = jest
+      .fn()
+      .mockResolvedValue(categoryQueryResponse)
+      .mockResolvedValueOnce(categoryQueryResponsePage2);
+
+    liveCategories({}, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback.mock.lastCall).toHaveLength(1);
+
+    const { onNextPage, hasNextPage } = callback.mock.lastCall[0];
+
+    expect(hasNextPage).toBe(true);
+    expect(onNextPage).toBeTruthy();
+
+    onNextPage();
+    await pause();
+
+    // 4 -> because 1 local & server call each per call (2)
+    expect(callback).toHaveBeenCalledTimes(4);
+    expect(callback).toHaveBeenNthCalledWith(
+      4,
+      expect.objectContaining(
+        getSnapshot({
+          loading: false,
+          data: [...payloadPage2.categories, ...payload.categories].sort(sortByName),
+        }),
+      ),
+    );
+  });
+});

package/src/channel/api/addChannelMembers.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.add
+*/
 /**
  * ```js
  * import { addChannelMembers } from '@amityco/ts-sdk'
@@ -25,19 +30,28 @@ export const addChannelMembers = async (
   const client = getActiveClient();
   client.log('channel/addChannelMembers', channelId, userIds);
 
-  const { data } = await client.http.post<Amity.ChannelMembershipPayload>(
+  const { data: payload } = await client.http.post<Amity.ChannelMembershipPayload>(
     `/api/v3/channels/${encodeURIComponent(channelId)}/users`,
     { channelId, userIds },
   );
 
-  if (client.cache) ingestInCache(data);
+  /*
+   * should fire event for each user that was added
+   */
+  userIds.forEach(id =>
+    fireEvent('channel.membersAdded', {
+      ...payload,
+      channelUsers: payload.channelUsers.filter(u => u.userId === id),
+    }),
+  );
 
-  fireEvent('v3.channel.didAddUsers', {
-    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/addChannelMembersRole.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.add_roles
+*/
 /**
  * ```js
  * import { addChannelMembersRole } from '@amityco/ts-sdk'
@@ -26,11 +31,13 @@ export const addChannelMembersRole = async (
   const client = getActiveClient();
   client.log('channel/addChannelMembersRole', channelId, roleId, userIds);
 
-  const { data } = await client.http.post<Amity.ChannelMembershipPayload>(
+  const { data: payload } = await client.http.post<Amity.ChannelMembershipPayload>(
     `/api/v3/channels/${encodeURIComponent(channelId)}/users/roles`,
     { channelId, role: roleId, userIds },
   );
 
+  const data = prepareChannelPayload(payload);
+
   if (client.cache) ingestInCache(data);
 
   const { channelUsers } = data;
@@ -38,3 +45,4 @@ export const addChannelMembersRole = async (
     channelUser => channelUser.channelId === channelId && channelUser.roles.includes(roleId),
   );
 };
+/* end_public_function */

package/src/channel/api/banChannelMembers.ts

@@ -0,0 +1,49 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '../utils';
+
+/* begin_public_function
+  id: channel.moderation.ban_members
+*/
+/**
+ * ```js
+ * import { banChannelMembers } from '@amityco/ts-sdk'
+ *
+ * await banChannelMembers('channel-id-1', ['userId1', 'userId2'])
+ * ```
+ *
+ * @param channelId of {@link Amity.Channel} from which the users should be banned
+ * @param userIds of the {@link Amity.User}'s to be banned
+ * @returns the updated {@link Amity.Membership}'s object
+ *
+ * @category Channel API
+ * @async
+ * */
+export const banChannelMembers = async (
+  channelId: Amity.Channel['channelId'],
+  userIds: Amity.User['userId'][],
+): Promise<Amity.Cached<Amity.Membership<'channel'>[]>> => {
+  const client = getActiveClient();
+  client.log('channel/banChannelMembers', { userIds, channelId });
+
+  const { data: payload } = await client.http.put<Amity.ChannelPayload>(
+    `/api/v3/channels/${channelId}/users/ban`,
+    {
+      userIds,
+    },
+  );
+
+  const preparedPayload = prepareChannelPayload(payload);
+  const { channelUsers } = preparedPayload;
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(preparedPayload, { cachedAt });
+
+  return {
+    data: channelUsers?.filter(user => user.membership === 'banned')!,
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/channel/api/createChannel.ts

@@ -2,10 +2,15 @@ import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { prepareChannelPayload } from '../utils';
+
+/* begin_public_function
+  id: channel.create
+*/
 /**
  * ```js
  * import { createChannel } from '@amityco/ts-sdk'
- * const created = await createChannel({ channelId: 'foobar', displayName: 'foobar' })
+ * const created = await createChannel({ displayName: 'foobar' })
  * ```
  *
  * Creates an {@link Amity.Channel}
@@ -36,12 +41,15 @@ export const createChannel = async <T extends Amity.ChannelType>(
     payload = await client.http.post<Amity.ChannelPayload>('/api/v3/channels', bundle);
   }
 
+  const data = prepareChannelPayload(payload.data);
+
   const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(payload.data, { cachedAt });
+  if (client.cache) ingestInCache(data, { cachedAt });
 
-  const { channels } = payload.data;
+  const { channels } = data;
   return {
     data: channels[0],
     cachedAt,
   };
 };
+/* end_public_function */

package/src/channel/api/getChannel.ts

@@ -3,6 +3,15 @@ import { getActiveClient } from '~/client/api';
 import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { isInTombstone } from '~/cache/api/isInTombstone';
+import { checkIfShouldGoesToTombstone } from '~/cache/utils';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+
+import { prepareChannelPayload } from '../utils';
+
+/* begin_public_function
+  id: channel.get
+*/
 /**
  * ```js
  * import { getChannel } from '@amityco/ts-sdk'
@@ -23,10 +32,23 @@ export const getChannel = async (
   const client = getActiveClient();
   client.log('channel/getChannel', channelId);
 
-  // API-FIX: endpoint should not be /list, parameters should be querystring.
-  const { data } = await client.http.get<Amity.ChannelPayload>(
-    `/api/v3/channels/${encodeURIComponent(channelId)}`,
-  );
+  isInTombstone('channel', channelId);
+
+  let data: Amity.ProcessedChannelPayload;
+
+  try {
+    const { data: payload } = await client.http.get<Amity.ChannelPayload>(
+      `/api/v3/channels/${encodeURIComponent(channelId)}`,
+    );
+
+    data = prepareChannelPayload(payload);
+  } catch (error) {
+    if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
+      pushToTombstone('channel', channelId);
+    }
+
+    throw error;
+  }
 
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
@@ -38,6 +60,7 @@ export const getChannel = async (
     cachedAt,
   };
 };
+/* end_public_function */
 
 /**
  * ```js

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 });
 
@@ -64,11 +68,11 @@ getChannels.locally = (
     .map(channelId => pullFromCache<Amity.Channel>(['channel', 'get', channelId])!)
     .filter(Boolean);
 
+  if (cached?.length < channelIds.length) return;
+
   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

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

package/src/channel/api/joinChannel.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.join
+*/
 /**
  * ```js
  * import { joinChannel } from '@amityco/ts-sdk'
@@ -20,10 +25,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;
@@ -32,3 +39,4 @@ export const joinChannel = async (channelId: Amity.Channel['channelId']): Promis
     channelUser => channelUser.channelId === channelId && channelUser.membership === 'member',
   );
 };
+/* end_public_function */

package/src/channel/api/leaveChannel.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.leave
+*/
 /**
  * ```js
  * import { leaveChannel } from '@amityco/ts-sdk'
@@ -20,10 +25,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;
@@ -32,3 +39,4 @@ export const leaveChannel = async (channelId: Amity.Channel['channelId']): Promi
     channelUser => channelUser.channelId === channelId && channelUser.membership !== 'member',
   );
 };
+/* end_public_function */