@amityco/ts-sdk 6.2.0 → 6.2.1-0cf9bee.0

package/src/@types/domains/channel.ts

@@ -45,7 +45,7 @@ declare global {
       autoDeleteMessageByFlagLimit?: number;
 
       memberCount?: number;
-      messageCount: number; // TODO remove from public interface
+      messageCount: number;
       moderatorMemberCount?: number;
 
       lastActivity: Amity.timestamp;
@@ -55,10 +55,15 @@ declare global {
       Amity.SoftDelete &
       Amity.Subscribable;
 
-    type Channel<T extends ChannelType = any> = RawChannel<T> & {
+    type Channel<T extends ChannelType = any> = Omit<RawChannel<T>, 'messageCount'> & {
       defaultSubChannelId: string;
       isUnreadCountSupport: boolean;
       unreadCount: number;
+
+      /**
+       * @deprecated Please use the default sub channel `messageCount` instead.
+       */
+      messageCount: RawChannel['messageCount'];
     };
 
     type QueryChannels = {

package/src/@types/domains/marker.ts

@@ -10,6 +10,7 @@ declare global {
       SUB_CHANNEL_CREATED = 'subchannel is created',
       SUBCHANNEL_IS_DELETED = 'subchannel is deleted',
       FORCE_SYNC = 'force sync',
+      MARKER_UPDATED = 'feed marker updated',
     }
   }
 }

package/src/categoryRepository/observers/getCategories.ts

@@ -99,16 +99,16 @@ export const getCategories = (
    *};
    */
 
-  const onFetch = () => {
+  const onFetch = (initial = false) => {
     const collection = pullFromCache<Amity.CategoryLiveCollectionCache>(cacheKey)?.data;
 
     const categories = collection?.data ?? [];
 
-    if (categories.length > 0 && !collection?.params.page) return;
+    if (!initial && categories.length > 0 && !collection?.params.page) return;
 
     const query = createQuery(queryCategories, {
       ...queryParams,
-      page: collection?.params.page ?? { limit },
+      page: (!initial ? collection?.params.page : undefined) ?? { limit },
     });
 
     runQuery(
@@ -137,7 +137,7 @@ export const getCategories = (
     // @TODO -> update once observers added
   });
 
-  onFetch();
+  onFetch(true);
 
   return () => {
     log(`getCategories(tmpid: ${timestamp}) > dispose`);

package/src/channelRepsitory/api/markAsRead.ts

@@ -3,7 +3,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
- * import { markAsRead } from '@amityco/ts-sdk'
+ * import { ChannelRepository } from '@amityco/ts-sdk'
  * const success = await ChannelRepository.markAsRead('channelId')
  * ```
  *

package/src/channelRepsitory/api/muteChannel.ts

@@ -1,4 +1,5 @@
 import { getActiveClient } from '~/client/api';
+import { ASCError } from '~/core/errors';
 
 /* begin_public_function
   id: channel.mute
@@ -26,6 +27,13 @@ export const muteChannel = async (
   const client = getActiveClient();
   client.log('channel/muteChannel', channelId);
 
+  if (mutePeriod !== MUTE_FOREVER && mutePeriod < 0)
+    throw new ASCError(
+      `Mute Period can only be positive numbers or ${MUTE_FOREVER}(mute forever)`,
+      Amity.ClientError.INVALID_PARAMETERS,
+      Amity.ErrorLevel.ERROR,
+    );
+
   const { data } = await client.http.put<{ success: boolean }>(
     `/api/v2/channel/${encodeURIComponent(channelId)}/mute`,
     { mutePeriod },

package/src/channelRepsitory/api/tests/muteChannel.test.ts

@@ -26,4 +26,16 @@ describe('muteChannel', () => {
 
     await expect(muteChannel('channel-id', 100)).rejects.toBe(err);
   });
+
+  test('it should throw error if mute period less than 0 and not -1', async () => {
+    const err = new ASCError(
+      'Mute Period can only be positive numbers or -1(mute forever)',
+      Amity.ClientError.INVALID_PARAMETERS,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.put = jest.fn().mockRejectedValue(err);
+
+    await expect(muteChannel('channel-id', 100)).rejects.toBe(err);
+  });
 });

package/src/channelRepsitory/channelMembership/observers/getMembers.ts

@@ -4,7 +4,7 @@ import { pullFromCache, pushToCache } from '~/cache/api';
 import { getActiveClient } from '~/client/api';
 import {
   createQuery,
-  filterByPropEquality,
+  filterByPropIntersection,
   filterBySearchTerm,
   queryOptions,
   runQuery,
@@ -76,7 +76,7 @@ export const getMembers = (
         .filter(Boolean)
         .map(({ data }) => data) ?? [];
 
-    channelMembers = filterByPropEquality(channelMembers, 'roles', params.roles);
+    channelMembers = filterByPropIntersection(channelMembers, 'roles', params.roles);
 
     if (params.memberships) {
       /*
@@ -140,16 +140,16 @@ export const getMembers = (
       responder(collection);
     };
 
-  const onFetch = () => {
+  const onFetch = (initial = false) => {
     const collection = pullFromCache<Amity.ChannelMembersLiveCollectionCache>(cacheKey)?.data;
 
     const channelMembers = collection?.data ?? [];
 
-    if (channelMembers.length > 0 && !collection?.params.page) return;
+    if (!initial && channelMembers.length > 0 && !collection?.params.page) return;
 
     const query = createQuery(queryChannelMembers, {
       ...queryParams,
-      page: collection?.params.page ?? { limit },
+      page: (!initial ? collection?.params.page : undefined) ?? { limit },
     });
 
     runQuery(
@@ -183,7 +183,7 @@ export const getMembers = (
     onChannelMemberUnbanned(realtimeRouter('onChannelMemberUnbanned')),
   );
 
-  onFetch();
+  onFetch(true);
 
   return () => {
     log(`getMembers(tmpid: ${timestamp}) > dispose`);

package/src/channelRepsitory/observers/getChannels.ts

@@ -149,16 +149,16 @@ export const getChannels = (
     responder(collection);
   };
 
-  const onFetch = () => {
+  const onFetch = (initial = false) => {
     const collection = pullFromCache<Amity.ChannelLiveCollectionCache>(cacheKey)?.data;
 
     const channels = collection?.data ?? [];
 
-    if (channels.length > 0 && !collection?.params.page) return;
+    if (!initial && channels.length > 0 && !collection?.params.page) return;
 
     const query = createQuery(queryChannels, {
       ...queryParams,
-      page: collection?.params.page ?? { limit },
+      page: (!initial ? collection?.params.page : undefined) ?? { limit },
     });
 
     runQuery(
@@ -195,12 +195,12 @@ export const getChannels = (
     onMessageCreated(() => null), // watch unread count
   );
 
-  onFetch();
+  onFetch(true);
+  dropFromCache(cacheKey);
 
   return () => {
     log(`getChannels(tmpid: ${timestamp}) > dispose`);
     disposers.forEach(fn => fn());
-    dropFromCache(cacheKey);
   };
 };
 /* end_public_function */

package/src/channelRepsitory/observers/tests/getChannels.test.ts

@@ -79,17 +79,11 @@ describe('getChannels', () => {
     getChannels({}, callback);
     await pause();
 
-    expect(callback).toHaveBeenCalledTimes(2);
+    // The second `getChannels` call fetches data from the cache,
+    // so there is no loading state and the callback only fires once.
+    expect(callback).toHaveBeenCalledTimes(1);
     expect(callback).toHaveBeenNthCalledWith(
       1,
-      expect.objectContaining(
-        getSnapshot({
-          data: convertRawChannelPayload(channelQueryResponse.data).channels,
-        }),
-      ),
-    );
-    expect(callback).toHaveBeenNthCalledWith(
-      2,
       expect.objectContaining(
         getSnapshot({
           data: convertRawChannelPayload(channelQueryResponse.data).channels,

package/src/client/utils/markerSyncEngine.ts

@@ -1,10 +1,10 @@
+import { onFeedMarkerUpdated } from '~/marker/events';
 import { onMessageCreated } from '~/messageRepository/events';
 import { onSubChannelCreated, onSubChannelDeleted } from '~/subChannelRepository/events';
 import { isUnreadCountSupport } from '~/subChannelRepository/utils';
 
 import { markerSync } from '../api';
 
-const FORCE_SYNC_INTERVAL_TIME = 8000;
 const SYNC_TRIGGER_INTERVAL_TIME = 2000;
 
 let clearSyncTrigger: Amity.Unsubscriber | undefined;
@@ -108,19 +108,7 @@ const registerEventListeners = () => {
 
     onSubChannelCreated(() => events.push(Amity.MarkerSyncEvent.SUB_CHANNEL_CREATED)),
     onSubChannelDeleted(() => events.push(Amity.MarkerSyncEvent.SUBCHANNEL_IS_DELETED)),
-
-    // In real-world use, we've encountered some cases where BE returns empty result
-    // even if a marker changes in the database, causing the SDK to mistakenly believe that
-    // no changes have been made in the database and end the sync prematurely.
-    // Did miss update the unread count
-    //
-    // We found that some time BE loads were too high, causing the calculation
-    // marker not to finish within the sync time, so it returned an empty value.
-    //
-    // Therefore, solve this problem by creating a second interval loop that
-    // runs every 8 seconds regardless of whether an event occurs or not so that
-    // the unread count is always updated in case of an error like the above.
-    setIntervalTask(() => events.push(Amity.MarkerSyncEvent.FORCE_SYNC), FORCE_SYNC_INTERVAL_TIME),
+    onFeedMarkerUpdated(() => events.push(Amity.MarkerSyncEvent.MARKER_UPDATED)),
   );
 };
 

package/src/commentRepository/observers/getComments.ts

@@ -123,16 +123,16 @@ export const getComments = (
     responder(collection);
   };
 
-  const onFetch = () => {
+  const onFetch = (initial = false) => {
     const collection = pullFromCache<Amity.CommentLiveCollectionCache>(cacheKey)?.data;
 
     const comments = collection?.data ?? [];
 
-    if (comments.length > 0 && !collection?.params?.page) return;
+    if (!initial && comments.length > 0 && !collection?.params?.page) return;
 
     const query = createQuery(queryComments, {
       ...queryParams,
-      page: collection?.params?.page ?? { limit },
+      page: (!initial ? collection?.params.page : undefined) ?? { limit },
     });
 
     runQuery(
@@ -170,12 +170,12 @@ export const getComments = (
     onCommentReactionRemoved(realtimeRouter('onReactionRemoved')),
   );
 
-  onFetch();
+  onFetch(true);
+  disposers.push(() => dropFromCache(cacheKey));
 
   return () => {
     log(`getComments(tmpid: ${timestamp}) > dispose`);
     disposers.forEach(fn => fn());
-    dropFromCache(cacheKey);
   };
 };
 /* end_public_function */

package/src/communityRepository/communityMembership/api/index.ts

@@ -0,0 +1,2 @@
+export * from './addMembers';
+export * from './removeMembers';

package/src/communityRepository/{communityModeration/api/test → communityMembership/api/tests}/addMembers.test.ts

@@ -10,7 +10,7 @@ import {
   user11,
 } from '~/utils/tests';
 
-import { onCommunityUserAdded } from '../../../communityMembership/events';
+import { onCommunityUserAdded } from '../../events';
 import { addMembers } from '../addMembers';
 
 const communityToAddUserTo = community11;

package/src/communityRepository/{communityModeration/api/test → communityMembership/api/tests}/removeMembers.test.ts

@@ -10,7 +10,7 @@ import {
   disconnectClient,
 } from '~/utils/tests';
 
-import { onCommunityUserRemoved } from '../../../communityMembership/events';
+import { onCommunityUserRemoved } from '../../events';
 import { removeMembers } from '../removeMembers';
 
 const communityToRemoveUser = community11;

package/src/communityRepository/communityMembership/index.ts

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

package/src/communityRepository/communityMembership/observers/getMembers.ts

@@ -9,6 +9,7 @@ import {
   sortByFirstCreated,
   sortByLastCreated,
   filterBySearchTerm,
+  filterByPropIntersection,
 } from '~/core/query';
 import {
   COLLECTION_DEFAULT_CACHING_POLICY,
@@ -76,10 +77,7 @@ export const getMembers = (
         .filter(Boolean)
         .map(({ data }) => data) ?? [];
 
-    if (params.roles)
-      communityMembers = communityMembers.filter(c =>
-        c.roles?.some(t => params.roles?.includes(t)),
-      );
+    communityMembers = filterByPropIntersection(communityMembers, 'roles', params.roles);
 
     if (params.membership) {
       communityMembers = communityMembers.filter(({ communityMembership }) =>
@@ -127,16 +125,16 @@ export const getMembers = (
       responder(collection);
     };
 
-  const onFetch = () => {
+  const onFetch = (initial = false) => {
     const collection = pullFromCache<Amity.CommunityMemberLiveCollectionCache>(cacheKey)?.data;
 
     const communityMembers = collection?.data ?? [];
 
-    if (communityMembers.length > 0 && !collection?.params.page) return;
+    if (!initial && communityMembers.length > 0 && !collection?.params.page) return;
 
     const query = createQuery(queryCommunityMembers, {
       ...queryParams,
-      page: collection?.params.page ?? { limit },
+      page: (!initial ? collection?.params.page : undefined) ?? { limit },
     });
 
     runQuery(
@@ -173,7 +171,7 @@ export const getMembers = (
     onCommunityUserRoleRemoved(realtimeRouter('onMemberCountChanged')),
   );
 
-  onFetch();
+  onFetch(true);
 
   return () => {
     log(`getMembers(tmpid: ${timestamp}) > dispose`);

package/src/communityRepository/communityModeration/api/banMembers.ts

@@ -0,0 +1,50 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareMembershipPayload } from '~/group/utils';
+
+/* begin_public_function
+  id: community.moderation.ban_members
+*/
+/**
+ * ```js
+ * import { CommunityRepository } from '@amityco/ts-sdk'
+ *
+ * await CommunityRepository.Moderation.banMembers('communityId', ['userId1', 'userId2'])
+ * ```
+ *
+ * @param communityId of {@link Amity.Community} 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 Community API
+ * @async
+ * */
+export const banMembers = async (
+  communityId: Amity.Community['communityId'],
+  userIds: Amity.User['userId'][],
+): Promise<Amity.Cached<Amity.Membership<'community'>[]>> => {
+  const client = getActiveClient();
+  client.log('community/banMembers', { userIds, communityId });
+
+  const { data: payload } = await client.http.put<Amity.CommunityMembershipPayload>(
+    `/api/v3/communities/${communityId}/users/ban`,
+    {
+      userIds,
+    },
+  );
+
+  const data = prepareMembershipPayload(payload, 'communityUsers');
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { communityUsers } = data;
+
+  return {
+    data: communityUsers.filter(u => userIds.includes(u.userId)),
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/communityRepository/communityModeration/api/index.ts

@@ -1,4 +1,5 @@
-export * from './addMembers';
-export * from './removeMembers';
 export * from './addRoles';
 export * from './removeRoles';
+
+export * from './banMembers';
+export * from './unbanMembers';

package/src/communityRepository/communityModeration/api/test/banMembers.test.ts

@@ -0,0 +1,70 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { prepareMembershipPayload } from '~/group/utils';
+import { getResolver } from '~/core/model';
+import { ASCError } from '~/core/errors';
+
+import { client, community11, communityUser11, user11 } from '~/utils/tests';
+
+import { banMembers } from '../banMembers';
+
+const userCommunity = community11;
+const user = {
+  ...communityUser11,
+  communityMebership: 'banned',
+};
+const resolvedCommunityValue = {
+  data: {
+    communities: [userCommunity],
+    communityUsers: [user],
+    files: [],
+    users: [user11],
+    categories: [],
+    feeds: [],
+  },
+};
+
+describe('community/ moderation/ banMembers', () => {
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  const { communityId } = communityUser11;
+  const { userId } = communityUser11;
+
+  const preparedPayload = prepareMembershipPayload(resolvedCommunityValue.data, 'communityUsers');
+  const { communityUsers: expectedUser } = preparedPayload;
+
+  // integration_test_id: d344e314-4a49-4947-b4d5-8fa2d55f8ecd
+  test('it should return banned members', async () => {
+    client.http.put = jest.fn().mockResolvedValue(resolvedCommunityValue);
+
+    const { data: recieved } = await banMembers(communityId, [userId]);
+
+    expect(recieved).toStrictEqual(expectedUser);
+  });
+
+  test('it should update cache', async () => {
+    client.http.put = jest.fn().mockResolvedValue(resolvedCommunityValue);
+
+    await banMembers(communityId, [userId]);
+    const recieved = pullFromCache([
+      'communityUsers',
+      'get',
+      getResolver('communityUsers')({ communityId, userId }),
+    ])?.data;
+
+    expect([recieved]).toStrictEqual(expectedUser);
+  });
+
+  // integration_test_id: 59b58ec8-8380-49b2-aa39-6da361692c2e
+  test('it should throw valid error', async () => {
+    const err = new ASCError(
+      'Permission Denied',
+      Amity.ServerError.UNAUTHORIZED,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.put = jest.fn().mockRejectedValue(err);
+
+    await expect(banMembers(communityId, [userId])).rejects.toThrow(err);
+  });
+});

package/src/communityRepository/communityModeration/api/test/unbanMembers.test.ts

@@ -0,0 +1,70 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { prepareMembershipPayload } from '~/group/utils';
+import { getResolver } from '~/core/model';
+import { ASCError } from '~/core/errors';
+
+import { client, community11, communityUser11, user11 } from '~/utils/tests';
+
+import { unbanMembers } from '../unbanMembers';
+
+const userCommunity = community11;
+const user = {
+  ...communityUser11,
+  communityMebership: 'none',
+};
+const resolvedCommunityValue = {
+  data: {
+    communities: [userCommunity],
+    communityUsers: [user],
+    files: [],
+    users: [user11],
+    categories: [],
+    feeds: [],
+  },
+};
+
+describe('community/ moderation/ unbanMembers', () => {
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  const { communityId } = communityUser11;
+  const { userId } = communityUser11;
+
+  const preparedPayload = prepareMembershipPayload(resolvedCommunityValue.data, 'communityUsers');
+  const { communityUsers: expectedUser } = preparedPayload;
+
+  // integration_test_id: bee19fd4-63f4-403f-9771-6424d94cf144
+  test('it should return banned members', async () => {
+    client.http.put = jest.fn().mockResolvedValue(resolvedCommunityValue);
+
+    const { data: recieved } = await unbanMembers(communityId, [userId]);
+
+    expect(recieved).toStrictEqual(expectedUser);
+  });
+
+  test('it should update cache', async () => {
+    client.http.put = jest.fn().mockResolvedValue(resolvedCommunityValue);
+
+    await unbanMembers(communityId, [userId]);
+    const recieved = pullFromCache([
+      'communityUsers',
+      'get',
+      getResolver('communityUsers')({ communityId, userId }),
+    ])?.data;
+
+    expect([recieved]).toStrictEqual(expectedUser);
+  });
+
+  // integration_test_id: 22ce5ced-641a-48e2-9a89-d3f51119d8ac
+  test('it should throw valid error', async () => {
+    const err = new ASCError(
+      'Permission Denied',
+      Amity.ServerError.UNAUTHORIZED,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.put = jest.fn().mockRejectedValue(err);
+
+    await expect(unbanMembers(communityId, [userId])).rejects.toThrow(err);
+  });
+});

package/src/communityRepository/communityModeration/api/unbanMembers.ts

@@ -0,0 +1,50 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareMembershipPayload } from '~/group/utils';
+
+/* begin_public_function
+  id: community.moderation.unban_members
+*/
+/**
+ * ```js
+ * import { CommunityRepository } from '@amityco/ts-sdk'
+ *
+ * await CommunityRepository.Moderation.unbanMembers('communityId', ['userId1', 'userId2'])
+ * ```
+ *
+ * @param communityId of {@link Amity.Community} from which 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 Community API
+ * @async
+ * */
+export const unbanMembers = async (
+  communityId: Amity.Community['communityId'],
+  userIds: Amity.User['userId'][],
+): Promise<Amity.Cached<Amity.Membership<'community'>[]>> => {
+  const client = getActiveClient();
+  client.log('community/unbanMembers', { userIds, communityId });
+
+  const { data: payload } = await client.http.put<Amity.CommunityMembershipPayload>(
+    `/api/v3/communities/${communityId}/users/unban`,
+    {
+      userIds,
+    },
+  );
+
+  const data = prepareMembershipPayload(payload, 'communityUsers');
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { communityUsers } = data;
+
+  return {
+    data: communityUsers.filter(u => userIds.includes(u.userId)),
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/communityRepository/observers/getCommunities.ts

@@ -138,16 +138,16 @@ export const getCommunities = (
     responder(collection);
   };
 
-  const onFetch = () => {
+  const onFetch = (initial = false) => {
     const collection = pullFromCache<Amity.CommunityLiveCollectionCache>(cacheKey)?.data;
 
     const communities = collection?.data ?? [];
 
-    if (communities.length > 0 && !collection?.params.page) return;
+    if (!initial && communities.length > 0 && !collection?.params.page) return;
 
     const query = createQuery(queryCommunities, {
       ...queryParams,
-      page: collection?.params.page ?? { limit },
+      page: (!initial ? collection?.params.page : undefined) ?? { limit },
     });
 
     runQuery(
@@ -181,12 +181,12 @@ export const getCommunities = (
     onCommunityUserChanged(realtimeRouter('onMemberCountChanged')),
   );
 
-  onFetch();
+  onFetch(true);
+  disposers.push(() => dropFromCache(cacheKey));
 
   return () => {
     log(`getCommunities(tmpid: ${timestamp}) > dispose`);
     disposers.forEach(fn => fn());
-    dropFromCache(cacheKey);
   };
 };
 /* end_public_function */