@amityco/ts-sdk 6.29.2 → 6.29.3-9895419.0

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

@@ -0,0 +1,61 @@
+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 PinnedPostQueryStreamController extends QueryStreamController<
+  Amity.PinnedPostPayload,
+  Amity.PinnedPostLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (response: Amity.PinnedPostPayload) => Amity.ProcessedPostPayload;
+
+  constructor(
+    query: Amity.PinnedPostLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    preparePayload: (response: Amity.PinnedPostPayload) => Amity.ProcessedPostPayload,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.preparePayload = preparePayload;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  async saveToMainDB(response: Amity.PinnedPostPayload) {
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    if (client.cache) {
+      ingestInCache(response, { cachedAt });
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.PinnedPostPayload & Partial<Amity.Pagination>,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: response.pins.map(getResolver('pin')),
+      });
+    } else {
+      const collection = pullFromCache<Amity.PinnedPostLiveCollectionCache>(this.cacheKey)?.data;
+
+      const pinnedPosts = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data: [...new Set([...pinnedPosts, ...response.pins.map(getResolver('pin'))])],
+      });
+
+      this.notifyChange({
+        origin: Amity.LiveDataOrigin.SERVER,
+        loading: false,
+      });
+    }
+  }
+}

package/src/postRepository/observers/getPinnedPosts.ts

