@amityco/ts-sdk 6.13.2-c41809f.0 → 6.13.2-e130aec.0

package/jest.config.ts

@@ -7,6 +7,7 @@ export default {
   globals: {
     'ts-jest': {
       useESM: true,
+      tsconfig: 'tsconfig.test.json',
     },
   },
   moduleNameMapper: { '~/(.*)$': '<rootDir>/$1' },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amityco/ts-sdk",
-  "version": "6.13.2-c41809f.0",
+  "version": "6.13.2-e130aec.0",
   "license": "CC-BY-ND-4.0",
   "author": "amity.co <developers@amity.co> (https://amity.co)",
   "description": "Amity Social Cloud Typescript SDK",
@@ -30,7 +30,8 @@
     "prewatch": "yarn run clean",
     "watch": "rollup -w -c ./rollup.config.js",
     "test": "jest",
-    "test:coverage": "jest --coverage --silent"
+    "test:coverage": "jest --coverage --silent",
+    "test:coverage-ci": "jest --coverage --ci --runInBand --detectOpenHandles --forceExit"
   },
   "devDependencies": {
     "@babel/plugin-transform-object-rest-spread": "^7.22.11",
@@ -41,6 +42,7 @@
     "@types/debug": "^4.1.7",
     "@types/jest": "^27.5.1",
     "@types/node": "^18.6.4",
+    "@types/object-hash": "^3.0.6",
     "@types/socket.io-client": "^1.4.34",
     "chalk": "^4.1.2",
     "concurrently": "^6.1.0",
@@ -65,6 +67,7 @@
     "js-base64": "^3.7.2",
     "mitt": "^3.0.0",
     "mqtt": "^4.3.7",
+    "object-hash": "^3.0.0",
     "react-native-uuid": "^2.0.1",
     "socket.io-client": "2.2.0"
   }

package/src/@types/core/live.ts

@@ -20,6 +20,8 @@ declare global {
     type LiveCollection<T extends any> = LiveObject<T[]> & {
       onNextPage: () => void;
       hasNextPage: boolean;
+      onPrevPage?: () => void;
+      hasPrevPage?: boolean;
     };
 
     type LiveCollectionCallback<T extends any> = Amity.Listener<LiveCollection<T>>;
@@ -36,5 +38,29 @@ declare global {
       LiveCollection<T>,
       'data' | 'error' | 'loading'
     > & { params: U };
+
+    const enum LiveDataOrigin {
+      LOCAL = 'local',
+      SERVER = 'server',
+      EVENT = 'event',
+    }
+
+    type LiveCollectionNotifyParams = {
+      origin?: LiveDataOrigin;
+      loading: boolean;
+      error?: unknown;
+    };
+
+    const enum LiveCollectionPageDirection {
+      FIRST = 'first',
+      PREV = 'prev',
+      NEXT = 'next',
+    }
+
+    type LiveCollectionPersistQueryStreamParams<T extends keyof Amity.Payloads> = {
+      response: Amity.Payloads[T] & Amity.Pagination;
+      direction: LiveCollectionPageDirection;
+      refresh?: boolean;
+    };
   }
 }

package/src/@types/core/paging.ts

@@ -8,15 +8,19 @@ declare global {
       limit: number;
     };
 
+    type PageAround = {
+      around?: string;
+    };
+
     type PrevPage<T extends number | string> = PageLimit & {
       after?: never;
       before?: T;
-    };
+    } & PageAround;
 
     type NextPage<T extends number | string> = PageLimit & {
       after?: T;
       before?: never;
-    };
+    } & PageAround;
 
     type Page<T extends number | string = number> = PrevPage<T> | NextPage<T>;
 

package/src/@types/domains/channel.ts

@@ -92,7 +92,8 @@ declare global {
       isDeleted?: Amity.Channel['isDeleted'];
       tags?: Amity.Taggable['tags'];
       excludeTags?: Amity.Taggable['tags'];
-      page?: Amity.Page;
+      limit?: number;
+      page?: string;
     };
 
     type ChannelLiveCollection = Amity.LiveCollectionParams<Omit<QueryChannels, 'page'>>;

package/src/@types/domains/message.ts

