@amityco/ts-sdk 7.10.1-86aa7706.0 → 7.10.1-9fe9d33d.0

package/src/report/api/deleteReport.ts

@@ -0,0 +1,132 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { fireEvent } from '~/core/events';
+import { prepareMessagePayload } from '~/messageRepository/utils';
+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/posts/${encodeURIComponent(referenceId)}/unflag`,
+  );
+
+  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/comments/${encodeURIComponent(referenceId)}/unflag`,
+  );
+
+  if (client.cache) {
+    const commentPayload = await prepareCommentPayload(payload);
+    ingestInCache(commentPayload);
+  }
+
+  fireEvent(`comment.unflagged`, payload);
+
+  return !!payload;
+};
+
+/**
+ * ```js
+ * import { deleteReport } from '@amityco/ts-sdk'
+ * const unflagged = await deleteReport('post', postId)
+ * ```
+ *
+ * @param referenceType The type of thing to delete a report to, such as a post or a comment.
+ * @param referenceId The ID of the thing to delete a report to.
+ * @returns the deleted report result
+ *
+ * @category Report API
+ * @async
+ * */
+export const deleteReport = async (
+  referenceType: 'user' | 'message' | 'post' | 'comment',
+  referenceId: string,
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('report/deleteReport', { referenceType, referenceId });
+
+  if (referenceType === 'user') {
+    return deleteUserReport({ client, referenceId });
+  }
+
+  if (referenceType === 'message') {
+    return deleteMessageReport({ client, referenceId });
+  }
+
+  if (referenceType === 'post') {
+    return deletePostReport({ client, referenceId });
+  }
+
+  if (referenceType === 'comment') {
+    return deleteCommentReport({ client, referenceId });
+  }
+
+  return false;
+};

package/src/report/api/index.ts

@@ -0,0 +1,4 @@
+export * from './createReport';
+export * from './deleteReport';
+
+export * from './isReportedByMe';

package/src/report/api/isReportedByMe.ts

