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

package/src/cache/api/tests/dropFromCache.test.ts

@@ -0,0 +1,59 @@
+import {
+  connectClient,
+  disconnectClient,
+  post11,
+  channel1,
+  message11,
+  user14,
+  channelPayload,
+} from '~/utils/tests';
+
+import { dropFromCache, enableCache, disableCache, pushToCache, pullFromCache } from '..';
+import { ingestInCache } from '../ingestInCache';
+
+describe('dropFromCache', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  test('it should return false if cache disabled', () => {
+    disableCache();
+
+    expect(dropFromCache(['post', 'get', 'postId'])).toBe(false);
+  });
+
+  test('it should return false if candidate not in cache', () => {
+    expect(dropFromCache(['post', 'get', 'non-existent-postId'], true)).toBe(false);
+  });
+
+  test('it should delete multiple matches when exact:false', () => {
+    ingestInCache(channelPayload);
+
+    const recieved = dropFromCache(['user', 'get', user14.userId]);
+
+    expect(recieved).toBe(true);
+    expect(pullFromCache(['user', 'get', user14.userId])).toBeUndefined();
+  });
+
+  const cases: [string, boolean, Amity.CacheKey, unknown][] = [
+    ['post', false, ['post', 'get', post11.postId], post11],
+    ['message', false, ['message', 'get', message11.messageId], message11],
+    ['channel', false, ['channel', 'get', channel1.channelId], channel1],
+    ['post', true, ['post', 'get', post11.postId], post11],
+    ['message', true, ['message', 'get', message11.messageId], message11],
+    ['channel', true, ['channel', 'get', channel1.channelId], channel1],
+  ];
+
+  test.each(cases)(
+    'it should delete %s from cache when exact:%s',
+    (candidate, exact, cacheKey, expected) => {
+      pushToCache(cacheKey, expected);
+      const recieved = dropFromCache(cacheKey, exact);
+
+      expect(recieved).toBe(true);
+      expect(pullFromCache(cacheKey)).toBeUndefined();
+    },
+  );
+});

package/src/cache/api/tests/enableCache.test.ts

@@ -0,0 +1,15 @@
+import { connectClient, client, disconnectClient } from '~/utils/tests';
+
+import { enableCache } from '../enableCache';
+
+describe('enableCache', () => {
+  test('it should enable cache', async () => {
+    await connectClient();
+
+    enableCache();
+
+    expect(client.cache).toBeDefined();
+
+    disconnectClient();
+  });
+});

package/src/cache/api/tests/pullFromCache.test.ts

@@ -0,0 +1,42 @@
+import { connectClient, disconnectClient, post11, message11, channel1 } from '~/utils/tests';
+
+import { pullFromCache, enableCache, disableCache, pushToCache } from '..';
+
+describe('pullFromCache', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('it should return undefined if entity not in cache', () => {
+    enableCache();
+
+    expect(pullFromCache(['post', 'get', 'non-existent-postId'])).toBeUndefined();
+
+    disableCache();
+  });
+
+  test('it should return undefined if cache disabled', () => {
+    disableCache();
+
+    expect(pullFromCache(['post', 'get', 'post-id'])).toBeUndefined();
+  });
+
+  const cases: [string, Amity.CacheKey, unknown][] = [
+    ['post', ['post', 'get', post11.postId], post11],
+    ['message', ['message', 'get', message11.messageId], message11],
+    ['channel', ['channel', 'get', channel1.channelId], channel1],
+  ];
+
+  test.each(cases)('it should return %s from cache', (type, cacheKey, expected) => {
+    enableCache();
+
+    pushToCache(cacheKey, expected);
+
+    const recieved = pullFromCache(cacheKey);
+
+    expect(recieved).toBeDefined();
+    expect(recieved?.data).toBeDefined();
+    expect(recieved?.data).toBe(expected);
+
+    disableCache();
+  });
+});

package/src/cache/api/tests/upsertInCache.test.ts

