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

package/src/reaction/events/onReactorAdded.ts

@@ -0,0 +1,80 @@
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onReactorAdded } from '@amityco/ts-sdk'
+ * const dispose = onReactorAdded('post', postId, reactor => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Reactor} has been added
+ *
+ * @param {@link Amity.ReactableType} referenceType
+ * @param {string} referenceId
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Events
+ * */
+export const onReactorAdded = (
+  referenceType: Amity.ReactableType,
+  referenceId: Amity.Reaction['referenceId'],
+  callback: Amity.Listener<Amity.Reactor>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const callbackWrapper = (
+    referenceType_: Amity.ReactableType,
+    referenceId_: Amity.Reaction['referenceId'],
+    reaction: Amity.Reactor,
+  ) => {
+    if (referenceType_ === referenceType && referenceId_ === referenceId) {
+      callback(reaction);
+    }
+  };
+
+  if (referenceType === 'message') {
+    const filter = (payload: Amity.MessagePayload) => {
+      if (!payload.messages[0].latestReaction) return;
+
+      const { eventName, referenceId, referenceType, userDisplayName, ...reactor } =
+        payload.messages[0].latestReaction;
+
+      if (eventName !== 'add') return;
+
+      ingestInCache(payload);
+      ingestInCache({ reactions: [reactor as Amity.Reactor] });
+
+      callbackWrapper('message', payload.messages[0].messageId, reactor);
+    };
+
+    return createEventSubscriber(client, 'reaction/onReactorAdded', 'v3.message.didUpdate', filter);
+  }
+
+  if (referenceType === 'post') {
+    const filter = (payload: Amity.PostPayload & { reactor: Amity.Reactor }) => {
+      const { reactor, ...rest } = payload;
+
+      ingestInCache(rest as Amity.PostPayload);
+      ingestInCache({ reactions: [reactor] });
+
+      callbackWrapper('post', payload.posts[0].postId, reactor);
+    };
+
+    return createEventSubscriber(client, 'post.addReaction', 'post.addReaction', filter);
+  }
+
+  const filter = (payload: Amity.CommentPayload & { reactor: Amity.Reactor }) => {
+    const { reactor, ...rest } = payload;
+
+    ingestInCache(rest as Amity.CommentPayload);
+    ingestInCache({ reactions: [reactor] });
+
+    callbackWrapper('comment', payload.comments[0].commentId, reactor);
+  };
+
+  return createEventSubscriber(client, 'comment.addReaction', 'comment.addReaction', filter);
+};

package/src/reaction/events/onReactorRemoved.ts

@@ -0,0 +1,85 @@
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onReactorRemoved } from '@amityco/ts-sdk'
+ * const dispose = onReactorRemoved('post', postId, reactor => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Reactor} has been removed
+ *
+ * @param {@link Amity.ReactableType} referenceType
+ * @param {string} referenceId
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Events
+ * */
+export const onReactorRemoved = (
+  referenceType: Amity.ReactableType,
+  referenceId: Amity.Reaction['referenceId'],
+  callback: Amity.Listener<Amity.Reactor>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const callbackWrapper = (
+    referenceType_: Amity.ReactableType,
+    referenceId_: Amity.Reaction['referenceId'],
+    reaction: Amity.Reactor,
+  ) => {
+    if (referenceType_ === referenceType && referenceId_ === referenceId) {
+      callback(reaction);
+    }
+  };
+
+  if (referenceType === 'message') {
+    const filter = (payload: Amity.MessagePayload) => {
+      if (!payload.messages[0].latestReaction) return;
+
+      const { eventName, referenceId, referenceType, ...reactor } =
+        payload.messages[0].latestReaction;
+
+      if (eventName !== 'remove') return;
+
+      ingestInCache(payload);
+      ingestInCache({ reactions: [reactor as Amity.Reactor] });
+
+      callbackWrapper('message', payload.messages[0].messageId, reactor);
+    };
+
+    return createEventSubscriber(
+      client,
+      'reaction/onReactorRemoved',
+      'v3.message.didUpdate',
+      filter,
+    );
+  }
+
+  if (referenceType === 'post') {
+    const filter = (payload: Amity.PostPayload & { reactor: Amity.Reactor }) => {
+      const { reactor, ...rest } = payload;
+
+      ingestInCache(rest as Amity.PostPayload);
+      ingestInCache({ reactions: [reactor] });
+
+      callbackWrapper('post', payload.posts[0].postId, reactor);
+    };
+
+    return createEventSubscriber(client, 'post.removeReaction', 'post.removeReaction', filter);
+  }
+
+  const filter = (payload: Amity.CommentPayload & { reactor: Amity.Reactor }) => {
+    const { reactor, ...rest } = payload;
+
+    ingestInCache(rest as Amity.CommentPayload);
+    ingestInCache({ reactions: [reactor] });
+
+    callbackWrapper('comment', payload.comments[0].commentId, reactor);
+  };
+
+  return createEventSubscriber(client, 'comment.removeReaction', 'comment.removeReaction', filter);
+};

