@amityco/ts-sdk 0.0.1-cb052d5.0 → 0.0.1-cb5cdb1.0

package/src/feed/api/test/queryGlobalFeed.test.ts

@@ -0,0 +1,138 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+
+import { client, post11, post12 } from '~/utils/tests';
+
+import { queryGlobalFeed } from '../queryGlobalFeed';
+
+const pagingToken = {
+  previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+  next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+};
+
+const postsToQuery = [post11, post12];
+const postIdsToQuery = postsToQuery.map(post => post.postId);
+const pagingCriteria = { limit: 10 };
+const queryCriteriaWithoutPage = { useCustomRanking: false };
+const queryCriteria = { ...queryCriteriaWithoutPage, page: pagingCriteria };
+
+const resolvedQueryFeedValue = {
+  data: {
+    posts: postsToQuery,
+    postChildren: [],
+    categories: [],
+    comments: [],
+    communityUsers: [],
+    feeds: [],
+    files: [],
+    polls: [],
+    users: [],
+    paging: pagingToken,
+  },
+};
+
+describe('queryGlobalFeed', () => {
+  test('should return fetched feed with correct paging', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedQueryFeedValue);
+
+    await expect(queryGlobalFeed(queryCriteria)).resolves.toEqual(
+      expect.objectContaining({
+        data: postsToQuery,
+        prevPage: { before: 55, limit: 10 },
+        nextPage: { before: 55, limit: 10 },
+      }),
+    );
+  });
+
+  test('should accept undefined query param', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedQueryFeedValue);
+
+    await expect(queryGlobalFeed()).resolves.not.toThrow();
+  });
+
+  test('should update cache after fetching feed', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(resolvedQueryFeedValue);
+
+    await queryGlobalFeed(queryCriteria);
+
+    const recieved = pullFromCache([
+      'globalFeed',
+      'query',
+      { ...queryCriteriaWithoutPage, options: pagingCriteria },
+    ])?.data;
+
+    expect(recieved).toEqual({
+      posts: postIdsToQuery,
+      paging: pagingToken,
+    });
+
+    disableCache();
+  });
+
+  test('should switch endpoint correctly according to the `useCustomRanking` condition', async () => {
+    expect.assertions(2);
+    const resolver = jest.fn().mockResolvedValue(resolvedQueryFeedValue);
+    client.http.get = resolver;
+
+    await queryGlobalFeed({ ...queryCriteria, useCustomRanking: true });
+
+    expect(resolver).toHaveBeenCalledWith(`/api/v5/me/global-feeds`, expect.any(Object));
+
+    await queryGlobalFeed({ ...queryCriteria, useCustomRanking: false });
+
+    expect(resolver).toHaveBeenCalledWith(`/api/v4/me/global-feeds`, expect.any(Object));
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(queryGlobalFeed(queryCriteria)).rejects.toThrow('error');
+  });
+});
+
+describe('queryGlobalFeed.locally', () => {
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  test('should return cached feed', () => {
+    postsToQuery.forEach(post => pushToCache(['post', 'get', post.postId], post));
+
+    pushToCache(['globalFeed', 'query', { ...queryCriteriaWithoutPage, options: pagingCriteria }], {
+      posts: postIdsToQuery,
+      paging: pagingToken,
+    });
+
+    expect(queryGlobalFeed.locally(queryCriteria)).toEqual(
+      expect.objectContaining({
+        data: postsToQuery,
+        prevPage: { before: 55, limit: 10 },
+        nextPage: { before: 55, limit: 10 },
+      }),
+    );
+  });
+
+  test('should accept undefined query param', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedQueryFeedValue);
+
+    expect(() => queryGlobalFeed.locally()).not.toThrow();
+  });
+
+  test(`shouldn't return if individual feed cache not exist`, () => {
+    pushToCache(['globalFeed', 'query', { ...queryCriteriaWithoutPage, options: pagingCriteria }], {
+      posts: postIdsToQuery,
+      paging: pagingToken,
+    });
+
+    expect(queryGlobalFeed.locally(queryCriteria)).toBeUndefined();
+  });
+
+  test('it should return undefined if feed not in cache', () => {
+    expect(queryGlobalFeed.locally({})).toBeUndefined();
+  });
+
+  test('it should return undefined if cache disabled', () => {
+    disableCache();
+
+    expect(queryGlobalFeed.locally({})).toBeUndefined();
+  });
+});

