@amityco/ts-sdk 6.29.2 → 6.29.3-9895419.0

package/src/channelRepository/channelMembership/observers/searchMembers/SearchChannelMemberPaginationController.ts

@@ -0,0 +1,28 @@
+/* eslint-disable no-use-before-define */
+
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+
+/**
+ * TODO: handle cache receive cache option, and cache policy
+ * TODO: check if querybyIds is supported
+ */
+export class SearchChannelMemberPaginationController extends PaginationController<
+  'channelUser',
+  Amity.ChannelMembersLiveCollection
+> {
+  async getRequest(queryParams: Amity.ChannelMembersLiveCollection, token: string | undefined) {
+    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, ...params } = queryParams;
+    const options = token ? { token } : { limit };
+
+    const { data: queryResponse } = await this.http.get<
+      Amity.ChannelMembershipPayload & Amity.Pagination
+    >(`/api/v4/channels/${encodeURIComponent(params.channelId)}/users`, {
+      params: {
+        ...params,
+        options,
+      },
+    });
+    return queryResponse;
+  }
+}

package/src/channelRepository/channelMembership/observers/searchMembers/SearchChannelMemberQueryStreamController.ts

@@ -0,0 +1,112 @@
+/* eslint-disable no-use-before-define */
+import { QueryStreamController } from '~/core/liveCollection/QueryStreamController';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getResolver } from '~/core/model';
+import { getActiveClient } from '~/client';
+
+export class SearchChannelMemberQueryStreamController extends QueryStreamController<
+  Amity.ChannelMembershipPayload,
+  Amity.SearchChannelMembersLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (
+    response: Amity.ChannelMembershipPayload,
+  ) => Promise<Amity.ProcessedChannelPayload>;
+
+  constructor(
+    query: Amity.SearchChannelMembersLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    preparePayload: (
+      response: Amity.ChannelMembershipPayload,
+    ) => Promise<Amity.ProcessedChannelPayload>,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.preparePayload = preparePayload;
+  }
+
+  async saveToMainDB(response: Amity.ChannelMembershipPayload) {
+    const processedPayload = await this.preparePayload(response);
+
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    if (client.cache) {
+      ingestInCache(processedPayload, { cachedAt });
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.ChannelPayload & Partial<Amity.Pagination>,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: response.channelUsers.map(({ channelId, userId }) =>
+          getResolver('channelUsers')({ channelId, userId }),
+        ),
+      });
+    } else {
+      const collection = pullFromCache<Amity.ChannelMembersLiveCollectionCache>(
+        this.cacheKey,
+      )?.data;
+
+      const channelUsers = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data: [
+          ...new Set([
+            ...channelUsers,
+            ...response.channelUsers.map(({ channelId, userId }) =>
+              getResolver('channelUsers')({ channelId, userId }),
+            ),
+          ]),
+        ],
+      });
+    }
+  }
+
+  reactor(action: string) {
+    return (channel: Amity.InternalChannel, channelMember: Amity.Membership<'channel'>) => {
+      if (this.query.channelId !== channelMember.channelId) return;
+
+      const collection = pullFromCache<Amity.ChannelMembersLiveCollectionCache>(
+        this.cacheKey,
+      )?.data;
+      if (!collection) return;
+
+      const channelMemberCacheId = getResolver('channelUsers')({
+        channelId: this.query.channelId,
+        userId: channelMember.userId,
+      });
+
+      if (channelMember.membership === 'none') {
+        collection.data = collection.data.filter(m => m !== channelMemberCacheId);
+      } else if (!collection.data.includes(channelMemberCacheId)) {
+        collection.data = [channelMemberCacheId, ...collection.data];
+      }
+
+      pushToCache(this.cacheKey, collection);
+      this.notifyChange({ origin: Amity.LiveDataOrigin.EVENT, loading: false });
+    };
+  }
+
+  subscribeRTE(
+    createSubscriber: {
+      fn: (
+        reactor: (
+          channel: Amity.InternalChannel,
+          channelMember: Amity.Membership<'channel'>,
+        ) => void,
+      ) => Amity.Unsubscriber;
+      action: string;
+    }[],
+  ) {
+    return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+  }
+}

