@amityco/ts-sdk 0.0.1 → 6.0.0

package/src/report/api/deleteReport.ts

@@ -1,11 +1,15 @@
-import { getActiveClient } from '~/client/api/activeClient'
+import { getActiveClient } from '~/client/api/activeClient';
 
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
-import REFERENCE_TYPES from '../constants/referenceTypes'
-import { fireEvent } from '~/core/events'
+import { fireEvent } from '~/core/events';
+import { prepareMembershipPayload } from '~/group/utils';
+import { prepareMessagePayload } from '~/message/utils';
+import REFERENCE_TYPES from '../constants/referenceTypes';
 
+/* begin_public_function
+  id: user.unflag, message.unflag, post.unflag, comment.unflag
+*/
 /**
  * ```js
  * import { deleteReport } from '@amityco/ts-sdk'
@@ -18,23 +22,46 @@ import { fireEvent } from '~/core/events'
  *
  * @category Report API
  * @async
- **/
+ * */
 export const deleteReport = async (
   referenceType: keyof typeof REFERENCE_TYPES,
-  referenceId: string
-) => {
-  const client = getActiveClient()
-  client.log('report/deleteReport', { referenceType, referenceId })
+  referenceId: string,
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('report/deleteReport', { referenceType, referenceId });
 
-  const { domainName } = REFERENCE_TYPES[referenceType]
+  const getAPIUrl = (): string => {
+    if (referenceType === 'user') {
+      return `/api/v4/me/flags/${encodeURIComponent(referenceId)}`;
+    }
 
-  const { data } = await client.http.delete<Amity.PostPayload | Amity.CommentPayload | Amity.MessagePayload | Amity.UserPayload>(
-    `/api/v3/${domainName}/${referenceId}/unflag`
-  )
+    if (referenceType === 'message') {
+      return `/api/v5/messages/${encodeURIComponent(referenceId)}/flags`;
+    }
 
-  decoratePayload(data)
-  ingestInCache(data)
-  fireEvent(`v3.${referenceType}.didUpdate`, data)
+    const { domainName } = REFERENCE_TYPES[referenceType];
 
-  return !!data
-}
+    return `/api/v3/${domainName}/${encodeURIComponent(referenceId)}/unflag`;
+  };
+
+  const { data: payload } = await client.http.delete<
+    Amity.PostPayload | Amity.CommentPayload | Amity.ProcessedMessagePayload | Amity.UserPayload
+  >(getAPIUrl());
+
+  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);
+    }
+  }
+
+  // @ts-ignore
+  fireEvent(`${referenceType}.unflagged`, payload);
+
+  return !!payload;
+};
+/* end_public_function */

package/src/report/api/index.ts

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

package/src/report/api/isReportedByMe.ts

@@ -1,8 +1,10 @@
-import { getActiveClient } from '~/client/api/activeClient'
-import { synchronousWSCall } from '~/core/transports'
-
-import REFERENCE_TYPES from '../constants/referenceTypes'
+import { getActiveClient } from '~/client/api/activeClient';
+import { synchronousWSCall } from '~/core/transports';
+import REFERENCE_TYPES from '../constants/referenceTypes';
 
+/* begin_public_function
+  id: user.check_flag_by_me, message.check_flag_by_me, post.check_flag_by_me, comment.check_flag_by_me
+*/
 /**
  * ```js
  * import { isReportedByMe } from '@amityco/ts-sdk'
@@ -15,23 +17,32 @@ import REFERENCE_TYPES from '../constants/referenceTypes'
  *
  * @category Report API
  * @async
- **/
+ * */
 export const isReportedByMe = async (
   referenceType: keyof typeof REFERENCE_TYPES,
-  referenceId: string
-) => {
-  const client = getActiveClient()
-  client.log('report/isReportedByMe', { referenceType, referenceId })
+  referenceId: string,
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('report/isReportedByMe', { referenceType, referenceId });
+
+  const { eventName, primaryKey } = REFERENCE_TYPES[referenceType];
+
+  if (referenceType === 'message') {
+    const { data } = await client.http.get<{ result: boolean }>(
+      `/api/v5/messages/${encodeURIComponent(referenceId)}/flags`,
+    );
 
-  const { eventName, primaryKey } = REFERENCE_TYPES[referenceType]
+    return data.result;
+  }
 
   const { result, isFlagByMe } =
     (await synchronousWSCall<{
-      result?: boolean
-      isFlagByMe?: boolean
+      result?: boolean;
+      isFlagByMe?: boolean;
     }>(client, eventName, {
       [primaryKey]: referenceId,
-    })) ?? {}
+    })) ?? {};
 
