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

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

@@ -1,4 +1,3 @@
-import { ASCApiError } from '~/core/errors';
 import { disableCache, enableCache } from '~/cache/api';
 import {
   pause,
@@ -30,27 +29,6 @@ describe('liveSubChannel', () => {
 
   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'],
@@ -149,64 +127,4 @@ describe('liveSubChannel', () => {
       );
     });
   });
-
-  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/user/api/tests/updateUser.test.ts

@@ -0,0 +1,60 @@
+import { disableCache, enableCache, pushToCache, pullFromCache } from '~/cache/api';
+
+import { client, userUpdateResponse } from '~/utils/tests';
+
+import { updateUser } from '../updateUser';
+import { onUserUpdated } from '../../events/onUserUpdated';
+
+describe('updateUser', () => {
+  const displayName = 'updated-display-name';
+  const userId = 'test-user';
+  const avatarCustomUrl = 'updated-avatarUrl';
+
+  // integration_test_id: a1a8260f-3314-41ba-9f5f-3a96dd52453d
+  test('it should return updated user on success', async () => {
+    const { users: expected } = userUpdateResponse.data;
+    client.http.put = jest.fn().mockResolvedValue(userUpdateResponse);
+
+    const { data: received } = await updateUser(userId, { displayName, avatarCustomUrl });
+
+    expect(received).toStrictEqual(expected[0]);
+  });
+
+  // integration_test_id: 67cb7ad8-28a9-4950-a86c-35497bb5212c
+  test('it should return 400301 when updating another user', async () => {
+    client.http.put = jest.fn().mockRejectedValueOnce(new Error('400301'));
+
+    await expect(
+      updateUser('different-user', { displayName: 'updated-display-name' }),
+    ).rejects.toThrow('400301');
+  });
+
+  test('it should update cache with updated user', async () => {
+    enableCache();
+
+    const expected = userUpdateResponse.data.users[0];
+    pushToCache(['user', 'get', userId], { ...expected, displayName: 'old-displayName' });
+
+    client.http.put = jest.fn().mockResolvedValue(userUpdateResponse);
+    await updateUser(userId, { displayName, avatarCustomUrl });
+
+    const received = pullFromCache(['user', 'get', userId])?.data;
+
+    expect(received).toStrictEqual(expected);
+    disableCache();
+  });
+
+  test('it should fire event for updated user', async () => {
+    let dispose;
+    const { users: expected } = userUpdateResponse.data;
+    client.http.put = jest.fn().mockResolvedValue(userUpdateResponse);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onUserUpdated(resolve);
+    }).finally(dispose);
+
+    await updateUser(userId, { displayName, avatarCustomUrl });
+
+    await expect(callbackPromise).resolves.toEqual(expect.objectContaining(expected[0]));
+  });
+});

package/src/user/observers/liveUser.ts

