@amityco/ts-sdk 6.13.2-de0b4c4.0 → 6.13.2-e5cbe27.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-de0b4c4.0",
+  "version": "6.13.2-e5cbe27.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/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/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/observers/getChannels.ts

@@ -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/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,63 @@
+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>;
+}

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/{dist/feedRepository/api/index.d.ts → src/feedRepository/internalApi/index.ts}

@@ -1,3 +1,2 @@
-export * from './queryGlobalFeed';
-export * from './getCustomRankingGlobalFeed';
-//# sourceMappingURL=index.d.ts.map
+export * from './queryGlobalFeed';
+export * from './getCustomRankingGlobalFeed';