@amityco/ts-sdk 0.0.1 → 6.0.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/feed/index.ts

@@ -0,0 +1 @@
+export * from './api';

package/src/file/api/createFile.ts

@@ -1,8 +1,10 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { decorateModels } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
+/* begin_public_function
+  id: file.upload.file
+*/
 /**
  * ```js
  * import { createFile } from '@amityco/ts-sdk'
@@ -12,6 +14,7 @@ import { ingestInCache } from '~/core/cache'
  * Creates an {@link Amity.File}
  *
  * @param formData The data necessary to create a new {@link Amity.File}
+ * @param onProgress The callback to track the upload progress
  * @returns The newly created {@link Amity.File}
  *
  * @category File API
@@ -20,32 +23,36 @@ import { ingestInCache } from '~/core/cache'
 export const createFile = async <T extends Amity.FileType = any>(
   formData: FormData,
   onProgress?: (percent: number) => void,
-) => {
-  const client = getActiveClient()
-  client.log('file/createFile', formData)
+): Promise<Amity.Cached<Amity.File[]>> => {
+  const client = getActiveClient();
+  client.log('file/createFile', formData);
 
-  if (!formData.getAll('file').length)
-    throw new Error('The formData object must have a `file` key.')
+  if (!formData.getAll('files').length)
+    throw new Error('The formData object must have a `files` key.');
 
-  const headers = 'getHeaders' in formData
-    ? (formData as any).getHeaders()
-    : { 'content-type': 'multipart/form-data' }
+  const headers =
+    'getHeaders' in formData
+      ? (formData as any).getHeaders()
+      : { 'content-type': 'multipart/form-data' };
 
-  const { data } = await client.http.post<Amity.CreateFilePayload<T>>(
-    '/api/v3/files', formData, {
-      headers, onUploadProgress({ loaded, total }) {
-        onProgress && onProgress(Math.round((loaded * 100) / total))
-      }
-    }
-  )
+  const { data } = await client.http.post<Amity.CreateFilePayload<T>>('/api/v4/files', formData, {
+    headers,
+    onUploadProgress({ loaded, total = 100 }) {
+      onProgress && onProgress(Math.round((loaded * 100) / total));
+    },
+  });
 
   // API-FIX: payload should be serialized properly
   // const { files } = data
 
-  decorateModels(data)
-  ingestInCache({ files: data })
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache({ files: data }, { cachedAt });
 
-  return data[0]
-}
+  return {
+    data,
+    cachedAt,
+  };
+};
+/* end_public_function */
 
 // TODO: consider doing local creation with URL.createObjectURL()

package/src/file/api/createImage.ts

@@ -0,0 +1,62 @@
+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'
+ * const created = await createImage(formData)
+ * ```
+ *
+ * Creates an {@link Amity.File<'image'>}
+ *
+ * @param formData The data necessary to create a new {@link Amity.File<'image'>}
+ * @param onProgress The callback to track the upload progress
+ * @returns The newly created {@link Amity.File<'image'>}
+ *
+ * @category File API
+ * @async
+ */
+export const createImage = async (
+  formData: FormData,
+  onProgress?: (percent: number) => void,
+): Promise<Amity.Cached<Amity.File<'image'>[]>> => {
+  const client = getActiveClient();
+  client.log('file/createImage', formData);
+
+  if (!formData.getAll('files').length)
+    throw new Error('The formData object must have a `files` key.');
+
+  const headers =
+    'getHeaders' in formData
+      ? (formData as any).getHeaders()
+      : { 'content-type': 'multipart/form-data' };
+
+  const { data } = await client.http.post<Amity.CreateFilePayload<'image'>>(
+    '/api/v4/images',
+    formData,
+    {
+      headers,
+      onUploadProgress({ loaded, total = 100 }) {
+        onProgress && onProgress(Math.round((loaded * 100) / total));
+      },
+    },
+  );
+
+  // API-FIX: payload should be serialized properly
+  // const { files } = data
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache({ files: data }, { cachedAt });
+
+  return {
+    data,
+    cachedAt,
+  };
+};
+/* end_public_function */
+
+// TODO: consider doing local creation with URL.createObjectURL()

package/src/file/api/createVideo.ts

@@ -0,0 +1,68 @@
+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'
+ * const created = await createVideo(formData)
+ * ```
+ *
+ * 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'>}
+ *
+ * @category File API
+ * @async
+ */
+export const createVideo = async (
+  formData: FormData,
+  feedType?: Amity.ContentFeedType,
+  onProgress?: (percent: number) => void,
+): Promise<Amity.Cached<Amity.File<'video'>[]>> => {
+  const client = getActiveClient();
+  client.log('file/createVideo', formData);
+
+  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()
+      : { 'content-type': 'multipart/form-data' };
+
+  const { data } = await client.http.post<Amity.CreateFilePayload<'video'>>(
+    '/api/v4/videos',
+    formData,
+    {
+      headers,
+      onUploadProgress({ loaded, total = 100 }) {
+        onProgress && onProgress(Math.round((loaded * 100) / total));
+      },
+    },
+  );
+
+  // API-FIX: payload should be serialized properly
+  // const { files } = data
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache({ files: data }, { cachedAt });
+
+  return {
+    data,
+    cachedAt,
+  };
+};
+/* end_public_function */
+
+// TODO: consider doing local creation with URL.createObjectURL()

