@amityco/ts-sdk-react-native 6.13.2 → 6.14.0

package/src/categoryRepository/internalApi/getCategory.ts

@@ -0,0 +1,43 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+export const getCategory = async (
+  categoryId: Amity.InternalCategory['categoryId'],
+): Promise<Amity.Cached<Amity.InternalCategory>> => {
+  const client = getActiveClient();
+  client.log('category/getCategory', categoryId);
+
+  const { data } = await client.http.get<Amity.CategoryPayload>(
+    `/api/v3/community-categories/${encodeURIComponent(categoryId)}`,
+  );
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { categories } = data;
+
+  return {
+    data: categories.find(category => category.categoryId === categoryId)!,
+    cachedAt,
+  };
+};
+
+getCategory.locally = (
+  categoryId: Amity.InternalCategory['categoryId'],
+): Amity.Cached<Amity.InternalCategory> | undefined => {
+  const client = getActiveClient();
+  client.log('category/getCategory.locally', categoryId);
+
+  if (!client.cache) return;
+
+  const cached = pullFromCache<Amity.InternalCategory>(['category', 'get', categoryId]);
+
+  if (!cached) return;
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  };
+};

package/src/categoryRepository/internalApi/index.ts

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

package/src/categoryRepository/internalApi/queryCategories.ts

@@ -0,0 +1,88 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { toToken, toPage } from '~/core/query';
+
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getResolver } from '~/core/model';
+
+import { inferIsDeleted } from '~/utils/inferIsDeleted';
+
+export const queryCategories = async (
+  query?: Amity.QueryCategories,
+): Promise<Amity.Cached<Amity.Paged<Amity.InternalCategory, Amity.Page>>> => {
+  const client = getActiveClient();
+  client.log('category/queryCategories', query);
+
+  const { page = { limit: 10 }, includeDeleted, ...params } = query ?? {};
+
+  const { data } = await client.http.get<Amity.CategoryPayload & Amity.Pagination>(
+    `/api/v3/community-categories`,
+    {
+      params: {
+        ...params,
+        isDeleted: inferIsDeleted(includeDeleted),
+        options: {
+          token: toToken(page, 'skiplimit'),
+        },
+      },
+    },
+  );
+
+  const { paging, ...payload } = data;
+  const { categories } = payload;
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) {
+    ingestInCache(payload as Amity.CategoryPayload, { cachedAt });
+
+    const cacheKey = [
+      'category',
+      'query',
+      { ...params, includeDeleted, options: { ...page } } as Amity.Serializable,
+    ];
+    pushToCache(cacheKey, { categories: categories.map(getResolver('category')), paging });
+  }
+
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
+
+  return {
+    data: categories,
+    cachedAt,
+    prevPage,
+    nextPage,
+  };
+};
+
+queryCategories.locally = (
+  query: Parameters<typeof queryCategories>[0],
+): Amity.Cached<Amity.Paged<Amity.InternalCategory, Amity.Page>> | undefined => {
+  const client = getActiveClient();
+  client.log('category/queryCategories.locally', query);
+
+  if (!client.cache) return;
+
+  const { page = { limit: 10 }, ...params } = query ?? {};
+
+  const queryKey = ['category', 'query', { ...params, options: { ...page } } as Amity.Serializable];
+  const { data, cachedAt } =
+    pullFromCache<{ categories: Pick<Amity.InternalCategory, 'categoryId'>[] } & Amity.Pagination>(
+      queryKey,
+    ) ?? {};
+
+  if (!data?.categories.length) return;
+
+  const categories: Amity.InternalCategory[] = data.categories
+    .map(categoryId => pullFromCache<Amity.InternalCategory>(['category', 'get', categoryId])!)
+    .filter(Boolean)
+    .map(({ data }) => data);
+
+  const prevPage = toPage(data?.paging.previous);
+  const nextPage = toPage(data?.paging.next);
+
+  return categories.length === data?.categories?.length
+    ? { data: categories, cachedAt, prevPage, nextPage }
+    : undefined;
+};

package/src/categoryRepository/observers/getCategories.ts

@@ -16,7 +16,7 @@ import {
   COLLECTION_DEFAULT_PAGINATION_LIMIT,
   ENABLE_CACHE_MESSAGE,
 } from '~/utils/constants';
