@amityco/ts-sdk 6.2.0 → 6.2.1-0cf9bee.0

package/src/core/query/filtering.ts

@@ -18,7 +18,10 @@ export const filterByPropEquality = <T = Record<string, unknown>>(
   collection: T[],
   key: keyof T,
   value: any,
-) => (value !== undefined ? collection.filter(item => item[key] === value) : collection);
+) =>
+  value !== undefined
+    ? collection.filter(item => JSON.stringify(item[key]) === JSON.stringify(value))
+    : collection;
 
 export const filterByPropInclusion = <T = Record<string, unknown>>(
   collection: T[],
@@ -26,6 +29,19 @@ export const filterByPropInclusion = <T = Record<string, unknown>>(
   value: any[] | undefined,
 ) => (value !== undefined ? collection.filter(item => value.includes(item[key])) : collection);
 
+export const filterByPropIntersection = <T extends Record<string, unknown>>(
+  collection: T[],
+  key: keyof T,
+  values: any[] | undefined,
+) => {
+  if (!values?.length) return collection;
+
+  return collection.filter(
+    item =>
+      Array.isArray(item[key]) && values.some(value => (item[key] as unknown[]).includes(value)),
+  );
+};
+
 /**
  * Filter a channel collection by membership of the userId
  *
@@ -189,7 +205,11 @@ export const filterBySearchTerm = <T extends { userId: Amity.User['userId']; use
   collection: T[],
   searchTerm: string,
 ): T[] => {
-  const containsMatcher = new RegExp(searchTerm);
+  /*
+   * Search term should match regardless of the case.
+   * Hence, the flag "i", is passed to the created regex
+   */
+  const containsMatcher = new RegExp(searchTerm, 'i');
 
   return collection.filter(m => {
     if (m.userId.match(containsMatcher)) return true;

package/src/core/query/sorting.ts

@@ -18,10 +18,8 @@ export const sortByDisplayName: SortingFunc<{ displayName: string }> = (
 /**
  * Alphabetic sorting of objects having a name
  */
-export const sortByName: SortingFunc<{ name: string }> = ({ name: a }, { name: b }) => {
-  if (a === b) return 0;
-  return a < b ? -1 : 1;
-};
+export const sortByName: SortingFunc<{ name: string }> = ({ name: a }, { name: b }) =>
+  a.localeCompare(b);
 
 /**
  * Sorting a collection by their apparition order (oldest first)

package/src/core/query/tests/filtering.test.ts

@@ -13,6 +13,12 @@ describe('filtering:', () => {
       ]);
     });
 
+    test('it should ignore search term case', () => {
+      expect(filterBySearchTerm(searchTermCollection, 'USER')).toStrictEqual([
+        searchTermCollection[0],
+      ]);
+    });
+
     test('it should return items that match displayName', () => {
       expect(filterBySearchTerm(searchTermCollection, 'displ')).toStrictEqual([
         searchTermCollection[0],

package/src/core/query/tests/runQuery.test.ts

@@ -3,7 +3,7 @@ import { disableCache, enableCache, pushToCache } from '~/cache/api';
 import { runQuery, createQuery } from '~/core/query';
 import { createPost } from '~/postRepository/api';
 import { getPost } from '~/postRepository/api/getPost';
-import { deleteMessage } from '~/messageRepository/api';
+import { softDeleteMessage } from '~/messageRepository/api';
 
 import { posts, client, pause, emptyPostPayload } from '~/utils/tests';
 
@@ -115,7 +115,7 @@ describe('Core/Query/runQuery', () => {
     // 'get', gets called after delete to verify delete
     client.http.get = jest.fn();
 
-    const query = createQuery(deleteMessage, deletingMsgId);
+    const query = createQuery(softDeleteMessage, deletingMsgId);
     runQuery(query);
 
     expect(client.http.delete).toHaveBeenCalledWith(`/api/v5/messages/${deletingMsgId}`);
@@ -148,7 +148,7 @@ describe('Core/Query/runQuery', () => {
       );
     const callback = jest.fn();
 
-    const query = createQuery(deleteMessage, deletingMsgId);
+    const query = createQuery(softDeleteMessage, deletingMsgId);
     runQuery(query, callback);
     await pause();
 

package/src/core/transports/mqtt.ts

@@ -1,6 +1,6 @@
 /* eslint-disable no-console */
 /* eslint-disable no-promise-executor-return */
-import mqtt, { MqttClient, IClientOptions, ISubscriptionGrant } from 'mqtt/dist/mqtt';
+import mqtt, { IClientOptions, ISubscriptionGrant, MqttClient } from 'mqtt/dist/mqtt';
 import { ASCError, ASCUnknownError } from '~/core/errors';
 
 const QOS_FAILURE_CODE = 128;
@@ -138,7 +138,8 @@ export const createMqttTransport = (endpoint: string): Amity.MqttClient => {
             : // TODO throw the actual error, once BE can tell us the actual error code
               new ASCUnknownError(Amity.ClientError.UNKNOWN_ERROR, Amity.ErrorLevel.ERROR);
 
-          console.error(`Failed to subscribe to topic ${topic}`, ascError);
+          // Use warning lv instead of error lv to prevent misunderstanding of user
+          console.warn(`Failed to subscribe to topic ${topic}`, ascError);
           callback?.(ascError);
         } else {
           console.log(`Subscribed to topic ${granted[0].topic}`);

package/src/feedRepository/api/getCustomRankingGlobalFeed.ts

@@ -0,0 +1,117 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { toPage, toToken } from '~/core/query';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { getResolver } from '~/core/model';
+import { prepareMembershipPayload } from '~/group/utils';
+
+/* begin_public_function
+  id: feed.query.custom_ranking_feed
+*/
+/**
+ * ```js
+ * import { FeedRepository } from '@amityco/ts-sdk'
+ * const posts = await FeedRepository.getCustomRankingGlobalFeed()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Post} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Post} objects
+ *
+ * @category Feed API
+ * @async
+ * */
+export const getCustomRankingGlobalFeed = async (query?: {
+  dataTypes?: ('video' | 'image' | 'file' | 'liveStream')[];
+  page?: Amity.Page;
+}): Promise<Amity.Cached<Amity.Paged<Amity.Post>>> => {
+  const client = getActiveClient();
+  client.log('feed/getCustomRankingGlobalFeed', query);
+
+  const { page, ...params } = query ?? {};
+
+  const { data: queryPayload } = await client.http.get<Amity.PostPayload & Amity.Pagination>(
+    `/api/v5/me/global-feeds`,
+    {
+      params: {
+        ...params,
+        options: {
+          token: toToken(page, 'skiplimit'),
+        },
+      },
+    },
+  );
+
+  const { paging, ...payload } = queryPayload;
+
+  const data = prepareMembershipPayload(payload, 'communityUsers');
+
+  const { posts } = data;
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) {
+    ingestInCache(data);
+
+    const cacheKey = [
+      'customGlobalFeed',
+      'query',
+      { ...params, options: { ...page } } as Amity.Serializable,
+    ];
+    pushToCache(cacheKey, { posts: posts.map(getResolver('post')), paging });
+  }
+
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
+
+  return { data: posts, cachedAt, prevPage, nextPage };
+};
+/* end_public_function */
+
+/**
+ * ```js
+ * import { FeedRepository } from '@amityco/ts-sdk'
+ * const posts = await FeedRepository.getCustomRankingGlobalFeed.locally()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Post} objects from cache
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Post} objects
+ *
+ * @category Feed API
+ * @async
+ * */
+getCustomRankingGlobalFeed.locally = (
+  query?: Parameters<typeof getCustomRankingGlobalFeed>[0],
+): Amity.Cached<Amity.Paged<Amity.Post>> | undefined => {
+  const client = getActiveClient();
+  client.log('post/getCustomRankingGlobalFeed.locally', query);
+
+  if (!client.cache) return;
+
+  const { page, ...params } = query ?? {};
+
+  const queryKey = [
+    'customGlobalFeed',
+    'query',
+    { ...params, options: { ...page } } as Amity.Serializable,
+  ];
+  const { data, cachedAt } = pullFromCache<{ posts: string[] } & Amity.Pagination>(queryKey) ?? {};
+
+  if (!data?.posts.length) return;
+
+  const posts: Amity.Post[] = data.posts
+    .map(postId => pullFromCache<Amity.Post>(['post', 'get', postId])!)
+    .filter(Boolean)
+    .map(({ data }) => data);
+
+  const prevPage = toPage(data?.paging.previous);
+  const nextPage = toPage(data?.paging.next);
+
+  return posts.length === data?.posts?.length
+    ? { data: posts, cachedAt, prevPage, nextPage }
+    : undefined;
+};

package/src/feedRepository/api/index.ts

@@ -1 +1,2 @@
 export * from './queryGlobalFeed';
+export * from './getCustomRankingGlobalFeed';

package/src/feedRepository/api/queryGlobalFeed.ts

@@ -33,8 +33,16 @@ export const queryGlobalFeed = async (query?: {
 
   const { useCustomRanking, page, ...params } = query ?? {};
 
+  /*
+   * TODO: Remove useCustomRanking key from query
+   */
+  if (useCustomRanking)
+    console.warn(
+      'The param "useCustomRanking" has been deprecated. To get custom ranking feed use FeedRepository.getCustomRankingGlobalFeed instead',
+    );
+
   const { data: queryPayload } = await client.http.get<Amity.PostPayload & Amity.Pagination>(
-    useCustomRanking ? `/api/v5/me/global-feeds` : `/api/v4/me/global-feeds`,
+    `/api/v4/me/global-feeds`,
     {
       params: {
         ...params,
@@ -59,7 +67,7 @@ export const queryGlobalFeed = async (query?: {
     const cacheKey = [
       'globalFeed',
       'query',
-      { ...params, useCustomRanking, options: { ...page } } as Amity.Serializable,
+      { ...params, options: { ...page } } as Amity.Serializable,
     ];
     pushToCache(cacheKey, { posts: posts.map(getResolver('post')), paging });
   }
@@ -93,12 +101,12 @@ queryGlobalFeed.locally = (
 
   if (!client.cache) return;
 
-  const { useCustomRanking, page, ...params } = query ?? {};
+  const { page, ...params } = query ?? {};
 
   const queryKey = [
     'globalFeed',
     'query',
-    { ...params, useCustomRanking, options: { ...page } } as Amity.Serializable,
+    { ...params, options: { ...page } } as Amity.Serializable,
   ];
   const { data, cachedAt } = pullFromCache<{ posts: string[] } & Amity.Pagination>(queryKey) ?? {};
 

package/src/feedRepository/api/test/getCustomRankingGlobalFeed.test.ts

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

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

@@ -12,7 +12,7 @@ const pagingToken = {
 const postsToQuery = [post11, post12];
 const postIdsToQuery = postsToQuery.map(post => post.postId);
 const pagingCriteria = { limit: 10 };
-const queryCriteriaWithoutPage = { useCustomRanking: false };
+const queryCriteriaWithoutPage = {};
 const queryCriteria = { ...queryCriteriaWithoutPage, page: pagingCriteria };
 
 const resolvedQueryFeedValue = {
@@ -69,20 +69,6 @@ describe('queryGlobalFeed', () => {
     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'));
 

package/src/fileRepository/api/index.ts

@@ -1,6 +1,6 @@
 export * from './getFile';
-export * from './createFile';
+export * from './uploadFile';
 export * from './deleteFile';
 export * from './fileUrlWithSize';
-export * from './createVideo';
-export * from './createImage';
+export * from './uploadVideo';
+export * from './uploadImage';

package/src/fileRepository/api/test/uploadFile.test.ts

@@ -0,0 +1,69 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { client, file12, createEmptyFormData, createFileFormData } from '~/utils/tests';
+
+import { uploadFile } from '../uploadFile';
+
+const videoToCreate = [file12];
+const createIds = videoToCreate.map(({ fileId }) => fileId);
+const resolvedPayloadValue = { data: videoToCreate };
+
+describe('uploadFile', () => {
+  test('it should return created file', async () => {
+    const formData = createFileFormData();
+    client.http.post = jest.fn().mockResolvedValue(resolvedPayloadValue);
+
+    const received = uploadFile(formData);
+
+    await expect(received).resolves.toEqual(expect.objectContaining({ data: videoToCreate }));
+  });
+
+  test('it should throw an error if request fails', async () => {
+    const formData = createFileFormData();
+    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(uploadFile(formData)).rejects.toThrow('error');
+  });
+
+  test('it should throw an error if formData is empty', async () => {
+    const emptyFormData = createEmptyFormData();
+
+    await expect(uploadFile(emptyFormData)).rejects.toThrow(
+      'The formData object must have a `files` key.',
+    );
+  });
+
+  test('it 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(
+      (_, __, 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 uploadFile(formData, onProgress);
+
+    expect(onProgress).toHaveBeenNthCalledWith(1, 0);
+    expect(onProgress).toHaveBeenNthCalledWith(2, 40);
+    expect(onProgress).toHaveBeenNthCalledWith(3, 100);
+  });
+
+  test('it should create cache after created file', async () => {
+    enableCache();
+    const formData = createFileFormData();
+    client.http.post = jest.fn().mockResolvedValue(resolvedPayloadValue);
+
+    await uploadFile(formData);
+    const received = createIds.map(id => pullFromCache(['file', 'get', id])?.data);
+
+    expect(received).toEqual(expect.objectContaining(videoToCreate));
+
+    disableCache();
+  });
+});

package/src/fileRepository/api/test/{createImage.test.ts → uploadImage.test.ts}

@@ -1,18 +1,18 @@
 import { disableCache, enableCache, pullFromCache } from '~/cache/api';
 import { client, file11, createEmptyFormData, createFileFormData } from '~/utils/tests';
 
-import { createImage } from '../createImage';
+import { uploadImage } from '../uploadImage';
 
 const imageToCreate = [file11];
 const createIds = imageToCreate.map(({ fileId }) => fileId);
 const resolvedPayloadValue = { data: imageToCreate };
 
-describe('createImage', () => {
+describe('uploadImage', () => {
   test('should return created image', async () => {
     const formData = createFileFormData();
     client.http.post = jest.fn().mockResolvedValue(resolvedPayloadValue);
 
-    const received = createImage(formData);
+    const received = uploadImage(formData);
 
     await expect(received).resolves.toEqual(expect.objectContaining({ data: imageToCreate }));
   });
@@ -21,13 +21,13 @@ describe('createImage', () => {
     const formData = createFileFormData();
     client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
 
-    await expect(createImage(formData)).rejects.toThrow('error');
+    await expect(uploadImage(formData)).rejects.toThrow('error');
   });
 
   test('should throw an error if formData is empty', async () => {
     const emptyFormData = createEmptyFormData();
 
-    await expect(createImage(emptyFormData)).rejects.toThrow(
+    await expect(uploadImage(emptyFormData)).rejects.toThrow(
       'The formData object must have a `files` key.',
     );
   });
@@ -47,7 +47,7 @@ describe('createImage', () => {
         }),
     );
 
-    await createImage(formData, onProgress);
+    await uploadImage(formData, onProgress);
 
     expect(onProgress).toHaveBeenNthCalledWith(1, 0);
     expect(onProgress).toHaveBeenNthCalledWith(2, 40);
@@ -59,7 +59,7 @@ describe('createImage', () => {
     const formData = createFileFormData();
     client.http.post = jest.fn().mockResolvedValue(resolvedPayloadValue);
 
-    await createImage(formData);
+    await uploadImage(formData);
     const received = createIds.map(id => pullFromCache(['file', 'get', id])?.data);
 
     expect(received).toEqual(expect.objectContaining(imageToCreate));

package/src/fileRepository/api/test/{createVideo.test.ts → uploadVideo.test.ts}

@@ -2,18 +2,18 @@ import { ContentFeedType } from '~/@types';
 import { disableCache, enableCache, pullFromCache } from '~/cache/api';
 import { client, file12, createEmptyFormData, createFileFormData } from '~/utils/tests';
 
-import { createVideo } from '../createVideo';
+import { uploadVideo } from '../uploadVideo';
 
 const videoToCreate = [file12];
 const createIds = videoToCreate.map(({ fileId }) => fileId);
 const resolvedPayloadValue = { data: videoToCreate };
 
-describe('createVideo', () => {
+describe('uploadVideo', () => {
   test('should return created video', async () => {
     const formData = createFileFormData();
     client.http.post = jest.fn().mockResolvedValue(resolvedPayloadValue);
 
-    const received = createVideo(formData);
+    const received = uploadVideo(formData);
 
     await expect(received).resolves.toEqual(expect.objectContaining({ data: videoToCreate }));
   });
@@ -22,13 +22,13 @@ describe('createVideo', () => {
     const formData = createFileFormData();
     client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
 
-    await expect(createVideo(formData)).rejects.toThrow('error');
+    await expect(uploadVideo(formData)).rejects.toThrow('error');
   });
 
   test('should throw an error if formData is empty', async () => {
     const emptyFormData = createEmptyFormData();
 
-    await expect(createVideo(emptyFormData)).rejects.toThrow(
+    await expect(uploadVideo(emptyFormData)).rejects.toThrow(
       'The formData object must have a `files` key.',
     );
   });
@@ -39,7 +39,7 @@ describe('createVideo', () => {
     const formData = createFileFormData();
     client.http.post = jest.fn().mockResolvedValue(resolvedPayloadValue);
 
-    await createVideo(formData, ContentFeedType.POST);
+    await uploadVideo(formData, ContentFeedType.POST);
 
     expect(formData.get('feedType')).toEqual(ContentFeedType.POST);
   });
@@ -59,7 +59,7 @@ describe('createVideo', () => {
         }),
     );
 
-    await createVideo(formData, undefined, onProgress);
+    await uploadVideo(formData, undefined, onProgress);
 
     expect(onProgress).toHaveBeenNthCalledWith(1, 0);
     expect(onProgress).toHaveBeenNthCalledWith(2, 40);
@@ -71,7 +71,7 @@ describe('createVideo', () => {
     const formData = createFileFormData();
     client.http.post = jest.fn().mockResolvedValue(resolvedPayloadValue);
 
-    await createVideo(formData);
+    await uploadVideo(formData);
     const received = createIds.map(id => pullFromCache(['file', 'get', id])?.data);
 
     expect(received).toEqual(expect.objectContaining(videoToCreate));

package/src/fileRepository/api/{createFile.ts → uploadFile.ts}

@@ -7,8 +7,8 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 */
 /**
  * ```js
- * import { createFile } from '@amityco/ts-sdk'
- * const created = await createFile(formData)
+ * import { FileRepository } from '@amityco/ts-sdk'
+ * const created = await FileRepository.uploadFile(formData)
  * ```
  *
  * Creates an {@link Amity.File}
@@ -20,12 +20,12 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * @category File API
  * @async
  */
-export const createFile = async <T extends Amity.FileType = any>(
+export const uploadFile = async <T extends Amity.FileType = any>(
   formData: FormData,
   onProgress?: (percent: number) => void,
 ): Promise<Amity.Cached<Amity.File[]>> => {
   const client = getActiveClient();
-  client.log('file/createFile', formData);
+  client.log('file/uploadFile', formData);
 
   if (!formData.getAll('files').length)
     throw new Error('The formData object must have a `files` key.');
@@ -54,5 +54,3 @@ export const createFile = async <T extends Amity.FileType = any>(
   };
 };
 /* end_public_function */
-
-// TODO: consider doing local creation with URL.createObjectURL()