@amityco/ts-sdk-react-native 6.14.2-5d7d534.0 → 6.15.1-fee6c8f.0

package/src/communityRepository/communityMembership/api/queryCommunityMembers.ts

@@ -2,7 +2,6 @@ import { pullFromCache, pushToCache } from '~/cache/api';
 import { getActiveClient } from '~/client/api';
 import { getResolver } from '~/core/model';
 
-import { toPage, toToken } from '~/core/query';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { prepareMembershipPayload } from '~/group/utils';
 
@@ -22,20 +21,25 @@ import { prepareMembershipPayload } from '~/group/utils';
  * */
 export const queryCommunityMembers = async (
   query: Amity.QueryCommunityMembers,
-): Promise<Amity.Cached<Amity.Paged<Amity.Membership<'community'>>>> => {
+): Promise<Amity.Cached<Amity.PageToken<Amity.Membership<'community'>>>> => {
   const client = getActiveClient();
   client.log('community/queryCommunityMembers', query);
 
-  const { page, ...params } = query ?? {};
+  const { page, limit, ...params } = query ?? {};
+
+  const options = (() => {
+    if (page) return { token: page };
+    if (limit) return { limit };
+
+    return undefined;
+  })();
 
   const { data: queryPayload } = await client.http.get<
     Amity.CommunityMembershipPayload & Amity.Pagination
   >(`/api/v3/communities/${params.communityId}/users`, {
     params: {
       ...params,
-      options: {
-        token: toToken(page, 'skiplimit'),
-      },
+      options,
     },
   });
 
@@ -47,11 +51,7 @@ export const queryCommunityMembers = async (
   if (client.cache) {
     ingestInCache(preparedPayload, { cachedAt });
 
-    const cacheKey = [
-      'communityUsers',
-      'query',
-      { ...params, options: { ...page } } as Amity.Serializable,
-    ];
+    const cacheKey = ['communityUsers', 'query', { ...params, options } as Amity.Serializable];
 
     pushToCache(cacheKey, {
       communityUsers: communityUsers.map(({ communityId, userId }) =>
@@ -61,10 +61,7 @@ export const queryCommunityMembers = async (
     });
   }
 
-  const nextPage = toPage(paging.next);
-  const prevPage = toPage(paging.previous);
-
-  return { data: communityUsers, cachedAt, nextPage, prevPage };
+  return { data: communityUsers, cachedAt, paging };
 };
 
 /**
@@ -80,19 +77,24 @@ export const queryCommunityMembers = async (
  *
  * @category Post API
  */
-queryCommunityMembers.locally = (query: Parameters<typeof queryCommunityMembers>[0]) => {
+queryCommunityMembers.locally = (
+  query: Parameters<typeof queryCommunityMembers>[0],
+): Amity.Cached<Amity.PageToken<Amity.Membership<'community'>>> | undefined => {
   const client = getActiveClient();
   client.log('community/queryCommunityMembers', query);
 
   if (!client.cache) return;
 
-  const { page, ...params } = query ?? {};
+  const { page, limit, ...params } = query ?? {};
+
+  const options = (() => {
+    if (page) return { token: page };
+    if (limit) return { limit };
+
+    return undefined;
+  })();
 
-  const cacheKey = [
-    'communityUsers',
-    'query',
-    { ...params, options: { ...page } } as Amity.Serializable,
-  ];
+  const cacheKey = ['communityUsers', 'query', { ...params, options } as Amity.Serializable];
 
   const { data, cachedAt } =
     pullFromCache<
@@ -108,10 +110,9 @@ queryCommunityMembers.locally = (query: Parameters<typeof queryCommunityMembers>
     .filter(Boolean)
     .map(({ data }) => data);
 
-  const prevPage = toPage(data?.paging.previous);
-  const nextPage = toPage(data?.paging.next);
+  const { paging } = data;
 
   return communityUsers.length === data?.communityUsers?.length
-    ? { data: communityUsers, cachedAt, prevPage, nextPage }
+    ? { data: communityUsers, cachedAt, paging }
     : undefined;
 };

package/src/communityRepository/communityMembership/observers/getMembers.ts

@@ -152,16 +152,17 @@ export const getMembers = (
 
     const query = createQuery(queryCommunityMembers, {
       ...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: communityMembers,
         };
 

package/src/communityRepository/observers/getCommunities.ts

@@ -68,7 +68,7 @@ export const getCommunities = (
   const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
 
   const disposers: Amity.Unsubscriber[] = [];
-  const cacheKey = ['community', 'collection', {}];
+  const cacheKey = ['community', 'collection', queryParams as Amity.Serializable];
 
   const responder = (data: Amity.CommunityLiveCollectionCache) => {
     let communities: Amity.Community[] =
@@ -148,21 +148,24 @@ export const getCommunities = (
 
     const query = createQuery(queryCommunities, {
       ...queryParams,
-      page: !initial ? collection?.params.page : { 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: communities,
         };
 
         if (result) {
-          data.data = [...new Set([...communities, ...result.map(getResolver('community'))])];
+          data.data = initial
+            ? result.map(getResolver('community'))
+            : [...new Set([...communities, ...result.map(getResolver('community'))])];
         }
 
         pushToCache(cacheKey, data);

package/src/communityRepository/utils/payload.ts

@@ -36,15 +36,20 @@ export const prepareCommunityPayload = (
 };
 
 export const prepareCommunityRequest = <
-  T extends { postSetting?: Amity.Community['postSetting']; [k: string]: any },
+  T extends {
+    postSetting?: Amity.Community['postSetting'];
+    [k: string]: any;
+  },
 >(
   params: T,
 ) => {
-  const { postSetting = undefined, ...restParam } = params;
+  const { postSetting = undefined, storySetting, ...restParam } = params;
 
   return {
     ...restParam,
     // Repack community payload by mapping postSetting to the actual value.
     ...(postSetting ? CommunityPostSettingMaps[postSetting] : undefined),
+    // Convert story setting to the actual value. (Allow by default)
+    allowCommentInStory: storySetting?.enableComment !== false,
   };
 };

package/src/core/liveCollection/LiveCollectionController.ts

@@ -1,11 +1,15 @@
+import { convertGetterPropsToStatic } from '~/utils/object';
 import { PaginationController } from './PaginationController';
 import { isEqual } from '~/utils/isEqual';
+import { PaginationNoPageController } from './PaginationNoPageController';
 
 export abstract class LiveCollectionController<
   TPayloadDomain extends keyof Amity.Payloads,
   TQueryParams,
-  TPublicPayload,
-  TPaginationController extends PaginationController<TPayloadDomain, TQueryParams>,
+  TPublicPayload extends Record<string, unknown>,
+  TPaginationController extends
+    | PaginationController<TPayloadDomain, TQueryParams>
+    | PaginationNoPageController<TPayloadDomain, TQueryParams>,
 > {
   protected paginationController: TPaginationController;
 
@@ -31,7 +35,13 @@ export abstract class LiveCollectionController<
 
   private async refresh() {
     try {
-      const result = await this.paginationController.loadFirstPage();
+      let result;
+
+      if (this.paginationController instanceof PaginationNoPageController) {
+        result = await this.paginationController.onFetch();
+      } else {
+        result = await this.paginationController.loadFirstPage();
+      }
       if (!result) return;
 
       await this.persistModel(result);
@@ -68,6 +78,8 @@ export abstract class LiveCollectionController<
 
   async loadNextPage() {
     try {
+      if (this.paginationController instanceof PaginationNoPageController) return;
+
       const result = await this.paginationController.loadNextPage();
       if (!result) return;
 
@@ -85,6 +97,8 @@ export abstract class LiveCollectionController<
 
   async loadPrevPage() {
     try {
+      if (this.paginationController instanceof PaginationNoPageController) return;
+
       const result = await this.paginationController.loadPreviousPage();
       if (!result) return;
 
@@ -101,7 +115,7 @@ export abstract class LiveCollectionController<
   }
 
   protected abstract persistModel(
-    response: Amity.Payloads[TPayloadDomain] & Amity.Pagination,
+    response: Amity.Payloads[TPayloadDomain] & Partial<Amity.Pagination>,
   ): Promise<void>;
 
   protected abstract persistQueryStream({
@@ -117,7 +131,7 @@ export abstract class LiveCollectionController<
   protected shouldNotify(data: TPublicPayload[]) {
     if (isEqual(this.snapshot, data)) return false;
 
-    this.snapshot = data;
+    this.snapshot = data.map(payload => convertGetterPropsToStatic(payload)) as TPublicPayload[];
     return true;
   }
 

package/src/core/liveCollection/PaginationNoPageController.ts

@@ -0,0 +1,26 @@
+import { AxiosInstance } from 'axios';
+import { getActiveClient } from '~/client/api';
+
+export abstract class PaginationNoPageController<
+  TPayloadDomain extends keyof Amity.Payloads,
+  TQueryParams,
+> {
+  private queryParams: TQueryParams;
+
+  protected http: AxiosInstance;
+
+  constructor(queryParams: TQueryParams) {
+    const { http } = getActiveClient();
+
+    this.queryParams = queryParams;
+    this.http = http;
+  }
+
+  async onFetch() {
+    const queryResponse = await this.getRequest(this.queryParams);
+
+    return queryResponse;
+  }
+
+  abstract getRequest(queryParams: TQueryParams): Promise<Amity.Payloads[TPayloadDomain]>;
+}

package/src/core/model/idResolvers.ts

@@ -46,6 +46,8 @@ const idResolvers: Resolvers = {
   followCount: ({ userId }) => userId,
 
   feed: ({ targetId, feedId }) => `${targetId}#${feedId}`,
+  story: ({ referenceId }) => referenceId!,
+  storyTarget: ({ targetId }) => targetId,
 };
 
 /**

package/src/core/model/index.ts

@@ -9,6 +9,8 @@ export const PAYLOAD2MODEL: Record<string, Amity.Domain> = {
   users: 'user',
   files: 'file',
   roles: 'role',
+  stories: 'story',
+  storyTargets: 'storyTarget',
 
   channels: 'channel',
   messageFeeds: 'subChannel',

package/src/core/query/sorting.ts

@@ -53,6 +53,24 @@ export const sortByLastCreated: SortingFunc<{ createdAt: Date | number | string
   { createdAt: b },
 ) => new Date(b).valueOf() - new Date(a).valueOf();
 
+/**
+ * Sorting a collection by its oldest items
+ * -- Due to Amity.UpdatedAt is an optional type, we need to define a default value to 0 to prevent error
+ */
+export const sortByFirstUpdated: SortingFunc<{ updatedAt?: Date | number | string }> = (
+  { updatedAt: a = 0 },
+  { updatedAt: b = 0 },
+) => new Date(a).valueOf() - new Date(b).valueOf();
+
+/**
+ * Sorting a collection by its newest items
+ * -- Due to Amity.UpdatedAt is an optional type, we need to define a default value to 0 to prevent error
+ */
+export const sortByLastUpdated: SortingFunc<{ updatedAt?: Date | number | string }> = (
+  { updatedAt: a = 0 },
+  { updatedAt: b = 0 },
+) => new Date(b).valueOf() - new Date(a).valueOf();
+
 /**
  * Sorting a collection by the items with most recent activity
  */

package/src/feedRepository/api/getCustomRankingGlobalFeed.ts

@@ -26,21 +26,50 @@ import { LinkedObject } from '~/utils/linkedObject';
  * */
 export const getCustomRankingGlobalFeed = async (query?: {
   dataTypes?: ('video' | 'image' | 'file' | 'liveStream')[];
+  /**
+   * @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.Post>>> => {
+  limit?: number;
+  queryToken?: string;
+}): Promise<
+  Omit<Amity.Cached<Amity.Paged<Amity.Post>> & Amity.Pagination, 'nextPage' | 'prevPage'> & {
+    /**
+     * @deprecated use `paging.next` value as queryToken instead
+     */
+    nextPage?: Amity.Page;
+    /**
+     * @deprecated use `paging.previous` value as queryToken instead
+     */
+    prevPage?: Amity.Page;
+  }
+> => {
   const client = getActiveClient();
   client.log('feed/getCustomRankingGlobalFeed', query);
 
-  const { page, ...params } = query ?? {};
+  const { page, queryToken, limit, ...params } = query ?? {};
+
+  const options = (() => {
+    if (queryToken) return { token: queryToken };
+
+    if (page)
+      return {
+        token: toToken(page, 'skiplimit'),
+      };
+
+    return undefined;
+  })();
 
   const { data: queryPayload } = await client.http.get<Amity.PostPayload & Amity.Pagination>(
     `/api/v5/me/global-feeds`,
     {
       params: {
         ...params,
-        options: {
-          token: toToken(page, 'skiplimit'),
-        },
+        limit: !queryToken ? limit : undefined,
+        options,
       },
     },
   );
@@ -67,7 +96,7 @@ export const getCustomRankingGlobalFeed = async (query?: {
   const nextPage = toPage(paging.next);
   const prevPage = toPage(paging.previous);
 
-  return { data: posts.map(LinkedObject.post), cachedAt, prevPage, nextPage };
+  return { data: posts.map(LinkedObject.post), cachedAt, prevPage, nextPage, paging };
 };
 /* end_public_function */
 
@@ -87,7 +116,18 @@ export const getCustomRankingGlobalFeed = async (query?: {
  * */
 getCustomRankingGlobalFeed.locally = (
   query?: Parameters<typeof getCustomRankingGlobalFeed>[0],
-): Amity.Cached<Amity.Paged<Amity.Post>> | undefined => {
+):
+  | (Omit<Amity.Cached<Amity.Paged<Amity.Post>> & Amity.Pagination, 'nextPage' | 'prevPage'> & {
+      /**
+       * @deprecated use `paging.next` value as queryToken instead
+       */
+      nextPage?: Amity.Page;
+      /**
+       * @deprecated use `paging.previous` value as queryToken instead
+       */
+      prevPage?: Amity.Page;
+    })
+  | undefined => {
   const client = getActiveClient();
   client.log('post/getCustomRankingGlobalFeed.locally', query);
 
@@ -114,7 +154,9 @@ getCustomRankingGlobalFeed.locally = (
   const prevPage = toPage(data?.paging.previous);
   const nextPage = toPage(data?.paging.next);
 
+  const { paging } = data;
+
   return posts.length === data?.posts?.length
-    ? { data: posts.map(LinkedObject.post), cachedAt, prevPage, nextPage }
+    ? { data: posts.map(LinkedObject.post), cachedAt, prevPage, nextPage, paging }
     : undefined;
 };

package/src/feedRepository/api/queryGlobalFeed.ts

@@ -24,15 +24,24 @@ import { LinkedObject } from '~/utils/linkedObject';
  * @category Feed API
  * @async
  * */
-export const queryGlobalFeed = async (query?: {
-  dataTypes?: ('video' | 'image' | 'file' | 'liveStream')[];
-  useCustomRanking?: boolean;
-  page?: Amity.Page;
-}): Promise<Amity.Cached<Amity.Paged<Amity.Post>>> => {
+export const queryGlobalFeed = async (
+  query?: Amity.QueryGlobalFeed,
+): Promise<
+  Omit<Amity.Cached<Amity.Paged<Amity.Post> & Amity.Pagination>, 'nextPage' | 'prevPage'> & {
+    /**
+     * @deprecated use `paging.next` value as queryToken instead
+     */
+    nextPage?: Amity.Page;
+    /**
+     * @deprecated use `paging.previous` value as queryToken instead
+     */
+    prevPage?: Amity.Page;
+  }
+> => {
   const client = getActiveClient();
   client.log('feed/queryGlobalFeed', query);
 
-  const { useCustomRanking, page, ...params } = query ?? {};
+  const { useCustomRanking, page, queryToken, ...params } = query ?? {};
 
   /*
    * TODO: Remove useCustomRanking key from query
@@ -42,14 +51,24 @@ export const queryGlobalFeed = async (query?: {
       'The param "useCustomRanking" has been deprecated. To get custom ranking feed use FeedRepository.getCustomRankingGlobalFeed instead',
     );
 
+  if (page) console.warn('The param "page" has been deprecated. Please use "queryToken" instead.');
+
+  const options = (() => {
+    if (queryToken) return { token: queryToken };
+    if (page)
+      return {
+        token: toToken(page, 'skiplimit'),
+      };
+
+    return undefined;
+  })();
+
   const { data: queryPayload } = await client.http.get<Amity.PostPayload & Amity.Pagination>(
     `/api/v4/me/global-feeds`,
     {
       params: {
         ...params,
-        options: {
-          token: toToken(page, 'skiplimit'),
-        },
+        options,
       },
     },
   );
@@ -76,7 +95,13 @@ export const queryGlobalFeed = async (query?: {
   const nextPage = toPage(paging.next);
   const prevPage = toPage(paging.previous);
 
-  return { data: posts.map(LinkedObject.post), cachedAt, prevPage, nextPage };
+  return {
+    data: posts.map(LinkedObject.post),
+    cachedAt,
+    prevPage,
+    nextPage,
+    paging,
+  };
 };
 /* end_public_function */
 
@@ -96,7 +121,18 @@ export const queryGlobalFeed = async (query?: {
  * */
 queryGlobalFeed.locally = (
   query?: Parameters<typeof queryGlobalFeed>[0],
-): Amity.Cached<Amity.Paged<Amity.Post>> | undefined => {
+):
+  | (Omit<Amity.Cached<Amity.Paged<Amity.Post> & Amity.Pagination>, 'nextPage' | 'prevPage'> & {
+      /**
+       * @deprecated use `paging.next` value as queryToken instead
+       */
+      nextPage?: Amity.Page;
+      /**
+       * @deprecated use `paging.previous` value as queryToken instead
+       */
+      prevPage?: Amity.Page;
+    })
+  | undefined => {
   const client = getActiveClient();
   client.log('post/queryGlobalFeed.locally', query);
 
@@ -120,10 +156,18 @@ queryGlobalFeed.locally = (
     .map(({ data }) => data)
     .map(LinkedObject.post);
 
+  const { paging } = data;
+
   const prevPage = toPage(data?.paging.previous);
   const nextPage = toPage(data?.paging.next);
 
   return posts.length === data?.posts?.length
-    ? { data: posts, cachedAt, prevPage, nextPage }
+    ? {
+        data: posts,
+        cachedAt,
+        prevPage,
+        nextPage,
+        paging,
+      }
     : undefined;
 };

package/src/index.ts

@@ -28,7 +28,6 @@ export * as ChannelRepository from './channelRepository';
 export * as MessageRepository from './messageRepository';
 export * as SubChannelRepository from './subChannelRepository';
 
-export * from './marker/api';
 export * from './marker/events';
 
 // // asc social
@@ -43,5 +42,7 @@ export * as PollRepository from './pollRepository';
 
 export * as LiveStreamPlayer from './liveStreamPlayer';
 
+export * as StoryRepository from './storyRepository';
+
 // // external apis
 export * from './external/api';

package/src/marker/api/getChannelMarkers.ts

@@ -10,11 +10,8 @@ import { convertChannelMarkerResponse, convertUserMarkerResponse } from '~/utils
  * const channelMarkers = await getChannelMarkers(['ch1', 'ch2'])
  * ```
  *
- * Fetches a paginable list of {@link Amity.ChannelMarker} objects
- *
  * @param channelIds the IDs of the {@link Amity.RawChannel} marker to fetch
- * @param page
- * @returns A page of {@link Amity.ChannelMarker} objects
+ * @returns A List of {@link Amity.ChannelMarker} by channelIds
  *
  * @category Channel API
  * @async
@@ -22,24 +19,20 @@ import { convertChannelMarkerResponse, convertUserMarkerResponse } from '~/utils
  */
 export const getChannelMarkers = async (
   channelIds: Amity.Channel['channelId'][],
-  page: Amity.Page = { limit: 100 },
-): Promise<Amity.Cached<Amity.Paged<Amity.ChannelMarker>>> => {
+): Promise<Amity.Cached<Amity.ChannelMarker[]>> => {
   const client = getActiveClient();
-  client.log('channel/getChannelMarkers', channelIds, page);
+  client.log('channel/getChannelMarkers', channelIds);
 
   const { data: queryPayload } = await client.http.get<
     Amity.ChannelMarkerPayload & Amity.Pagination
   >(`/api/v1/markers/channels`, {
     params: {
       channelIds,
-      options: {
-        token: toToken(page, 'skiplimit'),
-      },
     },
   });
 
-  const { paging, ...payload } = queryPayload;
-  const { userEntityMarkers: userEntityMarkersPayload, userMarkers: userMarkersPayload } = payload;
+  const { userEntityMarkers: userEntityMarkersPayload, userMarkers: userMarkersPayload } =
+    queryPayload;
 
   const userMarkers = convertUserMarkerResponse(userMarkersPayload);
   const userEntityMarkers = convertChannelMarkerResponse(userEntityMarkersPayload);
@@ -52,8 +45,5 @@ export const getChannelMarkers = async (
   });
   fireEvent('local.userMarker.fetched', { userMarkers });
 
-  const nextPage = toPage(paging.next);
-  const prevPage = toPage(paging.previous);
-
-  return { data: userEntityMarkers, cachedAt, prevPage, nextPage };
+  return { data: userEntityMarkers, cachedAt };
 };

package/src/marker/api/getMessageMarkers.ts

@@ -10,11 +10,10 @@ import { convertUserMarkerResponse } from '~/utils/marker';
  * const messageMarkers = await getMessageMarkers(['sch1', 'sch2'])
  * ```
  *
- * Fetches a paginable list of {@link Amity.MessageMarker} objects
+ * Fetches a list of {@link Amity.MessageMarker} by messageIds
  *
  * @param messageIds the feed IDs of the {@link Amity.RawMessage} marker to fetch
- * @param page
- * @returns A page of {@link Amity.MessageMarker} objects
+ * @returns A list of {@link Amity.MessageMarker} by messageIds
  *
  * @category Channel API
  * @async
@@ -22,24 +21,20 @@ import { convertUserMarkerResponse } from '~/utils/marker';
  */
 export const getMessageMarkers = async (
   messageIds: Amity.RawMessage['messageFeedId'][],
-  page: Amity.Page = { limit: 100 },
-): Promise<Amity.Cached<Amity.Paged<Amity.MessageMarker>>> => {
+): Promise<Amity.Cached<Amity.MessageMarker[]>> => {
   const client = getActiveClient();
-  client.log('channel/getMessageMarkers', messageIds, page);
+  client.log('channel/getMessageMarkers', messageIds);
 
-  const { data: queryPayload } = await client.http.get<
-    Amity.MessageMarkerPayload & Amity.Pagination
-  >(`/api/v1/markers/messages`, {
-    params: {
-      messageIds,
-      options: {
-        token: toToken(page, 'skiplimit'),
+  const { data: queryPayload } = await client.http.get<Amity.MessageMarkerPayload>(
+    `/api/v1/markers/messages`,
+    {
+      params: {
+        messageIds,
       },
     },
-  });
+  );
 
-  const { paging, ...payload } = queryPayload;
-  const { contentMarkers, feedMarkers, userMarkers: userMarkersPayload } = payload;
+  const { contentMarkers, feedMarkers, userMarkers: userMarkersPayload } = queryPayload;
 
   const userMarkers = convertUserMarkerResponse(userMarkersPayload);
 
@@ -50,8 +45,5 @@ export const getMessageMarkers = async (
   fireEvent('local.messageMarker.fetched', { contentMarkers });
   fireEvent('local.userMarker.fetched', { userMarkers });
 
-  const nextPage = toPage(paging.next);
-  const prevPage = toPage(paging.previous);
-
-  return { data: contentMarkers, cachedAt, prevPage, nextPage };
+  return { data: contentMarkers, cachedAt };
 };