@amityco/ts-sdk 0.0.1-beta.37 → 0.0.1-beta.38

package/src/channel/api/tests/queryChannels.test.ts

@@ -4,11 +4,17 @@ import { disableCache, enableCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
 import { prepareChannelPayload } from '~/channel/utils';
-import { client, channelQueryResponse } from '~/utils/tests';
+import {
+  client,
+  channelQueryResponse,
+  channelTagQueryResponse,
+  channelExcludeTagQueryResponse,
+} from '~/utils/tests';
 
 import { queryChannels } from '../queryChannels';
 
 describe('queryChannels', () => {
+  // integration_test_id: 06c14dab-4799-4f26-9e52-be7c12b3bdb3
   test('it should return channels', async () => {
     const expected = prepareChannelPayload(channelQueryResponse.data).channels;
     client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
@@ -18,6 +24,37 @@ describe('queryChannels', () => {
     expect(data).toEqual(expected);
   });
 
+  // integration_test_id: 253fb0ac-f868-4570-9b1e-98b08861aa53
+  test('it should return channels match with membership type', async () => {
+    // Actually there is no any flag to tell about this list is relate to membership type
+    // But need to implement this case to match with our test list
+    const expected = prepareChannelPayload(channelQueryResponse.data).channels;
+    client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
+    const { data } = await queryChannels({ membership: 'member' });
+    expect(data).toEqual(expected);
+  });
+
+  // integration_test_id: 92329d41-9403-44e7-979f-ed227e6ab120
+  test('it should return channels match with tags query type', async () => {
+    const expected = prepareChannelPayload(channelTagQueryResponse.data).channels;
+    client.http.get = jest.fn().mockResolvedValue(channelTagQueryResponse);
+    const { data } = await queryChannels({ tags: ['tag1'] });
+    expect(data).toEqual(expected);
+    expect(data[0].tags).toContain('tag1');
+  });
+
+  // integration_test_id: 5249778c-6d99-4e2f-9b80-2f4ea6ae1833
+  test('it should return channels without tags which defined in exclude options', async () => {
+    const expected = prepareChannelPayload(channelExcludeTagQueryResponse.data).channels;
+    client.http.get = jest.fn().mockResolvedValue(channelExcludeTagQueryResponse);
+    const { data } = await queryChannels({ excludeTags: ['tag1'] });
+    expect(data).toEqual(expected);
+
+    data.forEach(item => {
+      expect(item.tags).not.toContain('tag1');
+    });
+  });
+
   test('it should throw error', async () => {
     client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
 

package/src/channel/observers/liveChannel.ts

@@ -1,12 +1,4 @@
-import { ASCApiError } from '~/core/errors';
-import { getActiveClient } from '~/client/api';
-import { createQuery, runQuery } from '~/core/query';
-import {
-  LIVE_OBJECT_ENABLE_CACHE_MESSAGE,
-  UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
-  UNSYNCED_OBJECT_CACHED_AT_VALUE,
-} from '~/utils/constants';
-import { hasUpdates } from '~/core/model';
+import { liveObject } from '~/utils/liveObject';
 import { onMessageCreated } from '~/message/events';
 import { getChannel } from '../api';
 import { onChannelDeleted, onChannelJoined, onChannelMuted, onChannelUpdated } from '../events';
@@ -34,75 +26,11 @@ export const liveChannel = (
   channelId: Amity.Channel['channelId'],
   callback: Amity.LiveObjectCallback<Amity.Channel>,
 ): Amity.Unsubscriber => {
-  const { log, cache } = getActiveClient();
-  const timestamp = Date.now();
-  log(`liveChannel(tmpid: ${timestamp}) > listen`);
-
-  if (!cache) {
-    console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
-  }
-
-  let channel: Amity.Channel;
-  let isUnsyncedObject = false;
-  const disposers: Amity.Unsubscriber[] = [];
-
-  const dispatcher = (data: Amity.LiveObject<Amity.Channel>) => {
-    channel = data.data;
-    callback(data);
-  };
-
-  const realtimeRouter = (eventChannel: Amity.Channel) => {
-    if (channelId !== eventChannel.channelId) {
-      return;
-    }
-
-    if (channel && !hasUpdates(channel, eventChannel)) {
-      return;
-    }
-
-    dispatcher({ loading: false, data: eventChannel, origin: 'event' });
-  };
-
-  const onFetch = () => {
-    const query = createQuery(getChannel, channelId);
-
-    runQuery(query, ({ loading, data, error, origin, cachedAt }) => {
-      if (cachedAt === UNSYNCED_OBJECT_CACHED_AT_VALUE) {
-        dispatcher({
-          data,
-          origin,
-          loading: false,
-          error: new ASCApiError(
-            UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
-            Amity.ClientError.DISALOOW_UNSYNCED_OBJECT,
-            Amity.ErrorLevel.ERROR,
-          ),
-        });
-
-        isUnsyncedObject = true;
-        disposers.forEach(fn => fn());
-      } else if (!isUnsyncedObject) {
-        dispatcher({ loading, data, origin, error });
-      }
-
-      if (error) {
-        disposers.forEach(fn => fn());
-      }
-    });
-  };
-
-  disposers.push(
-    onChannelUpdated(realtimeRouter),
-    onChannelDeleted(realtimeRouter),
-    onChannelJoined(realtimeRouter),
-    onChannelMuted(realtimeRouter),
-    onMessageCreated(() => null), // watch unread count
-  );
-
-  onFetch();
-
-  return () => {
-    log(`liveChannel(tmpid: ${timestamp}) > dispose`);
-    disposers.forEach(fn => fn());
-  };
+  return liveObject(channelId, callback, 'channelId', getChannel, [
+    onChannelUpdated,
+    onChannelDeleted,
+    onChannelJoined,
+    onChannelMuted,
+    () => onMessageCreated(() => null), // watch unread count
+  ]);
 };

package/src/client/api/accessTokenExpiryWatcher.ts

@@ -26,10 +26,12 @@ export const isExpired = (expiresAt: Amity.Tokens['expiresAt']): boolean =>
  *
  * @category private
  */
-export const isAboutToExpire = (
-  expiresAt: Amity.Tokens['expiresAt'],
-  issuedAt: Amity.Tokens['issuedAt'],
-): boolean => {
+export const isAboutToExpire = (params: {
+  expiresAt: Amity.Tokens['expiresAt'];
+  issuedAt: Amity.Tokens['issuedAt'];
+}): boolean => {
+  const { expiresAt, issuedAt } = params;
+
   const expires = Date.parse(expiresAt);
   const issued = Date.parse(issuedAt);
   const now = Date.now();
@@ -74,7 +76,7 @@ export const accessTokenExpiryWatcher = (
       return;
     }
 
-    if (isAboutToExpire(issuedAt, expiresAt)) {
+    if (isAboutToExpire({ expiresAt, issuedAt })) {
       sessionHandler.sessionWillRenewAccessToken(renewal());
     }
   }, ACCESS_TOKEN_WATCHER_INTERVAL);

package/src/client/api/tests/accessTokenExpiryWatcher.test.ts

@@ -96,19 +96,22 @@ describe('accessTokenExpiryWatcher > aboutToExpire', () => {
 
     aboutToExpireTime.setHours(aboutToExpireTime.getHours() + 1);
 
-    expect(isAboutToExpire(aboutToExpireTime.toISOString(), oldIssuedAtTime.toISOString())).toBe(
-      true,
-    );
+    expect(
+      isAboutToExpire({
+        expiresAt: aboutToExpireTime.toISOString(),
+        issuedAt: oldIssuedAtTime.toISOString(),
+      }),
+    ).toBe(true);
   });
 
   test('it should return false if token expired', () => {
-    expect(isAboutToExpire(expiresAt, issuedAt)).toBe(false);
+    expect(isAboutToExpire({ expiresAt, issuedAt })).toBe(false);
   });
 
   test('it should return false if not about to expire', () => {
     oldIssuedAtTime.setDate(oldIssuedAtTime.getDate() - 10);
 
-    expect(isAboutToExpire(expiresAt, issuedAt)).toBe(false);
+    expect(isAboutToExpire({ expiresAt, issuedAt })).toBe(false);
   });
 });
 

package/src/comment/api/deleteComment.ts

@@ -1,10 +1,12 @@
 import { getActiveClient } from '~/client/api';
 
-import { dropFromCache, upsertInCache } from '~/cache/api';
+import { upsertInCache } from '~/cache/api';
 import { fireEvent } from '~/core/events';
 
-import { getComment } from './getComment';
 import { getPost } from '~/post/api/getPost';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+import { scheduleTask } from '~/core/microtasks';
+import { getComment } from './getComment';
 
 /**
  * ```js
@@ -49,9 +51,7 @@ export const deleteComment = async (
   fireEvent('comment.deleted', { comments: [deleted] });
 
   if (permanent) {
-    setTimeout(() => {
-      dropFromCache(['comment', 'get', commentId], true);
-    }, 0);
+    scheduleTask(() => pushToTombstone('comment', commentId));
   } else {
     upsertInCache(['comment', 'get', commentId], { isDeleted: true });
   }

package/src/comment/api/getComment.ts

@@ -1,7 +1,10 @@
 import { getActiveClient } from '~/client/api';
 
-import { pullFromCache, dropFromCache } from '~/cache/api';
+import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { isInTombstone } from '~/cache/api/isInTombstone';
+import { checkIfShouldGoesToTombstone } from '~/cache/utils';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
 
 /**
  * ```js
@@ -23,6 +26,8 @@ export const getComment = async (
   const client = getActiveClient();
   client.log('comment/getComment', commentId);
 
+  isInTombstone('comment', commentId);
+
   let data: Amity.CommentPayload;
 
   try {
@@ -33,8 +38,8 @@ export const getComment = async (
 
     data = response.data;
   } catch (error) {
-    if ((error as Amity.ErrorResponse)?.code === Amity.ServerError.ITEM_NOT_FOUND) {
-      dropFromCache(['comment', 'get', commentId], true);
+    if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
+      pushToTombstone('comment', commentId);
     }
 
     throw error;

package/src/comment/observers/index.ts

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

package/src/comment/observers/liveComment.ts

@@ -0,0 +1,43 @@
+import { liveObject } from '~/utils/liveObject';
+import { getComment } from '../api';
+import {
+  onCommentDeleted,
+  onCommentFlagged,
+  onCommentReactionAdded,
+  onCommentReactionRemoved,
+  onCommentUnflagged,
+  onCommentUpdated,
+} from '../events';
+
+/**
+ * ```js
+ * import { liveComment } from '@amityco/ts-sdk';
+ *
+ * let comment;
+ *
+ * const unsubscribe = liveComment(commentId, response => {
+ *   comment = response.data;
+ * });
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.Comment}
+ *
+ * @param commentId the ID of the comment 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 comment
+ *
+ * @category Comment Live Object
+ */
+export const liveComment = (
+  commentId: Amity.Comment['commentId'],
+  callback: Amity.LiveObjectCallback<Amity.Comment>,
+): Amity.Unsubscriber => {
+  return liveObject(commentId, callback, 'commentId', getComment, [
+    onCommentDeleted,
+    onCommentFlagged,
+    onCommentReactionAdded,
+    onCommentReactionRemoved,
+    onCommentUnflagged,
+    onCommentUpdated,
+  ]);
+};

package/src/comment/observers/tests/liveComment.test.ts

@@ -0,0 +1,95 @@
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  pause,
+  client,
+  connectClient,
+  disconnectClient,
+  generateComment,
+  user12,
+} from '~/utils/tests';
+import { getFutureDate } from '~/core/model';
+import { liveComment } from '../liveComment';
+
+describe('liveComment', () => {
+  const comment = generateComment();
+  const response = { data: { comments: [comment] } };
+
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  const events: [string, keyof Amity.MqttCommentEvents][] = [
+    ['should get update on comment.updated event', 'comment.updated'],
+    ['should get update on comment.deleted event', 'comment.deleted'],
+    ['should get update on comment.flagged event', 'comment.flagged'],
+    ['should get update on comment.unflagged event', 'comment.unflagged'],
+  ];
+
+  test.each(events)('%s', async (test, event) => {
+    const update = {
+      ...comment,
+      data: { text: 'new-text' },
+      updatedAt: getFutureDate(comment.updatedAt),
+    };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    liveComment(comment.commentId, callback);
+    await pause();
+    client.emitter.emit(event, { comments: [update] });
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(3);
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: update,
+        loading: false,
+      }),
+    );
+  });
+
+  test.each([
+    ['should get update on comment.addReaction event', 'comment.addReaction'],
+    ['should get update on comment.removeReaction event', 'comment.removeReaction'],
+  ] as [string, keyof Amity.MqttCommentEvents][])('%s', async (test, event) => {
+    const update = {
+      ...comment,
+      data: { text: 'new-text' },
+      updatedAt: getFutureDate(comment.updatedAt),
+    };
+    const reactor: Amity.Reaction = {
+      createdAt: getFutureDate(comment.updatedAt),
+      reactionId: 'like',
+      reactionName: 'like',
+      referenceId: comment.commentId,
+      referenceType: 'comment',
+      userId: user12.userId,
+    };
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    liveComment(comment.commentId, callback);
+    await pause();
+    client.emitter.emit(event, { comments: [update], reactor });
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(3);
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: update,
+        loading: false,
+      }),
+    );
+  });
+});