@@ -0,0 +1,41 @@
+import { getActiveClient } from '~/client/api';
+import { dropFromCache } from '~/cache/api';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { PinnedPostLiveCollectionController } from './getPinnedPosts/PinnedPostLiveCollectionController';
+
+/**
+ * Get pinned posts for a community
+ *
+ * @param communityId the ID of the community
+ * @param placement the placement of the pinned post ('announcement' or 'default'), or null to fetch all pinned posts
+ * @returns the associated pinned post(s)
+ *
+ * @category Pined Posts Live Collection
+ *
+ */
+export const getPinnedPosts = (
+  params: Amity.LiveCollectionParams<Amity.PinnedPostLiveCollection>,
+  callback: Amity.LiveCollectionCallback<Amity.PinnedPost>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`getPinnedPosts(tmpid: ${timestamp}) > listen`);
+
+  const pinnedPostLiveCollection = new PinnedPostLiveCollectionController(params, callback);
+  const disposers = pinnedPostLiveCollection.startSubscription();
+
+  const cacheKey = pinnedPostLiveCollection.getCacheKey();
+
+  disposers.push(() => dropFromCache(cacheKey));
+
+  return () => {
+    log(`getPinnedPosts(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/postRepository/observers/index.ts

@@ -2,3 +2,4 @@ export * from './observePosts';
 export * from './observePost';
 export * from './getPost';
 export * from './getPosts';
+export * from './getPinnedPosts';

package/src/postRepository/utils/payload.ts

@@ -1,17 +1,33 @@
-import { convertCommunityPayload } from '~/communityRepository/utils';
+import { addPostSetting } from '~/communityRepository/utils';
+import { updateMembershipStatus } from '~/communityRepository/utils/communityWithMembership';
 
 export const preparePostPayload = (postPayload: Amity.PostPayload): Amity.ProcessedPostPayload => {
   const { posts } = postPayload;
 
-  const { communities, communityUsers } = convertCommunityPayload({
-    communities: postPayload.communities,
-    communityUsers: postPayload.communityUsers,
-  });
+  // Unpack community payload by mapping payload field to postSetting value.
+  const communitiesWithPostSetting = addPostSetting({ communities: postPayload.communities });
+
+  // map users with community
+  const mappedCommunityUsers: Array<Amity.Membership<'community'>> = postPayload.communityUsers.map(
+    communityUser => {
+      const user = postPayload.users.find(user => user.userId === communityUser.userId)!;
+
+      return {
+        ...communityUser,
+        user,
+      };
+    },
+  );
+
+  const communityWithMembershipStatus = updateMembershipStatus(
+    communitiesWithPostSetting,
+    mappedCommunityUsers,
+  );
 
   return {
     ...postPayload,
     posts,
-    communities,
-    communityUsers,
+    communities: communityWithMembershipStatus,
+    communityUsers: mappedCommunityUsers,
   };
 };

package/src/report/api/createReport.ts

@@ -2,10 +2,94 @@ import { getActiveClient } from '~/client/api/activeClient';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
-import { prepareMembershipPayload } from '~/group/utils';
-
 import { prepareMessagePayload } from '~/messageRepository/utils';
-import REFERENCE_TYPES from '../constants/referenceTypes';
+import { preparePostPayload } from '~/postRepository/utils/payload';
+import { prepareUserPayload } from '~/userRepository/utils';
+import { prepareCommentPayload } from '~/commentRepository/utils/payload';
+
+const createMessageReport = async ({
+  client,
+  referenceId,
+}: {
+  client: Amity.Client;
+  referenceId: string;
+}) => {
+  const { data: payload } = await client.http.post<Amity.MessagePayload>(
+    `/api/v5/messages/${encodeURIComponent(referenceId)}/flags`,
+  );
+
+  if (client.cache) {
+    const messagePayload = await prepareMessagePayload(payload as Amity.MessagePayload);
+    ingestInCache(messagePayload);
+  }
+
+  fireEvent(`message.flagged`, payload);
+
+  return !!payload;
+};
+
+const createPostReport = async ({
+  client,
+  referenceId,
+}: {
+  client: Amity.Client;
+  referenceId: string;
+}) => {
+  const { data: payload } = await client.http.post<Amity.PostPayload>(
+    `/api/v3/post/${encodeURIComponent(referenceId)}/flag`,
+  );
+
+  if (client.cache) {
+    const postPayload = await preparePostPayload(payload);
+    ingestInCache(postPayload);
+  }
+
+  fireEvent(`post.flagged`, payload);
+
+  return !!payload;
+};
+
+const createUserReport = async ({
+  client,
+  referenceId,
+}: {
+  client: Amity.Client;
+  referenceId: string;
+}) => {
+  const { data: payload } = await client.http.post<Amity.UserPayload>(
+    `/api/v4/me/flags/${encodeURIComponent(referenceId)}`,
+  );
+
+  if (client.cache) {
+    const userPayload = await prepareUserPayload(payload);
+    ingestInCache(userPayload);
+  }
+
+  fireEvent(`user.flagged`, payload);
+
+  return !!payload;
+};
+
+const createCommentReport = async ({
+  client,
+  referenceId,
+}: {
+  client: Amity.Client;
+  referenceId: string;
+}) => {
+  const { data: payload } = await client.http.post<Amity.CommentPayload>(
+    `/api/v3/comment/${encodeURIComponent(referenceId)}/flag`,
+  );
+
+  if (client.cache) {
+    const commentPayload = await prepareCommentPayload(payload);
+    ingestInCache(commentPayload);
+  }
+
+  fireEvent(`comment.flagged`, payload);
+
+  return !!payload;
+};
 
 /**
  * ```js
@@ -21,42 +105,27 @@ import REFERENCE_TYPES from '../constants/referenceTypes';
  * @async
  * */
 export const createReport = async (
-  referenceType: keyof typeof REFERENCE_TYPES,
+  referenceType: 'post' | 'comment' | 'message' | 'user',
   referenceId: string,
 ): Promise<boolean> => {
   const client = getActiveClient();
   client.log('report/createReport', { referenceType, referenceId });
 
-  const getAPIUrl = (): string => {
-    if (referenceType === 'user') {
-      return `/api/v4/me/flags/${encodeURIComponent(referenceId)}`;
-    }
-
-    if (referenceType === 'message') {
-      return `/api/v5/messages/${encodeURIComponent(referenceId)}/flags`;
-    }
-
-    const { domainName } = REFERENCE_TYPES[referenceType];
-
-    return `/api/v3/${domainName}/${encodeURIComponent(referenceId)}/flag`;
-  };
+  if (referenceType === 'user') {
+    return createUserReport({ client, referenceId });
+  }
 
-  const { data: payload } = await client.http.post<
-    Amity.PostPayload | Amity.CommentPayload | Amity.MessagePayload | Amity.UserPayload
-  >(getAPIUrl());
+  if (referenceType === 'message') {
+    return createMessageReport({ client, referenceId });
+  }
 
-  if (client.cache) {
-    if (referenceType === 'message') {
-      const messagePayload = await prepareMessagePayload(payload as Amity.MessagePayload);
-      ingestInCache(messagePayload);
-    } else if (referenceType === 'post') {
-      ingestInCache(prepareMembershipPayload(payload as Amity.PostPayload, 'communityUsers'));
-    } else {
-      ingestInCache(payload as Amity.CommentPayload | Amity.UserPayload);
-    }
+  if (referenceType === 'post') {
+    return createPostReport({ client, referenceId });
   }
 
-  fireEvent(`${referenceType}.flagged`, payload);
+  if (referenceType === 'comment') {
+    return createCommentReport({ client, referenceId });
+  }
 
-  return !!payload;
+  return false;
 };

package/src/report/api/deleteReport.ts

@@ -3,9 +3,94 @@ import { getActiveClient } from '~/client/api/activeClient';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
 import { fireEvent } from '~/core/events';
-import { prepareMembershipPayload } from '~/group/utils';
 import { prepareMessagePayload } from '~/messageRepository/utils';
-import REFERENCE_TYPES from '../constants/referenceTypes';
+import { preparePostPayload } from '~/postRepository/utils/payload';
+import { prepareUserPayload } from '~/userRepository/utils';
+import { prepareCommentPayload } from '~/commentRepository/utils/payload';
+
+const deleteMessageReport = async ({
+  client,
+  referenceId,
+}: {
+  client: Amity.Client;
+  referenceId: string;
+}) => {
+  const { data: payload } = await client.http.delete<Amity.MessagePayload>(
+    `/api/v5/messages/${encodeURIComponent(referenceId)}/flags`,
+  );
+
+  if (client.cache) {
+    const messagePayload = await prepareMessagePayload(payload as Amity.MessagePayload);
+    ingestInCache(messagePayload);
+  }
+
+  fireEvent(`message.unflagged`, payload);
+
+  return !!payload;
+};
+
+const deletePostReport = async ({
+  client,
+  referenceId,
+}: {
+  client: Amity.Client;
+  referenceId: string;
+}) => {
+  const { data: payload } = await client.http.delete<Amity.PostPayload>(
+    `/api/v3/post/${encodeURIComponent(referenceId)}/flag`,
+  );
+
+  if (client.cache) {
+    const postPayload = await preparePostPayload(payload);
+    ingestInCache(postPayload);
+  }
+
+  fireEvent(`post.unflagged`, payload);
+
+  return !!payload;
+};
+
+const deleteUserReport = async ({
+  client,
+  referenceId,
+}: {
+  client: Amity.Client;
+  referenceId: string;
+}) => {
+  const { data: payload } = await client.http.delete<Amity.UserPayload>(
+    `/api/v4/me/flags/${encodeURIComponent(referenceId)}`,
+  );
+
+  if (client.cache) {
+    const userPayload = await prepareUserPayload(payload);
+    ingestInCache(userPayload);
+  }
+
+  fireEvent(`user.unflagged`, payload);
+
+  return !!payload;
+};
+
+const deleteCommentReport = async ({
+  client,
+  referenceId,
+}: {
+  client: Amity.Client;
+  referenceId: string;
+}) => {
+  const { data: payload } = await client.http.delete<Amity.CommentPayload>(
+    `/api/v3/comment/${encodeURIComponent(referenceId)}/flag`,
+  );
+
+  if (client.cache) {
+    const commentPayload = await prepareCommentPayload(payload);
+    ingestInCache(commentPayload);
+  }
+
+  fireEvent(`comment.unflagged`, payload);
+
+  return !!payload;
+};
 
 /**
  * ```js
@@ -21,43 +106,27 @@ import REFERENCE_TYPES from '../constants/referenceTypes';
  * @async
  * */
 export const deleteReport = async (
-  referenceType: keyof typeof REFERENCE_TYPES,
+  referenceType: 'user' | 'message' | 'post' | 'comment',
   referenceId: string,
 ): Promise<boolean> => {
   const client = getActiveClient();
   client.log('report/deleteReport', { referenceType, referenceId });
 
-  const getAPIUrl = (): string => {
-    if (referenceType === 'user') {
-      return `/api/v4/me/flags/${encodeURIComponent(referenceId)}`;
-    }
-
-    if (referenceType === 'message') {
-      return `/api/v5/messages/${encodeURIComponent(referenceId)}/flags`;
-    }
-
-    const { domainName } = REFERENCE_TYPES[referenceType];
-
-    return `/api/v3/${domainName}/${encodeURIComponent(referenceId)}/unflag`;
-  };
+  if (referenceType === 'user') {
+    return deleteUserReport({ client, referenceId });
+  }
 
-  const { data: payload } = await client.http.delete<
-    Amity.PostPayload | Amity.CommentPayload | Amity.ProcessedMessagePayload | Amity.UserPayload
-  >(getAPIUrl());
+  if (referenceType === 'message') {
+    return deleteMessageReport({ client, referenceId });
+  }
 
-  if (client.cache) {
-    if (referenceType === 'message') {
-      const messagePayload = await prepareMessagePayload(payload as Amity.MessagePayload);
-      ingestInCache(messagePayload);
-    } else if (referenceType === 'post') {
-      ingestInCache(prepareMembershipPayload(payload as Amity.PostPayload, 'communityUsers'));
-    } else {
-      ingestInCache(payload as Amity.CommentPayload | Amity.UserPayload);
-    }
+  if (referenceType === 'post') {
+    return deletePostReport({ client, referenceId });
   }
 
-  // @ts-ignore
-  fireEvent(`${referenceType}.unflagged`, payload);
+  if (referenceType === 'comment') {
+    return deleteCommentReport({ client, referenceId });
+  }
 
-  return !!payload;
+  return false;
 };

package/src/report/api/isReportedByMe.ts

@@ -1,5 +1,64 @@
 import { getActiveClient } from '~/client/api/activeClient';
-import REFERENCE_TYPES from '../constants/referenceTypes';
+
+type ResponseData = { result?: boolean; isFlagByMe?: boolean };
+
+const getMessageReport = async ({
+  client,
+  referenceId,
+}: {
+  client: Amity.Client;
+  referenceId: string;
+}) => {
+  const { data } = await client.http.get<ResponseData>(
+    `/api/v5/messages/${encodeURIComponent(referenceId)}/flags`,
+  );
+
+  const { result, isFlagByMe } = data ?? {};
+
+  return result ?? isFlagByMe ?? false;
+};
+
+const getPostReport = async ({
+  client,
+  referenceId,
+}: {
+  client: Amity.Client;
+  referenceId: string;
+}) => {
+  const { data } = await client.http.get<ResponseData>(`/api/v3/user/${referenceId}/isflagbyme`);
+
+  const { result, isFlagByMe } = data ?? {};
+
+  return result ?? isFlagByMe ?? false;
+};
+
+const getUserReport = async ({
+  client,
+  referenceId,
+}: {
+  client: Amity.Client;
+  referenceId: string;
+}) => {
+  const { data } = await client.http.get<ResponseData>(`/api/v3/user/${referenceId}/isflagbyme`);
+
+  const { result, isFlagByMe } = data ?? {};
+
+  return result ?? isFlagByMe ?? false;
+};
+
+const getCommentReport = async ({
+  client,
+  referenceId,
+}: {
+  client: Amity.Client;
+  referenceId: string;
+}) => {
+  const { data } = await client.http.get<ResponseData>(`/api/v3/comment/${referenceId}/isflagbyme`);
+
+  const { result, isFlagByMe } = data ?? {};
+
+  return result ?? isFlagByMe ?? false;
+};
 
 /**
  * ```js
@@ -15,25 +74,27 @@ import REFERENCE_TYPES from '../constants/referenceTypes';
  * @async
  * */
 export const isReportedByMe = async (
-  referenceType: keyof typeof REFERENCE_TYPES,
+  referenceType: 'user' | 'message' | 'post' | 'comment',
   referenceId: string,
 ): Promise<boolean> => {
   const client = getActiveClient();
   client.log('report/isReportedByMe', { referenceType, referenceId });
 
-  const { domainName } = REFERENCE_TYPES[referenceType];
+  if (referenceType === 'user') {
+    return getUserReport({ client, referenceId });
+  }
 
   if (referenceType === 'message') {
-    const { data } = await client.http.get<{ result: boolean }>(
-      `/api/v5/messages/${encodeURIComponent(referenceId)}/flags`,
-    );
-
-    return data.result;
+    return getMessageReport({ client, referenceId });
   }
 
-  const { data } = await client.http.get(`/api/v3/${domainName}/${referenceId}/isflagbyme`);
+  if (referenceType === 'post') {
+    return getPostReport({ client, referenceId });
+  }
 
-  const { result, isFlagByMe } = data ?? {};
+  if (referenceType === 'comment') {
+    return getCommentReport({ client, referenceId });
+  }
 
-  return result ?? isFlagByMe ?? false;
+  return false;
 };

package/src/userRepository/api/flagUser.ts

@@ -2,6 +2,7 @@ import { getActiveClient } from '~/client/api/activeClient';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
+import { prepareUserPayload } from '../utils';
 
 /* begin_public_function
   id: user.flag
@@ -22,15 +23,17 @@ export const flagUser = async (userId: Amity.User['userId']): Promise<boolean> =
   const client = getActiveClient();
   client.log('user/flagUser', userId);
 
-  const { data: payload } = await client.http.post<Amity.UserPayload>(
+  const { data } = await client.http.post<Amity.UserPayload>(
     `api/v4/me/flags/${encodeURIComponent(userId)}`,
   );
 
+  const payload = prepareUserPayload(data);
+
   if (client.cache) {
     ingestInCache(payload);
   }
 
-  fireEvent('user.flagged', payload);
+  fireEvent('user.flagged', data);
 
   return !!payload;
 };

package/src/userRepository/api/getUser.ts

@@ -1,13 +1,5 @@
-import { getActiveClient } from '~/client/api';
-
-import { pullFromCache } from '~/cache/api';
-import { ingestInCache } from '~/cache/api/ingestInCache';
-import { fireEvent } from '~/core/events';
-
-import { isInTombstone } from '~/cache/api/isInTombstone';
-import { checkIfShouldGoesToTombstone } from '~/cache/utils';
-import { pushToTombstone } from '~/cache/api/pushToTombstone';
 import { LinkedObject } from '~/utils/linkedObject';
+import { getUser as getUserInternal } from '../internalApi/getUser';
 
 /**
  * ```js
@@ -24,36 +16,10 @@ import { LinkedObject } from '~/utils/linkedObject';
  * @async
  */
 export const getUser = async (userId: Amity.User['userId']): Promise<Amity.Cached<Amity.User>> => {
-  const client = getActiveClient();
-  client.log('user/getUser', userId);
-
-  isInTombstone('user', userId);
-
-  let data: Amity.UserPayload;
-
-  try {
-    const response = await client.http.get<Amity.UserPayload>(
-      `/api/v3/users/${encodeURIComponent(userId)}`,
-    );
-
-    data = response.data;
-  } catch (error) {
-    if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
-      pushToTombstone('user', userId);
-    }
-
-    throw error;
-  }
-
-  const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(data, { cachedAt });
-
-  const { users } = data;
-
-  fireEvent('user.fetched', data);
+  const { data, cachedAt } = await getUserInternal(userId);
 
   return {
-    data: LinkedObject.user(users.find(user => user.userId === userId)!),
+    data: LinkedObject.user(data),
     cachedAt,
   };
 };
@@ -72,12 +38,7 @@ export const getUser = async (userId: Amity.User['userId']): Promise<Amity.Cache
  * @category User API
  */
 getUser.locally = (userId: Amity.User['userId']): Amity.Cached<Amity.User> | undefined => {
-  const client = getActiveClient();
-  client.log('user/getUser.locally', userId);
-
-  if (!client.cache) return;
-
-  const cached = pullFromCache<Amity.InternalUser>(['user', 'get', userId]);
+  const cached = getUserInternal.locally(userId);
 
   if (!cached) return;
 

package/src/userRepository/api/getUserByIds.ts

@@ -4,6 +4,7 @@ import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
 import { LinkedObject } from '~/utils/linkedObject';
+import { prepareUserPayload } from '../utils';
 
 /* begin_public_function
   id: user.get_by_ids
@@ -35,13 +36,15 @@ export const getUserByIds = async (
     params: { userIds: encodedUserIds },
   });
 
+  const payload = prepareUserPayload(data);
+
   const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(data, { cachedAt });
+  if (client.cache) ingestInCache(payload, { cachedAt });
 
   fireEvent('user.fetched', data);
 
   return {
-    data: data.users.map(user => LinkedObject.user(user)),
+    data: payload.users.map(user => LinkedObject.user(user)),
     cachedAt,
   };
 };