package/src/file/api/createFile.ts

@@ -2,6 +2,9 @@ import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+/* begin_public_function
+  id: file.upload.file
+*/
 /**
  * ```js
  * import { createFile } from '@amityco/ts-sdk'
@@ -34,7 +37,7 @@ export const createFile = async <T extends Amity.FileType = any>(
 
   const { data } = await client.http.post<Amity.CreateFilePayload<T>>('/api/v4/files', formData, {
     headers,
-    onUploadProgress({ loaded, total }) {
+    onUploadProgress({ loaded, total = 100 }) {
       onProgress && onProgress(Math.round((loaded * 100) / total));
     },
   });
@@ -50,5 +53,6 @@ export const createFile = async <T extends Amity.FileType = any>(
     cachedAt,
   };
 };
+/* end_public_function */
 
 // TODO: consider doing local creation with URL.createObjectURL()

package/src/file/api/createImage.ts

@@ -2,6 +2,9 @@ import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+/* begin_public_function
+  id: file.upload.image
+*/
 /**
  * ```js
  * import { createImage } from '@amityco/ts-sdk'
@@ -37,7 +40,7 @@ export const createImage = async (
     formData,
     {
       headers,
-      onUploadProgress({ loaded, total }) {
+      onUploadProgress({ loaded, total = 100 }) {
         onProgress && onProgress(Math.round((loaded * 100) / total));
       },
     },
@@ -54,5 +57,6 @@ export const createImage = async (
     cachedAt,
   };
 };
+/* end_public_function */
 
 // TODO: consider doing local creation with URL.createObjectURL()

package/src/file/api/createVideo.ts

