@amityco/ts-sdk 0.0.1-beta.32 → 0.0.1-beta.36

package/src/subChannel/observers/tests/liveSubChannel.test.ts

@@ -0,0 +1,212 @@
+import { ASCApiError } from '~/core/errors';
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  pause,
+  client,
+  connectClient,
+  disconnectClient,
+  generateRawSubChannel,
+} from '~/utils/tests';
+import { createQuery, runQuery } from '~/core/query';
+import { deleteSubChannel, getSubChannel, updateSubChannel } from '~/subChannel/api';
+import { getFutureDate } from '~/core/model';
+import { liveSubChannel } from '../liveSubChannel';
+import { convertFromRaw } from '../../utils';
+
+describe('liveSubChannel', () => {
+  const rawSubChannel = generateRawSubChannel();
+  const subChannel = convertFromRaw(rawSubChannel);
+  const response = { data: { messageFeeds: [rawSubChannel] } };
+
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  test('should get sub channel', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    liveSubChannel(rawSubChannel.messageFeedId, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({ data: undefined, loading: true }),
+    );
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        data: convertFromRaw(rawSubChannel),
+        loading: false,
+      }),
+    );
+  });
+
+  const events: [string, keyof Amity.Events][] = [
+    ['should get update on message-feed.updated event', 'message-feed.updated'],
+    ['should get update on message-feed.deleted event', 'message-feed.deleted'],
+  ];
+
+  test.each(events)('%s', async (test, event) => {
+    const update = {
+      ...rawSubChannel,
+      name: event,
+      updatedAt: getFutureDate(rawSubChannel.updatedAt),
+    };
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    liveSubChannel(subChannel.subChannelId, callback);
+    await pause();
+    client.emitter.emit(event, { messageFeeds: [update] });
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(3);
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: convertFromRaw(update),
+        loading: false,
+      }),
+    );
+  });
+
+  describe('should get an update without rte subscription', () => {
+    const update = {
+      ...rawSubChannel,
+      name: 'new name',
+      updatedAt: getFutureDate(rawSubChannel.updatedAt),
+    };
+
+    test('if getSubChannel is called', async () => {
+      const callback = jest.fn();
+      client.http.get = jest
+        .fn()
+        .mockResolvedValueOnce(response)
+        .mockResolvedValueOnce({ data: { messageFeeds: [update] } });
+
+      liveSubChannel(subChannel.subChannelId, callback);
+      await pause();
+      await getSubChannel(subChannel.subChannelId);
+      await pause();
+
+      expect(callback).toHaveBeenCalledTimes(3);
+      expect(callback).toHaveBeenNthCalledWith(
+        3,
+        expect.objectContaining({
+          data: convertFromRaw(update),
+          loading: false,
+        }),
+      );
+    });
+
+    test('if updateSubChannel is called', async () => {
+      const callback = jest.fn();
+      client.http.get = jest.fn().mockResolvedValue(response);
+      client.http.put = jest.fn().mockResolvedValue({ data: { messageFeeds: [update] } });
+
+      liveSubChannel(subChannel.subChannelId, callback);
+      await pause();
+      await updateSubChannel(subChannel.subChannelId, { displayName: update.name });
+      await pause();
+
+      expect(callback).toHaveBeenCalledTimes(3);
+      expect(callback).toHaveBeenNthCalledWith(
+        3,
+        expect.objectContaining({
+          data: convertFromRaw(update),
+          loading: false,
+        }),
+      );
+    });
+
+    test('if deleteSubChannel is called', async () => {
+      const callback = jest.fn();
+      client.http.get = jest.fn().mockResolvedValue(response);
+      client.http.delete = jest.fn().mockResolvedValue({ data: { success: true } });
+
+      liveSubChannel(subChannel.subChannelId, callback);
+      await pause();
+      runQuery(createQuery(deleteSubChannel, subChannel.subChannelId));
+      await pause();
+
+      expect(callback).toHaveBeenCalledTimes(3);
+      expect(callback).toHaveBeenNthCalledWith(
+        3,
+        expect.objectContaining({
+          data: { ...subChannel, isDeleted: true, updatedAt: expect.anything() },
+          loading: false,
+        }),
+      );
+    });
+  });
+
+  test('should not get update on api failure', async () => {
+    const error = new ASCApiError(
+      'server error!',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+    const update = {
+      ...rawSubChannel,
+      name: 'new name',
+      updatedAt: getFutureDate(rawSubChannel.updatedAt),
+    };
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockRejectedValue(error);
+
+    liveSubChannel(subChannel.subChannelId, callback);
+    await pause();
+    client.emitter.emit('message-feed.updated', { messageFeeds: [update] });
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        data: undefined,
+        error,
+        loading: false,
+      }),
+    );
+  });
+
+  test('should not call callback if liveMessage is disposed', async () => {
+    const update = {
+      ...rawSubChannel,
+      name: 'new name',
+      updatedAt: getFutureDate(rawSubChannel.updatedAt),
+    };
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    const dispose = liveSubChannel(subChannel.subChannelId, callback);
+    await pause();
+    dispose();
+    client.emitter.emit('message-feed.updated', { messageFeeds: [update] });
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+  });
+
+  test('should not call callback if data is the same', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    liveSubChannel(subChannel.subChannelId, callback);
+    await pause();
+    client.emitter.emit('message-feed.updated', { messageFeeds: response.data.messageFeeds });
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+  });
+});