-import { queryCategories } from '../api/queryCategories';
+import { queryCategories } from '../internalApi/queryCategories';
 import { LinkedObject } from '~/utils/linkedObject';
 
 /* begin_public_function

package/src/{channelRepsitory → channelRepository}/api/queryChannels.ts

@@ -40,9 +40,7 @@ export const queryChannels = async (
         ...params,
         keyword: displayName,
         filter: membership,
-        options: {
-          token: page,
-        },
+        options: page ? { token: page } : { limit },
       },
     },
   );

package/src/{channelRepsitory → channelRepository}/channelMembership/api/queryChannelMembers.ts

@@ -1,4 +1,4 @@
-import { prepareChannelPayload } from '~/channelRepsitory/utils';
+import { prepareChannelPayload } from '~/channelRepository/utils';
 import { getActiveClient } from '~/client/api';
 
 import { toPage, toToken } from '~/core/query';

package/src/{channelRepsitory → channelRepository}/channelMembership/api/tests/addMembers.test.ts

@@ -16,7 +16,7 @@ import {
   disconnectClient,
 } from '~/utils/tests';
 
-import { onChannelMemberAdded } from '~/channelRepsitory/events';
+import { onChannelMemberAdded } from '~/channelRepository/events';
 import { addMembers } from '../addMembers';
 import * as getChannelMarkers from '~/marker/api/getChannelMarkers';
 

package/src/{channelRepsitory → channelRepository}/channelMembership/api/tests/removeMembers.test.ts

@@ -15,7 +15,7 @@ import {
   disconnectClient,
 } from '~/utils/tests';
 
-import { onChannelMemberRemoved } from '~/channelRepsitory/events';
+import { onChannelMemberRemoved } from '~/channelRepository/events';
 
 import { removeMembers } from '../removeMembers';
 

package/src/{channelRepsitory → channelRepository}/observers/getChannels.ts

@@ -174,10 +174,10 @@ export const getChannels = (
 
     if (!initial && channels.length > 0 && !collection?.params.page) return;
 
+    const pagingCondition = initial ? { limit } : { page: collection?.params.page };
     const query = createQuery(queryChannels, {
       ...queryParams,
-      page: !initial ? collection?.params.page : undefined,
-      limit,
+      ...pagingCondition,
     });
 
     runQuery(
@@ -285,6 +285,8 @@ export const getChannels = (
       (callback: Amity.Listener<Amity.Message>) => {
         const updateMessagePreview = async (message: Amity.Message) => {
           const messagePreviewSetting = await getMessagePreviewSetting();
+          if (messagePreviewSetting === Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW) return;
+
           if (messagePreviewSetting === Amity.MessagePreviewSetting.MESSAGE_PREVIEW_INCLUDE_DELETED)
             await handleMessageUpdated(message);
 

package/src/client/api/login.ts

@@ -3,8 +3,8 @@ import { modifyMqttConnection } from '~/client/utils/modifyMqttConnection';
 /* eslint-disable require-atomic-updates */
 import { getDeviceId } from '~/core/device';
 import { proxyWebsocketEvents } from '~/core/events';
-import { onChannelDeleted } from '~/channelRepsitory/events/onChannelDeleted';
-import { onChannelMemberBanned } from '~/channelRepsitory/events/onChannelMemberBanned';
+import { onChannelDeleted } from '~/channelRepository/events/onChannelDeleted';
+import { onChannelMemberBanned } from '~/channelRepository/events/onChannelMemberBanned';
 
 import { markReadEngineOnLoginHandler } from '~/subChannelRepository/utils/markReadEngine';
 import { onUserDeleted } from '~/userRepository/events/onUserDeleted';

package/src/client/utils/markerSyncEngine.ts

@@ -3,7 +3,7 @@ import {
   onChannelDeleted,
   onChannelJoined,
   onChannelLeft,
-} from '~/channelRepsitory';
+} from '~/channelRepository';
 import { onUserMarkerSync } from '~/marker/events/onUserMarkerSync';
 import { setIntervalTask } from '~/utils/timer';
 import { getUserMarker } from '~/marker/api';

package/src/client/utils/messagePreviewEngine.ts

@@ -1,7 +1,7 @@
 import { dropFromCache, pullFromCache, pushToCache, queryCache } from '~/cache/api';
 import { getChatSettings } from '../api/getChatSettings';
 
