@amityco/ts-sdk 0.0.1-003998f.0

package/src/post/observers/observePost.ts

@@ -0,0 +1,100 @@
+import { getActiveClient } from '~/client/api';
+
+import { createQuery, runQuery, queryOptions } from '~/core/query';
+
+import { getPost } from '../api';
+
+import {
+  onPostUpdated,
+  onPostDeleted,
+  onPostApproved,
+  onPostDeclined,
+  onPostFlagged,
+  onPostUnflagged,
+  onPostReactionAdded,
+  onPostReactionRemoved,
+} from '../events';
+
+/**
+ * ```js
+ * import { observePost } from '@amityco/ts-sdk'
+ *
+ * let post = {}
+ * const dispose = observePost(postId, updated => post = updated)
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.Post}
+ *
+ * @param postId the ID of the post to observe
+ * @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 post
+ *
+ * @category Post Observer
+ */
+export const observePost = <
+  Events extends [
+    'onFetch',
+    'onUpdate',
+    'onDelete',
+    'onApproved',
+    'onDeclined',
+    'onFlagged',
+    'onUnflagged',
+    'onReactionAdded',
+    'onReactionRemoved',
+  ],
+>(
+  postId: string,
+  callback: Amity.ObjectListener<Amity.Snapshot<Amity.Post | undefined>, Events>,
+  policy: Amity.QueryPolicy = 'cache_then_server',
+): Amity.Unsubscriber => {
+  const { log } = getActiveClient();
+
+  const timestamp = Date.now();
+  log(`observePost(tmpid: ${timestamp}) > listen`);
+
+  // wrapper function to make sure
+  const router = (result: Amity.Snapshot<Amity.Post | undefined>, action: Events[number]) => {
+    if (callback instanceof Function) return callback(result);
+
+    if (action !== 'onFetch') callback.onEvent?.(action, result);
+
+    callback[action]?.(result);
+  };
+
+  const realtimeRouter = (result: Amity.Snapshot<Amity.Post>, action: Events[number]) => {
+    if (result.data?.postId !== postId) return;
+
+    router(result, action);
+  };
+
+  const disposers: Amity.Unsubscriber[] = [];
+
+  disposers.push(
+    onPostUpdated(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onUpdate')),
+    onPostDeleted(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onDelete')),
+    onPostApproved(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onApproved')),
+    onPostDeclined(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onDeclined')),
+    onPostFlagged(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onFlagged')),
+    onPostUnflagged(data =>
+      realtimeRouter({ data, loading: false, origin: 'event' }, 'onUnflagged'),
+    ),
+    onPostReactionAdded(data =>
+      realtimeRouter({ data, loading: false, origin: 'event' }, 'onReactionAdded'),
+    ),
+    onPostReactionRemoved(data =>
+      realtimeRouter({ data, loading: false, origin: 'event' }, 'onReactionRemoved'),
+    ),
+  );
+
+  runQuery(
+    createQuery(getPost, postId),
+    result => (result.data || result.error) && router(result, 'onFetch'),
+    queryOptions(policy),
+  );
+
+  return () => {
+    log(`observePosts(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/post/observers/observePosts.ts

@@ -0,0 +1,87 @@
+import { getActiveClient } from '~/client/api';
+
+import {
+  onPostCreated,
+  onPostUpdated,
+  onPostDeleted,
+  onPostApproved,
+  onPostDeclined,
+  onPostFlagged,
+  onPostUnflagged,
+  onPostReactionAdded,
+  onPostReactionRemoved,
+} from '../events';
+
+/**
+ * ```js
+ * import { observePosts } from '@amityco/ts-sdk'
+ *
+ * let posts = []
+ * const unsub = observePosts({
+ *   targetType: Amity.PostTargetType,
+ *   targetId: Amity.Post['targetId'],
+ * }, post => merge(posts, post))
+ * ```
+ *
+ * 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 Post Observer
+ */
+export const observePosts = (
+  params: {
+    targetType: Amity.PostTargetType;
+    targetId: Amity.Post['targetId'];
+  },
+  callback: Amity.ObjectListener<
+    Amity.Post,
+    [
+      'onCreate',
+      'onUpdate',
+      'onDelete',
+      'onApproved',
+      'onDeclined',
+      'onFlagged',
+      'onUnflagged',
+      'onReactionAdded',
+      'onReactionRemoved',
+    ]
+  >,
+): Amity.Unsubscriber => {
+  const { log } = getActiveClient();
+
+  const timestamp = Date.now();
+  log(`observePosts(tmpid: ${timestamp}) > listen`);
+
+  const disposers: Amity.Unsubscriber[] = [];
+
+  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);
+
+    callback.onEvent?.(action, post);
+    callback[action]?.(post);
+  };
+
+  disposers.push(
+    onPostCreated(post => router(post, 'onCreate')),
+    onPostUpdated(post => router(post, 'onUpdate')),
+    onPostDeleted(post => router(post, 'onDelete')),
+    onPostApproved(post => router(post, 'onApproved')),
+    onPostDeclined(post => router(post, 'onDeclined')),
+    onPostFlagged(post => router(post, 'onFlagged')),
+    onPostUnflagged(post => router(post, 'onUnflagged')),
+    onPostReactionAdded(post => router(post, 'onReactionAdded')),
+    onPostReactionRemoved(post => router(post, 'onReactionRemoved')),
+  );
+
+  return () => {
+    log(`observePosts(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

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

@@ -0,0 +1,88 @@
+import { ASCApiError } from '~/core/errors';
+import { client, posts } from '~/utils/tests';
+import { pushToCache, enableCache, disableCache } from '~/cache/api';
+
+import { getPost } from '~/post/api';
+
+describe('post/api', () => {
+  const post = { postId: posts.page1[0] };
+  const post2 = { postId: posts.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, posts } from '~/utils/tests';
+
+describe('post/api', () => {
+  test('should return a post query', async () => {
+    const returnValue = [{ postId: posts.page1[0] }];
+
+    client.http.get = jest.fn().mockResolvedValue({
+      data: {
+        posts: returnValue,
+        paging: {},
+      },
+    });
+
+    const data = await queryPosts({
+      targetId: posts.targetId,
+      targetType: posts.targetType,
+    });
+
+    expect(data).toBeDefined();
+    expect(data?.data).toEqual(returnValue);
+  });
+});

package/src/reaction/api/addReaction.ts

@@ -0,0 +1,99 @@
+import { getActiveClient } from '~/client/api';
+
+import { upsertInCache, pullFromCache } from '~/cache/api';
+
+import { dispatchReactable, fetchReference } from '../utils';
+
+/**
+ * ```js
+ * import { addReaction } from '@amityco/ts-sdk'
+ * const success = await addReaction('post', postId, 'like')
+ * ```
+ *
+ * Creates an {@link Amity.Reaction}
+ *
+ * @param referenceType The type of thing to add a {@link Amity.Reaction} to, such as a post or a comment.
+ * @param referenceId The ID of the thing to add a new {@link Amity.Reaction} to.
+ * @param reactionName Reaction name, such as a `like` or `love`.
+ * @returns The added result.
+ *
+ * @category Reaction API
+ * @async
+ * */
+export const addReaction = async (
+  referenceType: Amity.Reaction['referenceType'],
+  referenceId: Amity.Reaction['referenceId'],
+  reactionName: Amity.Reaction['reactionName'],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('reaction/createReaction', {
+    referenceId,
+    referenceType,
+    reactionName,
+  });
+
+  await client.http.post<{ addedId: 'string' }>('/api/v2/reactions', {
+    referenceId,
+    referenceType,
+    reactionName,
+  });
+
+  const model = await fetchReference(referenceType, referenceId);
+  dispatchReactable(referenceType, model.data);
+
+  return model.data.myReactions?.includes(reactionName) ?? false;
+};
+
+/**
+ * ```js
+ * import { addReaction } from '@amityco/ts-sdk'
+ * const success = addReaction.optimistically('post', postId, 'like')
+ * ```
+ *
+ * Creates an {@link Amity.Reaction} optimistically
+ *
+ * @param referenceType The type of thing to add a {@link Amity.Reaction} to, such as a post or a comment.
+ * @param referenceId The ID of the thing to add a new {@link Amity.Reaction} to.
+ * @param reactionName Reaction name, such as a `like` or `love`.
+ * @returns The added result.
+ *
+ * @category Reaction API
+ * */
+addReaction.optimistically = (
+  referenceType: Amity.ReactableType,
+  referenceId: Amity.Reaction['referenceId'],
+  reactionName: Amity.Reaction['reactionName'],
+): boolean | undefined => {
+  const client = getActiveClient();
+  client.log('reaction/createReaction.optimistically', {
+    referenceId,
+    referenceType,
+    reactionName,
+  });
+
+  if (!client.cache) return;
+
+  const model = pullFromCache<Amity.Model[Amity.ReactableType]>([
+    referenceType,
+    'get',
+    referenceId,
+  ]);
+
+  if (!model?.data || model.data.myReactions?.includes(reactionName)) return;
+
+  const reaction = {
+    ...model.data,
+    reactionsCount: model.data.reactionsCount + 1,
+    myReactions: [...(model.data.myReactions ?? []), reactionName],
+    reactions: {
+      ...model.data.reactions,
+      [reactionName]: (model.data.reactions[reactionName] ?? 0) + 1,
+    },
+  } as Amity.Model[Amity.ReactableType];
+
+  upsertInCache([referenceType, 'get', referenceId], reaction, { cachedAt: -1 });
+
+  dispatchReactable(referenceType, reaction);
+
+  return reaction?.myReactions?.includes(reactionName) ?? false;
+};

package/src/reaction/api/index.ts

@@ -0,0 +1,3 @@
+export * from './addReaction';
+export * from './removeReaction';
+export * from './queryReactions';

package/src/reaction/api/queryReactions.ts

@@ -0,0 +1,52 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { toToken, toPageRaw } from '~/core/query';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { queryReactions } from '@amityco/ts-sdk'
+ * const { data: reactions, prevPage, nextPage } = await queryReactions({
+ *   referenceId: 'postId',
+ *   referenceType: 'post',
+ * })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.ReactionQuery} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Reaction} objects
+ *
+ * @reaction Reaction API
+ * @async
+ * */
+export const queryReactions = async (
+  query: Amity.QueryReactions,
+): 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<Amity.ReactionPayload & Amity.Pagination>(
+    `/api/v3/reactions`,
+    {
+      params: {
+        ...params,
+        options: {
+          token: toToken(page, 'afterbeforeraw'),
+        },
+      },
+    },
+  );
+
+  const { paging, ...payload } = data;
+  const { reactions } = payload;
+
+  ingestInCache({ ...payload, reactions: reactions[0].reactors });
+
+  const nextPage = toPageRaw(paging.next);
+  const prevPage = toPageRaw(paging.previous);
+
+  return { data: reactions, prevPage, nextPage };
+};

package/src/reaction/api/removeReaction.ts

@@ -0,0 +1,97 @@
+import { getActiveClient } from '~/client/api';
+
+import { upsertInCache, pullFromCache } from '~/cache/api';
+
+import { dispatchReactable, fetchReference } from '../utils';
+
+/**
+ * ```js
+ * import { deleteReaction } from '@amityco/ts-sdk'
+ * const success = await deleteReaction('post', 'foobar', 'like')
+ * ```
+ *
+ * Removes a {@link Amity.Reaction} from a {@link Amity.Reactable} object
+ *
+ * @param referenceType The type of thing to add a {@link Amity.Reaction} to, such as a post or a comment.
+ * @param referenceId The ID of the thing to add a new {@link Amity.Reaction} to.
+ * @param reactionName Reaction name, such as a `like` or `love`.
+ * @returns The removed result.
+ *
+ * @category Reaction API
+ * @async
+ * */
+export const removeReaction = async (
+  referenceType: Amity.Reaction['referenceType'],
+  referenceId: Amity.Reaction['referenceId'],
+  reactionName: Amity.Reaction['reactionName'],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('reaction/removeReaction', {
+    referenceId,
+    referenceType,
+    reactionName,
+  });
+
+  await client.http.delete<{ removedId: string }>(`/api/v2/reactions`, {
+    data: { referenceId, referenceType, reactionName },
+  });
+
+  const model = await fetchReference(referenceType, referenceId);
+  dispatchReactable(referenceType, model.data);
+
+  return !model.data.myReactions?.includes(reactionName) ?? false;
+};
+
+/**
+ * ```js
+ * import { removeReaction } from '@amityco/ts-sdk'
+ * const success = removeReaction.optimistically('post', postId, 'like')
+ * ```
+ *
+ * Removes a {@link Amity.Reaction} from a {@link Amity.Reactable} object optimistically
+ *
+ * @param referenceType The type of thing to add a {@link Amity.Reaction} to, such as a post or a comment.
+ * @param referenceId The ID of the thing to add a new {@link Amity.Reaction} to.
+ * @param reactionName Reaction name, such as a `like` or `love`.
+ * @returns The added result.
+ *
+ * @category Reaction API
+ * */
+removeReaction.optimistically = (
+  referenceType: Amity.ReactableType,
+  referenceId: Amity.Reaction['referenceId'],
+  reactionName: Amity.Reaction['reactionName'],
+): boolean | undefined => {
+  const client = getActiveClient();
+  client.log('reaction/removeReaction.optimistically', {
+    referenceId,
+    referenceType,
+    reactionName,
+  });
+
+  if (!client.cache) return;
+
+  const model = pullFromCache<Amity.Model[Amity.ReactableType]>([
+    referenceType,
+    'get',
+    referenceId,
+  ]);
+
+  if (!model?.data || !model.data.myReactions?.includes(reactionName)) return;
+
+  const reaction = {
+    ...model.data,
+    reactionsCount: Math.max(0, model.data.reactionsCount - 1),
+    myReactions: (model.data.myReactions ?? []).filter(item => item !== reactionName),
+    reactions: {
+      ...model.data.reactions,
+      [reactionName]: Math.max(0, (model.data.reactions[reactionName] ?? 0) - 1),
+    },
+  } as Amity.Model[Amity.ReactableType];
+
+  upsertInCache([referenceType, 'get', referenceId], reaction, { cachedAt: -1 });
+
+  dispatchReactable(referenceType, reaction);
+
+  return !reaction?.myReactions?.includes(reactionName) ?? false;
+};

package/src/reaction/events/index.ts

@@ -0,0 +1,5 @@
+export * from './onReactionAdded';
+export * from './onReactionRemoved';
+
+export * from './onReactorAdded';
+export * from './onReactorRemoved';

package/src/reaction/events/onReactionAdded.ts

@@ -0,0 +1,72 @@
+import { getActiveClient } from '~/client/api';
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { createEventSubscriber } from '~/core/events';
+import { getResolver } from '~/core/model';
+import { onPostReactionAdded } from '~/post/events';
+import { onCommentReactionAdded } from '~/comment/events';
+
+/**
+ * ```js
+ * import { onReactionAdded } from '@amityco/ts-sdk'
+ * const dispose = onReactionAdded('post', postId, post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Reaction} 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 Message Events
+ * */
+export const onReactionAdded = (
+  referenceType: Amity.ReactableType,
+  referenceId: Amity.Reaction['referenceId'],
+  callback: Amity.Listener<Amity.Model[typeof referenceType]>,
+): Amity.Unsubscriber => {
+  const callbackWrapper = (model: Amity.Model[typeof referenceType]) => {
+    if (getResolver(referenceType)(model as any) === referenceId) {
+      callback(model);
+    }
+  };
+
+  /*
+   * Important: Want to point out that reference type will never be 'message'
+   * for onReactionAdded
+   */
+  if (referenceType === 'message') {
+    const client = getActiveClient();
+
+    const filter = (payload: Amity.MessagePayload) => {
+      const cached = pullFromCache<Amity.Message>([
+        'message',
+        'get',
+        payload.messages[0].messageId,
+      ]);
+      const isReactionEvent = cached?.data?.reactionsCount !== payload.messages[0].reactionsCount;
+
+      ingestInCache(payload);
+
+      if (isReactionEvent) {
+        callbackWrapper(payload.messages[0]);
+      }
+    };
+
+    return createEventSubscriber(
+      client,
+      'reaction/onReactionAdded',
+      'v3.message.didUpdate',
+      filter,
+    );
+  }
+
+  if (referenceType === 'post') {
+    return onPostReactionAdded(callbackWrapper);
+  }
+
+  return onCommentReactionAdded(callbackWrapper);
+};