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

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

@@ -0,0 +1,97 @@
+import { disableCache, enableCache, pushToCache, pullFromCache } from '~/cache/api';
+import { client, getChannelsResponse } from '~/utils/tests';
+
+import { getChannels } from '../getChannels';
+import { prepareChannelPayload } from '~/channel/utils';
+import { ASCApiError } from '~/core/errors';
+
+const channelIds = [
+  getChannelsResponse.data.channels[0].channelId,
+  getChannelsResponse.data.channels[1].channelId,
+  getChannelsResponse.data.channels[2].channelId,
+];
+const channel = prepareChannelPayload(getChannelsResponse.data).channels;
+
+describe('getChannels', () => {
+  // integration_test_id: ced0cd3b-1714-499d-862e-0284da1c8bb1
+  test('it should return a valid channels', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(getChannelsResponse);
+
+    const expected = channel;
+    const { data: received } = await getChannels(channelIds);
+
+    expect(received).toStrictEqual(expected);
+  });
+
+  test('it should update cache after fetch from server', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(getChannelsResponse);
+    await getChannels(channelIds);
+
+    const data = getChannels.locally(channelIds);
+
+    expect(data).toBeDefined();
+    expect(data?.data).toEqual(channel);
+
+    disableCache();
+  });
+
+  // integration_test_id: 344a8f3d-0e54-4eb9-850f-80283e638352
+  test('it should return an error 400400 when try to get channels by invalid channel id', async () => {
+    const error = new ASCApiError(
+      'Some channel not found',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.get = jest.fn().mockRejectedValueOnce(error);
+
+    await expect(getChannels(channelIds)).rejects.toThrow(error);
+  });
+});
+
+describe('getChannels locally', () => {
+  test('it should return data from cache', () => {
+    enableCache();
+
+    const cachedAt = Date.now();
+
+    pushToCache(['channel', 'get', channelIds[0]], channel[0], { cachedAt });
+    pushToCache(['channel', 'get', channelIds[1]], channel[1], { cachedAt });
+    pushToCache(['channel', 'get', channelIds[2]], channel[2], { cachedAt });
+
+    const data = getChannels.locally(channelIds);
+
+    expect(data).toBeDefined();
+    expect(data?.data).toEqual(channel);
+    expect(data?.cachedAt).toEqual(cachedAt);
+
+    disableCache();
+  });
+
+  test('should return undefined if channel not in cache', () => {
+    expect(
+      getChannels.locally(['non-existent-channel-1', 'non-existent-channel-2']),
+    ).toBeUndefined();
+  });
+
+  test('should return undefined if cache not enabled', () => {
+    expect(getChannels.locally(channelIds)).toBeUndefined();
+  });
+
+  test('it should return cachedAt same date with oldest record', () => {
+    enableCache();
+
+    const cachedAt = Date.now();
+
+    pushToCache(['channel', 'get', channelIds[0]], channel[0], { cachedAt });
+    pushToCache(['channel', 'get', channelIds[1]], channel[1], { cachedAt: cachedAt + 1 });
+    pushToCache(['channel', 'get', channelIds[2]], channel[2], { cachedAt: cachedAt + 2 });
+
+    const data = getChannels.locally(channelIds);
+
+    expect(data?.cachedAt).toEqual(cachedAt);
+
+    disableCache();
+  });
+});

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