@@ -0,0 +1,102 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+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/posts/${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/users/${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/comments/${referenceId}/isflagbyme`,
+  );
+
+  const { result, isFlagByMe } = data ?? {};
+
+  return result ?? isFlagByMe ?? false;
+};
+
+/**
+ * ```js
+ * import { isReportedByMe } from '@amityco/ts-sdk'
+ * const isReported = await isReportedByMe('post', postId)
+ * ```
+ *
+ * @param referenceType The type of thing to check a report to, such as a post or a comment.
+ * @param referenceId The ID of the thing to check a report to.
+ * @returns `true` if the report is created by me, `false` if doesn't.
+ *
+ * @category Report API
+ * @async
+ * */
+export const isReportedByMe = async (
+  referenceType: 'user' | 'message' | 'post' | 'comment',
+  referenceId: string,
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('report/isReportedByMe', { referenceType, referenceId });
+
+  if (referenceType === 'user') {
+    return getUserReport({ client, referenceId });
+  }
+
+  if (referenceType === 'message') {
+    return getMessageReport({ client, referenceId });
+  }
+
+  if (referenceType === 'post') {
+    return getPostReport({ client, referenceId });
+  }
+
+  if (referenceType === 'comment') {
+    return getCommentReport({ client, referenceId });
+  }
+
+  return false;
+};

package/src/report/api/tests/createReport.test.ts

@@ -0,0 +1,34 @@
+import { disableCache } from '~/cache/api';
+import { client, connectClient, disconnectClient } from '~/utils/tests';
+
+import { createReport } from '..';
+import REFERENCE_TYPES from '../../constants/referenceTypes';
+
+describe('createReport', () => {
+  beforeEach(disableCache);
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test.todo('it should fire event for flagging message');
+  test.todo('it should fire event for flagging post');
+
+  const tests: [keyof typeof REFERENCE_TYPES, string, string][] = [
+    ['post', 'postId', `/api/v3/posts/${encodeURIComponent('postId')}/flag`],
+    ['message', 'messageId', `/api/v5/messages/${encodeURIComponent('messageId')}/flags`],
+  ];
+
+  test.each(tests)(
+    'it should call the appropriate api for %s',
+    async (referenceType, referenceId, expected) => {
+      const apimock = jest.fn();
+
+      client.http.post = apimock.mockResolvedValue({ data: {} });
+
+      await createReport(referenceType, referenceId);
+
+      const received = apimock.mock.lastCall[0];
+
+      expect(received).toBe(expected);
+    },
+  );
+});

package/src/report/api/tests/deleteReport.test.ts

@@ -0,0 +1,34 @@
+import { disableCache } from '~/cache/api';
+import { client, connectClient, disconnectClient } from '~/utils/tests';
+
+import { deleteReport } from '..';
+import REFERENCE_TYPES from '../../constants/referenceTypes';
+
+describe('deleteReport', () => {
+  beforeEach(disableCache);
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test.todo('it should fire event for unflagging message');
+  test.todo('it should fire event for unflagging delete');
+
+  const tests: [keyof typeof REFERENCE_TYPES, string, string][] = [
+    ['post', 'postId', `/api/v3/posts/${encodeURIComponent('postId')}/unflag`],
+    ['message', 'messageId', `/api/v5/messages/${encodeURIComponent('messageId')}/flags`],
+  ];
+
+  test.each(tests)(
+    'it should call the appropriate api for %s',
+    async (referenceType, referenceId, expected) => {
+      const apimock = jest.fn();
+
+      client.http.delete = apimock.mockResolvedValue({ data: {} });
+
+      await deleteReport(referenceType, referenceId);
+
+      const received = apimock.mock.lastCall[0];
+
+      expect(received).toBe(expected);
+    },
+  );
+});

package/src/report/constants/referenceTypes.ts

@@ -0,0 +1,22 @@
+export default {
+  post: {
+    domainName: 'posts',
+    eventName: 'v3/post.isflagbyme',
+    primaryKey: 'postId',
+  },
+  comment: {
+    domainName: 'comments',
+    eventName: 'v3/comment.isflagbyme',
+    primaryKey: 'commentId',
+  },
+  message: {
+    domainName: 'messages',
+    eventName: 'v3/message.isFlaggedByMe',
+    primaryKey: 'messageId',
+  },
+  user: {
+    domainName: 'users',
+    eventName: 'user.isFlagByMe',
+    primaryKey: 'userId',
+  },
+};

package/src/role/api/getRole.ts

@@ -0,0 +1,62 @@
+import { getActiveClient } from '~/client/api';
+
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { getRole } from '@amityco/ts-sdk'
+ * const role = await getRole('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Role} object
+ *
+ * @param roleId the ID of the {@link Amity.Role} to fetch
+ * @returns the associated {@link Amity.Role} object
+ *
+ * @category Role API
+ * @async
+ */
+export const getRole = async (roleId: Amity.Role['roleId']): Promise<Amity.Cached<Amity.Role>> => {
+  const client = getActiveClient();
+  client.log('role/getRole', roleId);
+
+  const { data } = await client.http.get<Amity.Role[]>(`/api/v3/roles/${roleId}`);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache({ roles: data }, { cachedAt });
+
+  return {
+    data: data.find(role => role.roleId === roleId)!,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { getRole } from '@amityco/ts-sdk'
+ * const role = getRole.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Role} object from cache
+ *
+ * @param roleId the ID of the {@link Amity.Role} to fetch
+ * @returns the associated {@link Amity.Role} object
+ *
+ * @category Role API
+ */
+getRole.locally = (roleId: Amity.Role['roleId']): Amity.Cached<Amity.Role> | undefined => {
+  const client = getActiveClient();
+  client.log('role/getRole.locally', roleId);
+
+  if (!client.cache) return;
+
+  const cached = pullFromCache<Amity.Role>(['role', 'get', roleId]);
+
+  if (!cached) return;
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  };
+};

package/src/role/api/index.ts

@@ -0,0 +1,2 @@
+export { queryRoles } from './queryRoles';
+export { getRole } from './getRole';

package/src/role/api/queryRoles.ts

@@ -0,0 +1,81 @@
+import { getActiveClient } from '~/client/api';
+
+import { toPage, toToken } from '~/core/query';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { queryRoles } from '@amityco/ts-sdk'
+ * const roles = await queryRoles()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Role} objects
+ * Search is performed by displayName such as `.startsWith(search)`
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Role} objects
+ *
+ * @category Role API
+ * @async
+ */
+export const queryRoles = async (query?: {
+  displayName?: Amity.Role['displayName'];
+  sortBy?: 'displayName' | 'firstCreated' | 'lastCreated';
+  limit?: number;
+  queryToken?: string;
+}): Promise<Amity.Cached<Amity.Paged<Amity.Role>> & Amity.Pagination> => {
+  const client = getActiveClient();
+  client.log('role/queryRoles', query);
+
+  const { limit = 10, queryToken, displayName, sortBy, ...params } = query ?? {};
+
+  const options = (() => {
+    if (queryToken) return { token: queryToken };
+
+    if (limit) return { limit };
+
+    return undefined;
+  })();
+
+  // API-FIX: parameters should be querystring.
+  const { data } = await client.http.get<Amity.RolePayload & Amity.Pagination>(`/api/v3/roles`, {
+    params: {
+      ...params,
+      keyword: displayName,
+      sortBy,
+      options,
+    },
+  });
+
+  const { paging, ...payload } = data;
+  const { roles } = payload;
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(payload as Amity.RolePayload, { cachedAt });
+
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
+
+  return { data: roles, cachedAt, prevPage, nextPage, paging };
+};
+
+/**
+ * ```js
+ * import { queryRoles } from '@amityco/ts-sdk'
+ * const roles = queryRoles.locally({ keyword: 'foo' })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Role} objects from cache
+ * Search is performed by displayName such as `.startsWith(search)`
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Role} objects
+ *
+ * @category Role API
+ */
+queryRoles.locally = (query: Parameters<typeof queryRoles>[0]) => {
+  const client = getActiveClient();
+  client.log('role/queryRoles.locally', query);
+
+  // TODO
+};