@@ -77,8 +77,16 @@ declare global {
 
     type QueryMessages = {
       subChannelId: Amity.SubChannel['subChannelId'];
+      /**
+       * @deprecated use `type` instead
+       */
       dataType?: Amity.MessageContentType;
+      type?: Amity.MessageContentType;
+      /**
+       * @deprecated use `excludingTags` instead
+       */
       excludeTags?: Amity.Taggable['tags'];
+      excludingTags?: Amity.Taggable['tags'];
       hasFlags?: boolean;
       includeDeleted?: boolean;
       /*
@@ -87,8 +95,13 @@ declare global {
       page?: Amity.Page<string>;
       parentId?: Amity.Message['parentId'];
       sortBy?: 'segmentAsc' | 'segmentDesc';
+      /**
+       * @deprecated use `includingTags` instead
+       */
       tags?: Amity.Taggable['tags'];
+      includingTags?: Amity.Taggable['tags'];
       pageToken?: string;
+      aroundMessageId?: Amity.Message['messageId'];
     };
 
     type QueryReadUsers = {

package/src/@types/domains/user.ts

@@ -34,7 +34,8 @@ declare global {
       displayName?: Amity.InternalUser['displayName'];
       filter?: 'all' | 'flagged';
       sortBy?: 'displayName' | 'firstCreated' | 'lastCreated';
-      page?: Amity.Page;
+      limit?: number;
+      page?: string;
     };
 
     type UserLiveCollection = Amity.LiveCollectionParams<Omit<QueryUsers, 'page'>>;

package/src/categoryRepository/api/getCategory.ts

@@ -2,7 +2,7 @@ import { getActiveClient } from '~/client/api/activeClient';
 
 import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { categoryLinkedObject } from '~/utils/linkedObject/categoryLinkedObject';
+import { LinkedObject } from '~/utils/linkedObject';
 
 /* begin_public_function
   id: community.category.get
@@ -37,7 +37,7 @@ export const getCategory = async (
   const { categories } = data;
 
   return {
-    data: categoryLinkedObject(categories.find(category => category.categoryId === categoryId)!),
+    data: LinkedObject.category(categories.find(category => category.categoryId === categoryId)!),
     cachedAt,
   };
 };
@@ -64,12 +64,12 @@ getCategory.locally = (
 
   if (!client.cache) return;
 
-  const cached = pullFromCache<Amity.Category>(['category', 'get', categoryId]);
+  const cached = pullFromCache<Amity.InternalCategory>(['category', 'get', categoryId]);
 
   if (!cached) return;
 
   return {
-    data: cached.data,
+    data: LinkedObject.category(cached.data),
     cachedAt: cached.cachedAt,
   };
 };

package/src/categoryRepository/api/queryCategories.ts

@@ -111,6 +111,6 @@ queryCategories.locally = (
   const nextPage = toPage(data?.paging.next);
 
   return categories.length === data?.categories?.length
-    ? { data: categories, cachedAt, prevPage, nextPage }
+    ? { data: categories.map(LinkedObject.category), cachedAt, prevPage, nextPage }
     : undefined;
 };

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/channelRepository/api/queryChannels.ts

@@ -1,9 +1,7 @@
 import { getActiveClient } from '~/client/api';
-
-import { toPage, toToken } from '~/core/query';
 import { getResolver } from '~/core/model';
 
-import { pullFromCache, pushToCache } from '~/cache/api';
+import { pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
 import { prepareChannelPayload } from '../utils';
@@ -25,12 +23,12 @@ import { prepareChannelPayload } from '../utils';
  */
 export const queryChannels = async (
   query?: Amity.QueryChannels,
-): Promise<Amity.Cached<Amity.Paged<Amity.InternalChannel>>> => {
+): Promise<Amity.Cached<Amity.PageToken<Amity.InternalChannel>>> => {
   const client = getActiveClient();
   client.log('channel/queryChannels', query);
 
   // safe decapsulation
-  const { page = { limit: 10 }, displayName, membership, ...params } = query ?? {};
+  const { page = undefined, limit = 10, displayName, membership, ...params } = query ?? {};
 
   // API-FIX: parameters should be querystring.
   // API-FIX: backend doesn't answer Amity.Response
@@ -43,7 +41,7 @@ export const queryChannels = async (
         keyword: displayName,
         filter: membership,
         options: {
-          token: toToken(page, 'skiplimit'),
+          token: page,
         },
       },
     },
@@ -60,16 +58,9 @@ export const queryChannels = async (
   if (client.cache) {
     ingestInCache(data, { cachedAt });
 
-    const cacheKey = [
-      'channel',
-      'query',
-      { ...params, options: { ...page } } as Amity.Serializable,
-    ];
+    const cacheKey = ['channel', 'query', { ...params, options: { limit } } as Amity.Serializable];
     pushToCache(cacheKey, { channels: channels.map(getResolver('channel')), paging });
   }
 
-  const nextPage = toPage(paging.next);
-  const prevPage = toPage(paging.previous);
-
-  return { data: channels, cachedAt, prevPage, nextPage };
+  return { data: channels, cachedAt, paging };
 };

package/src/channelRepository/observers/getChannels.ts

@@ -1,6 +1,6 @@
 /* eslint-disable no-use-before-define */
 import { getResolver } from '~/core/model';
-import { dropFromCache, pullFromCache, pushToCache, upsertInCache } from '~/cache/api';
+import { dropFromCache, pullFromCache, pushToCache } from '~/cache/api';
 import { getActiveClient } from '~/client/api';
 import {
   createQuery,
@@ -22,32 +22,32 @@ import {
 import { CACHE_SHORTEN_LIFESPAN } from '~/cache/utils';
 import { convertEventPayload } from '~/utils/event';
 import { uuid } from '~/core/uuid';
-import {
-  onChannelCreated,
-  onChannelDeleted,
-  onChannelJoined,
-  onChannelLeft,
-  onChannelMemberAdded,
-  onChannelMemberRemoved,
-  onChannelMuted,
-  onChannelUpdated,
-} from '../events';
-import { queryChannels } from '../api/queryChannels';
-import { getChannelMessagePreview } from '../../messagePreview/utils/getChannelMessagePreview';
 import { onMessageCreated } from '~/messageRepository/events/onMessageCreated';
 import { onMessageUpdated } from '~/messageRepository/events/onMessageUpdated';
 import { onMessageDeleted } from '~/messageRepository/events/onMessageDeleted';
 import { onSubChannelUpdated } from '~/subChannelRepository/events/onSubChannelUpdated';
 import { onSubChannelDeleted } from '~/subChannelRepository/events/onSubChannelDeleted';
-import { getChannel } from '../api/getChannel';
-import { getChannelMessagePreviewWithUser } from '../../messagePreview/utils/getChannelMessagePreviewWithUser';
 import {
   handleMessageCreated,
   handleMessageUpdated,
   handleSubChannelUpdated,
 } from '~/messagePreview/utils/updateMessagePreviewFromMessage';
-import { updateChannelCache } from '../utils/updateChannelCache';
 import { onChannelMarkerUpdated } from '~/marker/events/onChannelMarkerUpdated';
+import { getChannel } from '../api/getChannel';
+import { getChannelMessagePreviewWithUser } from '../../messagePreview/utils/getChannelMessagePreviewWithUser';
+import { updateChannelCache } from '../utils/updateChannelCache';
+import { getChannelMessagePreview } from '../../messagePreview/utils/getChannelMessagePreview';
+import {
+  onChannelCreated,
+  onChannelDeleted,
+  onChannelJoined,
+  onChannelLeft,
+  onChannelMemberAdded,
+  onChannelMemberRemoved,
+  onChannelMuted,
+  onChannelUpdated,
+} from '../events';
+import { queryChannels } from '../api/queryChannels';
 
 /* begin_public_function
   id: channel.query
@@ -132,7 +132,7 @@ export const getChannels = (
       case 'displayName':
         /*
          * The server returns channels with empty | null displayName's first before
-         * returning sorted list of channels with displayNames
+         * returning a sorted list of channels with displayNames
          *
          * This section needs to be updated as displayNames can be null as well
          */
@@ -176,21 +176,24 @@ export const getChannels = (
 
     const query = createQuery(queryChannels, {
       ...queryParams,
-      page: (!initial ? collection?.params.page : undefined) ?? { limit },
+      page: !initial ? collection?.params.page : undefined,
+      limit,
     });
 
     runQuery(
       query,
-      ({ data: result, error, loading, nextPage: page }) => {
+      ({ data: result, error, loading, paging }) => {
         const data = {
           loading,
           error,
-          params: { page },
+          params: { page: paging?.next },
           data: channels,
         };
 
         if (result) {
-          data.data = [...new Set([...channels, ...result.map(getResolver('channel'))])];
+          data.data = initial
+            ? result.map(getResolver('channel')) // Replace all collection from BE when initial fetch
+            : [...new Set([...channels, ...result.map(getResolver('channel'))])];
         }
 
         pushToCache(cacheKey, data);
@@ -282,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/communityRepository/api/queryCommunities.ts

@@ -30,11 +30,11 @@ export const queryCommunities = async (
   client.log('channel/queryCommunities', query);
 
   // safe decapsulation
-  const { page, ...params } = query ?? {};
+  const { page = { limit: 10 }, ...params } = query ?? {};
   const { displayName, membership, includeDeleted, ...restParams } = params ?? {};
 
   // API-FIX: parameters should be querystring.
-  // API-FIX: backend doesnt answer Amity.Response
+  // API-FIX: backend doesn't answer Amity.Response
   // const { data } = await client.http.get<Amity.Response<Amity.PagedResponse<CommunityPayload>>>(
   const { data } = await client.http.get<Amity.CommunityPayload & Amity.Pagination>(
     `/api/v3/communities`,

package/src/communityRepository/observers/getCommunities.ts

@@ -148,7 +148,7 @@ export const getCommunities = (
 
     const query = createQuery(queryCommunities, {
       ...queryParams,
-      page: (!initial ? collection?.params.page : undefined) ?? { limit },
+      page: !initial ? collection?.params.page : { limit },
     });
 
     runQuery(

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;
+  }
+}