@@ -1,4 +1,5 @@
 import { pullFromCache, enableCache, disableCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
 import { getResolver } from '~/core/model';
 
 import {
@@ -19,6 +20,7 @@ describe('joinChannel', () => {
 
   const { channelId } = channel1;
 
+  // integration_test_id: efef33a8-bf09-4dfe-8ed9-e7c3615ad74d
   test('it should return channelUser', async () => {
     client.http.post = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
 
@@ -44,9 +46,66 @@ describe('joinChannel', () => {
     disableCache();
   });
 
-  test('it should throw error', async () => {
-    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+  // integration_test_id: 402a8cd8-6522-42d0-8f40-ccccae0093a1
+  test('it should throw error 400400 when user joins channel which does not exist', async () => {
+    const apiError = new ASCApiError(
+      'ChannelId Not Found',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
 
-    await expect(joinChannel(channelId)).rejects.toThrow('error');
+    client.http.post = jest.fn().mockRejectedValueOnce({
+      status: 403,
+      data: apiError,
+    });
+
+    try {
+      await joinChannel(channelId);
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(403);
+      expect(data).toEqual(apiError);
+    }
+  });
+
+  // integration_test_id: dcad7f35-586c-400f-8eca-2334d6d7b3e0
+  test("it should throw error 400300 when user tries to join channel in which he doesn't have permission", async () => {
+    const apiError = new ASCApiError(
+      "Can't join the conversation channel",
+      Amity.ServerError.FORBIDDEN,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.post = jest.fn().mockRejectedValueOnce({
+      status: 403,
+      data: apiError,
+    });
+
+    try {
+      await joinChannel(channelId);
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(403);
+      expect(data).toEqual(apiError);
+    }
+  });
+
+  // integration_test_id: 8ccb81b7-a89c-486a-81ed-7371b3ef1c4f
+  test('it should throw error 400304 when user tries to join channel in which he is banned', async () => {
+    const apiError = new ASCApiError(
+      'User is banned from this channel',
+      Amity.ServerError.CHANNEL_BAN,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.post = jest.fn().mockRejectedValueOnce({
+      status: 403,
+      data: apiError,
+    });
+
+    try {
+      await joinChannel(channelId);
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(403);
+      expect(data).toEqual(apiError);
+    }
   });
 });

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

@@ -0,0 +1,90 @@
+import { pullFromCache, enableCache, disableCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
+import { getResolver } from '~/core/model';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  channel1,
+  user11,
+  rawChannelUser,
+  channelUserQueryResponse,
+} from '~/utils/tests';
+
+import { leaveChannel } from '../leaveChannel';
+
+describe('leaveChannel', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  const { channelId } = channel1;
+
+  // integration_test_id: 3b4408dd-0f45-4270-9384-73d9ddac4511
+  test('it should return channelUser', async () => {
+    client.http.delete = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const recieved = await leaveChannel(channelId);
+
+    expect(recieved).toBe(true);
+  });
+
+  test('it should update cache', async () => {
+    enableCache();
+
+    const expected = rawChannelUser;
+    client.http.delete = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const didleaveChannel = await leaveChannel(channelId);
+
+    const resolverId = getResolver('channelUsers')({ channelId, userId: user11.userId });
+    const recieved = pullFromCache(['channelUsers', 'get', resolverId]);
+
+    expect(didleaveChannel).toBe(true);
+    expect(recieved?.data).toStrictEqual(expected);
+
+    disableCache();
+  });
+
+  // integration_test_id: 4f56790e-5fa0-4d04-8c20-ab0c39d0776f
+  test('it should throw error 400301 when user try to leave a channel which user is not a member', async () => {
+    const apiError = new ASCApiError(
+      'User is not member of channel',
+      Amity.ServerError.PERMISSION_DENIED,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.delete = jest.fn().mockRejectedValueOnce({
+      status: 403,
+      data: apiError,
+    });
+
+    try {
+      await leaveChannel(channelId);
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(403);
+      expect(data).toEqual(apiError);
+    }
+  });
+
+  // integration_test_id: 818d2317-e138-4d66-bdc0-bcc858580df5
+  test('it should throw error 400304 when user try to leave channel which he got banned', async () => {
+    const apiError = new ASCApiError(
+      'User is banned from this channel',
+      Amity.ServerError.CHANNEL_BAN,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.delete = jest.fn().mockRejectedValueOnce({
+      status: 403,
+      data: apiError,
+    });
+
+    try {
+      await leaveChannel(channelId);
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(403);
+      expect(data).toEqual(apiError);
+    }
+  });
+});

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

@@ -0,0 +1,85 @@
+import { fireEvent } from '~/core/events';
+import { scheduleTask } from '~/core/microtasks';
+import { MINUTE, ACCESS_TOKEN_WATCHER_INTERVAL } from '~/utils/constants';
+
+import { renewal } from './renewal';
+
+const ABOUT_TO_EXPIRE_THRESHOLD = 80 / 100;
+const COMPENSATED_DELAY = 5 * MINUTE;
+
+/*
+ * a helper function to check if the token has expires
+ *
+ * @param token to be checked
+ * @returns boolean indicating if token expires
+ *
+ * @category private
+ */
+export const isExpired = (expiresAt: Amity.Tokens['expiresAt']): boolean =>
+  Date.now() > Date.parse(expiresAt) - COMPENSATED_DELAY;
+
+/*
+ * a helper function to check if the token is about to expire
+ *
+ * @param token to be checked
+ * @returns boolean indicating if token is aboutToExpire
+ *
+ * @category private
+ */
+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();
+
+  const duration = expires - issued - COMPENSATED_DELAY;
+  const aboutToExpireAt = issued + duration * ABOUT_TO_EXPIRE_THRESHOLD;
+
+  return now > aboutToExpireAt && now < expires;
+};
+
+/*
+ * Monitors time to expire of token and updates session state to aboutToExpire
+ *
+ * @returns intervalId to be cleared after trigger
+ *
+ * @category private
+ */
+export const accessTokenExpiryWatcher = (
+  expiresAt: Amity.Tokens['expiresAt'],
+  issuedAt: Amity.Tokens['issuedAt'],
+  sessionHandler: Amity.SessionHandler,
+): Amity.Unsubscriber => {
+  const interval: ReturnType<typeof setInterval> = setInterval(() => {
+    if (isExpired(expiresAt)) {
+      /*
+       * the event handler will take care of updating session state
+       * Note, this will also clear the interval id, so this event will only be
+       * fired once
+       */
+      fireEvent('tokenExpired', Amity.SessionStates.TOKEN_EXPIRED);
+
+      /*
+       * https://ekoapp.atlassian.net/wiki/spaces/UP/pages/2082537485/ASC+Core+-+Session+Management+3.0#Automatically-initiate-renewal-flow
+       *
+       * Why sechduled task?
+       * Since fireEvent is scheduled, it will be called
+       * after sessionHandler leading to an invalid state change from
+       * establishing to tokenExpired
+       */
+      scheduleTask(() => sessionHandler.sessionWillRenewAccessToken(renewal()));
+
+      return;
+    }
+
+    if (isAboutToExpire({ expiresAt, issuedAt })) {
+      sessionHandler.sessionWillRenewAccessToken(renewal());
+    }
+  }, ACCESS_TOKEN_WATCHER_INTERVAL);
+
+  return (): void => clearInterval(interval);
+};

package/src/client/api/activeUser.ts

@@ -1,6 +1,6 @@
 import { ASCError } from '~/core/errors';
 
-let activeUser: Pick<Amity.User, '_id' | 'userId' | 'path'> | null = null;
+let activeUser: Pick<Amity.User, '_id' | 'userId' | 'path' | 'displayName'> | null = null;
 
 /**
  * for internal use