package/src/subChannel/observers/tests/liveSubChannels.test.ts

@@ -0,0 +1,206 @@
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  pause,
+  generateRawSubChannel,
+} from '~/utils/tests';
+import { convertFromRaw } from '~/subChannel/utils';
+import { getFutureDate, getPastDate } from '~/core/model';
+import { liveSubChannels } from '../liveSubChannels';
+
+describe('liveSubChannels', () => {
+  const rawSubChannel = generateRawSubChannel();
+  const response = {
+    data: {
+      messageFeeds: [rawSubChannel],
+      paging: {},
+    },
+  };
+
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  test('should get sub channels', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    liveSubChannels({ channelId: rawSubChannel.channelPublicId }, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({
+        data: [],
+        loading: true,
+      }),
+    );
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        data: [convertFromRaw(rawSubChannel)],
+        loading: false,
+      }),
+    );
+  });
+
+  test('should filter deleted sub channels based on params', async () => {
+    const rawSubChannels = [
+      generateRawSubChannel({ isDeleted: true }),
+      generateRawSubChannel({ messageFeedId: 'sub-channel-id-2' }),
+    ];
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: {
+        messageFeeds: rawSubChannels,
+        paging: {},
+      },
+    });
+
+    liveSubChannels({ channelId: rawSubChannel.channelPublicId, isDeleted: false }, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        data: [convertFromRaw(rawSubChannels[1])],
+        loading: false,
+      }),
+    );
+  });
+
+  test('should fetch next page', async () => {
+    const rawSubChannel2 = generateRawSubChannel({
+      messageFeedId: 'sub-channel-id-2',
+      lastMessageTimestamp: getPastDate(rawSubChannel.lastMessageTimestamp),
+    });
+    const callback = jest.fn();
+    client.http.get = jest
+      .fn()
+      .mockResolvedValueOnce({
+        data: {
+          messageFeeds: [rawSubChannel],
+          paging: {
+            previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+            next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+          },
+        },
+      })
+      .mockResolvedValueOnce({
+        data: {
+          messageFeeds: [rawSubChannel2],
+          paging: {
+            previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+            next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+          },
+        },
+      });
+
+    liveSubChannels({ channelId: rawSubChannel.channelPublicId }, callback);
+    await pause();
+    callback.mock.lastCall[0].onNextPage();
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(4);
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        hasNextPage: true,
+        onNextPage: expect.anything(),
+      }),
+    );
+    expect(callback).toHaveBeenNthCalledWith(
+      4,
+      expect.objectContaining({
+        data: [rawSubChannel, rawSubChannel2].map(convertFromRaw),
+        loading: false,
+      }),
+    );
+  });
+
+  describe('events', () => {
+    const newRawSubChannel = generateRawSubChannel({
+      messageFeedId: 'sub-channel-id-2',
+      lastMessageTimestamp: getFutureDate(rawSubChannel.lastMessageTimestamp),
+    });
+    const updatedRawSubChannel = {
+      ...rawSubChannel,
+      name: 'new name',
+      updatedAt: getFutureDate(rawSubChannel.updatedAt),
+    };
+    const deletedRawSubChannel = {
+      ...rawSubChannel,
+      isDeleted: true,
+      updatedAt: getFutureDate(rawSubChannel.updatedAt),
+    };
+
+    const cases: [string, keyof Amity.Events, Amity.RawSubChannel, Amity.SubChannel[]][] = [
+      [
+        'should add new sub channel to collection onCreate',
+        'message-feed.created',
+        newRawSubChannel,
+        [newRawSubChannel, rawSubChannel].map(convertFromRaw),
+      ],
+      [
+        'should remove sub channel from collection onDelete',
+        'message-feed.deleted',
+        deletedRawSubChannel,
+        [],
+      ],
+      [
+        'should update sub channel in collection onUpdate',
+        'message-feed.updated',
+        updatedRawSubChannel,
+        [updatedRawSubChannel].map(convertFromRaw),
+      ],
+      [
+        'should update sub channel in collection onFetch',
+        'local.message-feed.fetched',
+        updatedRawSubChannel,
+        [updatedRawSubChannel].map(convertFromRaw),
+      ],
+    ];
+
+    type testHandlerType = (...args: typeof cases[number]) => Promise<void>;
+    const testHandler: testHandlerType = async (test, event, rawEventSubChannel, expected) => {
+      const callback = jest.fn();
+      client.http.get = jest.fn().mockResolvedValue(response);
+
+      liveSubChannels({ channelId: rawSubChannel.channelPublicId, isDeleted: false }, callback);
+      await pause();
+      if (event === 'local.message-feed.fetched') {
+        pushToCache(
+          ['subChannel', 'get', rawEventSubChannel.messageFeedId],
+          convertFromRaw(rawEventSubChannel),
+        );
+        client.emitter.emit(event, { messageFeeds: [convertFromRaw(rawEventSubChannel)] });
+      } else {
+        client.emitter.emit(event, { messageFeeds: [rawEventSubChannel] });
+      }
+      await pause();
+
+      expect(callback).toHaveBeenCalledTimes(3);
+      expect(callback).toHaveBeenNthCalledWith(
+        3,
+        expect.objectContaining({
+          data: expected,
+          loading: false,
+        }),
+      );
+    };
+
+    test.each(cases)('%s', testHandler);
+  });
+});

