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

package/src/@types/domains/subChannel.ts

@@ -0,0 +1,48 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type RawSubChannel = {
+      channelId: string;
+      channelPublicId: string;
+      channelType: Amity.ChannelType;
+      childCount: number;
+      creatorId: string;
+      creatorPublicId: string;
+      editedAt?: Amity.timestamp;
+      isDeleted: boolean;
+      messageFeedId: string;
+      lastMessageId: string;
+      lastMessageTimestamp: Amity.timestamp;
+      name: string;
+    } & Amity.Timestamps &
+      Amity.Subscribable;
+
+    type SubChannel = {
+      channelId: string;
+      creatorId: string;
+      displayName: string;
+      editedAt?: Amity.timestamp;
+      isDeleted: boolean;
+      messageCount: number;
+      lastActivity: Amity.timestamp;
+      latestMessageId: string;
+      subChannelId: string;
+    } & Amity.Timestamps &
+      Amity.Subscribable;
+
+    type QuerySubChannels = {
+      channelId: Amity.Channel['channelId'];
+      excludeDefaultSubChannel?: boolean;
+      isDeleted?: Amity.SubChannel['isDeleted'];
+      page?: Amity.Page;
+    };
+
+    type SubChannelLiveCollection = Amity.LiveCollectionParams<Omit<QuerySubChannels, 'page'>>;
+
+    type SubChannelLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.SubChannel,
+      Pick<QuerySubChannels, 'page'>
+    >;
+  }
+}

package/src/@types/index.ts

@@ -21,6 +21,7 @@ import './domains/reaction';
 
 import './domains/group';
 import './domains/channel';
+import './domains/subChannel';
 
 import './domains/category';
 import './domains/comment';

package/src/cache/api/ingestInCache.ts

@@ -6,7 +6,7 @@ import { upsertInCache } from './upsertInCache';
  * Ingest a payload (v3) into the cache
  *
  * @param payload a "backend v3" payload object
- * @param order the order of the keys to process (in case of need)
+ * @param options caching options like cachedAt or offline
  *
  * @category Cache
  * @hidden
@@ -20,9 +20,9 @@ export const ingestInCache = (
     if (!type) return;
 
     const resolver = getResolver(type);
+
     models.forEach(model => {
       upsertInCache(
-        // eslint-disable @typescript-eslint no-explicit-any
         [type, 'get', resolver(model as any)], // this 'any' cannot be avoided, sorry.
         model,
         options,

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/ingestInCache.test.ts

@@ -0,0 +1,87 @@
+import { PAYLOAD2MODEL, getResolver } from '~/core/model';
+
+import {
+  userPayload,
+  rolePayload,
+  channelPayload,
+  messagePayload,
+  communityPayload,
+  postPayload,
+  commentPayload,
+  pollPayload,
+  reactionPayload,
+  followPayload,
+  user11,
+} from '~/utils/tests';
+
+import { enableCache, disableCache, pullFromCache } from '..';
+import { ingestInCache } from '../ingestInCache';
+
+describe('ingestInCache', () => {
+  beforeAll(enableCache);
+  afterAll(disableCache);
+
+  const payloads: [keyof Amity.Model, Record<string, Record<string, unknown>[]>][] = [
+    ['user', userPayload],
+    ['role', rolePayload],
+    ['channel', channelPayload],
+    ['message', messagePayload],
+    ['community', communityPayload],
+    ['post', postPayload],
+    ['comment', commentPayload],
+    ['poll', pollPayload],
+    ['reaction', reactionPayload],
+    ['follow', followPayload],
+  ];
+
+  test.each(payloads)('it should add %s payload to cache', (model, payload) => {
+    ingestInCache(payload);
+
+    Object.entries(payload).forEach(([k, v]) => {
+      const type = PAYLOAD2MODEL[k];
+      const resolver = getResolver(type);
+
+      expect(type).toBeDefined();
+
+      v.forEach(entity =>
+        expect(pullFromCache([type, 'get', resolver(entity as any)])).toBeDefined(),
+      );
+    });
+  });
+
+  test('it should not update cache if model invalid', () => {
+    const invalidPayload = {
+      invalids: [{ invalidId: 'invalidId' }],
+      users: [user11],
+    };
+
+    ingestInCache(invalidPayload);
+
+    expect(pullFromCache(['invalid', 'get', 'invalidId'])).toBeUndefined();
+    expect(pullFromCache(['user', 'get', user11.userId])).toBeDefined();
+  });
+});
+
+describe('ingestInCache -> cachedAt', () => {
+  beforeAll(enableCache);
+  afterAll(disableCache);
+
+  test('it should update cache if cachedAt is valid', () => {
+    const now = Date.now();
+    ingestInCache(userPayload, { cachedAt: now });
+
+    const { data, cachedAt } = pullFromCache(['user', 'get', user11.userId])!;
+
+    expect(data).toBeDefined();
+    expect(cachedAt).toBe(now);
+  });
+
+  test('it should update cache if cachedAt is expired', () => {
+    ingestInCache(userPayload, { cachedAt: -1 });
+
+    const { data, cachedAt } = pullFromCache(['user', 'get', user11.userId])!;
+
+    expect(data).toBeDefined();
+    expect(cachedAt).toBe(-1);
+  });
+});

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;
+};