@amityco/ts-sdk-react-native 6.14.1 → 6.15.0

package/src/marker/api/tests/getChannelMarkers.test.ts

@@ -7,13 +7,6 @@ import { client, generateChannelMarker, generateUserMarker } from '~/utils/tests
 
 import { getChannelMarkers } from '../getChannelMarkers';
 
-const pagingToken = {
-  previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
-  next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
-};
-
-const pagingCriteria = { limit: 10 };
-
 const userId = 'user1';
 
 const expectedChannelMarkers = [
@@ -29,7 +22,6 @@ const resolvedGetValue = {
   data: {
     userEntityMarkers: expectedChannelMarkers,
     userMarkers: expectedUserMarkers,
-    paging: pagingToken,
   },
 };
 
@@ -45,11 +37,9 @@ describe('getChannelMarkers', () => {
   test('should return fetched channel markers with correct paging', async () => {
     client.http.get = jest.fn().mockResolvedValueOnce(resolvedGetValue);
 
-    await expect(getChannelMarkers(channelIds, pagingCriteria)).resolves.toEqual(
+    await expect(getChannelMarkers(channelIds)).resolves.toEqual(
       expect.objectContaining({
         data: expectedChannelMarkers,
-        prevPage: { before: 55, limit: 10 },
-        nextPage: { before: 55, limit: 10 },
       }),
     );
   });

package/src/marker/api/tests/getMessageMarkers.test.ts

@@ -12,13 +12,6 @@ import {
 
 import { getMessageMarkers } from '../getMessageMarkers';
 
-const pagingToken = {
-  previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
-  next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
-};
-
-const pagingCriteria = { limit: 10 };
-
 const expectedMessageMarkers = [
   generateMessageMarker({ feedId: 'sub-ch1', contentId: 'message1' }),
   generateMessageMarker({ feedId: 'sub-ch1', contentId: 'message2' }),
@@ -38,7 +31,6 @@ const resolvedGetValue = {
     contentMarkers: expectedMessageMarkers,
     feedMarkers: expectedFeedMarkers,
     userMarkers: userMarkersResponse,
-    paging: pagingToken,
   } as Amity.MessageMarkerPayload,
 };
 
@@ -54,11 +46,9 @@ describe('getMessageMarkers', () => {
   test('should return fetched message markers with correct paging', async () => {
     client.http.get = jest.fn().mockResolvedValueOnce(resolvedGetValue);
 
-    await expect(getMessageMarkers(messageIds, pagingCriteria)).resolves.toEqual(
+    await expect(getMessageMarkers(messageIds)).resolves.toEqual(
       expect.objectContaining({
         data: expectedMessageMarkers,
-        prevPage: { before: 55, limit: 10 },
-        nextPage: { before: 55, limit: 10 },
       }),
     );
   });

package/src/marker/events/onMessageMarked.ts

@@ -1,8 +1,11 @@
+import { get } from 'http';
 import { pullFromCache, pushToCache, queryCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getActiveClient } from '~/client/api';
 import { createEventSubscriber } from '~/core/events';
+import { getResolver } from '~/core/model';
 import { isObject } from '~/utils/object';
+import { shallowClone } from '~/utils/shallowClone';
 
 /**
  * ```js
@@ -36,11 +39,7 @@ export const onMessageMarked = (
        * use feedId of the feedMarkers to check if it equal to subChannelId.
        */
       const currentMessageCollection = cacheCollection.filter(currentMessage => {
-        const cacheKey = currentMessage.key;
-        if (!isObject(cacheKey[2])) return false;
-
-        const queryParams = cacheKey[2] as Amity.MessagesLiveCollection;
-        return queryParams.subChannelId === feedMarkers[0].feedId;
+        return currentMessage.data?.query?.subChannelId === feedMarkers[0].feedId;
       });
 
       if (currentMessageCollection.length > 0 && contentMarkers?.length > 0) {

package/src/messagePreview/utils/getChannelMessagePreviewWithUser.ts

@@ -1,15 +1,22 @@
 import { pullFromCache } from '~/cache/api';
 import { getChannelMessagePreview } from './getChannelMessagePreview';
+import { LinkedObject } from '~/utils/linkedObject';
 
-export const getChannelMessagePreviewWithUser = (channel: Amity.Channel) => {
+export const getChannelMessagePreviewWithUser = (channel: Amity.InternalChannel): Amity.Channel => {
   const messagePreview = channel.messagePreviewId
     ? getChannelMessagePreview(channel.channelId)
     : null;
 
+  const internalUser = pullFromCache<Amity.InternalUser>([
+    'user',
+    'get',
+    messagePreview?.creatorId,
+  ])?.data;
+
   const messagePreviewWithUser = messagePreview
     ? {
         ...messagePreview,
-        user: pullFromCache<Amity.InternalUser>(['user', 'get', messagePreview?.creatorId])?.data,
+        user: internalUser ? LinkedObject.user(internalUser) : undefined,
       }
     : null;
 

package/src/messageRepository/observers/liveCollection/MessageLiveCollectionController.ts

@@ -56,6 +56,7 @@ export class MessageLiveCollectionController extends LiveCollectionController<
     if (!collection) {
       pushToCache(this.cacheKey, {
         data: [],
+        query: this.query,
       });
     }
   }

package/src/messageRepository/observers/liveCollection/MessageQueryStreamController.ts

@@ -44,13 +44,14 @@ export class MessageQueryStreamController extends QueryStreamController<
   }
 
   appendToQueryStream(
-    response: Amity.MessagePayload & Amity.Pagination,
+    response: Amity.MessagePayload & Partial<Amity.Pagination>,
     direction: Amity.LiveCollectionPageDirection,
     refresh = false,
   ) {
     if (refresh) {
       pushToCache(this.cacheKey, {
         data: response.messages.map(getResolver('message')),
+        query: this.query,
       });
     } else {
       const collection = pullFromCache<Amity.MessageLiveCollectionCache>(this.cacheKey)?.data;

package/src/postRepository/api/queryPosts.ts

@@ -26,13 +26,20 @@ import { LinkedObject } from '~/utils/linkedObject';
  */
 export const queryPosts = async (
   query: Amity.QueryPosts,
-): Promise<Amity.Cached<Amity.Paged<Amity.Post, Amity.PageRaw>>> => {
+): Promise<Amity.Cached<Amity.PageToken<Amity.Post>>> => {
   const client = getActiveClient();
   client.log('post/queryPosts', query);
 
-  const { page = { limit: 10 }, includeDeleted, ...params } = query;
+  const { page, limit = 10, includeDeleted, ...params } = query;
   const { dataTypes, matchingOnlyParentPost } = params;
 
+  const options = (() => {
+    if (page) return { token: page };
+    if (limit) return { limit };
+
+    return undefined;
+  })();
+
   // API-FIX: parameters should be querystring. (1)
   // API-FIX: backend should answer Amity.Response (2)
   // const { data } = await client.http.get<Amity.Response<Amity.PagedResponse<Amity.PostPayload>>>(
@@ -48,9 +55,7 @@ export const queryPosts = async (
        * By default, BE queries only parent post
        */
       matchingOnlyParentPost: matchingOnlyParentPost ?? !dataTypes?.length,
-      options: {
-        token: toToken(page, 'afterbeforeraw'),
-      },
+      options,
     },
   });
 
@@ -66,12 +71,9 @@ export const queryPosts = async (
   if (client.cache) {
     ingestInCache(paperedPayload, { cachedAt });
 
-    const cacheKey = ['post', 'query', { ...params, options: { ...page } } as Amity.Serializable];
+    const cacheKey = ['post', 'query', { ...params, options } as Amity.Serializable];
     pushToCache(cacheKey, { posts: posts.map(getResolver('post')), paging });
   }
 
-  const nextPage = toPageRaw(paging.next);
-  const prevPage = toPageRaw(paging.previous);
-
-  return { data: posts.map(LinkedObject.post), cachedAt, prevPage, nextPage };
+  return { data: posts.map(LinkedObject.post), cachedAt, paging };
 };

package/src/postRepository/observers/getPosts.ts

@@ -150,21 +150,24 @@ export const getPosts = (
 
     const query = createQuery(queryPosts, {
       ...queryParams,
-      page: (!initial ? collection?.params.page : undefined) ?? { limit },
+      limit: initial ? limit : undefined,
+      page: !initial ? collection?.params.page : undefined,
     });
 
     runQuery(
       query,
-      ({ data: result, error, loading, nextPage: page }) => {
+      ({ data: result, error, loading, paging }) => {
         const data = {
           loading,
           error,
-          params: { page },
+          params: { page: paging?.next },
           data: posts,
         };
 
         if (result) {
-          data.data = [...new Set([...posts, ...result.map(getResolver('post'))])];
+          data.data = initial
+            ? result.map(getResolver('post'))
+            : [...new Set([...posts, ...result.map(getResolver('post'))])];
         }
 
         pushToCache(cacheKey, data);

package/src/role/api/queryRoles.ts

@@ -21,12 +21,33 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 export const queryRoles = async (query?: {
   displayName?: Amity.Role['displayName'];
   sortBy?: 'displayName' | 'firstCreated' | 'lastCreated';
+  /**
+   * @deprecated please use `queryToken` to query next pages or previous pages
+   * The first page result includes previous token and next token in paging field
+   * use this token as the `queryToken` to query next pages or previous pages
+   *
+   */
   page?: Amity.Page;
-}): Promise<Amity.Cached<Amity.Paged<Amity.Role>>> => {
+  limit?: number;
+  queryToken?: string;
+}): Promise<Amity.Cached<Amity.Paged<Amity.Role>> & Amity.Pagination> => {
   const client = getActiveClient();
   client.log('role/queryRoles', query);
 
-  const { page = { limit: 10 }, displayName, sortBy, ...params } = query ?? {};
+  const { page, limit = 10, queryToken, displayName, sortBy, ...params } = query ?? {};
+
+  const options = (() => {
+    if (queryToken) return { token: queryToken };
+
+    if (limit) return { limit };
+
+    if (page)
+      return {
+        token: toToken(page, 'skiplimit'),
+      };
+
+    return undefined;
+  })();
 
   // API-FIX: parameters should be querystring.
   const { data } = await client.http.get<Amity.RolePayload & Amity.Pagination>(`/api/v3/roles`, {
@@ -34,9 +55,7 @@ export const queryRoles = async (query?: {
       ...params,
       keyword: displayName,
       sortBy,
-      options: {
-        token: toToken(page, 'skiplimit'),
-      },
+      options,
     },
   });
 
@@ -49,7 +68,7 @@ export const queryRoles = async (query?: {
   const nextPage = toPage(paging.next);
   const prevPage = toPage(paging.previous);
 
-  return { data: roles, cachedAt, prevPage, nextPage };
+  return { data: roles, cachedAt, prevPage, nextPage, paging };
 };
 
 /**

package/src/storyRepository/api/createImageStory.ts

@@ -0,0 +1,94 @@
+import { uploadImage } from '~/fileRepository';
+import { uuid } from '~/core/uuid';
+import { fireEvent } from '~/core/events';
+import { createOptimisticEvent } from '~/storyRepository/utils/createOptimisticEvent';
+import { LinkedObject } from '~/utils/linkedObject';
+import { createStory } from '../internalApi/createStory';
+
+/**
+ * ```js
+ * import { StoryRepository } from '@amityco/ts-sdk-react-native'
+ * StoryRepository.createImageStory('community', 'communityId', formData, metadata, imageDisplayMode, items)
+ * ```
+ *
+ * Create a new image story
+ * @param targetType The type of the target
+ * @param targetId The id of the target
+ * @param formData The form data
+ * @param metadata The metadata
+ * @param items The story items
+ * @param imageDisplayMode The image display mode
+ * @returns The created story
+ */
+export const createImageStory = async (
+  targetType: Amity.InternalStory['targetType'],
+  targetId: Amity.InternalStory['targetId'],
+  formData: FormData,
+  metadata: Amity.Metadata = {},
+  imageDisplayMode: Amity.ImageDisplayMode = 'fit',
+  items: Amity.StoryItem[] = [],
+): Promise<Amity.Cached<Amity.Story | undefined>> => {
+  if (!formData.getAll('files').length) {
+    throw new Error('The formData object must have a `files` key.');
+  }
+
+  let payload: Amity.StoryCreatePayload = {
+    data: {
+      text: '', // Still not in used now
+      fileId: undefined,
+      fileData: null,
+      imageDisplayMode,
+    },
+    syncState: Amity.SyncState.Syncing,
+    referenceId: uuid(),
+    dataType: Amity.StoryDataType.Image,
+    items,
+    targetType,
+    targetId,
+    metadata,
+  };
+
+  // Fire optimistic event
+  createOptimisticEvent({ payload, formData }, optimisticData => {
+    fireEvent('story.created', optimisticData);
+  });
+
+  try {
+    const { data } = await uploadImage(formData);
+
+    // @TODO: Need to implement retrying logic in a future
+    if (data.length === 0) throw new Error('Failed to upload image');
+    const { fileId } = data[0];
+
+    payload = {
+      ...payload,
+      data: {
+        ...payload.data,
+        fileId,
+      },
+    };
+
+    // Fire optimistic event - update fileId
+    createOptimisticEvent({ payload, formData }, optimisticData => {
+      fireEvent('story.created', optimisticData);
+    });
+
+    const result = await createStory(payload);
+    if (!result.data) return result;
+
+    return {
+      ...result,
+      data: LinkedObject.story(result.data),
+    };
+  } catch (error) {
+    // Fire optimistic event - failed to upload image
+    createOptimisticEvent(
+      { payload: { ...payload, syncState: Amity.SyncState.Error }, formData },
+      optimisticData => {
+        fireEvent('story.error', optimisticData);
+      },
+    );
+
+    throw error;
+  }
+};

package/src/storyRepository/api/createVideoStory.ts

@@ -0,0 +1,92 @@
+import { uploadVideo } from '~/fileRepository';
+import { uuid } from '~/core/uuid';
+import { fireEvent } from '~/core/events';
+import { createOptimisticEvent } from '~/storyRepository/utils/createOptimisticEvent';
+import { ContentFeedType } from '~/@types';
+import { LinkedObject } from '~/utils/linkedObject';
+import { createStory } from '../internalApi/createStory';
+
+/**
+ * ```js
+ * import { StoryRepository } from '@amityco/ts-sdk-react-native'
+ * StoryRepository.createVideoStory('community', 'communityId', formData, metadata, items)
+ * ```
+ *
+ * Create a new video story
+ * @param targetType
+ * @param targetId
+ * @param formData
+ * @param metadata
+ * @param items
+ */
+
+export const createVideoStory = async (
+  targetType: Amity.InternalStory['targetType'],
+  targetId: Amity.InternalStory['targetId'],
+  formData: FormData,
+  metadata: Amity.Metadata = {},
+  items: Amity.StoryItem[] = [],
+): Promise<Amity.Cached<Amity.Story | undefined>> => {
+  if (!formData.getAll('files').length)
+    throw new Error('The formData object must have a `files` key.');
+
+  let payload: Amity.StoryCreatePayload = {
+    data: {
+      text: '', // Still not in used now
+      fileId: undefined,
+      fileData: null,
+    },
+    syncState: Amity.SyncState.Syncing,
+    referenceId: uuid(),
+    dataType: Amity.StoryDataType.Video,
+    items,
+    targetType,
+    targetId,
+    metadata,
+  };
+
+  // Fire optimistic event
+  createOptimisticEvent({ payload, formData, isVideo: true }, optimisticData => {
+    fireEvent('story.created', optimisticData);
+  });
+
+  try {
+    const { data } = await uploadVideo(formData, ContentFeedType.STORY);
+
+    // @TODO: Need to implement retrying logic in a future
+    if (data.length === 0) throw new Error('Failed to upload video');
+    const { fileId } = data[0];
+
+    payload = {
+      ...payload,
+      data: {
+        ...payload.data,
+        fileId,
+        videoFileId: { original: fileId },
+      },
+    };
+
+    // Fire optimistic event - update fileId
+    createOptimisticEvent({ payload, formData, isVideo: true }, optimisticData => {
+      fireEvent('story.created', optimisticData);
+    });
+
+    const result = await createStory(payload);
+    if (!result.data) return result;
+
+    return {
+      ...result,
+      data: LinkedObject.story(result.data),
+    };
+  } catch (error) {
+    // Fire optimistic upload failed
+    createOptimisticEvent(
+      { payload: { ...payload, syncState: Amity.SyncState.Error }, formData, isVideo: true },
+      optimisticData => {
+        fireEvent('story.error', optimisticData);
+      },
+    );
+
+    throw error;
+  }
+};

package/src/storyRepository/api/hardDeleteStory.ts

@@ -0,0 +1,6 @@
+import { deleteStory } from '~/storyRepository/internalApi/deleteStory';
+
+export const hardDeleteStory = async (storyId: Amity.Story['storyId']): Promise<boolean> => {
+  const result = await deleteStory(storyId, true);
+  return result;
+};

package/src/storyRepository/api/index.ts

@@ -0,0 +1,4 @@
+export * from './createImageStory';
+export * from './createVideoStory';
+export * from './hardDeleteStory';
+export * from './softDeleteStory';

package/src/storyRepository/api/softDeleteStory.ts

@@ -0,0 +1,6 @@
+import { deleteStory } from '~/storyRepository/internalApi/deleteStory';
+
+export const softDeleteStory = async (storyId: Amity.Story['storyId']): Promise<boolean> => {
+  const result = await deleteStory(storyId);
+  return result;
+};

package/src/storyRepository/events/onStoryCreated.ts

@@ -0,0 +1,14 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+export const onStoryCreated = (callback: Amity.Listener<Amity.InternalStory[]>) => {
+  const client = getActiveClient();
+
+  const filter = async (payload: Amity.StoryPayload) => {
+    ingestInCache(payload);
+    callback(payload.stories);
+  };
+
+  return createEventSubscriber(client, 'onStoryCreated', 'story.created', filter);
+};

package/src/storyRepository/events/onStoryDeleted.ts

@@ -0,0 +1,14 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+export const onStoryDeleted = (callback: Amity.Listener<Amity.InternalStory[]>) => {
+  const client = getActiveClient();
+
+  const filter = async (payload: Amity.StoryPayload) => {
+    ingestInCache(payload);
+    callback(payload.stories);
+  };
+
+  return createEventSubscriber(client, 'onStoryDeleted', 'story.deleted', filter);
+};

package/src/storyRepository/events/onStoryError.ts

@@ -0,0 +1,14 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+export const onStoryError = (callback: Amity.Listener<Amity.InternalStory[]>) => {
+  const client = getActiveClient();
+
+  const filter = async (payload: Amity.StoryPayload) => {
+    ingestInCache(payload);
+    callback(payload.stories);
+  };
+
+  return createEventSubscriber(client, 'onStoryError', 'story.error', filter);
+};

package/src/storyRepository/index.ts

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

package/src/storyRepository/internalApi/createStory.ts

@@ -0,0 +1,26 @@
+import { getActiveClient } from '~/client';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { convertStoryRawToInternal } from '~/storyRepository/utils/convertRawToStory';
+import { fireEvent } from '~/core/events';
+
+export const createStory = async (
+  payload: Amity.StoryCreatePayload,
+): Promise<Amity.Cached<Amity.InternalStory | undefined>> => {
+  const client = getActiveClient();
+  client.log('post/createStory', payload);
+
+  const response = await client.http.post<Amity.StoryPayload>('/api/v4/stories', payload);
+
+  const convertedResponse = convertStoryRawToInternal(response.data);
+
+  if (client.cache) ingestInCache(convertedResponse);
+
+  fireEvent('story.created', convertedResponse);
+
+  const cachedAt = client.cache && Date.now();
+
+  return {
+    data: convertedResponse.stories.length > 0 ? convertedResponse.stories[0] : undefined,
+    cachedAt,
+  };
+};

package/src/storyRepository/internalApi/deleteStory.ts

@@ -0,0 +1,35 @@
+import { getActiveClient } from '~/client';
+import { fireEvent } from '~/core/events';
+import { getStoryCache } from '../utils/getStoryCache';
+
+export const deleteStory = async (
+  storyId: Amity.Story['storyId'],
+  permanent = false,
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('story/deleteStory', storyId);
+
+  let cached;
+
+  if (client.cache) {
+    cached = getStoryCache(storyId);
+    if (cached?.data) {
+      const { data } = cached;
+      fireEvent('story.deleted', {
+        categories: [],
+        comments: [],
+        communities: [],
+        communityUsers: [],
+        files: [],
+        users: [],
+        stories: [{ ...data, isDeleted: true }],
+      });
+    }
+  }
+
+  const response = await client.http.delete(`/api/v4/stories/${storyId}`, {
+    params: { permanent },
+  });
+
+  return response.data.success;
+};

package/src/storyRepository/internalApi/getActiveStoriesByTarget.ts

@@ -0,0 +1,36 @@
+import { getActiveClient } from '~/client';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { convertStoryRawToInternal } from '~/storyRepository/utils/convertRawToStory';
+
+export const getActiveStoriesByTarget = async (
+  targetType: Amity.InternalStory['targetType'],
+  targetId: Amity.InternalStory['targetId'],
+  option?: Amity.StorySortOption,
+): Promise<Amity.Cached<Amity.PageToken<Amity.InternalStory>>> => {
+  const client = getActiveClient();
+  client.log('story/getActiveStoriesByTarget');
+  const cachedAt = client.cache && Date.now();
+
+  const response = await client.http.get<Amity.StoryPayload>('/api/v4/stories', {
+    params: {
+      targetType,
+      targetId,
+      options: {
+        sortBy: option?.sortBy || 'createdAt',
+        orderBy: option?.orderBy || 'desc',
+      },
+    },
+  });
+
+  const convertedData: Amity.StoryPayload = convertStoryRawToInternal(response.data);
+
+  if (client.cache) {
+    ingestInCache(convertedData);
+  }
+
+  return {
+    data: convertedData.stories,
+    cachedAt,
+    paging: { next: undefined, previous: undefined }, // Disable pagination for this API
+  };
+};