package/src/community/api/queryCommunities.ts

@@ -22,16 +22,9 @@ import { unpackCommunityPayload } from '../utils';
  * @category Community API
  * @async
  */
-export const queryCommunities = async (query?: {
-  displayName?: string;
-  membership?: 'all' | 'member' | 'notMember';
-  categoryId?: Amity.Category['categoryId'];
-  isDeleted?: Amity.Community['isDeleted'];
-  hasFlag?: boolean;
-  tags?: Amity.Taggable['tags'];
-  sortBy?: 'displayName' | 'firstCreated' | 'lastCreated';
-  page?: Amity.Page;
-}): Promise<Amity.Cached<Amity.Paged<Amity.Community>>> => {
+export const queryCommunities = async (
+  query?: Amity.QueryCommunities,
+): Promise<Amity.Cached<Amity.Paged<Amity.Community>>> => {
   const client = getActiveClient();
   client.log('channel/queryCommunities', query);
 

package/src/community/api/test/addCommunityMember.test.ts

@@ -1,7 +1,14 @@
 import { disableCache, enableCache, pullFromCache } from '~/cache/api';
 import { getResolver } from '~/core/model';
 
-import { client, community11, communityUser11, user11 } from '~/utils/tests';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  community11,
+  communityUser11,
+  user11,
+} from '~/utils/tests';
 
 import { onCommunityUserAdded } from '../../events';
 import { addCommunityMembers } from '../addCommunityMembers';
@@ -21,6 +28,9 @@ const resolvedPostValue = {
 };
 
 describe('addCommunityMembers', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
   test('should return true value', async () => {
     client.http.post = jest.fn().mockResolvedValue(resolvedPostValue);
 
@@ -66,6 +76,8 @@ describe('addCommunityMembers', () => {
 
     await addCommunityMembers(communityToAddUserTo.communityId, [userToAdd.userId]);
 
-    await expect(callback).resolves.toEqual(expect.objectContaining(communityToAddUserTo));
+    await expect(callback).resolves.toEqual(
+      expect.objectContaining({ ...communityToAddUserTo, isJoined: true }),
+    );
   });
 });

package/src/community/api/test/joinCommunity.test.ts

@@ -1,7 +1,14 @@
 import { disableCache, enableCache, pullFromCache } from '~/cache/api';
 import { getResolver } from '~/core/model';
 
-import { client, community11, communityUser11, user11 } from '~/utils/tests';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  community11,
+  communityUser11,
+  user11,
+} from '~/utils/tests';
 
 import { onCommunityJoined } from '../../events';
 import { joinCommunity } from '../joinCommunity';
@@ -21,6 +28,9 @@ const resolvedPostValue = {
 };
 
 describe('joinCommunity', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
   test('should return true value', async () => {
     client.http.post = jest.fn().mockResolvedValue(resolvedPostValue);
 
@@ -65,6 +75,8 @@ describe('joinCommunity', () => {
 
     await joinCommunity(communityToJoin.communityId);
 
-    await expect(callback).resolves.toEqual(expect.objectContaining(communityToJoin));
+    await expect(callback).resolves.toEqual(
+      expect.objectContaining({ ...communityToJoin, isJoined: true }),
+    );
   });
 });

package/src/community/api/test/leaveCommunity.test.ts

@@ -1,6 +1,13 @@
 import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
 import { getResolver } from '~/core/model';
-import { client, community11, communityUser11, user11 } from '~/utils/tests';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  community11,
+  communityUser11,
+  user11,
+} from '~/utils/tests';
 
 import { leaveCommunity } from '../leaveCommunity';
 import { onCommunityLeft } from '../../events';
@@ -21,6 +28,9 @@ const resolvedDeleteValue = {
 };
 
 describe('leaveCommunity', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
   test('should return true value', async () => {
     client.http.delete = jest.fn().mockResolvedValueOnce(resolvedDeleteValue);
 

package/src/community/api/test/removeCommunityMembers.test.ts

@@ -1,7 +1,14 @@
 import { disableCache, enableCache, pullFromCache } from '~/cache/api';
 import { getResolver } from '~/core/model';
 
-import { client, community11, communityUser11, user11 } from '~/utils/tests';
+import {
+  client,
+  community11,
+  communityUser11,
+  user11,
+  connectClient,
+  disconnectClient,
+} from '~/utils/tests';
 
 import { onCommunityUserRemoved } from '../../events';
 import { removeCommunityMembers } from '../removeCommunityMembers';
@@ -22,6 +29,9 @@ const resolvedDeleteValue = {
 };
 
 describe('removeCommunityMembers', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
   test('should return true value', async () => {
     client.http.delete = jest.fn().mockResolvedValue(resolvedDeleteValue);
 

package/src/community/events/index.ts

@@ -7,5 +7,6 @@ export * from './onCommunityLeft';
 
 export * from './onCommunityUserAdded';
 export * from './onCommunityUserRemoved';
+export * from './onCommunityUserChanged';
 export * from './onCommunityUserBanned';
 export * from './onCommunityUserUnbanned';

package/src/community/events/onCommunityUserChanged.ts

@@ -0,0 +1,20 @@
+import { createCommunityMemberEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onCommunityUserChanged } from '@amityco/ts-sdk'
+ * const dispose = onCommunityUserChanged((community, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a user has been added or removed from a {@link Amity.Community}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Community Events
+ */
+export const onCommunityUserChanged = (
+  callback: (community: Amity.Community, member: Amity.Membership<'community'>) => void,
+) => createCommunityMemberEventSubscriber('community.userChanged', callback);

package/src/community/events/test/onCommunityJoined.test.ts

@@ -35,7 +35,7 @@ describe('onCommunityJoined', () => {
     unsub();
 
     expect(callback).toHaveBeenCalled();
-    expect(callback).toHaveBeenCalledWith(communityToJoin, joinedUser);
+    expect(callback).toHaveBeenCalledWith({ ...communityToJoin, isJoined: true }, joinedUser);
   });
 
   test('it should got nothing if we did unsubscribe before got event', () => {

package/src/community/events/test/onCommunityUserAdded.test.ts

@@ -35,7 +35,7 @@ describe('onCommunityUserAdded', () => {
     unsub();
 
     expect(callback).toHaveBeenCalled();
-    expect(callback).toHaveBeenCalledWith(communityToAddUserTo, userToAdd);
+    expect(callback).toHaveBeenCalledWith({ ...communityToAddUserTo, isJoined: true }, userToAdd);
   });
 
   test('it should got nothing if we did unsubscribe before got event', () => {

package/src/community/events/test/onCommunityUserBanned.test.ts

@@ -35,7 +35,7 @@ describe('onCommunityUserBanned', () => {
     unsub();
 
     expect(callback).toHaveBeenCalled();
-    expect(callback).toHaveBeenCalledWith(community, banedUser);
+    expect(callback).toHaveBeenCalledWith({ ...community, isJoined: true }, banedUser);
   });
 
   test('it should got nothing if we did unsubscribe before got event', () => {

package/src/community/events/test/onCommunityUserUnbaned.test.ts

@@ -35,7 +35,7 @@ describe('onCommunityUserUnbanned', () => {
     unsub();
 
     expect(callback).toHaveBeenCalled();
-    expect(callback).toHaveBeenCalledWith(community, unbannedUser);
+    expect(callback).toHaveBeenCalledWith({ ...community, isJoined: true }, unbannedUser);
   });
 
   test('it should got nothing if we did unsubscribe before got event', () => {