-import { getChannelByIds } from '~/channelRepsitory/api/getChannelByIds';
+import { getChannelByIds } from '~/channelRepository/api/getChannelByIds';
 import { getSubChannels as getSubChannelByIds } from '~/subChannelRepository/api/getSubChannels';
 
 const convertMessagePreviewSetting = (

package/src/core/liveCollection/LiveCollectionController.ts

@@ -0,0 +1,127 @@
+import { PaginationController } from './PaginationController';
+import { isEqual } from '~/utils/isEqual';
+
+export abstract class LiveCollectionController<
+  TPayloadDomain extends keyof Amity.Payloads,
+  TQueryParams,
+  TPublicPayload,
+  TPaginationController extends PaginationController<TPayloadDomain, TQueryParams>,
+> {
+  protected paginationController: TPaginationController;
+
+  protected queryStreamId: string;
+
+  protected cacheKey: string[];
+
+  protected callback: Amity.LiveCollectionCallback<TPublicPayload>;
+
+  protected snapshot: TPublicPayload[] | undefined;
+
+  constructor(
+    paginationController: TPaginationController,
+    queryStreamId: string,
+    cacheKey: string[],
+    callback: Amity.LiveCollectionCallback<TPublicPayload>,
+  ) {
+    this.paginationController = paginationController;
+    this.queryStreamId = queryStreamId;
+    this.cacheKey = cacheKey;
+    this.callback = callback;
+  }
+
+  private async refresh() {
+    try {
+      const result = await this.paginationController.loadFirstPage();
+      if (!result) return;
+
+      await this.persistModel(result);
+
+      this.persistQueryStream({
+        response: result,
+        direction: Amity.LiveCollectionPageDirection.NEXT,
+        refresh: true,
+      });
+      this.notifyChange({ origin: Amity.LiveDataOrigin.SERVER, loading: false });
+    } catch (e) {
+      this.notifyChange({ origin: Amity.LiveDataOrigin.SERVER, loading: false, error: e });
+    }
+  }
+
+  protected loadPage(
+    initial = false,
+    direction: Amity.LiveCollectionPageDirection = Amity.LiveCollectionPageDirection.NEXT,
+  ) {
+    this.setup();
+
+    this.notifyChange({ origin: Amity.LiveDataOrigin.LOCAL, loading: true });
+
+    if (initial) {
+      this.refresh();
+    } else if (direction === Amity.LiveCollectionPageDirection.PREV) {
+      this.loadPrevPage();
+    } else if (direction === Amity.LiveCollectionPageDirection.NEXT) {
+      this.loadNextPage();
+    }
+  }
+
+  protected abstract setup(): void;
+
+  async loadNextPage() {
+    try {
+      const result = await this.paginationController.loadNextPage();
+      if (!result) return;
+
+      await this.persistModel(result);
+
+      this.persistQueryStream({
+        response: result,
+        direction: Amity.LiveCollectionPageDirection.NEXT,
+      });
+      this.notifyChange({ origin: Amity.LiveDataOrigin.SERVER, loading: false });
+    } catch (e) {
+      this.notifyChange({ origin: Amity.LiveDataOrigin.SERVER, loading: false, error: e });
+    }
+  }
+
+  async loadPrevPage() {
+    try {
+      const result = await this.paginationController.loadPreviousPage();
+      if (!result) return;
+
+      await this.persistModel(result);
+
+      this.persistQueryStream({
+        response: result,
+        direction: Amity.LiveCollectionPageDirection.PREV,
+      });
+      this.notifyChange({ origin: Amity.LiveDataOrigin.SERVER, loading: false });
+    } catch (e) {
+      this.notifyChange({ origin: Amity.LiveDataOrigin.SERVER, loading: false, error: e });
+    }
+  }
+
+  protected abstract persistModel(
+    response: Amity.Payloads[TPayloadDomain] & Amity.Pagination,
+  ): Promise<void>;
+
+  protected abstract persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<TPayloadDomain>): void;
+
+  abstract startSubscription(): Amity.Unsubscriber[];
+
+  abstract notifyChange(params: Amity.LiveCollectionNotifyParams): void;
+
+  protected shouldNotify(data: TPublicPayload[]) {
+    if (isEqual(this.snapshot, data)) return false;
+
+    this.snapshot = data;
+    return true;
+  }
+
+  public getCacheKey() {
+    return this.cacheKey;
+  }
+}

package/src/core/liveCollection/PaginationController.ts

