@amityco/ts-sdk-react-native 6.29.3-669217e.0 → 6.30.0

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/prepareUserPayload';
+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 '~/userRepository/utils/prepareUserPayload';
 
 /* 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 '~/userRepository/utils/prepareUserPayload';
 
 /* 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,
   };
 };

package/src/userRepository/api/queryBlockedUsers.ts

@@ -3,6 +3,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 import { pullFromCache, pushToCache } from '~/cache/api';
 import { getResolver } from '~/core/model';
 import { toPageRaw } from '~/core/query';
+import { prepareUserPayload } from '~/userRepository/utils/prepareUserPayload';
 
 /**
  * ```js
@@ -41,23 +42,22 @@ export const queryBlockedUsers = async (
     params,
   });
 
-  const { paging, ...blockedUsers } = data;
-  const { users } = blockedUsers;
+  const payload = prepareUserPayload(data);
 
   const cachedAt = client.cache && Date.now();
 
   if (client.cache) {
-    ingestInCache(blockedUsers as Amity.UserPayload, { cachedAt });
+    ingestInCache(payload, { cachedAt });
 
     const cacheKey = ['blockedUsers', 'query', params as Amity.Serializable];
-    pushToCache(cacheKey, { users: users.map(getResolver('user')), paging });
+    pushToCache(cacheKey, { users: payload.users.map(getResolver('user')), paging: data.paging });
   }
 
-  const { next, previous, total } = paging;
+  const { next, previous, total } = data.paging;
   const nextPage = toPageRaw(next);
   const prevPage = toPageRaw(previous);
 
-  return { data: users, prevPage, nextPage, total, cachedAt };
+  return { data: payload.users, prevPage, nextPage, total, cachedAt };
 };
 
 /**

package/src/userRepository/api/queryUsers.ts

@@ -1,10 +1,5 @@
-import { getActiveClient } from '~/client/api';
-
-import { pullFromCache, pushToCache } from '~/cache/api';
-import { ingestInCache } from '~/cache/api/ingestInCache';
-import { getResolver } from '~/core/model';
-import { fireEvent } from '~/core/events';
 import { LinkedObject } from '~/utils/linkedObject';
+import { queryUsers as queryUsersInternal } from '../internalApi/queryUsers';
 
 /**
  * ```js
@@ -24,56 +19,10 @@ import { LinkedObject } from '~/utils/linkedObject';
 export const queryUsers = async (
   query: Amity.QueryUsers = {},
 ): Promise<Amity.Cached<Amity.PageToken<Amity.User>>> => {
-  const client = getActiveClient();
-  client.log('user/queryUsers', query);
-
-  const {
-    page,
-    limit = 10,
-    displayName,
-    filter = 'all',
-    sortBy = 'displayName',
-    ...params
-  } = query;
-
-  const { data } = await client.http.get<Amity.UserPayload & Amity.Pagination>(`/api/v3/users`, {
-    params: {
-      ...params,
-      keyword: displayName,
-      filter,
-      sortBy,
-      options: {
-        token: page,
-        limit,
-      },
-    },
-  });
-
-  // unpacking
-  const { paging, ...payload } = data;
-  const { users } = payload;
-
-  const cachedAt = client.cache && Date.now();
-
-  if (client.cache) {
-    ingestInCache(payload as Amity.UserPayload, { cachedAt });
-
-    /*
-     * using a query as a cache key over params because if the keyword, filter, sort
-     * change the API will NOT cache results, when it should
-     */
-    const cacheKey = [
-      'user',
-      'query',
-      { ...query, options: { limit, token: page } } as Amity.Serializable,
-    ];
-    pushToCache(cacheKey, { users: users.map(getResolver('user')), paging });
-  }
-
-  fireEvent('user.fetched', data);
+  const { cachedAt, data, paging } = await queryUsersInternal(query);
 
   return {
-    data: users.map(user => LinkedObject.user(user)),
+    data: data.map(user => LinkedObject.user(user)),
     cachedAt,
     paging,
   };
