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

package/src/subChannel/observers/liveSubChannel.ts

@@ -1,7 +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 { getSubChannel } from '../api';
 import { onSubChannelDeleted, onSubChannelUpdated } from '../events';
 import { onSubChannelFetched } from '../events/onSubChannelFetched';
@@ -29,56 +26,9 @@ export const liveSubChannel = (
   subChannelId: Amity.SubChannel['subChannelId'],
   callback: Amity.LiveObjectCallback<Amity.SubChannel>,
 ): Amity.Unsubscriber => {
-  const { log, cache } = getActiveClient();
-  const timestamp = Date.now();
-  log(`liveSubChannel(tmpid: ${timestamp}) > listen`);
-
-  if (!cache) {
-    console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
-  }
-
-  let subChannel: Amity.SubChannel;
-  const disposers: Amity.Unsubscriber[] = [];
-
-  const dispatcher = (data: Amity.LiveObject<Amity.SubChannel>) => {
-    subChannel = data.data;
-    callback(data);
-  };
-
-  const realtimeRouter = (eventSubChannel: Amity.SubChannel) => {
-    if (subChannelId !== eventSubChannel.subChannelId) {
-      return;
-    }
-
-    if (subChannel && !hasUpdates(subChannel, eventSubChannel)) {
-      return;
-    }
-
-    dispatcher({ loading: false, data: eventSubChannel, origin: 'event' });
-  };
-
-  const onFetch = () => {
-    const query = createQuery(getSubChannel, subChannelId);
-
-    runQuery(query, ({ error, data, loading, origin }) => {
-      dispatcher({ error, data, loading, origin });
-
-      if (error) {
-        disposers.forEach(fn => fn());
-      }
-    });
-  };
-
-  disposers.push(
-    onSubChannelFetched(realtimeRouter),
-    onSubChannelUpdated(realtimeRouter),
-    onSubChannelDeleted(realtimeRouter),
-  );
-
-  onFetch();
-
-  return () => {
-    log(`liveSubChannel(tmpid: ${timestamp}) > dispose`);
-    disposers.forEach(fn => fn());
-  };
+  return liveObject(subChannelId, callback, 'subChannelId', getSubChannel, [
+    onSubChannelFetched,
+    onSubChannelUpdated,
+    onSubChannelDeleted,
+  ]);
 };

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/constants.ts

@@ -6,3 +6,5 @@ export const LIVE_OBJECT_ENABLE_CACHE_MESSAGE =
 export const UNSYNCED_OBJECT_CACHED_AT_MESSAGE =
   'Observing unsynced object is not supported by Live Object.';
 export const UNSYNCED_OBJECT_CACHED_AT_VALUE = -5;
+export const MINUTE = 60 * 1000;
+export const ACCESS_TOKEN_WATCHER_INTERVAL = 10 * MINUTE;

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/client.ts

@@ -6,9 +6,22 @@ import {
 
 import { user11 } from './dummy';
 
+const sessionHandler: Amity.SessionHandler = {
+  sessionWillRenewAccessToken(_) {
+    // do nothing
+  },
+};
+
 export const client = createClient('key', 'sg');
+client.accessTokenExpiryWatcher = (_, __, ___) => () => {
+  //
+};
 
 export const connectClient = async () => {
+  const now = new Date();
+  const nextMonth = new Date();
+  nextMonth.setDate(now.getDate() + 30);
+
   client.mqtt.connect = jest.fn();
   client.mqtt.subscribe = jest.fn();
   client.http.post = jest.fn().mockReturnValueOnce({
@@ -16,14 +29,17 @@ export const connectClient = async () => {
       accessToken: 'accessToken',
       refreshToken: 'refreshToken',
       users: [user11],
+      expiresAt: nextMonth.toISOString(),
+      issuedAt: now.toISOString(),
     },
   });
 
   setTimeout(() => {
     client.ws.emit('connect');
-  }, 500);
+    // fixes jest warning of open handles
+  }, 500).unref();
 
-  await sdkConnectClient({ userId: 'test' });
+  await sdkConnectClient({ userId: 'test' }, sessionHandler);
 };
 
 export const disconnectClient = async () => {

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==',
+    },
+  },
+};