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

package/src/feedRepository/observers/utils.ts

@@ -0,0 +1,85 @@
+import { pullFromCache } from '~/cache/api';
+import { onCommentCreated, onCommentDeleted } from '~/commentRepository';
+import { getPost } from '~/postRepository/internalApi';
+import {
+  onPostCreated,
+  onPostUpdated,
+  onPostDeleted,
+  onPostFlagged,
+  onPostUnflagged,
+  onPostReactionAdded,
+  onPostReactionRemoved,
+  onPostApproved,
+  onPostDeclined,
+} from '~/postRepository/events';
+import { onLocalPostDeleted } from '~/postRepository/events/onLocalPostDeleted';
+import { onLocalPostReactionAdded } from '~/postRepository/events/onLocalPostReactionAdded';
+import { onLocalPostReactionRemoved } from '~/postRepository/events/onLocalPostReactionRemoved';
+import { onPostUpdatedLocal } from '~/postRepository/events/onPostUpdatedLocal';
+import { EnumPostActions } from '~/postRepository/observers/enums';
+import { convertEventPayload } from '~/utils/event';
+import { onCommentCreatedLocal } from '~/commentRepository/events/onCommentCreatedLocal';
+import { onCommentDeleteLocal } from '~/commentRepository/events/onCommentDeletedLocal';
+import { onCommentReactionAdded, onCommentReactionRemoved } from '~/commentRepository/events';
+import { onLocalCommentReactionAdded } from '~/commentRepository/events/onLocalCommentReactionAdded';
+import { onLocalCommentReactionRemoved } from '~/commentRepository/events/onLocalCommentReactionRemoved';
+
+type CommentEventHandler = (callback: Amity.Listener<Amity.InternalComment>) => Amity.Unsubscriber;
+
+const commentEventHandler = (
+  callback: Amity.Listener<Amity.InternalComment>,
+  eventHandler: CommentEventHandler,
+  cacheKey: Amity.CacheKey,
+) => {
+  return eventHandler(async (comment: Amity.InternalComment) => {
+    const currentCollection =
+      pullFromCache<Amity.CustomRankingGlobalFeedLiveCollectionCache>(cacheKey)?.data;
+
+    if (!currentCollection || !currentCollection.data.includes(comment.referenceId)) return;
+
+    await getPost(comment.referenceId);
+    callback(comment);
+  });
+};
+
+const generateCommentSubscriptions = (cacheKey: Amity.CacheKey) => {
+  const eventHandlers = [
+    onCommentCreated,
+    onCommentDeleted,
+    onCommentReactionAdded,
+    onCommentReactionRemoved,
+    onCommentCreatedLocal,
+    onCommentDeleteLocal,
+    onLocalCommentReactionAdded,
+    onLocalCommentReactionRemoved,
+  ];
+
+  return eventHandlers.map(handler => ({
+    fn: convertEventPayload(
+      (callback: Amity.Listener<Amity.InternalComment>) =>
+        commentEventHandler(callback, handler, cacheKey),
+      'referenceId',
+      'post',
+    ),
+    action: EnumPostActions.OnPostUpdated,
+  }));
+};
+
+export const getGlobalFeedSubscriptions = (cacheKey: Amity.CacheKey) => {
+  return [
+    { fn: onPostCreated, action: EnumPostActions.OnPostCreated },
+    { fn: onPostUpdated, action: EnumPostActions.OnPostUpdated },
+    { fn: onPostUpdatedLocal, action: EnumPostActions.OnPostUpdated },
+    { fn: onPostDeleted, action: EnumPostActions.OnPostDeleted },
+    { fn: onPostFlagged, action: EnumPostActions.OnPostFlagged },
+    { fn: onPostUnflagged, action: EnumPostActions.OnPostUnflagged },
+    { fn: onPostApproved, action: EnumPostActions.OnPostApproved },
+    { fn: onPostDeclined, action: EnumPostActions.OnPostDeclined },
+    { fn: onPostReactionAdded, action: EnumPostActions.OnPostReactionAdded },
+    { fn: onPostReactionRemoved, action: EnumPostActions.OnPostReactionRemoved },
+    { fn: onLocalPostReactionAdded, action: EnumPostActions.OnPostReactionAdded },
+    { fn: onLocalPostReactionRemoved, action: EnumPostActions.OnPostReactionRemoved },
+    { fn: onLocalPostDeleted, action: EnumPostActions.OnPostDeleted },
+    ...generateCommentSubscriptions(cacheKey),
+  ];
+};