@@ -96,40 +45,15 @@ export const queryUsers = async (
 queryUsers.locally = (
   query: Parameters<typeof queryUsers>[0] = {},
 ): Amity.Cached<Amity.PageToken<Amity.User>> | undefined => {
-  const client = getActiveClient();
-  client.log('user/queryUsers.locally', query);
+  const cache = queryUsersInternal.locally(query);
 
-  if (!client.cache) return;
+  if (!cache) return;
 
-  const { limit = 10, page } = query ?? {};
+  const { cachedAt, data, paging } = cache;
 
-  const cacheKey = [
-    'user',
-    'query',
-    {
-      ...query,
-      options: {
-        limit,
-        token: page,
-      },
-    } as Amity.Serializable,
-  ];
-
-  const { data, cachedAt } =
-    pullFromCache<{ users: Pick<Amity.InternalUser, 'userId'>[] } & Amity.Pagination>(cacheKey) ??
-    {};
-
-  const users: Amity.InternalUser[] =
-    data?.users
-      .map(userId => pullFromCache<Amity.InternalUser>(['user', 'get', userId])!)
-      .filter(Boolean)
-      .map(({ data }) => data) ?? [];
-
-  return users.length > 0 && users.length === data?.users?.length
-    ? {
-        data: users.map(LinkedObject.user),
-        cachedAt,
-        paging: data?.paging,
-      }
-    : undefined;
+  return {
+    data: data.map(LinkedObject.user),
+    cachedAt,
+    paging,
+  };
 };

package/src/userRepository/api/unflagUser.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 '~/userRepository/utils/prepareUserPayload';
 
 /* begin_public_function
   id: user.unflag
@@ -22,15 +23,17 @@ export const unflagUser = async (userId: Amity.User['userId']): Promise<boolean>
   const client = getActiveClient();
   client.log('user/unflag', userId);
 
-  const { data: payload } = await client.http.delete<Amity.UserPayload>(
+  const { data } = await client.http.delete<Amity.UserPayload>(
     `/api/v4/me/flags/${encodeURIComponent(userId)}`,
   );
 
+  const payload = prepareUserPayload(data);
+
   if (client.cache) {
     ingestInCache(payload);
   }
 
-  fireEvent('user.unflagged', payload);
+  fireEvent('user.unflagged', data);
 
   return !!payload;
 };

package/src/userRepository/api/updateUser.ts

@@ -2,6 +2,7 @@ import { getActiveClient } from '~/client/api';
 
 import { fireEvent } from '~/core/events';
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareUserPayload } from '~/userRepository/utils/prepareUserPayload';
 
 /* begin_public_function
   id: client.update_user
@@ -31,28 +32,21 @@ export const updateUser = async (
   const client = getActiveClient();
   client.log('user/updateUser', userId, patch);
 
-  // API-FIX: Endpoint is malformed, userId should be a url param.
-  /*
-    const { data } = await client.http.put<Amity.Response<UserPayload>>(
-      `/api/v3/users/${userId}`, patch,
-    )
-  */
-
   const { data } = await client.http.put<Amity.UserPayload>(`/api/v3/users/`, {
     userId,
     ...patch,
     createNewUserWhenNotFound: false,
   });
 
-  const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(data, { cachedAt });
+  const payload = prepareUserPayload(data);
 
-  const { users } = data;
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(payload, { cachedAt });
 
   fireEvent('user.updated', data);
 
   return {
-    data: users.find(user => user.userId === userId)!,
+    data: payload.users.find(user => user.userId === userId)!,
     cachedAt,
   };
 };

package/src/userRepository/events/utils.ts

@@ -2,6 +2,7 @@ import { getActiveClient } from '~/client/api/activeClient';
 import { createEventSubscriber } from '~/core/events';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareUserPayload } from '../utils/prepareUserPayload';
 
 export const createUserEventSubscriber = (
   event: keyof Amity.MqttUserEvents,
@@ -9,7 +10,9 @@ export const createUserEventSubscriber = (
 ) => {
   const client = getActiveClient();
 
-  const filter = (payload: Amity.UserPayload) => {
+  const filter = (data: Amity.UserPayload) => {
+    const payload = prepareUserPayload(data);
+
     if (client.cache) {
       ingestInCache(payload);
     }

package/src/userRepository/internalApi/getUser.ts

@@ -7,6 +7,7 @@ import { fireEvent } from '~/core/events';
 import { isInTombstone } from '~/cache/api/isInTombstone';
 import { checkIfShouldGoesToTombstone } from '~/cache/utils';
 import { pushToTombstone } from '~/cache/api/pushToTombstone';
+import { prepareUserPayload } from '~/userRepository/utils/prepareUserPayload';
 
 /**
  * ```js
@@ -30,14 +31,21 @@ export const getUser = async (
 
   isInTombstone('user', userId);
 
-  let data: Amity.UserPayload;
-
   try {
-    const response = await client.http.get<Amity.UserPayload>(
+    const { data } = await client.http.get<Amity.UserPayload>(
       `/api/v3/users/${encodeURIComponent(userId)}`,
     );
 
-    data = response.data;
+    const cachedAt = client.cache && Date.now();
+    const payload = prepareUserPayload(data);
+    if (client.cache) ingestInCache(payload, { cachedAt });
+
+    fireEvent('user.fetched', data);
+
+    return {
+      data: payload.users.find(user => user.userId === userId)!,
+      cachedAt,
+    };
   } catch (error) {
     if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
       pushToTombstone('user', userId);
@@ -45,18 +53,6 @@ export const getUser = async (
 
     throw error;
   }
-
-  const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(data, { cachedAt });
-
-  const { users } = data;
-
-  fireEvent('user.fetched', data);
-
-  return {
-    data: users.find(user => user.userId === userId)!,
-    cachedAt,
-  };
 };
 
 /**