package/src/channelRepository/channelMembership/observers/searchMembers/index.ts

@@ -0,0 +1 @@
+export * from './searchMembers';

package/src/channelRepository/channelMembership/observers/searchMembers/searchMembers.ts

@@ -0,0 +1,111 @@
+/* eslint-disable no-use-before-define */
+import { getActiveClient } from '~/client/api';
+import {
+  filterByPropIntersection,
+  filterBySearchTerm,
+  sortByFirstCreated,
+  sortByLastCreated,
+} from '~/core/query';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { dropFromCache } from '~/cache/api';
+import { SearchChannelMemberLiveCollectionController } from './SearchChannelMemberLiveCollectionController';
+
+/*
+ * Exported for testing
+ * @hidden
+ */
+export const applyFilter = <T extends Amity.Membership<'channel'>>(
+  data: T[],
+  params: Amity.ChannelMembersLiveCollection,
+): T[] => {
+  let channelMembers = filterByPropIntersection(data, 'roles', params.roles);
+
+  if (params.memberships) {
+    /*
+     * even though membership includes muted as a possible value
+     * when querying the server.
+     * Muted is specified under seperarte property namely isMuted
+     * Hence why I've seperately checked for it's equality
+     */
+    channelMembers = channelMembers.filter(member => {
+      // @ts-ignore
+      if (params.memberships.includes('muted') && member.isMuted) {
+        return true;
+      }
+
+      // @ts-ignore
+      return params.memberships.includes(member.membership);
+    });
+  }
+
+  if (params.search) {
+    // eslint-disable-next-line no-console
+    console.warn(
+      '`search` param will be deprecated in the next major release. If you want to search channel members by displayName, Please use `searchMembers()` instead.',
+    );
+    channelMembers = filterBySearchTerm(channelMembers, params.search);
+  }
+
+  // sort, 'lastCreated' is the default sort order
+  const sortBy = params.sortBy ? params.sortBy : 'lastCreated';
+  channelMembers = channelMembers.sort(
+    sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated,
+  );
+
+  return channelMembers;
+};
+
+/* begin_public_function
+  id: channel.member.query
+*/
+/**
+ * ```js
+ * import { searchChannelMembers } from '@amityco/ts-sdk'
+ *
+ * let channelMembers = []
+ * const unsub = searchChannelMembers({
+ *   channelId: Amity.Channel['channelId'],
+ * }, response => merge(channelMembers, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.ChannelUser}s
+ *
+ * @param params for querying channel 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 channel users
+ *
+ * @category Channel Live Collection
+ */
+export const searchMembers = (
+  params: Amity.SearchChannelMembersLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Membership<'channel'>>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    // eslint-disable-next-line no-console
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`searchChannelMembers(tmpid: ${timestamp}) > listen`);
+
+  const searchChannelMemberLiveCollection = new SearchChannelMemberLiveCollectionController(
+    params,
+    callback,
+  );
+  const disposers = searchChannelMemberLiveCollection.startSubscription();
+
+  const cacheKey = searchChannelMemberLiveCollection.getCacheKey();
+
+  disposers.push(() => {
+    dropFromCache(cacheKey);
+  });
+
+  return () => {
+    log(`searchChannelMembers(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};
+/* end_public_function */

package/src/channelRepository/utils/prepareChannelPayload.ts

@@ -1,5 +1,5 @@
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { withUsers } from '~/group/utils/withUser';
+import { convertRawMembershipToMembership } from '~/group/utils/withUser';
 import { getChannelMarkers } from '~/marker/api/getChannelMarkers';
 
 import { updateChannelMessagePreviewCache } from '~/messagePreview/utils';
@@ -7,8 +7,7 @@ import { getActiveClient } from '~/client/api/activeClient';
 import { pullFromCache } from '~/cache/api/pullFromCache';
 import { getSubChannelsUnreadCount } from './getSubChannelsUnreadCount';
 import { getChannelIsMentioned } from './getChannelIsMentioned';
-import { getUserMessageFeedMakers } from '~/marker/api/getUserMessageFeedMarkers';
-import { persistUnreadCountInfo } from '~/marker/utils/persistUnreadCountInfo';
+import { convertRawUserToInternalUser } from '~/userRepository/utils';
 
 export const MARKER_INCLUDED_CHANNEL_TYPE = ['broadcast', 'conversation', 'community'];
 export const isUnreadCountSupport = ({ type }: Pick<Amity.RawChannel, 'type'>) =>
@@ -99,12 +98,17 @@ export const prepareChannelPayload = async (
   );
 
   // user marker to channel users
-  const channelUsers: Amity.Membership<'channel'>[] = withUsers(rawPayload.channelUsers);
+  const channelUsers: Amity.Membership<'channel'>[] = rawPayload.channelUsers.map(channelUser => {
+    return convertRawMembershipToMembership<'channel'>(channelUser);
+  });
+
+  const users = rawPayload.users.map(convertRawUserToInternalUser);
 
   const { messageFeedsInfo, messagePreviews, ...restRawPayload } = rawPayload;
 
   return {
     ...restRawPayload,
+    users,
     channels,
     channelUsers,
   };

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

@@ -128,6 +128,12 @@ export class CommunityMembersLiveCollectionController extends LiveCollectionCont
       communityMembers = filterBySearchTerm(communityMembers, this.query.search);
     }
 
+    if (typeof this.query.includeDeleted === 'boolean') {
+      communityMembers = communityMembers.filter(
+        ({ user }) => user?.isDeleted === this.query.includeDeleted,
+      );
+    }
+
     switch (this.query.sortBy) {
       case 'firstCreated':
         communityMembers = communityMembers.sort(sortByFirstCreated);

package/src/communityRepository/communityMembership/observers/searchMembers/SearchCommunityMembersLiveCollectionController.ts

@@ -125,6 +125,12 @@ export class SearchCommunityMembersLiveCollectionController extends LiveCollecti
       communityMembers = filterBySearchTerm(communityMembers, this.query.search);
     }
 
+    if (typeof this.query.includeDeleted === 'boolean') {
+      communityMembers = communityMembers.filter(
+        ({ user }) => user?.isDeleted === this.query.includeDeleted,
+      );
+    }
+
     return communityMembers;
   }
 }

package/src/communityRepository/observers/getCommunities/CommunitiesLiveCollectionController.ts

@@ -136,11 +136,11 @@ export class CommunityLiveCollectionController extends LiveCollectionController<
     if (!this.query.displayName) {
       const sortFn = (() => {
         switch (this.query.sortBy) {
-          case 'firstCreated':
+          case Amity.CommunitySortByEnum.FirstCreated:
             return sortByFirstCreated;
-          case 'lastCreated':
+          case Amity.CommunitySortByEnum.LastCreated:
             return sortByLastCreated;
-          case 'displayName':
+          case Amity.CommunitySortByEnum.DisplayName:
             return sortByDisplayName;
           default:
             return sortByLastCreated;

package/src/communityRepository/utils/payload.ts

@@ -1,6 +1,4 @@
 import { CommunityPostSettingMaps, DefaultCommunityPostSetting } from '~/@types';
-import { pullFromCache } from '~/cache/api';
-import { withUsers } from '~/group/utils';
 import { updateMembershipStatus } from './communityWithMembership';
 
 const getMatchPostSetting = (value: {
@@ -14,31 +12,8 @@ const getMatchPostSetting = (value: {
       value.onlyAdminCanPost === CommunityPostSettingMaps[key].onlyAdminCanPost,
   ) ?? DefaultCommunityPostSetting;
 
-const convertCommunityUsersToUniqueObject = (
-  communityUsers: Amity.RawMembership<'community'>[],
-) => {
-  if (!communityUsers) return communityUsers;
-
-  const result: {
-    [key: string]: Amity.RawMembership<'community'>;
-  } = {};
-
-  communityUsers.forEach(user => {
-    result[`${user.userId}#${user.communityId}`] = user;
-  });
-
-  return result;
-};
-
-export const convertCommunityPayload = (rawPayload: {
-  communities: Amity.RawCommunity[];
-  communityUsers: Amity.RawMembership<'community'>[];
-}): {
-  communities: Amity.Community[];
-  communityUsers: Amity.Membership<'community'>[];
-} => {
-  // Unpack community payload by mapping payload field to postSetting value.
-  const communities = rawPayload.communities.map<Amity.Community>(
+export function addPostSetting({ communities }: { communities: Amity.RawCommunity[] }) {
+  return communities.map<Amity.Community>(
     ({ needApprovalOnPostCreation, onlyAdminCanPost, ...restCommunityPayload }) => ({
       postSetting: getMatchPostSetting({
         needApprovalOnPostCreation,
@@ -47,44 +22,34 @@ export const convertCommunityPayload = (rawPayload: {
       ...restCommunityPayload,
     }),
   );
-
-  const mergeCommunityUsers = communities.reduce<{
-    [key: string]: Amity.RawMembership<'community'>;
-  }>((acc, { communityId }) => {
-    const users = pullFromCache<Amity.RawMembership<'community'>[]>([
-      'communityUsers',
-      'collection',
-      communityId,
-    ])?.data;
-
-    if (!users) return acc;
-
-    return {
-      ...convertCommunityUsersToUniqueObject(users),
-      ...acc,
-    };
-  }, convertCommunityUsersToUniqueObject(rawPayload.communityUsers));
-
-  const communityUsers = withUsers(Object.values(mergeCommunityUsers));
-
-  const communityWithMembershipStatus = updateMembershipStatus(communities, communityUsers);
-
-  return {
-    ...rawPayload,
-    communities: communityWithMembershipStatus,
-    communityUsers,
-  };
-};
+}
 
 export const prepareCommunityPayload = (
   rawPayload: Amity.CommunityPayload,
 ): Amity.ProcessedCommunityPayload => {
-  const { communities, communityUsers } = convertCommunityPayload(rawPayload);
+  const communitiesWithPostSetting = addPostSetting({ communities: rawPayload.communities });
+
+  // map users with community
+  const mappedCommunityUsers: Array<Amity.Membership<'community'>> = rawPayload.communityUsers.map(
+    communityUser => {
+      const user = rawPayload.users.find(user => user.userId === communityUser.userId)!;
+
+      return {
+        ...communityUser,
+        user,
+      };
+    },
+  );
+
+  const communityWithMembershipStatus = updateMembershipStatus(
+    communitiesWithPostSetting,
+    mappedCommunityUsers,
+  );
 
   return {
     ...rawPayload,
-    communities,
-    communityUsers,
+    communities: communityWithMembershipStatus,
+    communityUsers: mappedCommunityUsers,
   };
 };
 

package/src/core/model/idResolvers.ts

@@ -56,6 +56,9 @@ const idResolvers: Resolvers = {
 
   ad: ({ adId }) => adId,
   advertiser: ({ advertiserId }) => advertiserId,
+
+  pin: ({ referenceId }) => referenceId,
+  pinTarget: ({ targetId }) => targetId,
 };
 
 /**

package/src/core/model/index.ts

@@ -49,6 +49,9 @@ export const PAYLOAD2MODEL: Record<string, Amity.Domain> = {
   feeds: 'feed',
   ads: 'ad',
   advertisers: 'advertiser',
+
+  pinTargets: 'pinTarget',
+  pins: 'pin',
 };
 
 /** hidden */

package/src/group/utils/withUser.ts

@@ -1,6 +1,39 @@
 import { pullFromCache } from '~/cache/api/pullFromCache';
 import { getActiveClient } from '~/client/api/activeClient';
 
+/**
+ * Attach user object to membership model
+ * - If cache is not enabled, set user to undefined ({..., user: undefined})
+ * - If user object is not found in cache, set user to undefined
+ * ({..., user: undefined})
+ * - If a user is found in the cache, it attaches the user from the cache
+ * ({..., user: { userId, displayName,... }})
+ *
+ * @param member The membership model object
+ * @returns The membership model object that is already mapped to user
+ * @hidden
+ */
+export const convertRawMembershipToMembership = <T extends Amity.GroupType>(
+  member: Amity.RawMembership<T>,
+): Amity.Membership<T> => {
+  return {
+    ...member,
+    get user() {
+      const client = getActiveClient();
+
+      if (!client.cache) return undefined;
+
+      const userCache = pullFromCache<Amity.InternalUser>(['user', 'get', member.userId])?.data;
+
+      if (!userCache) {
+        return undefined;
+      }
+
+      return userCache;
+    },
+  };
+};
+
 /**
  * Attach user object to membership model
  * - If cache is not enabled, set user to undefined ({..., user: undefined})

package/src/postRepository/internalApi/index.ts

@@ -1,16 +1 @@
-export * from './getPostByIds';
-
-export * from './createPost';
-export * from './updatePost';
-export * from './editPost';
-
-export * from './deletePost';
-export * from './softDeletePost';
-export * from './hardDeletePost';
-
-export * from './approvePost';
-export * from './declinePost';
-
-export * from './flagPost';
-export * from './unflagPost';
-export * from './isPostFlaggedByMe';
+export * from './getPost';

package/src/postRepository/observers/getPinnedPosts/PinnedPostLiveCollectionController.ts

@@ -0,0 +1,104 @@
+import hash from 'object-hash';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { PinnedPostPaginationController } from './PinnedPostPaginationController';
+import { PinnedPostQueryStreamController } from './PinnedPostQueryStreamController';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import { isNonNullable } from '~/utils';
+import { LinkedObject } from '~/utils/linkedObject';
+import { sortByLastCreated } from '~/core/query';
+
+export class PinnedPostLiveCollectionController extends LiveCollectionController<
+  'pinnedPost',
+  Amity.PinnedPostLiveCollection,
+  Amity.PinnedPost,
+  PinnedPostPaginationController
+> {
+  private queryStreamController: PinnedPostQueryStreamController;
+
+  private query: Amity.PinnedPostLiveCollection;
+
+  constructor(
+    query: Amity.PinnedPostLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.PinnedPost>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['pinnedPosts', 'collection', queryStreamId];
+    const paginationController = new PinnedPostPaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new PinnedPostQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      response => response,
+    );
+
+    this.callback = callback.bind(this);
+    this.loadPage({ initial: true });
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.PostLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        params: {},
+      });
+    }
+  }
+
+  protected async persistModel(queryPayload: Amity.PinnedPostPayload & Amity.Pagination) {
+    await this.queryStreamController.saveToMainDB(queryPayload);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'pinnedPost'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  startSubscription() {
+    return [] as Amity.Unsubscriber[];
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.PinnedPostLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) return;
+
+    let data = (
+      collection.data
+        .map(id => pullFromCache<Amity.InternalPin>(['pin', 'get', id])!)
+        .filter(isNonNullable)
+        .map(({ data }) => data) ?? []
+    ).map(LinkedObject.pinnedPost);
+
+    data = this.applyFilter(data);
+
+    if (!this.shouldNotify(data) && origin === 'event') return;
+
+    this.callback({
+      data,
+      loading,
+      error,
+    });
+  }
+
+  private applyFilter(data: Amity.PinnedPost[]) {
+    let pinnedPost = data;
+    switch (this.query.sortBy) {
+      case 'lastCreated':
+        pinnedPost = pinnedPost.sort(({ post: postA }, { post: postB }) =>
+          sortByLastCreated({ createdAt: postA?.createdAt! }, { createdAt: postB?.createdAt! }),
+        );
+        break;
+      default:
+        break;
+    }
+    return pinnedPost;
+  }
+}

package/src/postRepository/observers/getPinnedPosts/PinnedPostPaginationController.ts

@@ -0,0 +1,23 @@
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+
+export class PinnedPostPaginationController extends PaginationController<
+  'pinnedPost',
+  Amity.PinnedPostLiveCollection
+> {
+  async getRequest(queryParams: Amity.PinnedPostLiveCollection, token: string | undefined) {
+    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, ...params } = queryParams;
+
+    const { communityId, placement } = params;
+
+    const path = placement
+      ? `/api/v1/pinned-posts/communities/${communityId}/${placement}`
+      : `/api/v1/pinned-posts/communities/${communityId}`;
+
+    const { data: queryResponse } = await this.http.get<Amity.PinnedPostPayload & Amity.Pagination>(
+      path,
+    );
+
+    return queryResponse;
+  }
+}