@@ -2,6 +2,9 @@ import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+/* begin_public_function
+  id: file.upload.video
+*/
 /**
  * ```js
  * import { createVideo } from '@amityco/ts-sdk'
@@ -11,6 +14,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * Creates an {@link Amity.File<'video'>}
  *
  * @param formData The data necessary to create a new {@link Amity.File<'video'>}
+ * @param feedType The {@link Amity.File<'video'>} feed type
  * @param onProgress The callback to track the upload progress
  * @returns The newly created {@link Amity.File<'video'>}
  *
@@ -19,6 +23,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  */
 export const createVideo = async (
   formData: FormData,
+  feedType?: Amity.ContentFeedType,
   onProgress?: (percent: number) => void,
 ): Promise<Amity.Cached<Amity.File<'video'>[]>> => {
   const client = getActiveClient();
@@ -27,6 +32,10 @@ export const createVideo = async (
   if (!formData.getAll('files').length)
     throw new Error('The formData object must have a `files` key.');
 
+  if (feedType) {
+    formData.append('feedType', feedType);
+  }
+
   const headers =
     'getHeaders' in formData
       ? (formData as any).getHeaders()
@@ -37,7 +46,7 @@ export const createVideo = async (
     formData,
     {
       headers,
-      onUploadProgress({ loaded, total }) {
+      onUploadProgress({ loaded, total = 100 }) {
         onProgress && onProgress(Math.round((loaded * 100) / total));
       },
     },
@@ -54,5 +63,6 @@ export const createVideo = async (
     cachedAt,
   };
 };
+/* end_public_function */
 
 // TODO: consider doing local creation with URL.createObjectURL()

package/src/file/api/deleteFile.ts

@@ -2,6 +2,9 @@ import { getActiveClient } from '~/client/api';
 
 import { dropFromCache } from '~/cache/api';
 
+/* begin_public_function
+  id: file.delete
+*/
 /**
  * ```js
  * import { deleteFile } from '@amityco/ts-sdk'
@@ -29,3 +32,4 @@ export const deleteFile = async (
 
   return { success: true };
 };
+/* end_public_function */

package/src/file/api/getFile.ts

@@ -3,6 +3,9 @@ import { getActiveClient } from '~/client/api';
 import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+/* begin_public_function
+  id: file.get
+*/
 /**
  * ```js
  * import { getFile } from '@amityco/ts-sdk'
@@ -36,6 +39,7 @@ export const getFile = async <T extends Amity.FileType = any>(
     cachedAt,
   };
 };
+/* end_public_function */
 
 /**
  * ```js

package/src/file/api/test/createImage.test.ts

@@ -0,0 +1,69 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { client, file11, createEmptyFormData, createFileFormData } from '~/utils/tests';
+
+import { createImage } from '../createImage';
+
+const imageToCreate = [file11];
+const createIds = imageToCreate.map(({ fileId }) => fileId);
+const resolvedPayloadValue = { data: imageToCreate };
+
+describe('createImage', () => {
+  test('should return created image', async () => {
+    const formData = createFileFormData();
+    client.http.post = jest.fn().mockResolvedValue(resolvedPayloadValue);
+
+    const received = createImage(formData);
+
+    await expect(received).resolves.toEqual(expect.objectContaining({ data: imageToCreate }));
+  });
+
+  test('should throw an error if request fails', async () => {
+    const formData = createFileFormData();
+    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(createImage(formData)).rejects.toThrow('error');
+  });
+
+  test('should throw an error if formData is empty', async () => {
+    const emptyFormData = createEmptyFormData();
+
+    await expect(createImage(emptyFormData)).rejects.toThrow(
+      'The formData object must have a `files` key.',
+    );
+  });
+
+  test('should call onProgress params on upload progress updated', async () => {
+    expect.assertions(3);
+    const formData = createFileFormData();
+    const onProgress = jest.fn();
+
+    jest.spyOn(client.http, 'post').mockImplementationOnce(
+      (url, data, config) =>
+        new Promise((resolve, _reject) => {
+          config?.onUploadProgress?.({ loaded: 0, bytes: 0, total: 100 });
+          config?.onUploadProgress?.({ loaded: 40, bytes: 40, total: 100 });
+          config?.onUploadProgress?.({ loaded: 100, bytes: 100, total: 100 });
+          resolve(resolvedPayloadValue);
+        }),
+    );
+
+    await createImage(formData, onProgress);
+
+    expect(onProgress).toHaveBeenNthCalledWith(1, 0);
+    expect(onProgress).toHaveBeenNthCalledWith(2, 40);
+    expect(onProgress).toHaveBeenNthCalledWith(3, 100);
+  });
+
+  test('should create cache after created image', async () => {
+    enableCache();
+    const formData = createFileFormData();
+    client.http.post = jest.fn().mockResolvedValue(resolvedPayloadValue);
+
+    await createImage(formData);
+    const received = createIds.map(id => pullFromCache(['file', 'get', id])?.data);
+
+    expect(received).toEqual(expect.objectContaining(imageToCreate));
+
+    disableCache();
+  });
+});

package/src/file/api/test/createVideo.test.ts

@@ -0,0 +1,81 @@
+import { ContentFeedType } from '~/@types';
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { client, file12, createEmptyFormData, createFileFormData } from '~/utils/tests';
+
+import { createVideo } from '../createVideo';
+
+const videoToCreate = [file12];
+const createIds = videoToCreate.map(({ fileId }) => fileId);
+const resolvedPayloadValue = { data: videoToCreate };
+
+describe('createVideo', () => {
+  test('should return created video', async () => {
+    const formData = createFileFormData();
+    client.http.post = jest.fn().mockResolvedValue(resolvedPayloadValue);
+
+    const received = createVideo(formData);
+
+    await expect(received).resolves.toEqual(expect.objectContaining({ data: videoToCreate }));
+  });
+
+  test('should throw an error if request fails', async () => {
+    const formData = createFileFormData();
+    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(createVideo(formData)).rejects.toThrow('error');
+  });
+
+  test('should throw an error if formData is empty', async () => {
+    const emptyFormData = createEmptyFormData();
+
+    await expect(createVideo(emptyFormData)).rejects.toThrow(
+      'The formData object must have a `files` key.',
+    );
+  });
+
+  // There is currently no polyfill or native API for generating complete formData
+  // in Node.js, so I'll skip this until 100% browser-compatible formData can be created.
+  test.skip('should append feedType to formData when define feedType param', async () => {
+    const formData = createFileFormData();
+    client.http.post = jest.fn().mockResolvedValue(resolvedPayloadValue);
+
+    await createVideo(formData, ContentFeedType.POST);
+
+    expect(formData.get('feedType')).toEqual(ContentFeedType.POST);
+  });
+
+  test('should call onProgress params on upload progress updated', async () => {
+    expect.assertions(3);
+    const formData = createFileFormData();
+    const onProgress = jest.fn();
+
+    jest.spyOn(client.http, 'post').mockImplementationOnce(
+      (url, data, config) =>
+        new Promise((resolve, _reject) => {
+          config?.onUploadProgress?.({ loaded: 0, bytes: 0, total: 100 });
+          config?.onUploadProgress?.({ loaded: 40, bytes: 40, total: 100 });
+          config?.onUploadProgress?.({ loaded: 100, bytes: 100, total: 100 });
+          resolve(resolvedPayloadValue);
+        }),
+    );
+
+    await createVideo(formData, undefined, onProgress);
+
+    expect(onProgress).toHaveBeenNthCalledWith(1, 0);
+    expect(onProgress).toHaveBeenNthCalledWith(2, 40);
+    expect(onProgress).toHaveBeenNthCalledWith(3, 100);
+  });
+
+  test('should create cache after created video', async () => {
+    enableCache();
+    const formData = createFileFormData();
+    client.http.post = jest.fn().mockResolvedValue(resolvedPayloadValue);
+
+    await createVideo(formData);
+    const received = createIds.map(id => pullFromCache(['file', 'get', id])?.data);
+
+    expect(received).toEqual(expect.objectContaining(videoToCreate));
+
+    disableCache();
+  });
+});

package/src/follow/api/acceptFollower.ts

@@ -2,6 +2,9 @@ import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
 
+/* begin_public_function
+  id: user.relationship.accept_follow
+*/
 /**
  * ```js
  * import { acceptFollower } from '@amityco/ts-sdk'
@@ -28,7 +31,8 @@ export const acceptFollower = async (userId: Amity.User['userId']): Promise<bool
     ingestInCache(data);
   }
 
-  fireEvent('follow.accepted', data.follows[0]);
+  fireEvent('follow.accepted', data);
 
   return true;
 };
+/* end_public_function */

package/src/follow/api/declineFollower.ts

@@ -2,6 +2,9 @@ import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
 
+/* begin_public_function
+  id: user.relationship.decline_follow
+*/
 /**
  * ```js
  * import { declineFollower } from '@amityco/ts-sdk'
@@ -28,7 +31,8 @@ export const declineFollower = async (userId: Amity.User['userId']): Promise<boo
     ingestInCache(data);
   }
 
-  fireEvent('follow.requestDeclined', data.follows[0]);
+  fireEvent('follow.requestDeclined', data);
 
   return true;
 };
+/* end_public_function */

package/src/follow/api/follow.ts

@@ -2,6 +2,9 @@ import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
 
+/* begin_public_function
+  id: user.relationship.follow
+*/
 /**
  * ```js
  * import { follow } from '@amityco/ts-sdk'
@@ -32,13 +35,11 @@ export const follow = async (
     ingestInCache(data, { cachedAt });
   }
 
-  fireEvent(
-    data.follows[0].status === 'accepted' ? 'follow.created' : 'follow.requested',
-    data.follows[0],
-  );
+  fireEvent(data.follows[0].status === 'accepted' ? 'follow.created' : 'follow.requested', data);
 
   return {
     data: data.follows[0],
     cachedAt,
   };
 };
+/* end_public_function */

package/src/follow/api/getFollowInfo.ts

@@ -1,12 +1,9 @@
 import { getActiveClient } from '~/client/api';
 import { pullFromCache, pushToCache } from '~/cache/api';
 
-const getCacheKey = (userId: Amity.User['userId']) => [
-  'followInfo',
-  'get',
-  `${getActiveClient().userId}#${userId}`,
-];
-
+/* begin_public_function
+  id: user.relationship.get_follow_info, user.relationship.get_my_follow_info
+*/
 /**
  * ```js
  * import { getFollowInfo } from '@amityco/ts-sdk'
@@ -27,18 +24,23 @@ export const getFollowInfo = async (
   const client = getActiveClient();
   client.log('follow/getFollowInfo', userId);
 
-  const { data } = await client.http.get<Amity.FollowInfoPayload>(
+  const { data } = await client.http.get<Amity.FollowInfoMePayload | Amity.FollowInfoPayload>(
     client.userId === userId ? `/api/v4/me/followInfo` : `/api/v4/users/${userId}/followInfo`,
   );
 
   const cachedAt = client.cache && Date.now();
-  const followInfo = {
-    ...data.followCounts[0],
-    status: data.follows?.[0]?.status,
-  };
+  const followInfo =
+    'follows' in data
+      ? {
+          ...data.followCounts[0],
+          status: data.follows?.[0]?.status,
+        }
+      : data.followCounts[0];
 
   if (client.cache) {
-    pushToCache(getCacheKey(userId), followInfo, { cachedAt });
+    pushToCache(['followInfo', 'get', userId], followInfo, {
+      cachedAt,
+    });
   }
 
   return {
@@ -46,6 +48,7 @@ export const getFollowInfo = async (
     cachedAt,
   };
 };
+/* end_public_function */
 
 /**
  * ```js
@@ -70,7 +73,7 @@ getFollowInfo.locally = (
     return;
   }
 
-  const cached = pullFromCache<Amity.FollowInfo>(getCacheKey(userId));
+  const cached = pullFromCache<Amity.FollowInfo>(['followInfo', 'get', userId]);
 
   if (!cached) {
     return;

package/src/follow/api/queryFollowers.ts

@@ -1,5 +1,8 @@
 import { queryFollows } from './utils';
 
+/* begin_public_function
+  id: user.relationship.query_my_followers, user.relationship.query_followers
+*/
 /**
  * ```js
  * import { queryFollowers } from '@amityco/ts-sdk'
@@ -14,11 +17,11 @@ import { queryFollows } from './utils';
  * @category Follow API
  * @async
  */
-export const queryFollowers = async (query: {
-  userId: Amity.User['userId'];
-  status?: 'all' | Exclude<Amity.FollowStatus['status'], 'none'>;
-  page?: Amity.Page;
-}): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus>>> => queryFollows('followers', query);
+export const queryFollowers = async (
+  query: Amity.QueryFollowers,
+): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>>> =>
+  queryFollows('followers', query);
+/* end_public_function */
 
 /**
  * ```js
@@ -35,5 +38,5 @@ export const queryFollowers = async (query: {
  */
 queryFollowers.locally = (
   query: Parameters<typeof queryFollowers>[0],
-): Amity.Cached<Amity.Paged<Amity.FollowStatus>> | undefined =>
+): Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>> | undefined =>
   queryFollows.locally('followers', query);

package/src/follow/api/queryFollowings.ts

@@ -1,5 +1,8 @@
 import { queryFollows } from './utils';
 
+/* begin_public_function
+  id: user.relationship.query_my_followings, user.relationship.query_followings
+*/
 /**
  * ```js
  * import { queryFollowings } from '@amityco/ts-sdk'
@@ -14,11 +17,11 @@ import { queryFollows } from './utils';
  * @category Follow API
  * @async
  */
-export const queryFollowings = async (query: {
-  userId: Amity.User['userId'];
-  status?: Exclude<Amity.FollowStatus['status'], 'none'>;
-  page?: Amity.Page;
-}): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus>>> => queryFollows('following', query);
+export const queryFollowings = async (
+  query: Amity.QueryFollowings,
+): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>>> =>
+  queryFollows('following', query);
+/* end_public_function */
 
 /**
  * ```js
@@ -35,5 +38,5 @@ export const queryFollowings = async (query: {
  */
 queryFollowings.locally = (
   query: Parameters<typeof queryFollowings>[0],
-): Amity.Cached<Amity.Paged<Amity.FollowStatus>> | undefined =>
+): Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>> | undefined =>
   queryFollows.locally('following', query);

package/src/follow/api/unfollow.ts

@@ -2,6 +2,9 @@ import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
 
+/* begin_public_function
+  id: user.relationship.unfollow
+*/
 /**
  * ```js
  * import { unfollow } from '@amityco/ts-sdk'
@@ -28,7 +31,8 @@ export const unfollow = async (userId: Amity.User['userId']): Promise<boolean> =
     ingestInCache(data);
   }
 
-  fireEvent('follow.unfollowed', data.follows[0]);
+  fireEvent('follow.unfollowed', data);
 
   return true;
 };
+/* end_public_function */