@@ -0,0 +1,60 @@
+import { connectClient, disconnectClient, post11, message11, channel1 } from '~/utils/tests';
+
+import { upsertInCache, enableCache, disableCache, pullFromCache } from '..';
+
+describe('upsertInCache', () => {
+  beforeAll(connectClient);
+  afterAll(() => {
+    disableCache();
+    disconnectClient();
+  });
+
+  const cacheKey = ['post', 'get', 'test-candidate-id'];
+
+  test('it should add candidate to cache if non-existent', () => {
+    enableCache();
+
+    expect(upsertInCache(cacheKey, post11)).toBe(true);
+    expect(pullFromCache(cacheKey)?.data).toBe(post11);
+
+    disableCache();
+  });
+
+  test('it should return false if cache disabled', () => {
+    disableCache();
+
+    expect(upsertInCache(cacheKey, post11)).toBe(false);
+  });
+
+  test('it should update cachedAt value', () => {
+    enableCache();
+
+    const now = Date.now();
+
+    expect(upsertInCache(cacheKey, post11, { cachedAt: now })).toBe(true);
+    expect(pullFromCache(cacheKey)?.cachedAt).toBe(now);
+
+    disableCache();
+  });
+
+  // create table of tests for message, post, channel
+  const cases: [string, Amity.CacheKey, Record<string, unknown>][] = [
+    ['post', ['post', 'get', post11.postId], post11],
+    ['message', ['message', 'get', message11.messageId], message11],
+    ['channel', ['channel', 'get', channel1.channelId], channel1],
+    ['post', ['post', 'get', post11.postId], { ...post11, channelId: 'altered' }],
+    ['message', ['message', 'get', message11.messageId], { ...message11, userId: 'updated-user' }],
+    ['channel', ['channel', 'get', channel1.channelId], { ...channel1, displayName: 'updated' }],
+  ];
+
+  // cache is not disabled, so as to test update
+  test.each(cases)('it should update %s in cache', (type, cacheKey, expected) => {
+    enableCache();
+
+    const recieved = upsertInCache(cacheKey, expected);
+
+    expect(recieved).toBe(true);
+    expect(pullFromCache(cacheKey)?.data).toBeDefined();
+    expect(pullFromCache(cacheKey)?.data).toStrictEqual(expected);
+  });
+});

package/src/cache/utils/tests/encodeKey.test.ts

@@ -0,0 +1,19 @@
+import { encodeKey } from '..';
+
+describe('cache util > encodeKey', () => {
+  test('it should return encoded string', () => {
+    const key = ['post', 'get', 'post-id'];
+    const keyObject = { 0: 'post', 1: 'get', 2: 'post-id' };
+
+    const expected = JSON.stringify(keyObject);
+
+    expect(encodeKey(key)).toBe(expected);
+  });
+
+  test('it should normalize key', () => {
+    const key = [{ c: 'last', b: 'middle', a: 'first' }];
+    const expected = JSON.stringify({ 0: { a: 'first', b: 'middle', c: 'last' } });
+
+    expect(encodeKey(key)).toBe(expected);
+  });
+});

package/src/cache/utils/tests/partialMatch.test.ts

@@ -0,0 +1,13 @@
+import { partialMatch } from '..';
+
+import { post11, post12 } from '~/utils/tests';
+
+describe('cache util > partialMatch', () => {
+  test('it should return true if objects are deep equal', () => {
+    expect(partialMatch(post11, post11)).toBe(true);
+  });
+
+  test('it should return false if objects are not deep equal', () => {
+    expect(partialMatch(post11, post12)).toBe(false);
+  });
+});

package/src/channel/api/addChannelMembers.ts

