@amityco/ts-sdk 0.0.1-beta.23 → 0.0.1-beta.26

package/src/post/observers/livePosts.ts

@@ -0,0 +1,170 @@
+/* eslint-disable no-use-before-define */
+import { getResolver } from '~/core/model';
+import { getActiveClient } from '~/client/api';
+import { pushToCache, pullFromCache } from '~/cache/api';
+import {
+  createQuery,
+  runQuery,
+  queryOptions,
+  filterByPropEquality,
+  sortByFirstCreated,
+  sortByLastCreated,
+} from '~/core/query';
+
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+} from '~/utils/constants';
+
+import {
+  onPostCreated,
+  onPostUpdated,
+  onPostDeleted,
+  onPostApproved,
+  onPostDeclined,
+  onPostFlagged,
+  onPostUnflagged,
+  onPostReactionAdded,
+  onPostReactionRemoved,
+} from '../events';
+import { queryPosts } from '../api';
+
+/**
+ * ```js
+ * import { livePosts } from '@amityco/ts-sdk'
+ *
+ * let posts = []
+ * const unsub = livePosts({
+ *   targetType: Amity.PostTargetType,
+ *   targetId: Amity.Post['targetId'],
+ * }, response => merge(posts, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Post} for a given target object
+ *
+ * @param targetType the type of the target
+ * @param targetId the ID of the target
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the messages
+ *
+ * @category Posts Live Collection
+ */
+export const livePosts = (
+  params: Amity.PostLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Post>,
+  config?: Amity.LiveCollectionConfig,
+): Amity.Unsubscriber => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log('For using Live Collection feature you need to enable Cache!');
+  }
+
+  const timestamp = Date.now();
+  log(`livePosts(tmpid: ${timestamp}) > listen`);
+
+  const { limit: queryLimit, ...queryParams } = params;
+
+  const limit = queryLimit ?? COLLECTION_DEFAULT_PAGINATION_LIMIT;
+  const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
+
+  const disposers: Amity.Unsubscriber[] = [];
+  const cacheKey = [
+    'post',
+    'collection',
+    { targetId: params.targetId, targetType: params.targetType },
+  ];
+
+  const responder = (data: Amity.PostLiveCollectionCache) => {
+    let posts: Amity.Post[] =
+      data.data
+        .map(postId => pullFromCache<Amity.Post>(['post', 'get', postId])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    posts = filterByPropEquality(posts, 'isDeleted', params.isDeleted);
+
+    const sortBy = params.sortBy ? params.sortBy : 'lastCreated';
+
+    posts = posts.sort(sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated);
+
+    callback({
+      onNextPage: onFetch,
+      data: posts,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (post: Amity.Post, action: Amity.PostActionType) => {
+    const collection = pullFromCache<Amity.PostLiveCollectionCache>(cacheKey)?.data;
+
+    if (params.targetId !== post.targetId || params.targetType !== post.targetType || !collection)
+      return;
+
+    if (action === 'onCreate') {
+      collection.data = [...new Set([post.postId, ...collection.data])];
+    } else if (['onDelete', 'onDeclined'].includes(action)) {
+      collection.data = collection.data.filter(p => p !== post.postId);
+    }
+
+    pushToCache(cacheKey, collection);
+
+    responder(collection);
+  };
+
+  const onFetch = () => {
+    const collection = pullFromCache<Amity.PostLiveCollectionCache>(cacheKey)?.data;
+
+    const posts = collection?.data ?? [];
+
+    if (posts.length > 0 && !collection?.params?.page) return;
+
+    const query = createQuery(queryPosts, {
+      ...queryParams,
+      page: collection?.params?.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, nextPage: page }) => {
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: posts,
+        };
+
+        if (result) {
+          data.data = [...new Set([...posts, ...result.map(getResolver('post'))])];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onPostCreated(post => realtimeRouter(post, 'onCreate')),
+    onPostApproved(post => realtimeRouter(post, 'onApproved')),
+    onPostDeclined(post => realtimeRouter(post, 'onDeclined')),
+    onPostDeleted(post => realtimeRouter(post, 'onDelete')),
+
+    onPostUpdated(post => realtimeRouter(post, 'onUpdate')),
+    onPostFlagged(post => realtimeRouter(post, 'onFlagged')),
+    onPostUnflagged(post => realtimeRouter(post, 'onUnflagged')),
+    onPostReactionAdded(post => realtimeRouter(post, 'onReactionAdded')),
+    onPostReactionRemoved(post => realtimeRouter(post, 'onReactionRemoved')),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`livePosts(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/post/observers/observePosts.ts

@@ -59,19 +59,7 @@ export const observePosts = (
 
   const disposers: Amity.Unsubscriber[] = [];
 
-  const router = (
-    post: Amity.Post,
-    action:
-      | 'onCreate'
-      | 'onUpdate'
-      | 'onDelete'
-      | 'onApproved'
-      | 'onDeclined'
-      | 'onFlagged'
-      | 'onUnflagged'
-      | 'onReactionAdded'
-      | 'onReactionRemoved',
-  ) => {
+  const router = (post: Amity.Post, action: Exclude<Amity.PostActionType, 'onFetch'>) => {
     if (params.targetId !== post.targetId || params.targetType !== post.targetType) return;
 
     if (callback instanceof Function) return callback(post);

package/src/post/tests/api/getPost.test.ts

@@ -0,0 +1,88 @@
+import { ASCApiError } from '~/core/errors';
+import { client, userPosts } from '~/utils/tests';
+import { pushToCache, enableCache, disableCache } from '~/cache/api';
+
+import { getPost } from '~/post/api';
+
+describe('post/api', () => {
+  const post = { postId: userPosts.page1[0] };
+  const post2 = { postId: userPosts.page1[1] };
+
+  describe('getPost.locally', () => {
+    test('should return undefined if cache is turned off', () => {
+      expect(getPost.locally(post.postId)).toBeUndefined();
+    });
+
+    test('should return undefined if post not in cache', () => {
+      enableCache();
+
+      const cachedAt = Date.now();
+
+      pushToCache(['post', 'get', post.postId], post, { cachedAt });
+
+      expect(getPost.locally(post2.postId)).toBeUndefined();
+
+      disableCache();
+    });
+
+    test('should return post if post in cache', () => {
+      enableCache();
+
+      const cachedAt = Date.now();
+
+      pushToCache(['post', 'get', post.postId], post, { cachedAt });
+
+      const data = getPost.locally(post.postId);
+
+      expect(data).toBeDefined();
+      expect(data?.data).toEqual(post);
+      expect(data?.cachedAt).toEqual(cachedAt);
+
+      disableCache();
+    });
+  });
+
+  describe('getPost', () => {
+    test('should return a post', async () => {
+      client.http.get = jest.fn().mockReturnValueOnce({ data: { posts: [post] } });
+
+      const data = await getPost(post.postId);
+
+      expect(data).toBeDefined();
+      expect(data?.data).toEqual(post);
+    });
+
+    test('should put post into the cache after fetch', async () => {
+      enableCache();
+      client.http.get = jest.fn().mockReturnValueOnce({ data: { posts: [post] } });
+
+      await getPost(post.postId);
+
+      expect(getPost.locally(post.postId)?.data).toEqual(post);
+
+      disableCache();
+    });
+
+    test('should return an error', async () => {
+      client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+      await expect(getPost(post.postId)).rejects.toThrow('error');
+    });
+
+    test('should return an error if post in cache but api throws not found', async () => {
+      enableCache();
+      pushToCache(['post', 'get', post.postId], post, { cachedAt: Date.now() });
+
+      client.http.get = jest
+        .fn()
+        .mockRejectedValueOnce(
+          new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+        );
+
+      await expect(getPost(post.postId)).rejects.toThrow();
+
+      expect(getPost.locally(post.postId)).toBeUndefined();
+      disableCache();
+    });
+  });
+});

package/src/post/tests/api/queryPosts.test.ts

@@ -0,0 +1,23 @@
+import { queryPosts } from '~/post/api';
+import { client, userPosts } from '~/utils/tests';
+
+describe('post/api', () => {
+  test('should return a post query', async () => {
+    const returnValue = [{ postId: userPosts.page1[0] }];
+
+    client.http.get = jest.fn().mockResolvedValue({
+      data: {
+        posts: returnValue,
+        paging: {},
+      },
+    });
+
+    const data = await queryPosts({
+      targetId: userPosts.targetId,
+      targetType: userPosts.targetType,
+    });
+
+    expect(data).toBeDefined();
+    expect(data?.data).toEqual(returnValue);
+  });
+});

package/src/reaction/api/queryReactions.ts

@@ -1,6 +1,6 @@
 import { getActiveClient } from '~/client/api/activeClient';
 
-import { toToken, toPage } from '~/core/query';
+import { toToken, toPageRaw } from '~/core/query';
 
 /**
  * ```js
@@ -23,30 +23,30 @@ export const queryReactions = async (query: {
   referenceId: Amity.Reaction['referenceId'];
   referenceType: Amity.Reaction['referenceType'];
   reactionName?: Amity.Reaction['reactionName'];
-  page?: Amity.Page;
-}): Promise<Amity.Paged<Amity.ReactionQuery, Amity.Page>> => {
+  page?: Amity.Page<string>;
+}): Promise<Amity.Paged<Amity.ReactionQuery, Amity.Page<string>>> => {
   const client = getActiveClient();
   client.log('reaction/queryReactions', query);
 
   const { page = { limit: 10 }, ...params } = query ?? {};
 
-  const { data } = await client.http.get<{ results: Amity.ReactionPayload } & Amity.Pagination>(
-    `/api/v2/reactions`,
+  const { data } = await client.http.get<Amity.ReactionPayload & Amity.Pagination>(
+    `/api/v3/reactions`,
     {
       params: {
         ...params,
         options: {
-          token: toToken(page, 'skiplimit'),
+          token: toToken(page, 'afterbeforeraw'),
         },
       },
     },
   );
 
-  const { paging, results } = data;
-  const { reactions } = results;
+  const { paging, ...payload } = data;
+  const { reactions } = payload;
 
-  const nextPage = toPage(paging.next);
-  const prevPage = toPage(paging.previous);
+  const nextPage = toPageRaw(paging.next);
+  const prevPage = toPageRaw(paging.previous);
 
   return { data: reactions, prevPage, nextPage };
 };

package/src/report/api/createReport.ts

@@ -29,7 +29,13 @@ export const createReport = async (
 
   const { data } = await client.http.post<
     Amity.PostPayload | Amity.CommentPayload | Amity.MessagePayload | Amity.UserPayload
-  >(`/api/v3/${domainName}/${encodeURIComponent(referenceId)}/flag`);
+  >(
+    `/api/${
+      referenceType === 'user'
+        ? `v4/me/flags/${encodeURIComponent(referenceId)}`
+        : `v3/${domainName}/${encodeURIComponent(referenceId)}/flag`
+    }`,
+  );
 
   if (client.cache) ingestInCache(data);
 

package/src/report/api/deleteReport.ts

@@ -29,7 +29,13 @@ export const deleteReport = async (
 
   const { data } = await client.http.delete<
     Amity.PostPayload | Amity.CommentPayload | Amity.MessagePayload | Amity.UserPayload
-  >(`/api/v3/${domainName}/${encodeURIComponent(referenceId)}/unflag`);
+  >(
+    `/api/${
+      referenceType === 'user'
+        ? `v4/me/flags/${encodeURIComponent(referenceId)}`
+        : `v3/${domainName}/${encodeURIComponent(referenceId)}/unflag`
+    }`,
+  );
 
   if (client.cache) ingestInCache(data);
 

package/src/utils/constants.ts

@@ -0,0 +1,2 @@
+export const COLLECTION_DEFAULT_PAGINATION_LIMIT = 5;
+export const COLLECTION_DEFAULT_CACHING_POLICY: Amity.QueryPolicy = 'cache_then_server';

package/src/utils/tests/client.ts

@@ -0,0 +1,5 @@
+import { createClient } from '~/client/api';
+
+const client = createClient('key', 'sg');
+
+export default client;

package/src/utils/tests/dummy.ts

@@ -0,0 +1,7 @@
+export const userPosts = {
+  targetId: 'userId',
+  targetType: 'user' as Amity.PostTargetType,
+  page1: ['postId11', 'postId12', 'postId13'],
+  page2: ['postId21', 'postId22', 'postId23'],
+  page3: ['postId31', 'postId32', 'postId33'],
+};

package/src/utils/tests/index.ts

@@ -0,0 +1,2 @@
+export { userPosts } from './dummy';
+export { default as client } from './client';

package/tsconfig.json

@@ -1,29 +1,30 @@
 {
-  "extends": "../../tsconfig.json",
+	"extends": "../../tsconfig.json",
 
-  "include": ["./src"],
-  "exclude": ["node_modules"],
+	"include": ["./src"],
+	"exclude": ["node_modules", "**/*.spec.ts"],
 
-  "compilerOptions": {
-    "baseUrl": "./src",
-    "paths": {
-      "~/*": ["./*"],
-    },
+	"compilerOptions": {
+		"baseUrl": "./src",
+		"paths": {
+			"~/*": ["./*"]
+		},
 
-    "rootDir": "./src",
-    "outDir": "./dist",
-    "declaration": true,
-    "declarationDir": "./dist",
-    "noEmit": true, // by rollup
+		"rootDir": "./src",
+		"outDir": "./dist",
+		"declaration": true,
+		"declarationDir": "./dist",
+		"noEmit": true,
 
-    "module": "es2020",
-    "target": "es2017",
+		"module": "es2020",
+		"target": "es2017",
 
-    "lib": [
-      "esnext",
-      "es7",
-      "es6",
-      "dom",
-    ],
-  }
+		"lib": [
+			"esnext",
+			"es7",
+			"es6",
+			"dom"
+		],
+		"resolveJsonModule": true
+	}
 }