package/src/storyRepository/api/createImageStory.ts

@@ -0,0 +1,110 @@
+import { uploadImage } from '~/fileRepository';
+import { uuid } from '~/core/uuid';
+import { fireEvent } from '~/core/events';
+import { createOptimisticEvent } from '~/storyRepository/utils/createOptimisticEvent';
+import { LinkedObject } from '~/utils/linkedObject';
+import { pushToCache } from '~/cache/api';
+import { STORY_KEY_CACHE } from '~/storyRepository/constants';
+import { createStory } from '../internalApi/createStory';
+import { createOptimisticTarget } from '../utils/createOptimisticTarget';
+
+/**
+ * ```js
+ * import { StoryRepository } from '@amityco/ts-sdk'
+ * StoryRepository.createImageStory('community', 'communityId', formData, metadata, imageDisplayMode, items)
+ * ```
+ *
+ * Create a new image story
+ * @param targetType The type of the target
+ * @param targetId The id of the target
+ * @param formData The form data
+ * @param metadata The metadata
+ * @param imageDisplayMode The image display mode
+ * @param items The story items
+ * @returns The created story
+ */
+export const createImageStory = async (
+  targetType: Amity.InternalStory['targetType'],
+  targetId: Amity.InternalStory['targetId'],
+  formData: FormData,
+  metadata: Amity.Metadata = {},
+  imageDisplayMode: Amity.ImageDisplayMode = 'fit',
+  items: Amity.StoryItem[] = [],
+): Promise<Amity.Cached<Amity.Story | undefined>> => {
+  if (!formData.getAll('files').length) {
+    throw new Error('The formData object must have a `files` key.');
+  }
+
+  let payload: Amity.StoryCreatePayload = {
+    data: {
+      text: '', // Still not in used now
+      fileId: undefined,
+      fileData: null,
+      imageDisplayMode,
+    },
+    syncState: Amity.SyncState.Syncing,
+    referenceId: uuid(),
+    dataType: Amity.StoryDataType.Image,
+    items,
+    targetType,
+    targetId,
+    metadata,
+  };
+
+  const date = new Date();
+  pushToCache([STORY_KEY_CACHE.SYNC_STATE, targetId], Amity.SyncState.Syncing);
+
+  // Update local story expires time
+  pushToCache(
+    [STORY_KEY_CACHE.EXPIRE, targetId],
+    new Date(date.setFullYear(date.getFullYear() + 1)),
+  );
+
+  // Fire optimistic event
+  createOptimisticEvent({ payload, formData }, optimisticData => {
+    fireEvent('local.story.created', optimisticData);
+  });
+
+  try {
+    const { data } = await uploadImage(formData);
+
+    // @TODO: Need to implement retrying logic in a future
+    if (data.length === 0) throw new Error('Failed to upload image');
+    const { fileId } = data[0];
+
+    payload = {
+      ...payload,
+      data: {
+        ...payload.data,
+        fileId,
+      },
+    };
+
+    createOptimisticTarget({ targetId, targetType });
+
+    // Fire optimistic event - update fileId
+    createOptimisticEvent({ payload, formData }, optimisticData => {
+      fireEvent('local.story.created', optimisticData);
+    });
+
+    const result = await createStory(payload);
+    if (!result.data) return result;
+
+    return {
+      ...result,
+      data: LinkedObject.story(result.data),
+    };
+  } catch (error) {
+    pushToCache([STORY_KEY_CACHE.SYNC_STATE, targetId], Amity.SyncState.Error);
+
+    // Fire optimistic event - failed to upload image
+    createOptimisticEvent(
+      { payload: { ...payload, syncState: Amity.SyncState.Error }, formData },
+      optimisticData => {
+        fireEvent('local.story.error', optimisticData);
+      },
+    );
+
+    throw error;
+  }
+};