@@ -40,8 +40,8 @@ export const addChannelMembers = async (
    * should fire event for each user that was added
    */
   userIds.forEach(id =>
-    fireEvent('v3.channel.didAddUsers', {
-      ...data,
+    fireEvent('channel.membersAdded', {
+      ...payload,
       channelUsers: data.channelUsers.filter(u => u.userId === id),
     }),
   );

package/src/channel/api/banChannelMembers.ts

@@ -1,6 +1,7 @@
 import { getActiveClient } from '~/client/api/activeClient';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareMembershipPayload } from '~/group/utils';
 
 import { prepareChannelPayload } from '../utils';
 
@@ -32,12 +33,13 @@ export const banChannelMembers = async (
     },
   );
 
-  const data = prepareChannelPayload(payload);
+  const channelPayload = prepareChannelPayload(payload);
+  const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+  const { channelUsers } = preparedPayload;
 
   const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(data, { cachedAt });
+  if (client.cache) ingestInCache(preparedPayload, { cachedAt });
 
-  const { channelUsers } = data;
   return {
     data: channelUsers?.filter(user => user.membership === 'banned')!,
     cachedAt,

package/src/channel/api/createChannel.ts

@@ -7,7 +7,7 @@ import { prepareChannelPayload } from '../utils';
 /**
  * ```js
  * import { createChannel } from '@amityco/ts-sdk'
- * const created = await createChannel({ channelId: 'foobar', displayName: 'foobar' })
+ * const created = await createChannel({ displayName: 'foobar' })
  * ```
  *
  * Creates an {@link Amity.Channel}

package/src/channel/api/getChannels.ts

@@ -68,11 +68,11 @@ getChannels.locally = (
     .map(channelId => pullFromCache<Amity.Channel>(['channel', 'get', channelId])!)
     .filter(Boolean);
 
+  if (cached?.length < channelIds.length) return;
+
   const channels = cached.map(({ data }) => data);
   const oldest = cached.sort((a, b) => (a.cachedAt! < b.cachedAt! ? -1 : 1))?.[0];
 
-  if (cached?.length < channelIds.length) return;
-
   return {
     data: channels,
     cachedAt: oldest.cachedAt,

package/src/channel/api/index.ts

@@ -19,3 +19,6 @@ export * from './removeChannelMembersRole';
 
 export * from './banChannelMembers';
 export * from './unbanChannelMembers';
+
+export * from './startReading';
+export * from './stopReading';

package/src/channel/api/queryChannelMembers.ts

@@ -1,3 +1,4 @@
+import { prepareChannelPayload } from '~/channel/utils';
 import { getActiveClient } from '~/client/api';
 
 import { toPage, toToken } from '~/core/query';
@@ -5,8 +6,7 @@ import { getResolver } from '~/core/model';
 
 import { pullFromCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
-
-import { prepareChannelPayload } from '../utils';
+import { prepareMembershipPayload } from '~/group/utils';
 
 /**
  * ```js
@@ -28,7 +28,7 @@ export const queryChannelMembers = async (
   const client = getActiveClient();
   client.log('channel/queryChannelMembers', query);
 
-  const { page = { limit: 10 }, ...params } = query ?? {};
+  const { page, ...params } = query ?? {};
 
   const { data: queryPayload } = await client.http.get<
     Amity.ChannelMembershipPayload & Amity.Pagination
@@ -42,14 +42,14 @@ export const queryChannelMembers = async (
   });
 
   const { paging, ...payload } = queryPayload;
-
-  const data = prepareChannelPayload(payload);
-
-  const { channelUsers } = data;
+  const channelPayload = prepareChannelPayload(payload);
+  const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+  const { channelUsers } = preparedPayload;
 
   const cachedAt = client.cache && Date.now();
+
   if (client.cache) {
-    ingestInCache(data as Amity.ChannelMembershipPayload);
+    ingestInCache(preparedPayload);
 
     const cacheKey = [
       'channelUsers',
@@ -68,7 +68,12 @@ export const queryChannelMembers = async (
   const nextPage = toPage(paging.next);
   const prevPage = toPage(paging.previous);
 
-  return { data: channelUsers, cachedAt, nextPage, prevPage };
+  return {
+    data: channelUsers,
+    cachedAt,
+    nextPage,
+    prevPage,
+  };
 };
 
 /**
@@ -92,7 +97,7 @@ queryChannelMembers.locally = (
 
   if (!client.cache) return;
 
-  const { page = { limit: 10 }, ...params } = query;
+  const { page, ...params } = query;
 
   const cacheKey = [
     'channelUsers',

package/src/channel/api/queryChannels.ts

@@ -58,7 +58,7 @@ export const queryChannels = async (
   const cachedAt = client.cache && Date.now();
 
   if (client.cache) {
-    ingestInCache(data as Amity.ChannelPayload, { cachedAt });
+    ingestInCache(data, { cachedAt });
 
     const cacheKey = [
       'channel',

package/src/channel/api/removeChannelMembers.ts

@@ -36,7 +36,15 @@ export const removeChannelMembers = async (
 
   if (client.cache) ingestInCache(data);
 
-  fireEvent('v3.channel.didRemoveUsers', data);
+  /*
+   * should fire event for each user that was removed
+   */
+  userIds.forEach(id =>
+    fireEvent('channel.membersRemoved', {
+      ...payload,
+      channelUsers: data.channelUsers.filter(u => u.userId === id),
+    }),
+  );
 
   const { channelUsers } = data;
   return !!channelUsers.find(

package/src/channel/api/startReading.ts

@@ -0,0 +1,53 @@
+import { getActiveClient } from '~/client/api';
+import { synchronousWSCall } from '~/core/transports';
+import { pullFromCache, pushToCache } from '~/cache/api';
+
+/**
+ * ```js
+ * import { startReading } from '@amityco/ts-sdk'
+ * const success = await startReading('foo')
+ * ```
+ *
+ * Mark all messages as read and start reading message inside channel
+ *
+ * @param {string} subChannelId - The channel ID to start reading.
+ * @param {string} userId - The user ID of channel member.
+ * @return {Promise<boolean>>} A success boolean if the channel reading of the sub channel had begun.
+ *
+ * @category Message API
+ * @async
+ */
+export const startReading = async (subChannelId: string, userId = getActiveClient().userId) => {
+  const client = getActiveClient();
+  client.log('message/startReading', { subChannelId });
+
+  const subChannel = pullFromCache<Amity.SubChannel>(['subChannel', 'get', subChannelId]);
+
+  if (!subChannel) {
+    return;
+  }
+
+  const { channelId } = subChannel.data;
+  const channel = pullFromCache<Amity.Channel>(['channel', 'get', channelId]);
+
+  if (!channel || channel.data.defaultSubChannelId !== subChannelId) {
+    return;
+  }
+
+  const update: Amity.Channel = {
+    ...channel.data,
+    // @ts-ignore
+    localReading: true,
+    defaultSubChannelUnreadCount: 0,
+    defaultSubChannelHasUnreadMention: false,
+  };
+
+  pushToCache(['channel', 'get', channelId], update);
+  client.emitter.emit('local.channel.updated', { channels: [update] });
+
+  const result = await synchronousWSCall<Record<never, never>>(client, 'channel.startReading', {
+    channelId,
+  });
+
+  return !!result;
+};

package/src/channel/api/stopReading.ts

@@ -0,0 +1,49 @@
+import { getActiveClient } from '~/client/api';
+import { synchronousWSCall } from '~/core/transports';
+import { pullFromCache, pushToCache } from '~/cache/api';
+
+/**
+ * ```js
+ * import { stopReading } from '@amityco/ts-sdk'
+ * const success = await stopReading('foo')
+ * ```
+ *
+ * Stop reading message inside channel
+ *
+ * @param {string} subChannelId - The channel ID to stop reading.
+ * @return {Promise<boolean>>} A success boolean if the sub channel reading was halted.
+ *
+ * @category Message API
+ * @async
+ */
+export const stopReading = async (subChannelId: string) => {
+  const client = getActiveClient();
+  client.log('message/stopReading', { subChannelId });
+
+  const subChannel = pullFromCache<Amity.SubChannel>(['subChannel', 'get', subChannelId]);
+
+  if (!subChannel) {
+    return;
+  }
+
+  const { channelId } = subChannel.data;
+  const channel = pullFromCache<Amity.Channel>(['channel', 'get', channelId]);
+
+  if (!channel || channel.data.defaultSubChannelId !== subChannelId) {
+    return;
+  }
+
+  const update: Amity.Channel = {
+    ...channel.data,
+    // @ts-ignore
+    localReading: false,
+  };
+
+  pushToCache(['channel', 'get', channelId], update);
+
+  const result = await synchronousWSCall<Record<never, never>>(client, 'channel.stopReading', {
+    channelId,
+  });
+
+  return !!result;
+};

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

@@ -5,9 +5,10 @@ import {
   client,
   pause,
   channelUserQueryResponse,
-  channelUser1,
-  channelUser3,
-  channel11,
+  rawChannelUser,
+  rawChannelUser3,
+  channel1,
+  user11,
 } from '~/utils/tests';
 
 import { onChannelMemberAdded } from '~/channel/events';
@@ -15,7 +16,7 @@ import { addChannelMembers } from '../addChannelMembers';
 
 describe('addChannelMembers', () => {
   const { channelId } = channelUserQueryResponse.data.channels[0];
-  const { userId } = channelUser1;
+  const { userId } = rawChannelUser;
 
   test('it should add channel members in channel', async () => {
     client.http.post = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
@@ -44,7 +45,7 @@ describe('addChannelMembers', () => {
 
     expect(recieved).toBe(true);
     expect(channelUser).toBeDefined();
-    expect(channelUser).toBe(channelUser1);
+    expect(channelUser).toBe(rawChannelUser);
 
     disableCache();
   });
@@ -68,7 +69,7 @@ describe('addChannelMembers', () => {
     client.http.post = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
 
     const callback = jest.fn();
-    const { userId: userId2 } = channelUser3;
+    const { userId: userId2 } = rawChannelUser3;
     const unsub = onChannelMemberAdded(callback);
 
     const recieved = await addChannelMembers(channelId, [userId, userId2]);
@@ -81,12 +82,39 @@ describe('addChannelMembers', () => {
      * Assertion below is required to check if the event handler is called with the right
      * params. It's not enough to check if the handler does not throw
      */
-    expect(callback).toHaveBeenNthCalledWith(1, { ...channel11 }, { ...channelUser1 });
-    expect(callback).toHaveBeenNthCalledWith(2, { ...channel11 }, { ...channelUser3 });
+    expect(callback).toHaveBeenNthCalledWith(1, { ...channel1 }, { ...rawChannelUser });
 
     unsub();
   });
 
+  test('it should fire event with all new members by attaching a user', async () => {
+    enableCache();
+    client.http.post = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const callback = jest.fn();
+    const { userId: userId2 } = rawChannelUser3;
+    const unsub = onChannelMemberAdded(callback);
+
+    const recieved = await addChannelMembers(channelId, [userId, userId2]);
+
+    expect(recieved).toBe(true);
+
+    await pause();
+
+    /*
+     * Assertion below is required to check if the event handler is called with the right
+     * params. It's not enough to check if the handler does not throw
+     */
+    expect(callback).toHaveBeenNthCalledWith(
+      1,
+      { ...channel1 },
+      { ...rawChannelUser, user: user11 },
+    );
+
+    unsub();
+    disableCache();
+  });
+
   test('it should return an error', async () => {
     client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
 

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

@@ -0,0 +1,53 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { channelPayload, client } from '~/utils/tests';
+import { prepareChannelPayload } from '~/channel/utils';
+import { createChannel } from '../createChannel';
+
+const resPayload = { data: channelPayload };
+
+describe('createChannel', () => {
+  const channel = prepareChannelPayload(channelPayload).channels[0];
+
+  test('it should create a channel', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce(resPayload);
+
+    const res = await createChannel({ type: 'community' });
+
+    expect(res).toBeDefined();
+    expect(res.data).toStrictEqual(channel);
+  });
+
+  test('it should add channel to cache', async () => {
+    enableCache();
+
+    client.http.post = jest.fn().mockResolvedValueOnce(resPayload);
+    const { channelId } = channelPayload.channels[0];
+
+    await createChannel({ type: 'community' });
+    const data = pullFromCache(['channel', 'get', channelId]);
+
+    expect(data).toBeDefined();
+    expect(data?.data).toStrictEqual(channel);
+
+    disableCache();
+  });
+
+  test('it should call conversation channel with /conversation api', async () => {
+    const mockFn = jest.fn();
+    client.http.post = mockFn.mockResolvedValueOnce(resPayload);
+    const expected = '/api/v3/channels/conversation';
+    const expectedPayload = { type: 'conversation', isDistinct: true };
+
+    await createChannel({ type: 'conversation' });
+    const [recieved, recievedPayload] = mockFn.mock.lastCall;
+
+    expect(recieved).toBe(expected);
+    expect(recievedPayload).toStrictEqual(expectedPayload);
+  });
+
+  test('it should return an error', async () => {
+    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(createChannel({ type: 'conversation' })).rejects.toThrow('error');
+  });
+});

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

@@ -6,9 +6,10 @@ import { pushToTombstone } from '~/cache/api/pushToTombstone';
 import { isInTombstone } from '~/cache/api/isInTombstone';
 
 import { getChannel } from '../getChannel';
+import { prepareChannelPayload } from '~/channel/utils';
 
 const { channelId } = channelQueryResponse.data.channels[0];
-const channel = channelQueryResponse.data.channels[0];
+const channel = prepareChannelPayload(channelQueryResponse.data).channels[0];
 
 describe('getChannel', () => {
   test('it should return a channel', async () => {
@@ -82,7 +83,7 @@ describe('getChannel locally', () => {
 describe('getChannel tombostone', () => {
   test('it should add channel to tombostone if 404', async () => {
     enableCache();
-    
+
     client.http.get = jest
       .fn()
       .mockRejectedValueOnce(