@amityco/ts-sdk 0.0.1-beta.39 → 0.0.1-beta.40

package/src/community/api/joinCommunity.ts

@@ -1,6 +1,7 @@
 import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareCommunityPayload } from '~/community/utils';
 import { fireEvent } from '~/core/events';
 
 /**
@@ -23,15 +24,17 @@ export const joinCommunity = async (
   const client = getActiveClient();
   client.log('community/joinCommunity', communityId);
 
-  const { data } = await client.http.post<Amity.CommunityMembershipPayload>(
+  const { data: payload } = await client.http.post<Amity.CommunityMembershipPayload>(
     `/api/v3/communities/${communityId}/join`,
   );
 
+  fireEvent('community.joined', payload);
+
+  const data = prepareCommunityPayload(payload);
+
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 
-  fireEvent('community.joined', data);
-
   const { communityUsers } = data;
 
   return !!communityUsers.find(

package/src/community/api/leaveCommunity.ts

@@ -1,6 +1,7 @@
 import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareCommunityPayload } from '~/community/utils';
 import { fireEvent } from '~/core/events';
 
 /**
@@ -23,15 +24,17 @@ export const leaveCommunity = async (
   const client = getActiveClient();
   client.log('community/leaveCommunity', communityId);
 
-  const { data } = await client.http.delete<Amity.CommunityMembershipPayload>(
+  const { data: payload } = await client.http.delete<Amity.CommunityMembershipPayload>(
     `/api/v3/communities/${communityId}/leave`,
   );
 
+  fireEvent('community.left', payload);
+
+  const data = prepareCommunityPayload(payload);
+
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 
-  fireEvent('community.left', data);
-
   const { communityUsers } = data;
 
   return !!communityUsers.find(

package/src/community/api/queryCommunities.ts

@@ -5,7 +5,7 @@ import { pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
 
-import { unpackCommunityPayload } from '../utils';
+import { prepareCommunityPayload } from '../utils';
 
 /**
  * ```js
@@ -50,13 +50,13 @@ export const queryCommunities = async (
   );
 
   const { paging, ...payload } = data;
-  const unpackedPayload = unpackCommunityPayload(payload);
+  const unpackedPayload = prepareCommunityPayload(payload);
   const { communities } = unpackedPayload;
 
   const cachedAt = client.cache && Date.now();
 
   if (client.cache) {
-    ingestInCache(unpackedPayload as Amity.CommunityPayload, { cachedAt });
+    ingestInCache(unpackedPayload, { cachedAt });
 
     const cacheKey = [
       'community',

package/src/community/api/queryCommunityMembers.ts

@@ -20,13 +20,9 @@ import { prepareMembershipPayload } from '~/group/utils';
  * @category Community API
  * @async
  * */
