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

package/src/core/query/query.ts

@@ -215,8 +215,21 @@ export const runQuery = <Args extends any[], Returned extends any>(
   if (isMutator(func)) {
     // @ts-ignore
     const modelKey = local && local.data && identifyModelKey(local.data);
-    // @ts-ignore
-    optimisticArgs = modelKey ? [...args, { [modelKey]: local.data[modelKey] }] : args;
+    if (modelKey) {
+      /*
+       * modal key is only required for create as update and delete queries pass
+       * the modal key in the param itself
+       * For update & delete the first argument is always an id which is of type
+       * string, whereas for create the first and only argument is the param object
+       * 
+       * When creating an AmityObject optimistically we need to pass the modal key 
+       * on to the server. ex: for create message modal key will be 'messageId`
+       */
+      if (typeof args[0] !== 'string') {
+        // @ts-ignore
+        optimisticArgs = [{ ...args[0], [modelKey]: local.data[modelKey] }];
+      }
+    }
   }
 
   func(...optimisticArgs)

package/src/core/tests/query/filtering.test.ts

@@ -0,0 +1,11 @@
+import { filterByPropEquality } from '~/core/query';
+
+describe('Core/Query/Filtering', () => {
+  test('check filterByPropEquality', () => {
+    const prop = 'prop';
+    const collection = [{ [prop]: 'value' }];
+
+    expect(filterByPropEquality(collection, prop, 'value')).toStrictEqual(collection);
+    expect(filterByPropEquality(collection, prop, 'otherValue')).toStrictEqual([]);
+  });
+});

package/src/core/tests/query/query.test.ts

@@ -0,0 +1,19 @@
+import { isFetcher } from '~/core/query';
+
+type isFetcherMockType = jest.Mock<any, any> & {
+  locally?: jest.Mock<any, any>;
+};
+
+describe('Core/Query/Query', () => {
+  const isFetcherMock: isFetcherMockType = jest.fn();
+
+  test('isFetcher without locally', () => {
+    expect(isFetcher(isFetcherMock)).toBe(false);
+  });
+
+  test('isFetcher with locally', () => {
+    isFetcherMock.locally = jest.fn();
+
+    expect(isFetcher(isFetcherMock)).toBe(true);
+  });
+});

package/src/post/api/queryPosts.ts

@@ -20,18 +20,9 @@ import { getResolver } from '~/core/model';
  * @category Post API
  * @async
  */
-export const queryPosts = async (query: {
-  targetId: string;
-  targetType: Amity.Post['targetType'];
-  sortBy?: 'lastCreated' | 'firstCreated' | 'lastUpdated' | 'firstUpdated';
-  dataType?: string;
-  isDeleted?: Amity.Post['isDeleted'];
-  hasFlag?: boolean;
-  feedType?: 'reviewing' | 'published';
-  tags?: Amity.Taggable['tags'];
-  matchingOnlyParentPost?: boolean;
-  page?: Amity.PageRaw;
-}): Promise<Amity.Cached<Amity.Paged<Amity.Post, Amity.PageRaw>>> => {
+export const queryPosts = async (
+  query: Amity.QueryPosts,
+): Promise<Amity.Cached<Amity.Paged<Amity.Post, Amity.PageRaw>>> => {
   const client = getActiveClient();
   client.log('post/queryPosts', query);
 

package/src/post/observers/index.ts

@@ -1,2 +1,3 @@
 export * from './observePosts';
 export * from './observePost';
+export * from './livePosts';

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