package/src/fileRepository/api/deleteFile.ts

@@ -0,0 +1,35 @@
+import { getActiveClient } from '~/client/api';
+
+import { dropFromCache } from '~/cache/api';
+
+/* begin_public_function
+  id: file.delete
+*/
+/**
+ * ```js
+ * import { deleteFile } from '@amityco/ts-sdk'
+ * const success = await deleteFile('foo')
+ * ```
+ *
+ * Deletes a {@link Amity.File}
+ *
+ * @param fileId The {@link Amity.File} ID to delete
+ * @return A success boolean if the {@link Amity.File} was deleted
+ *
+ * @category File API
+ * @async
+ */
+export const deleteFile = async (
+  fileId: Amity.File<any>['fileId'],
+): Promise<{ success: boolean }> => {
+  const client = getActiveClient();
+  client.log('file/deleteFile', fileId);
+
+  // API-FIX: payload is different than swagger docs!!
+  await client.http.delete<{ fileId: string }>(`/api/v3/files/${fileId}`);
+
+  dropFromCache(['file', 'get', fileId], true);
+
+  return { success: true };
+};
+/* end_public_function */

package/src/fileRepository/api/fileUrlWithSize.ts

@@ -0,0 +1,13 @@
+/**
+ * Allow to query a file url with a selected size
+ *
+ * @param fileUrl the file Url to decorate
+ * @param size one of the selected sizes
+ * @returns the computed url for the selected size
+ */
+export const fileUrlWithSize = (
+  fileUrl: Amity.File['fileUrl'],
+  size: 'small' | 'medium' | 'large' | 'full',
+) => {
+  return `${fileUrl}?size=${size}`;
+};

package/src/fileRepository/api/getFile.ts

@@ -0,0 +1,71 @@
+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'
+ * const file = await getFile('foo')
+ * ```
+ *
+ * Fetches a {@link Amity.File} object
+ *
+ * @param fileId the ID of the {@link Amity.File} to fetch
+ * @returns the associated {@link Amity.File} object
+ *
+ * @category File API
+ * @async
+ */
+export const getFile = async <T extends Amity.FileType = any>(
+  fileId: Amity.File<any>['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}`);
+
+  // API-FIX: backend bad serializer issue. it should be:
+  // const { files } = data
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache({ files: [data] }, { cachedAt });
+
+  return {
+    data,
+    cachedAt,
+  };
+};
+/* end_public_function */
+
+/**
+ * ```js
+ * import { getFile } from '@amityco/ts-sdk'
+ * const file = getFile.locally('foo')
+ * ```
+ *
+ * Fetches a {@link Amity.File} object from cache
+ *
+ * @param fileId the ID of the {@link Amity.File} to fetch
+ * @returns the associated {@link Amity.File} object
+ *
+ * @category File API
+ */
+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;
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  };
+};

package/src/fileRepository/api/index.ts

@@ -0,0 +1,8 @@
+export * from './getFile';
+export * from './uploadFile';
+export * from './deleteFile';
+export * from './fileUrlWithSize';
+export * from './uploadVideo';
+export * from './uploadImage';
+export * from './updateAltText';
+export * from './uploadClip';

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/uploadImage.test.ts