package/src/file/api/deleteFile.ts

@@ -1,7 +1,10 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { mergeInCache } from '~/core/cache'
+import { dropFromCache } from '~/cache/api';
 
+/* begin_public_function
+  id: file.delete
+*/
 /**
  * ```js
  * import { deleteFile } from '@amityco/ts-sdk'
@@ -18,18 +21,15 @@ import { mergeInCache } from '~/core/cache'
  */
 export const deleteFile = async (
   fileId: Amity.File<any>['fileId'],
-) => {
-  const client = getActiveClient()
-  client.log('file/deleteFile', fileId)
+): Promise<{ success: boolean }> => {
+  const client = getActiveClient();
+  client.log('file/deleteFile', fileId);
 
-  const { data } = await client.http.delete<{ success: boolean }>(
-    `/api/v3/files/${fileId}`,
-  )
+  // API-FIX: payload is different than swagger docs!!
+  await client.http.delete<{ fileId: string }>(`/api/v3/files/${fileId}`);
 
-  const { success } = data
+  dropFromCache(['file', 'get', fileId], true);
 
-  if (success)
-    mergeInCache('file', { fileId, isDeleted: true })
-
-  return success
-}
+  return { success: true };
+};
+/* end_public_function */

package/src/file/api/fileUrlWithSize.ts

@@ -9,5 +9,5 @@ export const fileUrlWithSize = (
   fileUrl: Amity.File['fileUrl'],
   size: 'small' | 'medium' | 'large' | 'full',
 ) => {
-  return `${fileUrl}?size=${size}`
-}
+  return `${fileUrl}?size=${size}`;
+};

package/src/file/api/getFile.ts

@@ -1,8 +1,11 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { decorateModel } from '~/core/query'
-import { ingestInCache, pullFromCache } from '~/core/cache'
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
+/* begin_public_function
+  id: file.get
+*/
 /**
  * ```js
  * import { getFile } from '@amityco/ts-sdk'
@@ -11,7 +14,7 @@ import { ingestInCache, pullFromCache } from '~/core/cache'
  *
  * Fetches a {@link Amity.File} object
  *
- * @param filelId the ID of the {@link Amity.File} to fetch
+ * @param fileId the ID of the {@link Amity.File} to fetch
  * @returns the associated {@link Amity.File} object
  *
  * @category File API
@@ -19,22 +22,24 @@ import { ingestInCache, pullFromCache } from '~/core/cache'
  */
 export const getFile = async <T extends Amity.FileType = any>(
   fileId: Amity.File<any>['fileId'],
-) => {
-  const client = getActiveClient()
-  client.log('file/getFile', fileId)
+): Promise<Amity.Cached<Amity.File>> => {
+  const client = getActiveClient();
+  client.log('file/getFile', fileId);
 
-  const { data } = await client.http.get<Amity.FilePayload<T>>(
-    `/api/v3/files/${fileId}`,
-  )
+  const { data } = await client.http.get<Amity.FilePayload<T>>(`/api/v3/files/${fileId}`);
 
   // API-FIX: backend bad serializer issue. it should be:
   // const { files } = data
 
-  decorateModel(data)
-  ingestInCache({ files: [data] })
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache({ files: [data] }, { cachedAt });
 
-  return data
-}
+  return {
+    data,
+    cachedAt,
+  };
+};
+/* end_public_function */
 
 /**
  * ```js
@@ -49,12 +54,18 @@ export const getFile = async <T extends Amity.FileType = any>(
  *
  * @category File API
  */
-getFile.locally = (
-  fileId: Amity.File<any>['fileId'],
-) => {
-  const client = getActiveClient()
-  client.log('file/getFile.locally', fileId)
+getFile.locally = (fileId: Amity.File<any>['fileId']): Amity.Cached<Amity.File> | undefined => {
+  const client = getActiveClient();
+  client.log('file/getFile.locally', fileId);
+
+  if (!client.cache) return;
+
+  const cached = pullFromCache<Amity.File>(['file', 'get', fileId]);
+
+  if (!cached) return;
 
-  const [file] = pullFromCache('file', fileId) ?? []
-  return file
-}
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  };
+};

package/src/file/api/index.ts

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

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/file/index.ts

@@ -0,0 +1,2 @@
+export * from './api';
+export * from './observers';

package/src/file/observers/index.ts

@@ -1 +1 @@
-export * from './observeFile'
+export * from './observeFile';