-  return result ?? isFlagByMe ?? false
-}
+  return result ?? isFlagByMe ?? false;
+};
+/* end_public_function */

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

@@ -0,0 +1,93 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  flaggedUser,
+  flaggedUserQueryResponse,
+} from '~/utils/tests';
+import { ASCApiError } from '~/core/errors';
+
+import { onUserFlagged } from '~/user/events';
+
+import { createReport } from '..';
+import REFERENCE_TYPES from '../../constants/referenceTypes';
+
+describe('createReport', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  // integration_test_id: ca4a760f-4342-4a99-9f3c-6c17cd205ca6
+  test('it should flag user with userId', async () => {
+    const expected = true;
+    client.http.post = jest.fn().mockResolvedValue(flaggedUserQueryResponse);
+
+    const received = await createReport('user', flaggedUser.userId);
+
+    expect(received).toBe(expected);
+  });
+
+  // integration_test_id: e8d0f02c-3558-488f-bdae-e70835d8cefb
+  test('it should throw error with 400400 when sending invalid userId', async () => {
+    client.http.post = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('unauthorized', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(createReport('user', flaggedUser.userId)).rejects.toThrow('400400');
+  });
+
+  test('it should fire event for user', async () => {
+    let dispose;
+    const expected = flaggedUser;
+
+    client.http.post = jest.fn().mockResolvedValue(flaggedUserQueryResponse);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onUserFlagged(resolve);
+    }).finally(dispose);
+
+    const recieved = await createReport('user', flaggedUser.userId);
+
+    expect(recieved).toBe(true);
+    await expect(callbackPromise).resolves.toEqual(expect.objectContaining(expected));
+  });
+
+  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][] = [
+    ['user', 'userId', `/api/v4/me/flags/${encodeURIComponent('userId')}`],
+    ['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);
+    },
+  );
+
+  test('it should add data to cache', async () => {
+    enableCache();
+    const expected = flaggedUser;
+    client.http.post = jest.fn().mockResolvedValue(flaggedUserQueryResponse);
+
+    await createReport('user', flaggedUser.userId);
+    const recieved = pullFromCache(['user', 'get', flaggedUser.userId]);
+
+    expect(recieved?.data).toBe(expected);
+
+    disableCache();
+  });
+});

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

@@ -0,0 +1,93 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  flaggedUser as unflaggedUser,
+  flaggedUserQueryResponse as unflaggedUserQueryResponse,
+} from '~/utils/tests';
+import { ASCApiError } from '~/core/errors';
+
+import { onUserUnflagged } from '~/user/events';
+
+import { deleteReport } from '..';
+import REFERENCE_TYPES from '../../constants/referenceTypes';
+
+describe('deleteReport', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  // integration_test_id: fddf1d63-98e2-4296-ab3a-4e2b55044f89
+  test('it should unflag user with userId', async () => {
+    const expected = true;
+    client.http.delete = jest.fn().mockResolvedValue(unflaggedUserQueryResponse);
+
+    const received = await deleteReport('user', unflaggedUser.userId);
+
+    expect(received).toBe(expected);
+  });
+
+  // integration_test_id: a95a0784-56ce-4b17-ac1b-0f1c50a361ef
+  test('it should throw error with 400400 when sending invalid userId', async () => {
+    client.http.delete = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('unauthorized', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(deleteReport('user', unflaggedUser.userId)).rejects.toThrow('400400');
+  });
+
+  test('it should fire event for user', async () => {
+    let dispose;
+    const expected = unflaggedUser;
+
+    client.http.delete = jest.fn().mockResolvedValue(unflaggedUserQueryResponse);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onUserUnflagged(resolve);
+    }).finally(dispose);
+
+    const recieved = await deleteReport('user', unflaggedUser.userId);
+
+    expect(recieved).toBe(true);
+    await expect(callbackPromise).resolves.toEqual(expect.objectContaining(expected));
+  });
+
+  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][] = [
+    ['user', 'userId', `/api/v4/me/flags/${encodeURIComponent('userId')}`],
+    ['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);
+    },
+  );
+
+  test('it should add data to cache', async () => {
+    enableCache();
+    const expected = unflaggedUser;
+    client.http.delete = jest.fn().mockResolvedValue(unflaggedUserQueryResponse);
+
+    await deleteReport('user', unflaggedUser.userId);
+    const recieved = pullFromCache(['user', 'get', unflaggedUser.userId]);
+
+    expect(recieved?.data).toBe(expected);
+
+    disableCache();
+  });
+});