@@ -0,0 +1,69 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { client, file11, createEmptyFormData, createFileFormData } from '~/utils/tests';
+
+import { uploadImage } from '../uploadImage';
+
+const imageToCreate = [file11];
+const createIds = imageToCreate.map(({ fileId }) => fileId);
+const resolvedPayloadValue = { data: imageToCreate };
+
+describe('uploadImage', () => {
+  test('should return created image', async () => {
+    const formData = createFileFormData();
+    client.http.post = jest.fn().mockResolvedValue(resolvedPayloadValue);
+
+    const received = uploadImage(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(uploadImage(formData)).rejects.toThrow('error');
+  });
+
+  test('should throw an error if formData is empty', async () => {
+    const emptyFormData = createEmptyFormData();
+
+    await expect(uploadImage(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 uploadImage(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 uploadImage(formData);
+    const received = createIds.map(id => pullFromCache(['file', 'get', id])?.data);
+
+    expect(received).toEqual(expect.objectContaining(imageToCreate));
+
+    disableCache();
+  });
+});

package/src/fileRepository/api/test/uploadVideo.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 { uploadVideo } from '../uploadVideo';
+
+const videoToCreate = [file12];
+const createIds = videoToCreate.map(({ fileId }) => fileId);
+const resolvedPayloadValue = { data: videoToCreate };
+
+describe('uploadVideo', () => {
+  test('should return created video', async () => {
+    const formData = createFileFormData();
+    client.http.post = jest.fn().mockResolvedValue(resolvedPayloadValue);
+
+    const received = uploadVideo(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(uploadVideo(formData)).rejects.toThrow('error');
+  });
+
+  test('should throw an error if formData is empty', async () => {
+    const emptyFormData = createEmptyFormData();
+
+    await expect(uploadVideo(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 uploadVideo(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 uploadVideo(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 uploadVideo(formData);
+    const received = createIds.map(id => pullFromCache(['file', 'get', id])?.data);
+
+    expect(received).toEqual(expect.objectContaining(videoToCreate));
+
+    disableCache();
+  });
+});

package/src/fileRepository/api/updateAltText.ts

@@ -0,0 +1,39 @@
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client';
+
+/* begin_public_function
+  id: file.update.altText
+*/
+/**
+ * ```js
+ * import { FileRepository } from '@amityco/ts-sdk'
+ * const updated = await FileRepository.updateAltText(fileId, altText)
+ * ```
+ *
+ * Updates an {@link Amity.File<'image'>['altText']}.
+ *
+ * @param fileId The ID of the {@link Amity.File<'image'>} to edit
+ * @param altText The new alt text for the {@link Amity.File<'image'>}
+ * @returns the updated {@link Amity.File<'image'>} object
+ *
+ * @category File API
+ * @async
+ */
+export const updateAltText = async (
+  fileId: Amity.File['fileId'],
+  altText: string,
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('file/updateAltText', altText);
+
+  const { data } = await client.http.put<Amity.FilePayload<'image'>>(`/api/v3/files/${fileId}`, {
+    altText,
+  });
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) ingestInCache({ files: [data] }, { cachedAt });
+
+  return true;
+};
+/* end_public_function */

package/src/fileRepository/api/uploadClip.ts

@@ -0,0 +1,71 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import GlobalFileAccessType from '~/client/utils/GlobalFileAccessType';
+
+/* begin_public_function
+  id: file.upload.clip
+*/
+/**
+ * ```js
+ * import { FileRepository } from '@amityco/ts-sdk'
+ * const created = await FileRepository.uploadClip(formData)
+ * ```
+ *
+ * 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
+ * @async
+ */
+export const uploadClip = async (
+  formData: FormData,
+  feedType?: Amity.ContentFeedType,
+  onProgress?: (percent: number) => void,
+): Promise<Amity.Cached<Amity.File<'clip'>[]>> => {
+  const client = getActiveClient();
+  client.log('file/uploadClip', formData);
+
+  const file = formData.get('files');
+
+  if (!file) throw new Error('The formData object must have a `files` key.');
+
+  const accessType = GlobalFileAccessType.getInstance().getFileAccessType();
+  formData.append('accessType', accessType);
+
+  formData.append('preferredFilename', (file as File).name);
+
+  if (feedType) {
+    formData.append('feedType', feedType);
+  }
+
+  const headers =
+    'getHeaders' in formData
+      ? (formData as any).getHeaders()
+      : { 'content-type': 'multipart/form-data' };
+
+  const { data } = await client.upload.post<Amity.CreateFilePayload<'clip'>>(
+    '/api/v4/clips',
+    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 */

package/src/fileRepository/api/uploadFile.ts

@@ -0,0 +1,63 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import GlobalFileAccessType from '~/client/utils/GlobalFileAccessType';
+
+/* begin_public_function
+  id: file.upload.file
+*/
+/**
+ * ```js
+ * import { FileRepository } from '@amityco/ts-sdk'
+ * const created = await FileRepository.uploadFile(formData)
+ * ```
+ *
+ * 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
+ * @async
+ */
+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/uploadFile', formData);
+
+  const files = formData.getAll('files');
+
+  if (!files.length) throw new Error('The formData object must have a `files` key.');
+
+  const accessType = GlobalFileAccessType.getInstance().getFileAccessType();
+  formData.append('accessType', accessType);
+
+  formData.append('preferredFilename', (files[0] as File).name);
+
+  const headers =
+    'getHeaders' in formData
+      ? (formData as any).getHeaders()
+      : { 'content-type': 'multipart/form-data' };
+
+  const { data } = await client.upload.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
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache({ files: data }, { cachedAt });
+
+  return {
+    data,
+    cachedAt,
+  };
+};
+/* end_public_function */