@@ -0,0 +1,71 @@
+import { AxiosInstance } from 'axios';
+import { getActiveClient } from '~/client/api';
+
+export abstract class PaginationController<
+  TPayloadDomain extends keyof Amity.Payloads,
+  TQueryParams,
+> {
+  private queryParams: Amity.LiveCollectionParams<TQueryParams>;
+
+  protected http: AxiosInstance;
+
+  private previousToken: string | undefined;
+
+  private nextToken: string | undefined;
+
+  constructor(queryParams: Amity.LiveCollectionParams<TQueryParams>) {
+    const { http } = getActiveClient();
+
+    this.queryParams = queryParams;
+    this.http = http;
+  }
+
+  loadFirstPage(): Promise<(Amity.Payloads[TPayloadDomain] & Amity.Pagination) | undefined> {
+    return this.onFetch(Amity.LiveCollectionPageDirection.FIRST);
+  }
+
+  loadNextPage(): Promise<(Amity.Payloads[TPayloadDomain] & Amity.Pagination) | undefined> {
+    return this.onFetch(Amity.LiveCollectionPageDirection.NEXT);
+  }
+
+  loadPreviousPage(): Promise<(Amity.Payloads[TPayloadDomain] & Amity.Pagination) | undefined> {
+    return this.onFetch(Amity.LiveCollectionPageDirection.PREV);
+  }
+
+  async onFetch(
+    direction: Amity.LiveCollectionPageDirection = Amity.LiveCollectionPageDirection.FIRST,
+  ) {
+    if (direction === 'prev' && !this.previousToken) return;
+    if (direction === 'next' && !this.nextToken) return;
+
+    let token: string | undefined;
+
+    if (direction === 'prev') token = this.previousToken;
+    if (direction === 'next') token = this.nextToken;
+
+    const queryResponse = await this.getRequest(this.queryParams, token);
+
+    if (direction === 'first') {
+      this.nextToken = queryResponse.paging?.next;
+      this.previousToken = queryResponse.paging?.previous;
+    }
+
+    if (direction === 'prev') this.previousToken = queryResponse.paging?.previous;
+    if (direction === 'next') this.nextToken = queryResponse.paging?.next;
+
+    return queryResponse;
+  }
+
+  abstract getRequest(
+    queryParams: TQueryParams,
+    token: string | undefined,
+  ): Promise<Amity.Payloads[TPayloadDomain] & Amity.Pagination>;
+
+  getNextToken(): string | undefined {
+    return this.nextToken;
+  }
+
+  getPrevToken(): string | undefined {
+    return this.previousToken;
+  }
+}

package/src/core/liveCollection/QueryStreamController.ts

@@ -0,0 +1,21 @@
+export abstract class QueryStreamController<
+  TQueryResponse extends ValueOf<Amity.Payloads>,
+  TQueryParams,
+> {
+  protected query: Amity.LiveCollectionParams<TQueryParams>;
+
+  protected cacheKey: string[];
+
+  constructor(query: Amity.LiveCollectionParams<TQueryParams>, cacheKey: string[]) {
+    this.query = query;
+    this.cacheKey = cacheKey;
+  }
+
+  abstract saveToMainDB(response: TQueryResponse): Promise<void>;
+
+  abstract appendToQueryStream(
+    response: TQueryResponse & Amity.Pagination,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh: boolean | undefined,
+  ): void;
+}

package/src/feedRepository/internalApi/getCustomRankingGlobalFeed.ts

@@ -0,0 +1,87 @@
+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';
+
+export const getCustomRankingGlobalFeed = async (query?: {
+  dataTypes?: ('video' | 'image' | 'file' | 'liveStream')[];
+  page?: Amity.Page;
+}): Promise<Amity.Cached<Amity.Paged<Amity.InternalPost>>> => {
+  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 };
+};
+
+getCustomRankingGlobalFeed.locally = (
+  query?: Parameters<typeof getCustomRankingGlobalFeed>[0],
+): Amity.Cached<Amity.Paged<Amity.InternalPost>> | 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: Amity.InternalPost['postId'][] } & Amity.Pagination>(queryKey) ?? {};
+
+  if (!data?.posts.length) return;
+
+  const posts: Amity.InternalPost[] = data.posts
+    .map(postId => pullFromCache<Amity.InternalPost>(['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/internalApi/index.ts

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

package/src/feedRepository/internalApi/queryGlobalFeed.ts

@@ -0,0 +1,95 @@
+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';
+
+export const queryGlobalFeed = async (query?: {
+  dataTypes?: ('video' | 'image' | 'file' | 'liveStream')[];
+  useCustomRanking?: boolean;
+  page?: Amity.Page;
+}): Promise<Amity.Cached<Amity.Paged<Amity.InternalPost>>> => {
+  const client = getActiveClient();
+  client.log('feed/queryGlobalFeed', 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>(
+    `/api/v4/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 = [
+      'globalFeed',
+      '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 };
+};
+
+queryGlobalFeed.locally = (
+  query?: Parameters<typeof queryGlobalFeed>[0],
+): Amity.Cached<Amity.Paged<Amity.InternalPost>> | undefined => {
+  const client = getActiveClient();
+  client.log('post/queryGlobalFeed.locally', query);
+
+  if (!client.cache) return;
+
+  const { page, ...params } = query ?? {};
+
+  const queryKey = [
+    'globalFeed',
+    'query',
+    { ...params, options: { ...page } } as Amity.Serializable,
+  ];
+  const { data, cachedAt } =
+    pullFromCache<{ posts: Amity.InternalPost['postId'][] } & Amity.Pagination>(queryKey) ?? {};
+
+  if (!data?.posts.length) return;
+
+  const posts: Amity.InternalPost[] = data.posts
+    .map(postId => pullFromCache<Amity.InternalPost>(['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;
+};