package/src/subChannel/utils/index.ts

@@ -0,0 +1,50 @@
+export function convertFromRaw({
+  channelId,
+  channelPublicId,
+  channelType,
+  childCount,
+  creatorId,
+  creatorPublicId,
+  lastMessageId,
+  lastMessageTimestamp,
+  messageFeedId,
+  name,
+  ...rest
+}: Amity.RawSubChannel): Amity.SubChannel {
+  return {
+    ...rest,
+    channelId: channelPublicId,
+    creatorId: creatorPublicId,
+    displayName: name,
+    lastActivity: lastMessageTimestamp,
+    latestMessageId: lastMessageId,
+    messageCount: childCount,
+    subChannelId: messageFeedId,
+  };
+}
+
+export const prepareSubChannelPayload = (
+  payload: Amity.RawSubChannelPayload,
+): Amity.SubChannelPayload => {
+  return {
+    ...payload,
+    messageFeeds: payload.messageFeeds.map(convertFromRaw),
+  };
+};
+
+type RawQuerySubChannels = Omit<Amity.QuerySubChannels, 'excludeDefaultSubChannel'> & {
+  excludeDefaultMessageFeed?: Amity.QuerySubChannels['excludeDefaultSubChannel'];
+};
+
+export function convertQueryParams({
+  excludeDefaultSubChannel,
+  ...rest
+}: Amity.QuerySubChannels): RawQuerySubChannels {
+  const out: RawQuerySubChannels = { ...rest };
+
+  if (excludeDefaultSubChannel !== undefined) {
+    out.excludeDefaultMessageFeed = excludeDefaultSubChannel;
+  }
+
+  return out;
+}