package/src/reaction/observers/index.ts

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

package/src/reaction/observers/liveReactions.ts

@@ -0,0 +1,142 @@
+/* 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 } from '~/core/query';
+
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+} from '~/utils/constants';
+
+import { onReactorAdded, onReactorRemoved } from '../events';
+import { queryReactions } from '../api';
+
+/**
+ * ```js
+ * import { liveReactions } from '@amityco/ts-sdk'
+ *
+ * let reactions = []
+ * const unsub = liveReactions({
+ *   referenceId: Amity.Reaction['referenceId'],
+ *   referenceType: Amity.Reaction['referenceType'],
+ * }, response => merge(reactions, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Reaction} for a given target object
+ *
+ * @param referenceType the type of the target
+ * @param referenceId 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 Reactions Live Collection
+ */
+export const liveReactions = (
+  params: Amity.ReactionLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Reactor>,
+  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(`liveReactions(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 = [
+    'reaction',
+    'collection',
+    { referenceId: params.referenceId, referenceType: params.referenceType },
+  ];
+
+  const responder = (data: Amity.ReactionLiveCollectionCache) => {
+    const reactions: Amity.Reactor[] =
+      data.data
+        .map(reactorId => pullFromCache<Amity.Reactor>(['reaction', 'get', reactorId])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    callback({
+      onNextPage: onFetch,
+      data: reactions,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (reaction: Amity.Reactor, action: Amity.ReactionActionType) => {
+    const collection = pullFromCache<Amity.ReactionLiveCollectionCache>(cacheKey)?.data;
+    if (!collection) return;
+
+    if (action === 'onAdded') {
+      collection.data = [...new Set([reaction.reactionId, ...collection.data])];
+    } else if (action === 'onRemoved') {
+      collection.data = collection.data.filter(p => p !== reaction.reactionId);
+    }
+
+    pushToCache(cacheKey, collection);
+    responder(collection);
+  };
+
+  const onFetch = () => {
+    const collection = pullFromCache<Amity.ReactionLiveCollectionCache>(cacheKey)?.data;
+
+    const reactions = collection?.data ?? [];
+
+    if (reactions.length > 0 && !collection?.params?.page) return;
+
+    const query = createQuery(queryReactions, {
+      ...queryParams,
+      page: collection?.params?.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, nextPage: page }) => {
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: reactions,
+        };
+
+        if (result) {
+          data.data = [
+            ...new Set([...reactions, ...result[0].reactors.map(getResolver('reaction'))]),
+          ];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onReactorAdded(queryParams.referenceType, queryParams.referenceId, reaction =>
+      realtimeRouter(reaction, 'onAdded'),
+    ),
+    onReactorRemoved(queryParams.referenceType, queryParams.referenceId, reaction =>
+      realtimeRouter(reaction, 'onRemoved'),
+    ),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveReactions(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/utils/constants.ts

@@ -0,0 +1,3 @@
+export const COLLECTION_DEFAULT_PAGINATION_LIMIT = 5;
+export const COLLECTION_DEFAULT_CACHING_POLICY: Amity.QueryPolicy = 'cache_then_server';
+export const ENABLE_CACHE_MESSAGE = 'For using Live Collection feature you need to enable Cache!';

package/src/utils/tests/client.ts

@@ -0,0 +1,33 @@
+import {
+  createClient,
+  connectClient as sdkConnectClient,
+  disconnectClient as sdkDisconnectClient,
+} from '~/client/api';
+
+import { user11 } from './dummy';
+
+export const client = createClient('key', 'sg');
+
+export const connectClient = async () => {
+  client.mqtt.connect = jest.fn();
+  client.mqtt.subscribe = jest.fn();
+  client.http.post = jest.fn().mockReturnValueOnce({
+    data: {
+      accessToken: 'accessToken',
+      refreshToken: 'refreshToken',
+      users: [user11],
+    },
+  });
+
+  setTimeout(() => {
+    client.ws.emit('connect');
+  }, 500);
+
+  await sdkConnectClient({ userId: 'test' });
+};
+
+export const disconnectClient = async () => {
+  sdkDisconnectClient().then(() => client.ws.emit('disconnect'));
+};
+
+export default {};

package/src/utils/tests/dummy/channel.ts

@@ -0,0 +1,52 @@
+import { date, rolesAndPermissions, user11 } from '.';
+
+export const channelRaw1: Amity.ChannelRaw = {
+  messageCount: 1,
+  createdAt: date,
+  type: 'community',
+  channelId: 'channelId11',
+};
+
+export const channelRaw2: Amity.ChannelRaw = {
+  messageCount: 3,
+  createdAt: date,
+  type: 'community',
+  channelId: 'channelId12',
+};
+
+export const channel11: Amity.Channel = {
+  ...channelRaw1,
+  hasMention: false,
+  unreadCount: 0,
+};
+
+export const channel12: Amity.Channel = {
+  ...channelRaw2,
+  hasMention: true,
+  unreadCount: 2,
+};
+
+export const channelUser1: Amity.Membership<'channel'> = {
+  isMuted: false,
+  createdAt: date,
+  muteTimeout: '',
+  isBanned: false,
+  readToSegment: 1,
+  lastActivity: date,
+  membership: 'member',
+  userId: user11.userId,
+  ...rolesAndPermissions,
+  lastMentionedSegment: 0,
+  channelId: channel11.channelId,
+};
+
+export const channelUser2: Amity.Membership<'channel'> = {
+  ...channelUser1,
+  readToSegment: 1,
+  lastMentionedSegment: 2,
+  channelId: channel12.channelId,
+};
+
+export const channels = {
+  page1: [channel11.channelId, channel12.channelId],
+};

package/src/utils/tests/dummy/index.ts

@@ -0,0 +1,7 @@
+export const date = new Date().toISOString();
+export const rolesAndPermissions = { roles: [], permissions: [] };
+
+export * from './user';
+export * from './post';
+export * from './channel';
+export * from './message';

package/src/utils/tests/dummy/message.ts

@@ -0,0 +1,21 @@
+import { date, channel11, user11 } from '.';
+
+export const message: Amity.Message = {
+  reactions: {},
+  editedAt: date,
+  createdAt: date,
+  reactionsCount: 0,
+  channelSegment: 1,
+  childrenNumber: 0,
+  userId: user11.userId,
+  messageId: 'message11',
+  channelId: channel11.channelId,
+  data: { text: 'message1' },
+};
+
+export const messages = {
+  channelId: 'channelId',
+  page1: ['messageId11', 'messageId12', 'messageId13'],
+  page2: ['messageId21', 'messageId22', 'messageId23'],
+  page3: ['messageId31', 'messageId32', 'messageId33'],
+};

package/src/utils/tests/dummy/post.ts

@@ -0,0 +1,31 @@
+import { user11, date } from '.';
+
+export const post1: Amity.Post = {
+  path: '',
+  feedId: '',
+  children: [],
+  comments: [],
+  flagCount: 0,
+  reactions: {},
+  hashFlag: null,
+  editedAt: date,
+  createdAt: date,
+  commentsCount: 0,
+  reactionsCount: 0,
+  postId: 'postId11',
+  targetType: 'user',
+  parentId: 'postId12',
+  data: { text: 'post1' },
+  targetId: user11.userId,
+  hasFlaggedComment: false,
+  hasFlaggedChildren: false,
+  postedUserId: user11.userId,
+};
+
+export const posts = {
+  targetId: user11.userId,
+  targetType: 'user' as Amity.PostTargetType,
+  page1: [post1.postId, 'postId12', 'postId13'],
+  page2: ['postId21', 'postId22', 'postId23'],
+  page3: ['postId31', 'postId32', 'postId33'],
+};

package/src/utils/tests/dummy/user.ts

@@ -0,0 +1,11 @@
+import { date, rolesAndPermissions } from '.';
+
+export const user11: Amity.User = {
+  _id: '',
+  path: '',
+  flagCount: 0,
+  userId: 'test',
+  hashFlag: null,
+  createdAt: date,
+  ...rolesAndPermissions,
+};

package/src/utils/tests/index.ts

@@ -0,0 +1,2 @@
+export * from './dummy';
+export * 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
+	}
 }