package/src/report/constants/referenceTypes.ts

@@ -19,4 +19,4 @@ export default {
     eventName: 'user.isFlagByMe',
     primaryKey: 'userId',
   },
-}
+};

package/src/role/api/getRole.ts

@@ -1,7 +1,7 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { ingestInCache, pullFromCache } from '~/core/cache'
-import { decorateModels } from '~/core/query'
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
@@ -17,19 +17,20 @@ import { decorateModels } from '~/core/query'
  * @category Role API
  * @async
  */
-export const getRole = async (roleId: Amity.Role['roleId']) => {
-  const client = getActiveClient()
-  client.log('role/getRole', roleId)
+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 { data } = await client.http.get<Amity.Role[]>(`/api/v3/roles/${roleId}`);
 
-  decorateModels(data)
-  ingestInCache({ roles: data })
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache({ roles: data }, { cachedAt });
 
-  return data.find(role => role.roleId === roleId)!
-}
+  return {
+    data: data.find(role => role.roleId === roleId)!,
+    cachedAt,
+  };
+};
 
 /**
  * ```js
@@ -44,10 +45,18 @@ export const getRole = async (roleId: Amity.Role['roleId']) => {
  *
  * @category Role API
  */
-getRole.locally = (roleId: Amity.Role['roleId']) => {
-  const client = getActiveClient()
-  client.log('role/getRole.locally', roleId)
+getRole.locally = (roleId: Amity.Role['roleId']): Amity.Cached<Amity.Role> | undefined => {
+  const client = getActiveClient();
+  client.log('role/getRole.locally', roleId);
 
-  const [role] = pullFromCache('role', roleId) ?? []
-  return role
-}
+  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

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

package/src/role/api/queryRoles.ts

@@ -1,8 +1,7 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { decoratePayload, toPage, toToken } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
-import { toRecord } from '~/core/model'
+import { toPage, toToken } from '~/core/query';
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
@@ -20,42 +19,38 @@ import { toRecord } from '~/core/model'
  * @async
  */
 export const queryRoles = async (query?: {
-  displayName?: Amity.Role['displayName']
-  sortBy?: 'displayName' | 'firstCreated' | 'lastCreated'
-  page?: Amity.Page
-}) => {
-  const client = getActiveClient()
-  client.log('role/queryRoles', query)
+  displayName?: Amity.Role['displayName'];
+  sortBy?: 'displayName' | 'firstCreated' | 'lastCreated';
+  page?: Amity.Page;
+}): Promise<Amity.Cached<Amity.Paged<Amity.Role>>> => {
+  const client = getActiveClient();
+  client.log('role/queryRoles', query);
 
-  const { page, displayName, sortBy, ...params } = query ?? {}
+  const { page = { limit: 10 }, displayName, sortBy, ...params } = query ?? {};
 
   // 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: {
-          token: toToken(page, 'skiplimit'),
-        },
+  const { data } = await client.http.get<Amity.RolePayload & Amity.Pagination>(`/api/v3/roles`, {
+    params: {
+      ...params,
+      keyword: displayName,
+      sortBy,
+      options: {
+        token: toToken(page, 'skiplimit'),
       },
-    }
-  )
+    },
+  });
 
-  // unpacking
-  const { paging, ...response } = data
+  const { paging, ...payload } = data;
+  const { roles } = payload;
 
-  decoratePayload(response as unknown as Record<string, any[]>)
-  ingestInCache(response as unknown as Record<string, any[]>)
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(payload as Amity.RolePayload, { cachedAt });
 
-  const prevPage = toPage(paging.previous)
-  const nextPage = toPage(paging.next)
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
 
-  const { roles } = response
-  return { data: toRecord(roles), prevPage, nextPage }
-}
+  return { data: roles, cachedAt, prevPage, nextPage };
+};
 
 /**
  * ```js
@@ -72,8 +67,8 @@ export const queryRoles = async (query?: {
  * @category Role API
  */
 queryRoles.locally = (query: Parameters<typeof queryRoles>[0]) => {
-  const client = getActiveClient()
-  client.log('role/queryRoles.locally', query)
+  const client = getActiveClient();
+  client.log('role/queryRoles.locally', query);
 
   // TODO
-}
+};