package/src/user/events/index.ts

@@ -1,4 +1,3 @@
-export * from './onUserFetched';
 export * from './onUserUpdated';
 export * from './onUserDeleted';
 

package/src/user/events/utils.ts

@@ -4,7 +4,7 @@ import { createEventSubscriber } from '~/core/events';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
 export const createUserEventSubscriber = (
-  event: keyof Amity.MqttUserMessageEvents,
+  event: keyof Amity.MqttUserEvents,
   callback: Amity.Listener<Amity.User>,
 ) => {
   const client = getActiveClient();

package/src/user/observers/liveUser.ts

@@ -3,29 +3,33 @@ import { createQuery, runQuery } from '~/core/query';
 
 import { LIVE_OBJECT_ENABLE_CACHE_MESSAGE } from '~/utils/constants';
 
+import { hasUpdates } from '~/core/model';
 import {
-  onUserFetched,
   onUserDeleted,
   onUserUpdated,
   onUserFlagCleared,
   onUserFlagged,
   onUserUnflagged,
 } from '../events';
+import { onUserFetched } from '../events/onUserFetched';
 import { getUser } from '../api';
 
 /**
  * ```js
- * import { liveUser } from '@amityco/ts-sdk'
+ * import { liveUser } from '@amityco/ts-sdk';
  *
- * let users = []
- * const unsub = liveUser(userId, response => merge(users, response.data))
+ * let user;
+ *
+ * const unsubscribe = liveUser(userId, response => {
+ *   user = response.data;
+ * });
  * ```
  *
  * Observe all mutation on a given {@link Amity.User}
  *
  * @param userId the ID of the user 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 users
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the user
  *
  * @category Message Live Object
  */
@@ -34,28 +38,31 @@ export const liveUser = (
   callback: Amity.LiveObjectCallback<Amity.User>,
 ): Amity.Unsubscriber => {
   const { log, cache } = getActiveClient();
-  let user: Amity.User;
+  const timestamp = Date.now();
+  log(`liveUser(tmpid: ${timestamp}) > listen`);
 
   if (!cache) {
     console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
   }
 
-  const timestamp = Date.now();
-  log(`liveUser(tmpid: ${timestamp}) > listen`);
-
+  let user: Amity.User;
   const disposers: Amity.Unsubscriber[] = [];
 
   const dispatcher = (data: Amity.LiveObject<Amity.User>) => {
-    // we check updatedAt to see if the current snapshot is new so
-    // we won't send old data back, only fresh new data
-    if (user && data.data?.updatedAt === user?.updatedAt && data.origin !== 'server') return;
-
-    callback(data);
     user = data.data;
+    callback(data);
   };
 
-  const realtimeRouter = (user: Amity.User, action: Amity.UserActionType) => {
-    dispatcher({ loading: false, data: user, origin: 'event' });
+  const realtimeRouter = (eventUser: Amity.User) => {
+    if (userId !== eventUser.userId) {
+      return;
+    }
+
+    if (user && !hasUpdates(user, eventUser)) {
+      return;
+    }
+
+    dispatcher({ loading: false, data: eventUser, origin: 'event' });
   };
 
   const onFetch = () => {
@@ -65,19 +72,18 @@ export const liveUser = (
       dispatcher({ loading, data, origin, error });
 
       if (error) {
-        // Terminate observe functionality on error
         disposers.forEach(fn => fn());
       }
     });
   };
 
   disposers.push(
-    onUserFetched(user => realtimeRouter(user, 'onFetch')),
-    onUserUpdated(user => realtimeRouter(user, 'onUpdate')),
-    onUserDeleted(user => realtimeRouter(user, 'onDelete')),
-    onUserFlagged(user => realtimeRouter(user, 'onFlagged')),
-    onUserUnflagged(user => realtimeRouter(user, 'onUnflagged')),
-    onUserFlagCleared(user => realtimeRouter(user, 'onFlagCleared')),
+    onUserFetched(realtimeRouter),
+    onUserUpdated(realtimeRouter),
+    onUserDeleted(realtimeRouter),
+    onUserFlagged(realtimeRouter),
+    onUserUnflagged(realtimeRouter),
+    onUserFlagCleared(realtimeRouter),
   );
 
   onFetch();

package/src/user/tests/observers/liveUser.test.ts

@@ -1,17 +1,16 @@
 import { ASCApiError } from '~/core/errors';
 import { disableCache, enableCache } from '~/cache/api';
 import { LIVE_OBJECT_ENABLE_CACHE_MESSAGE } from '~/utils/constants';
-
-import { liveUser } from '../../observers/liveUser';
-
 import {
-  pause,
   client,
   connectClient,
   disconnectClient,
-  userQueryResponse,
+  pause,
   user11 as defaultUser,
+  userQueryResponse,
 } from '~/utils/tests';
+import { getFutureDate } from '~/core/model';
+import { liveUser } from '../../observers/liveUser';
 
 const getSnapshot = () => {
   return {
@@ -207,12 +206,9 @@ describe('liveUser', () => {
 
     expect(callback).toHaveBeenCalledTimes(2);
 
-    const updatedAt = new Date(defaultUser?.updatedAt ?? new Date());
-    updatedAt.setDate(updatedAt.getDate() + 7);
-
     const updatedUser = {
       ...defaultUser,
-      updatedAt: updatedAt.toISOString(),
+      updatedAt: getFutureDate(defaultUser.updatedAt),
     };
     client.emitter.emit(event, { users: [updatedUser], files: [] });
 

package/src/utils/index.ts

@@ -0,0 +1,52 @@
+import { hasUpdates, identifyModelKey } from '~/core/model';
+
+export function hasMention(model: Amity.Mentionable<'user' | 'channel'>, userId: string) {
+  const channelMention = model?.mentionees?.find(x => x.type === 'channel') as Amity.ChannelMention;
+
+  if (channelMention) {
+    return true;
+  }
+
+  const userMention = model?.mentionees?.find(x => x.type === 'user') as Amity.UserMention;
+
+  if (userMention) {
+    return userMention.userIds.includes(userId);
+  }
+
+  return false;
+}
+
+export function isCollectionOutdated<T extends Amity.Model[Amity.Domain] & Amity.UpdatedAt>(
+  collection: T[],
+  newItem: T,
+  action: 'onCreate' | string,
+): boolean {
+  const key = identifyModelKey(newItem);
+  // @ts-ignore
+  const item = collection.find(x => x[key] === newItem[key]);
+
+  if (item) {
+    return hasUpdates(item, newItem);
+  }
+
+  return action === 'onCreate';
+}
+
+export function merge<T extends Amity.Model[Amity.Domain]>(
+  collection1: T[],
+  collection2: T[],
+): T[] {
+  const temp = [...collection1, ...collection2];
+
+  if (temp.length === 0) {
+    return [];
+  }
+
+  const key = identifyModelKey(temp[0]);
+  const map = new Map<string, T>();
+
+  // @ts-ignore
+  temp.forEach(x => map.set(x[key], x));
+
+  return Array.from(map.values());
+}