-export const queryCommunityMembers = async (query: {
-  communityId: string;
-  membership?: ('banned' | 'member')[];
-  roles?: string[];
-  sortBy?: 'firstCreated' | 'lastCreated';
-  page?: Amity.Page;
-}): Promise<Amity.Cached<Amity.Paged<Amity.Membership<'community'>>>> => {
+export const queryCommunityMembers = async (
+  query: Amity.QueryCommunityMembers,
+): Promise<Amity.Cached<Amity.Paged<Amity.Membership<'community'>>>> => {
   const client = getActiveClient();
   client.log('community/queryCommunityMembers', query);
 

package/src/community/api/removeCommunityMembers.ts

@@ -2,6 +2,7 @@ import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
+import { prepareMembershipPayload } from '~/group/utils';
 
 /**
  * ```js
@@ -25,16 +26,19 @@ export const removeCommunityMembers = async (
   const client = getActiveClient();
   client.log('community/removeCommunityMembers', communityId, userIds);
 
-  const { data } = await client.http.delete<Amity.CommunityMembershipPayload>(
+  const { data: payload } = await client.http.delete<Amity.CommunityMembershipPayload>(
     `/api/v3/communities/${communityId}/users`,
     { data: { communityId, userIds } },
   );
 
-  if (client.cache) ingestInCache(data);
+  fireEvent('community.userRemoved', payload);
+
+  const data = prepareMembershipPayload(payload, 'communityUsers');
 
-  fireEvent('community.userRemoved', data);
+  if (client.cache) ingestInCache(data);
 
   const { communityUsers } = data;
+
   return !!communityUsers.find(
     communityUser =>
       communityUser.communityId === communityId && communityUser.communityMembership !== 'member',

package/src/community/api/removeCommunityMembersRoles.ts

@@ -1,6 +1,7 @@
 import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareMembershipPayload } from '~/group/utils';
 
 /**
  * ```js
@@ -12,7 +13,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  *
  * @param communityId The ID of the {@link Amity.Community} to perform
  * @param roleIds Array of IDs 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.Community}
  *
  * @category Community API
@@ -26,11 +27,13 @@ export const removeCommunityMembersRoles = async (
   const client = getActiveClient();
   client.log('community/removeCommunityMembersRoles', communityId, roleIds, userIds);
 
-  const { data } = await client.http.delete<Amity.CommunityMembershipPayload>(
+  const { data: payload } = await client.http.delete<Amity.CommunityMembershipPayload>(
     `/api/v4/communities/${communityId}/users/roles`,
     { data: { communityId, roles: roleIds, userIds } },
   );
 
+  const data = prepareMembershipPayload(payload, 'communityUsers');
+
   if (client.cache) ingestInCache(data);
 
   const { communityUsers } = data;

package/src/community/api/test/queryCommunityMembers.test.ts

@@ -87,10 +87,11 @@ describe('queryCommunityMembers.locally', () => {
     const { communityUsers } = preparedPayload;
 
     // ingest incomplete data
+    // @ts-ignore
     ingestInCache({
       ...preparedPayload,
       communityUsers: [payload.communityUsers[0]],
-    } as Amity.CommunityMembershipPayload);
+    } as Amity.ProcessedCommunityMembershipPayload);
 
     pushToCache(cacheKey, {
       communityUsers: communityUsers.map(({ communityId, userId }) =>

package/src/community/api/test/removeCommunityMemberRole.test.ts

@@ -7,7 +7,10 @@ import { removeCommunityMembersRoles } from '../removeCommunityMembersRoles';
 
 const community = community11;
 const roleToRemove = 'some-exist-role';
-const userToRemoveRole = { ...communityUser11, roles: [...communityUser11.roles, roleToRemove] };
+const userToRemoveRole = {
+  ...communityUser11,
+  roles: [...communityUser11.roles, roleToRemove],
+};
 const removedRoleUser = { ...communityUser11 };
 
 const resolvedDeleteValue = {

package/src/community/api/updateCommunity.ts

@@ -3,7 +3,7 @@ import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
 
-import { packCommunityPayload, unpackCommunityPayload } from '../utils';
+import { prepareCommunityRequest, prepareCommunityPayload } from '../utils';
 
 /**
  * ```js
@@ -32,16 +32,16 @@ export const updateCommunity = async (
 
   const { data: payload } = await client.http.put<Amity.CommunityPayload>(
     `/api/v3/communities/${communityId}`,
-    packCommunityPayload(patch),
+    prepareCommunityRequest(patch),
   );
 
-  const data = unpackCommunityPayload(payload);
+  fireEvent('community.updated', payload);
+
+  const data = prepareCommunityPayload(payload);
 
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 
-  fireEvent('community.updated', data);
-
   const { communities } = data;
 
   return {

package/src/community/events/index.ts

@@ -10,3 +10,5 @@ export * from './onCommunityUserRemoved';
 export * from './onCommunityUserChanged';
 export * from './onCommunityUserBanned';
 export * from './onCommunityUserUnbanned';
+export * from './onCommunityUserRoleAdded';
+export * from './onCommunityUserRoleRemoved';

package/src/community/events/onCommunityUserRoleAdded.ts

@@ -0,0 +1,20 @@
+import { createCommunityMemberEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onCommunityUserRoleAdded } from '@amityco/ts-sdk'
+ * const dispose = onCommunityUserRoleAdded((community, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a role has been added to {@link Amity.CommunityUser}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Community Events
+ */
+export const onCommunityUserRoleAdded = (
+  callback: (community: Amity.Community, member: Amity.Membership<'community'>) => void,
+) => createCommunityMemberEventSubscriber('community.roleAdded', callback);

package/src/community/events/onCommunityUserRoleRemoved.ts

@@ -0,0 +1,20 @@
+import { createCommunityMemberEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onCommunityUserRoleRemoved } from '@amityco/ts-sdk'
+ * const dispose = onCommunityUserRoleRemoved((community, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a role has been removed from {@link Amity.CommunityUser}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Community Events
+ */
+export const onCommunityUserRoleRemoved = (
+  callback: (community: Amity.Community, member: Amity.Membership<'community'>) => void,
+) => createCommunityMemberEventSubscriber('community.roleRemoved', callback);

package/src/community/events/test/onCommunityDeleted.test.ts

@@ -1,10 +1,17 @@
-import { client, connectClient, disconnectClient, community11 } from '~/utils/tests';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  community11,
+  emptyCommunityPayload,
+} from '~/utils/tests';
 
 import { onCommunityDeleted } from '../onCommunityDeleted';
 
 const deletedCommunity = { ...community11, isDeleted: true };
 
 const eventPayload: Amity.CommunityPayload = {
+  ...emptyCommunityPayload,
   communities: [deletedCommunity],
 };
 

package/src/community/events/test/onCommunityUserRoleAdded.test.ts

@@ -0,0 +1,50 @@
+import { withUser } from '~/group/utils';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  community11,
+  communityUser11,
+  user11,
+} from '~/utils/tests';
+
+import { onCommunityUserRoleAdded } from '../onCommunityUserRoleAdded';
+
+const community = community11;
+const userWithRoleRaw = { ...communityUser11, role: ['new-role'] };
+const userWithRole = withUser(userWithRoleRaw);
+
+const eventPayload: Amity.CommunityMembershipPayload = {
+  communities: [community],
+  communityUsers: [userWithRoleRaw],
+  files: [],
+  users: [user11],
+  categories: [],
+  feeds: [],
+};
+
+describe('onCommunityUserRoleAdded', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('it should got event after role added to community user', () => {
+    const callback = jest.fn();
+    const unsub = onCommunityUserRoleAdded(callback);
+    client.emitter.emit('community.roleAdded', eventPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith({ ...community, isJoined: true }, userWithRole);
+  });
+
+  test('it should got nothing if we did unsubscribe before event', () => {
+    const callback = jest.fn();
+    const unsub = onCommunityUserRoleAdded(callback);
+
+    unsub();
+
+    client.emitter.emit('community.roleAdded', eventPayload);
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/community/events/test/onCommunityUserRoleRemoved.test.ts

@@ -0,0 +1,50 @@
+import { withUser } from '~/group/utils';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  community11,
+  communityUser11,
+  user11,
+} from '~/utils/tests';
+
+import { onCommunityUserRoleRemoved } from '../onCommunityUserRoleRemoved';
+
+const community = community11;
+const userWithoutRoleRaw = { ...communityUser11, role: [''] };
+const userWithoutRole = withUser(userWithoutRoleRaw);
+
+const eventPayload: Amity.CommunityMembershipPayload = {
+  communities: [community],
+  communityUsers: [userWithoutRoleRaw],
+  files: [],
+  users: [user11],
+  categories: [],
+  feeds: [],
+};
+
+describe('onCommunityUserRoleAdded', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('it should got event after role added to community user', () => {
+    const callback = jest.fn();
+    const unsub = onCommunityUserRoleRemoved(callback);
+    client.emitter.emit('community.roleRemoved', eventPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith({ ...community, isJoined: true }, userWithoutRole);
+  });
+
+  test('it should got nothing if we did unsubscribe before event', () => {
+    const callback = jest.fn();
+    const unsub = onCommunityUserRoleRemoved(callback);
+
+    unsub();
+
+    client.emitter.emit('community.roleRemoved', eventPayload);
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/community/events/utils.ts

@@ -4,9 +4,8 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 import { createEventSubscriber } from '~/core/events';
 import { pullFromCache } from '~/cache/api';
 import { getResolver } from '~/core/model';
-import { prepareMembershipPayload } from '~/group/utils';
 
-import { unpackCommunityPayload } from '../utils';
+import { prepareCommunityPayload } from '../utils';
 
 export const createCommunityEventSubscriber = (
   event: keyof Amity.MqttCommunityEvents,
@@ -15,7 +14,7 @@ export const createCommunityEventSubscriber = (
   const client = getActiveClient();
 
   const filter = (payload: Amity.CommunityPayload) => {
-    const unpackedPayload = unpackCommunityPayload(payload);
+    const unpackedPayload = prepareCommunityPayload(payload);
 
     if (!client.cache) {
       // TODO: here we are missing specific properties here!
@@ -125,11 +124,8 @@ export const createCommunityMemberEventSubscriber = (
   const client = getActiveClient();
 
   const filter = (payload: Amity.CommunityMembershipPayload) => {
-    const communityPayload = unpackCommunityPayload(payload);
-    const { communities } = communityPayload;
-
-    const preparedPayload = prepareMembershipPayload(communityPayload, 'communityUsers');
-    const { communityUsers } = preparedPayload;
+    const preparedPayload = prepareCommunityPayload(payload);
+    const { communities, communityUsers } = preparedPayload;
 
     /*
      * community.isJoined is not part of the communityMembership payload, and needs

package/src/community/observers/index.ts

@@ -1,2 +1,6 @@
 export * from './observeCommunity';
+
 export * from './liveCommunities';
+export * from './liveCommunity';
+
+export * from './liveCommunityMembers';

package/src/community/observers/liveCommunity.ts

@@ -0,0 +1,45 @@
+import { liveObject } from '~/utils/liveObject';
+import { getCommunity } from '../api';
+import {
+  onCommunityUpdated,
+  onCommunityDeleted,
+  onCommunityJoined,
+  onCommunityLeft,
+  onCommunityUserBanned,
+  onCommunityUserUnbanned,
+  onCommunityUserChanged,
+} from '../events';
+
+/**
+ * ```js
+ * import { liveCommunity } from '@amityco/ts-sdk';
+ *
+ * let community;
+ *
+ * const unsubscribe = liveCommunity(communityId, response => {
+ *   community = response.data;
+ * });
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.Community}
+ *
+ * @param communityId the ID of the message to observe
+ * @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 community
+ *
+ * @category Community Live Object
+ */
+export const liveCommunity = (
+  communityId: Amity.Community['communityId'],
+  callback: Amity.LiveObjectCallback<Amity.Community>,
+): Amity.Unsubscriber => {
+  return liveObject(communityId, callback, 'communityId', getCommunity, [
+    onCommunityUpdated,
+    onCommunityDeleted,
+    onCommunityJoined,
+    onCommunityLeft,
+    onCommunityUserBanned,
+    onCommunityUserUnbanned,
+    onCommunityUserChanged,
+  ]);
+};

package/src/community/observers/liveCommunityMembers.ts

@@ -0,0 +1,187 @@
+/* eslint-disable no-use-before-define */
+import { getResolver } from '~/core/model';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api';
+import {
+  createQuery,
+  queryOptions,
+  runQuery,
+  sortByFirstCreated,
+  sortByLastCreated,
+} from '~/core/query';
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+  ENABLE_CACHE_MESSAGE,
+} from '~/utils/constants';
+import {
+  onCommunityLeft,
+  onCommunityJoined,
+  onCommunityUserBanned,
+  onCommunityUserChanged,
+  onCommunityUserUnbanned,
+  onCommunityUserRoleAdded,
+  onCommunityUserRoleRemoved,
+} from '../events';
+import { queryCommunityMembers } from '../api';
+
+/**
+ * ```js
+ * import { liveCommunityMembers } from '@amityco/ts-sdk'
+ *
+ * let communityMembers = []
+ * const unsub = liveCommunityMembers({
+ *   communityId: Amity.Community['communityId'],
+ * }, response => merge(communityMembers, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.CommunityUser}s
+ *
+ * @param params for querying community users
+ * @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 community users
+ *
+ * @category Community Live Collection
+ */
+export const liveCommunityMembers = (
+  params: Amity.CommunityMemberLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Membership<'community'>>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`liveCommunityMembers(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 = ['communityUsers', 'collection', { communityId: params.communityId }];
+
+  const responder = (data: Amity.CommunityMemberLiveCollectionCache) => {
+    let communityMembers: Amity.Membership<'community'>[] =
+      data.data
+        .map(id => pullFromCache<Amity.Membership<'community'>>(['communityUsers', 'get', id])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    if (params.roles)
+      communityMembers = communityMembers.filter(c =>
+        c.roles?.some(t => params.roles?.includes(t)),
+      );
+
+    if (params.membership) {
+      communityMembers = communityMembers.filter(({ communityMembership }) =>
+        // @ts-ignore
+        params.membership.includes(communityMembership),
+      );
+    }
+
+    if (params.search) {
+      /*
+       * Search by userId | displayName
+       */
+      const containsMatcher = new RegExp(params.search);
+
+      communityMembers = communityMembers.filter(m => {
+        if (m.userId.match(containsMatcher)) return true;
+
+        return m.user && m.user.displayName?.match(containsMatcher);
+      });
+    }
+
+    const sortBy = params.sortBy ? params.sortBy : 'lastCreated';
+    communityMembers = communityMembers.sort(
+      sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated,
+    );
+
+    callback({
+      onNextPage: onFetch,
+      data: communityMembers,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter =
+    (_: Amity.CommunityMemberActionType) =>
+    (_: Amity.Community, communityMember: Amity.Membership<'community'>) => {
+      if (params.communityId !== communityMember.communityId) {
+        return;
+      }
+
+      const collection = pullFromCache<Amity.CommunityMemberLiveCollectionCache>(cacheKey)?.data;
+      if (!collection) return;
+
+      const communityMemberCacheId = getResolver('communityUsers')({
+        communityId: params.communityId,
+        userId: communityMember.userId,
+      });
+
+      collection.data = [...new Set([communityMemberCacheId, ...collection.data])];
+
+      pushToCache(cacheKey, collection);
+      responder(collection);
+    };
+
+  const onFetch = () => {
+    const collection = pullFromCache<Amity.CommunityMemberLiveCollectionCache>(cacheKey)?.data;
+
+    const communityMembers = collection?.data ?? [];
+
+    if (communityMembers.length > 0 && !collection?.params.page) return;
+
+    const query = createQuery(queryCommunityMembers, {
+      ...queryParams,
+      page: collection?.params.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, nextPage: page }) => {
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: communityMembers,
+        };
+
+        if (result) {
+          data.data = [
+            ...new Set([...communityMembers, ...result.map(getResolver('communityUsers'))]),
+          ];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onCommunityLeft(realtimeRouter('onLeft')),
+    onCommunityJoined(realtimeRouter('onJoin')),
+    onCommunityUserBanned(realtimeRouter('onBan')),
+    onCommunityUserUnbanned(realtimeRouter('onUnban')),
+    onCommunityUserChanged(realtimeRouter('onMemberCountChanged')),
+    onCommunityUserRoleAdded(realtimeRouter('onMemberCountChanged')),
+    onCommunityUserRoleRemoved(realtimeRouter('onMemberCountChanged')),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveCommunityMembers(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};