package/src/storyRepository/api/createVideoStory.ts

@@ -0,0 +1,108 @@
+import { uploadVideo } from '~/fileRepository';
+import { uuid } from '~/core/uuid';
+import { fireEvent } from '~/core/events';
+import { createOptimisticEvent } from '~/storyRepository/utils/createOptimisticEvent';
+import { ContentFeedType } from '~/@types';
+import { LinkedObject } from '~/utils/linkedObject';
+import { pushToCache } from '~/cache/api';
+import { STORY_KEY_CACHE } from '~/storyRepository/constants';
+import { createStory } from '../internalApi/createStory';
+import { createOptimisticTarget } from '../utils/createOptimisticTarget';
+
+/**
+ * ```js
+ * import { StoryRepository } from '@amityco/ts-sdk'
+ * StoryRepository.createVideoStory('community', 'communityId', formData, metadata, items)
+ * ```
+ *
+ * Create a new video story
+ * @param targetType
+ * @param targetId
+ * @param formData
+ * @param metadata
+ * @param items
+ */
+
+export const createVideoStory = async (
+  targetType: Amity.InternalStory['targetType'],
+  targetId: Amity.InternalStory['targetId'],
+  formData: FormData,
+  metadata: Amity.Metadata = {},
+  items: Amity.StoryItem[] = [],
+): Promise<Amity.Cached<Amity.Story | undefined>> => {
+  if (!formData.getAll('files').length)
+    throw new Error('The formData object must have a `files` key.');
+
+  let payload: Amity.StoryCreatePayload = {
+    data: {
+      text: '', // Still not in used now
+      fileId: undefined,
+      fileData: null,
+    },
+    syncState: Amity.SyncState.Syncing,
+    referenceId: uuid(),
+    dataType: Amity.StoryDataType.Video,
+    items,
+    targetType,
+    targetId,
+    metadata,
+  };
+
+  const date = new Date();
+  pushToCache([STORY_KEY_CACHE.SYNC_STATE, targetId], Amity.SyncState.Syncing);
+
+  // Update local story expires time
+  pushToCache(
+    [STORY_KEY_CACHE.EXPIRE, targetId],
+    new Date(date.setFullYear(date.getFullYear() + 1)),
+  );
+
+  createOptimisticTarget({ targetId, targetType });
+
+  // Fire optimistic event
+  createOptimisticEvent({ payload, formData, isVideo: true }, optimisticData => {
+    fireEvent('local.story.created', optimisticData);
+  });
+
+  try {
+    const { data } = await uploadVideo(formData, ContentFeedType.STORY);
+
+    // @TODO: Need to implement retrying logic in a future
+    if (data.length === 0) throw new Error('Failed to upload video');
+    const { fileId } = data[0];
+
+    payload = {
+      ...payload,
+      data: {
+        ...payload.data,
+        fileId,
+        videoFileId: { original: fileId },
+      },
+    };
+
+    // Fire optimistic event - update fileId
+    createOptimisticEvent({ payload, formData, isVideo: true }, optimisticData => {
+      fireEvent('local.story.created', optimisticData);
+    });
+
+    const result = await createStory(payload);
+    if (!result.data) return result;
+
+    return {
+      ...result,
+      data: LinkedObject.story(result.data),
+    };
+  } catch (error) {
+    pushToCache([STORY_KEY_CACHE.SYNC_STATE, targetId], Amity.SyncState.Error);
+
+    // Fire optimistic upload failed
+    createOptimisticEvent(
+      { payload: { ...payload, syncState: Amity.SyncState.Error }, formData, isVideo: true },
+      optimisticData => {
+        fireEvent('local.story.error', optimisticData);
+      },
+    );
+
+    throw error;
+  }
+};