package/src/stream/api/createStream.ts

@@ -1,8 +1,10 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
+/* begin_public_function
+  id: stream.create
+*/
 /**
  * ```js
  * import { createStream } from '@amityco/ts-sdk'
@@ -18,18 +20,21 @@ import { ingestInCache } from '~/core/cache'
  * @async
  */
 export const createStream = async (
-  bundle: Pick<Amity.Stream, 'title' | 'thumbnailFileId' | 'description'> & { isSecure?: boolean }
-) => {
-  const client = getActiveClient()
-  client.log('stream/createStream', bundle)
+  bundle: Pick<Amity.Stream, 'title' | 'thumbnailFileId' | 'description'> & { isSecure?: boolean },
+): Promise<Amity.Cached<Amity.Stream>> => {
+  const client = getActiveClient();
+  client.log('stream/createStream', bundle);
 
-  const { data } = await client.http.post<Amity.StreamPayload>(
-    '/api/v3/video-streaming', bundle,
-  )
+  const { data } = await client.http.post<Amity.StreamPayload>('/api/v3/video-streaming', bundle);
 
-  decoratePayload(data)
-  ingestInCache(data)
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
 
-  const { videoStreamings } = data
-  return videoStreamings[0]!
-}
+  const { videoStreamings } = data;
+
+  return {
+    data: videoStreamings[0],
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/stream/api/deleteStream.ts

@@ -1,7 +1,14 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
+
+import { upsertInCache } from '~/cache/api';
+
+import { getStream } from './getStream';
 
 // import { unwrapPayload } from '~/core/transports'
 
+/* begin_public_function
+  id: stream.delete
+*/
 /**
  * ```js
  * import { deleteStream } from '@amityco/ts-sdk'
@@ -16,19 +23,22 @@ import { getActiveClient } from '~/client/api'
  * @category Stream API
  * @async
  */
-export const deleteStream = async (
-  streamId: Amity.Stream['streamId'],
-) => {
-  const client = getActiveClient()
-  client.log('stream/deleteStream', streamId)
+export const deleteStream = async (streamId: Amity.Stream['streamId']): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('stream/deleteStream', streamId);
+
+  const stream = await getStream(streamId);
 
   // API-FIX: it returns { success: boolean } but seems it should be Amity.Response<{ success: boolean }
   // API-FIX: swagger docs are wrong!
   const { data } = await client.http.delete<{ success: boolean }>(
-    `/api/v3/video-streaming/${streamId}`
-  )
+    `/api/v3/video-streaming/${streamId}`,
+  );
+
+  const { success } = data; // unwrapPayload(data)
+  const deleted = { ...stream.data, isDeleted: true };
 
-  const { success } = data // unwrapPayload(data)
+  upsertInCache(['stream', 'get', streamId], deleted);
 
-  return success
-}
+  return success;
+};

package/src/stream/api/disposeStream.ts

@@ -1,6 +1,6 @@
-import { getActiveClient } from '~/client/api'
-import { ingestInCache } from '~/core/cache'
-import { decoratePayload } from '~/core/query'
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
@@ -19,17 +19,21 @@ import { decoratePayload } from '~/core/query'
  */
 export const disposeStream = async (
   streamId: Amity.Stream['streamId'],
-) => {
-  const client = getActiveClient()
-  client.log('stream/disposeStream', streamId)
+): Promise<Amity.Cached<Amity.Stream>> => {
+  const client = getActiveClient();
+  client.log('stream/disposeStream', streamId);
 
   const { data } = await client.http.delete<Amity.StreamPayload>(
-    `/api/v3/video-streaming/${streamId}/streaming-url`
-  )
+    `/api/v3/video-streaming/${streamId}/streaming-url`,
+  );
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
 
-  decoratePayload(data)
-  ingestInCache(data)
+  const { videoStreamings } = data;
 
-  const { videoStreamings } = data
-  return videoStreamings.find(stream => stream.streamId === streamId)!
-}
+  return {
+    data: videoStreamings.find(stream => stream.streamId === streamId)!,
+    cachedAt,
+  };
+};