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

package/src/channel/api/updateChannel.ts

@@ -19,7 +19,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  */
 export const updateChannel = async (
   channelId: Amity.Channel['channelId'],
-  patch: Patch<Amity.Channel, 'displayName' | 'description' | 'avatarFileId' | 'metadata'>,
+  patch: Patch<Amity.Channel, 'displayName' | 'avatarFileId' | 'tags' | 'metadata'>,
 ): Promise<Amity.Cached<Amity.Channel>> => {
   const client = getActiveClient();
   client.log('channel/updateChannel', channelId, patch);

package/src/comment/api/queryComments.ts

@@ -19,15 +19,9 @@ import { getResolver } from '~/core/model';
  * @category Comment API
  * @async
  */
-export const queryComments = async (query: {
-  referenceType: Amity.Comment['referenceType'];
-  referenceId: Amity.Comment['referenceId'];
-  sortBy?: 'lastCreated' | 'firstCreated' | 'lastUpdated' | 'firstUpdated';
-  parentId?: Amity.Comment['commentId'] | null;
-  hasFlag?: boolean;
-  isDeleted?: Amity.Comment['isDeleted'];
-  page?: Amity.Page;
-}): Promise<Amity.Cached<Amity.Paged<Amity.Comment>>> => {
+export const queryComments = async (
+  query: Amity.QueryComments,
+): Promise<Amity.Cached<Amity.Paged<Amity.Comment>>> => {
   const client = getActiveClient();
   client.log('comment/queryComments', query);
 

package/src/comment/observers/index.ts

@@ -1,2 +1,3 @@
 export * from './observeComments';
 export * from './observeComment';
+export * from './liveComments';

package/src/comment/observers/liveComments.ts

@@ -0,0 +1,169 @@
+/* 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 {
+  onCommentCreated,
+  onCommentUpdated,
+  onCommentDeleted,
+  onCommentFlagged,
+  onCommentUnflagged,
+  onCommentReactionAdded,
+  onCommentReactionRemoved,
+} from '../events';
+import { queryComments } from '../api';
+
+/**
+ * ```js
+ * import { liveComments } from '@amityco/ts-sdk'
+ *
+ * let comments = []
+ * const unsub = liveComments({
+ *   referenceType: Amity.Comment['referenceType'];
+ *   referenceId: Amity.Comment['referenceId'];
+ * }, response => merge(comments, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Comment} 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 Comments Live Collection
+ */
+export const liveComments = (
+  params: Amity.CommentLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Comment>,
+  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(`liveComments(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 = [
+    'comment',
+    'collection',
+    { referenceId: params.referenceType, referenceType: params.referenceId },
+  ];
+
+  const responder = (data: Amity.CommentLiveCollectionCache) => {
+    let comments: Amity.Comment[] =
+      data.data
+        .map(commentId => pullFromCache<Amity.Comment>(['comment', 'get', commentId])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    comments = filterByPropEquality(comments, 'isDeleted', params.isDeleted);
+
+    const sortBy = params.sortBy ? params.sortBy : 'lastCreated';
+
+    comments = comments.sort(sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated);
+
+    callback({
+      onNextPage: onFetch,
+      data: comments,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (comment: Amity.Comment, action: Amity.CommentActionType) => {
+    const collection = pullFromCache<Amity.CommentLiveCollectionCache>(cacheKey)?.data;
+
+    if (
+      params.referenceId !== comment.referenceId ||
+      params.referenceType !== comment.referenceType ||
+      !collection
+    )
+      return;
+
+    if (action === 'onCreate') {
+      collection.data = [...new Set([comment.commentId, ...collection.data])];
+    } else if (action === 'onDelete') {
+      collection.data = collection.data.filter(p => p !== comment.commentId);
+    }
+
+    pushToCache(cacheKey, collection);
+
+    responder(collection);
+  };
+
+  const onFetch = () => {
+    const collection = pullFromCache<Amity.CommentLiveCollectionCache>(cacheKey)?.data;
+
+    const comments = collection?.data ?? [];
+
+    if (comments.length > 0 && !collection?.params?.page) return;
+
+    const query = createQuery(queryComments, {
+      ...queryParams,
+      page: collection?.params?.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, prevPage: page }) => {
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: comments,
+        };
+
+        if (result) {
+          data.data = [...new Set([...comments, ...result.map(getResolver('comment'))])];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onCommentCreated(comment => realtimeRouter(comment, 'onCreate')),
+    onCommentUpdated(comment => realtimeRouter(comment, 'onUpdate')),
+    onCommentDeleted(comment => realtimeRouter(comment, 'onDelete')),
+    onCommentFlagged(comment => realtimeRouter(comment, 'onFlagged')),
+    onCommentUnflagged(comment => realtimeRouter(comment, 'onUnflagged')),
+    onCommentReactionAdded(comment => realtimeRouter(comment, 'onReactionAdded')),
+    onCommentReactionRemoved(comment => realtimeRouter(comment, 'onReactionRemoved')),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveComments(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/comment/observers/observeComments.ts

@@ -48,17 +48,7 @@ export const observeComments = (
 
   const disposers: Amity.Unsubscriber[] = [];
 
-  const router = (
-    comment: Amity.Comment,
-    action:
-      | 'onCreate'
-      | 'onUpdate'
-      | 'onDelete'
-      | 'onFlagged'
-      | 'onUnflagged'
-      | 'onReactionAdded'
-      | 'onReactionRemoved',
-  ) => {
+  const router = (comment: Amity.Comment, action: Exclude<Amity.CommentActionType, 'onFetch'>) => {
     if (comment.referenceId !== postId) return;
 
     if (callback instanceof Function) return callback(comment);

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[0], [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/index.ts

@@ -59,6 +59,8 @@ export * from './comment/events';
 export * from './comment/observers';
 
 export * from './poll/api';
+export * from './poll/events';
+export * from './poll/observers';
 
 export * from './stream/api';
 export * from './stream/events';

package/src/message/api/createMessage.ts

@@ -75,8 +75,11 @@ createMessage.optimistically = (
   /*
    * when creating messages optimistically a messageId needs to be added by the
    * client, created a new variable so as to allow backward compatibility of API
+   *
+   * Updated to handle client requirement to add messageId while uploading
+   * message with image. Temporary!
    */
-  const bundleWithMessageId = { ...bundle, messageId: uuid() };
+  const bundleWithMessageId = { messageId: uuid(), ...bundle };
 
   // only log if cache is enabled
   client.log('user/createMessage.locally', bundleWithMessageId);

package/src/poll/api/closePoll.ts

@@ -1,3 +1,4 @@
+import { fireEvent } from '~/core/events';
 import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
@@ -30,6 +31,8 @@ export const closePoll = async (
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 
+  fireEvent('poll.updated', data);
+
   const { polls } = data;
 
   return {

package/src/poll/api/deletePoll.ts

@@ -1,3 +1,4 @@
+import { fireEvent } from '~/core/events';
 import { getActiveClient } from '~/client/api';
 
 import { upsertInCache } from '~/cache/api';
@@ -32,5 +33,7 @@ export const deletePoll = async (pollId: Amity.Poll['pollId']): Promise<boolean>
 
   upsertInCache(['poll', 'get', pollId], deleted);
 
+  fireEvent('poll.deleted', { polls: [deleted], users: [] });
+
   return success;
 };

package/src/poll/api/votePoll.ts

@@ -1,3 +1,4 @@
+import { fireEvent } from '~/core/events';
 import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
@@ -34,6 +35,8 @@ export const votePoll = async (
 
   const { polls } = data;
 
+  fireEvent('poll.updated', data);
+
   return {
     data: polls.find(poll => poll.pollId === pollId)!,
     cachedAt,

package/src/poll/events/index.ts

@@ -0,0 +1,2 @@
+export * from './onPollUpdated';
+export * from './onPollDeleted';

package/src/poll/events/onPollDeleted.ts

@@ -0,0 +1,31 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { onPollDeleted } from '@amityco/ts-sdk'
+ * const dispose = onPollDeleted(poll => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Poll} has been deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Poll Events
+ */
+export const onPollDeleted = (callback: Amity.Listener<Amity.Poll>): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.PollPayload) => {
+    if (client.cache) ingestInCache(payload);
+
+    callback(payload.polls[0]);
+  };
+
+  return createEventSubscriber(client, 'poll/onPollDeleted', 'poll.deleted', filter);
+};

package/src/poll/events/onPollUpdated.ts

@@ -0,0 +1,31 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { onPollUpdated } from '@amityco/ts-sdk'
+ * const dispose = onPollUpdated(poll => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Poll} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Poll Events
+ */
+export const onPollUpdated = (callback: Amity.Listener<Amity.Poll>): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.PollPayload) => {
+    if (client.cache) ingestInCache(payload);
+
+    callback(payload.polls[0]);
+  };
+
+  return createEventSubscriber(client, 'poll/onPollUpdated', 'poll.updated', filter);
+};

package/src/poll/observers/index.ts

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

package/src/poll/observers/observePoll.ts

@@ -0,0 +1,67 @@
+import { getActiveClient } from '~/client/api';
+
+import { createQuery, runQuery, queryOptions } from '~/core/query';
+
+import { getPoll } from '../api';
+
+import { onPollUpdated, onPollDeleted } from '../events';
+
+/**
+ * ```js
+ * import { observePoll } from '@amityco/ts-sdk'
+ *
+ * let poll = {}
+ * const dispose = observePoll(pollId, updated => poll = updated)
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.Poll}
+ *
+ * @param pollId the ID of the poll 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 poll
+ *
+ * @category Poll Observer
+ */
+export const observePoll = <Events extends ['onFetch', 'onUpdate', 'onDelete']>(
+  pollId: string,
+  callback: Amity.ObjectListener<Amity.Snapshot<Amity.Poll | undefined>, Events>,
+  policy: Amity.QueryPolicy = 'cache_then_server',
+): Amity.Unsubscriber => {
+  const { log } = getActiveClient();
+
+  const timestamp = Date.now();
+  log(`observePoll(tmpid: ${timestamp}) > listen`);
+
+  // wrapper function to make sure
+  const router = (result: Amity.Snapshot<Amity.Poll | 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.Poll>, action: Events[number]) => {
+    if (result.data?.pollId !== pollId) return;
+
+    router(result, action);
+  };
+
+  const disposers: Amity.Unsubscriber[] = [];
+
+  disposers.push(
+    onPollUpdated(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onUpdate')),
+    onPollDeleted(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onDelete')),
+  );
+
+  runQuery(
+    createQuery(getPoll, pollId),
+    result => (result.data || result.error) && router(result, 'onFetch'),
+    queryOptions(policy),
+  );
+
+  return () => {
+    log(`observePoll(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/post/api/approvePost.ts

@@ -0,0 +1,48 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+/**
+ * ```js
+ * import { approvePost } from '@amityco/ts-sdk'
+ *
+ * const { data: post } = await approvePost('postId')
+ * ```
+ *
+ * Approves a {@link Amity.Post}
+ *
+ * @param postId The {@link Amity.Post} ID to be approved
+ * @return A {@link Amity.Post} that was approved
+ *
+ * @category Post API
+ * @async
+ */
+export const approvePost = async (
+  postId: Amity.Post['postId'],
+): Promise<Amity.Cached<Amity.Post>> => {
+  const client = getActiveClient();
+  client.log('post/approvePost', postId);
+
+  const { data: approved } = await client.http.post<Amity.PostPayload>(
+    `/api/v3/posts/${encodeURIComponent(postId)}/approve`,
+  );
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(approved, { cachedAt });
+
+  // fire virtual event for community update
+  if (approved.posts[0].targetType === 'community') {
+    const community = approved.communities?.[0];
+
+    // @ts-ignore as communities is optional currently in PostPayload
+    fireEvent('community.updated', { communities: [community] });
+  }
+
+  fireEvent('post.approved', { posts: [approved.posts[0]] });
+
+  return {
+    data: approved.posts.find(post => post.postId === postId)!,
+    cachedAt,
+  };
+};

package/src/post/api/declinePost.ts

@@ -0,0 +1,48 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+/**
+ * ```js
+ * import { declinePost } from '@amityco/ts-sdk'
+ *
+ * const {data: post} = await declinePost('postId')
+ * ```
+ *
+ * Declines a {@link Amity.Post}
+ *
+ * @param postId The {@link Amity.Post} ID to be declined
+ * @return A {@link Amity.Post} that was declined
+ *
+ * @category Post API
+ * @async
+ */
+export const declinePost = async (
+  postId: Amity.Post['postId'],
+): Promise<Amity.Cached<Amity.Post>> => {
+  const client = getActiveClient();
+  client.log('post/declinePost', postId);
+
+  const { data: declined } = await client.http.post<Amity.PostPayload>(
+    `/api/v3/posts/${encodeURIComponent(postId)}/decline`,
+  );
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(declined, { cachedAt });
+
+  // fire virtual event
+  if (declined.posts[0].targetType === 'community') {
+    const community = declined.communities?.[0];
+
+    // @ts-ignore as communities is optional currently in PostPayload
+    fireEvent('community.updated', { communities: [community] });
+  }
+
+  fireEvent('post.declined', { posts: [declined.posts[0]] });
+
+  return {
+    data: declined.posts.find(post => post.postId === postId)!,
+    cachedAt,
+  };
+};

package/src/post/api/index.ts

@@ -5,3 +5,6 @@ export * from './getPost';
 export * from './createPost';
 export * from './updatePost';
 export * from './deletePost';
+
+export * from './approvePost';
+export * from './declinePost';

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';