@@ -1,9 +1,4 @@
-import { getActiveClient } from '~/client/api';
-import { createQuery, runQuery } from '~/core/query';
-
-import { LIVE_OBJECT_ENABLE_CACHE_MESSAGE } from '~/utils/constants';
-
-import { hasUpdates } from '~/core/model';
+import { liveObject } from '~/utils/liveObject';
 import {
   onUserDeleted,
   onUserUpdated,
@@ -37,59 +32,12 @@ export const liveUser = (
   userId: Amity.User['userId'],
   callback: Amity.LiveObjectCallback<Amity.User>,
 ): Amity.Unsubscriber => {
-  const { log, cache } = getActiveClient();
-  const timestamp = Date.now();
-  log(`liveUser(tmpid: ${timestamp}) > listen`);
-
-  if (!cache) {
-    console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
-  }
-
-  let user: Amity.User;
-  const disposers: Amity.Unsubscriber[] = [];
-
-  const dispatcher = (data: Amity.LiveObject<Amity.User>) => {
-    user = data.data;
-    callback(data);
-  };
-
-  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 = () => {
-    const query = createQuery(getUser, userId, true);
-
-    runQuery(query, ({ loading, data, error, origin }) => {
-      dispatcher({ loading, data, origin, error });
-
-      if (error) {
-        disposers.forEach(fn => fn());
-      }
-    });
-  };
-
-  disposers.push(
-    onUserFetched(realtimeRouter),
-    onUserUpdated(realtimeRouter),
-    onUserDeleted(realtimeRouter),
-    onUserFlagged(realtimeRouter),
-    onUserUnflagged(realtimeRouter),
-    onUserFlagCleared(realtimeRouter),
-  );
-
-  onFetch();
-
-  return () => {
-    log(`liveUser(tmpid: ${timestamp}) > dispose`);
-    disposers.forEach(fn => fn());
-  };
+  return liveObject(userId, callback, 'userId', getUser, [
+    onUserFetched,
+    onUserUpdated,
+    onUserDeleted,
+    onUserFlagged,
+    onUserUnflagged,
+    onUserFlagCleared,
+  ]);
 };

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

@@ -1,6 +1,4 @@
-import { ASCApiError } from '~/core/errors';
 import { disableCache, enableCache } from '~/cache/api';
-import { LIVE_OBJECT_ENABLE_CACHE_MESSAGE } from '~/utils/constants';
 import {
   client,
   connectClient,
@@ -29,161 +27,10 @@ describe('liveUser', () => {
     await disconnectClient();
   });
 
-  beforeEach(async () => {
-    enableCache();
-  });
+  beforeEach(enableCache);
 
   afterEach(disableCache);
 
-  test('it should show user if cache not enabled', () => {
-    /*
-     * NOTE: at the time of writing this test cache is diabled by default, but
-     * there is a proposal to enable cache by default. So I'm disabling cache
-     * here to ensure cache is disabled
-     */
-    disableCache();
-
-    const callback = jest.fn();
-    jest.spyOn(global.console, 'log');
-    client.http.get = jest.fn();
-
-    // call liveUser check if mocked console get's called with the correct
-    // user
-    client.use();
-    liveUser(defaultUser.userId, callback);
-
-    expect(console.log).toBeCalledWith(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
-  });
-
-  test('it should return user live object', async () => {
-    const snapshot = getSnapshot();
-
-    // mock response of queryUsers and validate
-    const callback = jest.fn();
-    client.http.get = jest.fn().mockResolvedValue(userQueryResponse);
-
-    liveUser(defaultUser.userId, callback);
-
-    expect(callback).toHaveBeenCalledTimes(1);
-
-    // check if cache data returned (should be empty)
-    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
-
-    await pause();
-
-    expect(callback).toHaveBeenCalledTimes(2);
-
-    snapshot.loading = false;
-    snapshot.data = defaultUser;
-
-    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
-  });
-
-  test('it should return error on api failure', async () => {
-    const snapshot = getSnapshot();
-    const error = new ASCApiError(
-      'server error!',
-      Amity.ServerError.ITEM_NOT_FOUND,
-      Amity.ErrorLevel.ERROR,
-    );
-
-    // mock response of queryUsers and validate
-    const callback = jest.fn();
-    client.http.get = jest.fn().mockRejectedValue(error);
-
-    liveUser(defaultUser.userId, callback);
-
-    expect(callback).toHaveBeenCalledTimes(1);
-
-    // check if cache data returned (should be empty)
-    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
-
-    await pause();
-
-    expect(callback).toHaveBeenCalledTimes(2);
-
-    snapshot.error = error;
-    snapshot.loading = false;
-    expect(callback).toHaveBeenLastCalledWith(expect.objectContaining(snapshot));
-  });
-
-  test('it should terminate updates on api failure', async () => {
-    const snapshot = getSnapshot();
-    const error = new ASCApiError(
-      'server error!',
-      Amity.ServerError.ITEM_NOT_FOUND,
-      Amity.ErrorLevel.ERROR,
-    );
-
-    // mock response of queryUsers and validate
-    const callback = jest.fn();
-    client.http.get = jest.fn().mockRejectedValue(error);
-
-    liveUser(defaultUser.userId, callback);
-
-    expect(callback).toHaveBeenCalledTimes(1);
-
-    // check if cache data returned (should be empty)
-    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
-
-    await pause();
-
-    expect(callback).toHaveBeenCalledTimes(2);
-
-    snapshot.error = error;
-    snapshot.loading = false;
-    expect(callback).toHaveBeenLastCalledWith(expect.objectContaining(snapshot));
-
-    const updatedAt = new Date(defaultUser?.updatedAt ?? new Date());
-    updatedAt.setDate(updatedAt.getDate() + 7);
-
-    const updatedUser = {
-      ...defaultUser,
-      updatedAt: updatedAt.toISOString(),
-    };
-    client.emitter.emit('user.updated', { users: [updatedUser], files: [] });
-
-    delete snapshot.error;
-    snapshot.loading = false;
-    snapshot.data = updatedUser;
-    expect(callback).not.toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
-  });
-
-  test('it should not return updates on obtain once!', async () => {
-    const snapshot = getSnapshot();
-
-    // mock response of queryUsers and validate
-    const callback = jest.fn();
-    client.http.get = jest.fn().mockResolvedValue(userQueryResponse);
-
-    const unsub = liveUser(defaultUser.userId, callback);
-
-    expect(callback).toHaveBeenCalledTimes(1);
-
-    // check if cache data returned (should be empty)
-    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
-
-    await pause();
-
-    expect(callback).toHaveBeenCalledTimes(2);
-
-    unsub();
-
-    const updatedAt = new Date(defaultUser?.updatedAt ?? new Date());
-    updatedAt.setDate(updatedAt.getDate() + 7);
-
-    const updatedUser = {
-      ...defaultUser,
-      updatedAt: updatedAt.toISOString(),
-    };
-    client.emitter.emit('user.updated', { users: [updatedUser], files: [] });
-
-    delete snapshot.error;
-    snapshot.loading = false;
-    snapshot.data = updatedUser;
-    expect(callback).not.toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
-  });
-
   const events: [string, keyof Amity.Events][] = [
     ['it should return updated user on onFetch', 'user.fetched'],
     ['it should return updated user on onUpdate', 'user.updated'],

package/src/utils/liveObject.ts

@@ -0,0 +1,86 @@
+import { getActiveClient } from '~/client/api';
+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 { createQuery, runQuery } from '~/core/query';
+import { ASCApiError } from '~/core/errors';
+
+export const liveObject = <
+  T extends Exclude<Amity.Model[Amity.Domain], Amity.Reaction | Amity.FollowCount>,
+  K extends keyof T,
+>(
+  id: T[K],
+  callback: Amity.LiveObjectCallback<T>,
+  key: K,
+  fetcher: (id: T[K]) => Promise<Amity.Cached<T>>,
+  eventHandlers: Array<(callback: Amity.Listener<T>) => Amity.Unsubscriber>,
+): Amity.Unsubscriber => {
+  const { cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
+  }
+
+  let model: T;
+  let isUnsyncedModel = false; // for messages
+  const disposers: Amity.Unsubscriber[] = [];
+
+  const dispatcher = (data: Amity.LiveObject<T>) => {
+    model = data.data;
+    callback(data);
+  };
+
+  const realtimeRouter = (eventModel: T) => {
+    if (id !== eventModel[key]) {
+      return;
+    }
+
+    if (model && !hasUpdates(model, eventModel)) {
+      return;
+    }
+
+    dispatcher({ loading: false, data: eventModel, origin: 'event' });
+  };
+
+  const onFetch = () => {
+    // @ts-ignore
+    const query = createQuery(fetcher, id, true);
+
+    runQuery(query, ({ error, data, loading, origin, cachedAt }) => {
+      if (cachedAt === UNSYNCED_OBJECT_CACHED_AT_VALUE) {
+        dispatcher({
+          // @ts-ignore
+          data,
+          origin,
+          loading: false,
+          error: new ASCApiError(
+            UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
+            Amity.ClientError.DISALOOW_UNSYNCED_OBJECT,
+            Amity.ErrorLevel.ERROR,
+          ),
+        });
+
+        isUnsyncedModel = true;
+        disposers.forEach(fn => fn());
+      } else if (!isUnsyncedModel) {
+        // @ts-ignore
+        dispatcher({ loading, data, origin, error });
+      }
+
+      if (error) {
+        disposers.forEach(fn => fn());
+      }
+    });
+  };
+
+  disposers.push(...eventHandlers.map(fn => fn(realtimeRouter)));
+
+  onFetch();
+
+  return () => {
+    disposers.forEach(fn => fn());
+  };
+};

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

@@ -0,0 +1,57 @@
+export const category11 = {
+  name: 'a-hello',
+  updatedAt: '2022-11-25T04:19:34.446Z',
+  createdAt: '2022-11-25T04:19:34.446Z',
+  isDeleted: false,
+  categoryId: '2ddea5ad242d0a2bd5dc5be8ae9fc8c2',
+};
+
+export const category12 = {
+  name: 'b-testing-category',
+  updatedAt: '2022-11-25T03:56:06.238Z',
+  createdAt: '2022-11-25T03:56:06.238Z',
+  isDeleted: false,
+  categoryId: '88d175da65cbfeb39b81e722b322430e',
+};
+
+export const category13 = {
+  name: 'c-deleted-category',
+  updatedAt: '2022-11-25T03:56:06.238Z',
+  createdAt: '2022-11-25T03:56:06.238Z',
+  isDeleted: true,
+  categoryId: '88d175da65cbfeb39b81e722b322430d',
+};
+
+export const category21 = {
+  name: 'a-0asd',
+  updatedAt: '2022-11-25T04:18:59.180Z',
+  createdAt: '2022-11-25T04:18:59.180Z',
+  isDeleted: false,
+  categoryId: '10051d82a1f371c6be3a8f4a4654b8a1',
+};
+
+export const category22 = {
+  name: 'b-A Category',
+  updatedAt: '2022-11-25T03:56:29.037Z',
+  createdAt: '2022-11-25T03:56:29.037Z',
+  isDeleted: false,
+  categoryId: '639942c6b2f121bed3901cf4a4c296e7',
+};
+
+export const categoryQueryResponse = {
+  data: {
+    categories: [category11, category12, category13],
+    paging: {
+      next: 'eyJza2lwIjoxMCwibGltaXQiOjEwfQ==',
+    },
+  },
+};
+
+export const categoryQueryResponsePage2 = {
+  data: {
+    categories: [category21, category22],
+    paging: {
+      next: 'eyJza2lwIjoxMCwibGltaXQiOjEwfQ==',
+    },
+  },
+};

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

@@ -54,7 +54,13 @@ export const mockPage = {
   },
 };
 
-export const channelRaw1: Amity.ChannelRaw = generateRawChannel();
+export const channelRaw1: Amity.ChannelRaw = generateRawChannel({ type: 'community' });
+
+export const channelRawLive1: Amity.ChannelRaw = generateRawChannel({ type: 'live' });
+
+export const channelRawConversation1: Amity.ChannelRaw = generateRawChannel({
+  type: 'conversation',
+});
 
 export const channelRaw2: Amity.ChannelRaw = generateRawChannel({
   channelId: 'channelId12',
@@ -132,6 +138,16 @@ export const channelQueryResponse = {
   },
 };
 
+export const getChannelsResponse = {
+  data: {
+    channels: [channelRaw1, channelRaw2, channelRaw3],
+    channelUsers: [],
+    files: [],
+    users: [],
+    ...mockPage,
+  },
+};
+
 export const channelQueryResponsePage2 = {
   data: {
     channels: [channelRaw3],
@@ -142,6 +158,26 @@ export const channelQueryResponsePage2 = {
   },
 };
 
+export const channelTagQueryResponse = {
+  data: {
+    channels: [channelRaw2],
+    channelUsers: [],
+    files: [],
+    users: [],
+    ...mockPage,
+  },
+};
+
+export const channelExcludeTagQueryResponse = {
+  data: {
+    channels: [channelRaw1, channelRaw3],
+    channelUsers: [],
+    files: [],
+    users: [],
+    ...mockPage,
+  },
+};
+
 export const channelUserQueryResponse = {
   data: {
     channels: [channelRaw1],
@@ -191,3 +227,17 @@ export const channelPayload = {
   users: [user14, user11],
   files: [file11],
 };
+
+export const liveChannelPayload = {
+  channels: [channelRawLive1],
+  channelUsers: [rawChannelUserWithRole, rawMutedChannelUser],
+  users: [user14, user11],
+  files: [file11],
+};
+
+export const conversationChannelPayload = {
+  channels: [channelRawConversation1],
+  channelUsers: [rawChannelUserWithRole, rawMutedChannelUser],
+  users: [user14, user11],
+  files: [file11],
+};