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

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

@@ -51,9 +51,10 @@ declare global {
       ? string | Record<string, unknown> // custom type
       : never;
 
-    type Content<T extends ContentType, K extends 'type' | 'dataType' = 'dataType'> = {
-      [S in K]?: T;
-    } & { data: ContentData<T> };
+    type Content<T extends ContentType> = {
+      dataType?: T;
+      data: ContentData<T>;
+    };
 
     type ContentSettingText = {
       contentType: 'text';

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

@@ -25,12 +25,16 @@ declare global {
       : never) &
       Amity.Timestamps;
 
-    type Membership<T extends GroupType> = {
+    type MemberWithUser<T extends GroupType> = Member<T> & { user: Amity.User | undefined };
+
+    type MembershipRaw<T extends GroupType, WithUser = false> = {
       isBanned: boolean;
       isMuted: boolean;
       muteTimeout: string;
       lastActivity: Amity.timestamp;
-    } & Member<T> &
+    } & (WithUser extends true ? MemberWithUser<T> : Member<T>) &
       Amity.Accredited;
+
+    type Membership<T extends Amity.GroupType> = Amity.MembershipRaw<T, true>;
   }
 }

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

@@ -11,48 +11,81 @@ declare global {
   namespace Amity {
     type MessageContentType = ValueOf<typeof MessageContentType>;
 
-    type MessageContent<T extends Amity.MessageContentType = any> = {
-      fileId: T extends 'file' | 'image' | 'video' | 'audio' ? string : null;
-    };
-
-    type MessageActionType = 'onCreate' | 'onUpdate' | 'onDelete' | 'onFetch';
+    type MessageActionType =
+      | 'onCreate'
+      | 'onUpdate'
+      | 'onDelete'
+      | 'onFetch'
+      | 'onFlagged'
+      | 'onUnflagged'
+      | 'onFlagCleared'
+      | 'onReactionAdded'
+      | 'onReactionRemoved';
 
-    type Message<T extends Amity.MessageContentType = any> = {
+    type RawMessage<T extends Amity.MessageContentType = any> = {
+      channelId: string;
+      channelPublicId: string;
+      channelType: Amity.Channel['type'];
+      childCount: number;
+      creatorId: string;
+      creatorPublicId: string;
+      // TODO: check if editedAt appears on edit
+      editedAt?: Amity.timestamp;
+      mentionedUsers?: Array<
+        Amity.ChannelMention | (Amity.UserMention & { userPublicIds: string[] })
+      >;
+      messageFeedId: Amity.RawSubChannel['messageFeedId'];
       messageId: string;
+      myReactions?: string[];
+      parentId?: string;
+      reactionCount: number;
+      reactions?: Record<string, number>;
+      referenceId?: string; // https://ekoapp.atlassian.net/wiki/spaces/UP/pages/2085716114/SDK+V5+message+migration#Handling-%E2%80%98ReferenceId%E2%80%99-in-message-creation
+      segment: number;
+    } & Amity.Content<T> &
+      Amity.Flaggable &
+      Amity.Metadata &
+      // Amity.Reactable &
+      Amity.SoftDelete &
+      Amity.Subscribable &
+      Amity.Taggable &
+      Amity.Timestamps;
 
+    type Message<T extends Amity.MessageContentType = any> = {
       channelId: Amity.Channel['channelId'];
-      userId: Amity.User['userId'];
-
-      parentId?: Message['messageId'];
-      childrenNumber: number;
-
       channelSegment: number;
-
-      editedAt: Amity.timestamp;
-    } & Amity.Content<T, 'type'> &
-      Amity.MessageContent<T> &
+      childrenNumber: number;
+      creatorId: string;
+      editedAt?: Amity.timestamp;
+      parentId?: string;
+      messageId: string;
+      subChannelId: Amity.SubChannel['subChannelId'];
+      uniqueId: string;
+    } & Amity.Content<T> &
+      Amity.Mentionable<'user' | 'channel'> &
       Amity.Metadata &
-      Amity.Timestamps &
-      Amity.SoftDelete &
-      Amity.Taggable &
       Amity.Reactable &
-      Amity.Mentionable<'user' | 'channel'>;
+      Amity.SoftDelete &
+      Amity.Subscribable &
+      Amity.Timestamps &
+      Amity.Taggable;
 
     type QueryMessages = {
-      channelId: Amity.Channel['channelId'];
-      type?: Amity.MessageContentType;
-      parentId?: Amity.Message['parentId'];
-      filterByParentId?: boolean;
-      isDeleted?: boolean;
-      tags?: Amity.Taggable['tags'];
+      subChannelId: Amity.SubChannel['subChannelId'];
+      dataType?: Amity.MessageContentType;
       excludeTags?: Amity.Taggable['tags'];
+      hasFlags?: boolean;
+      isDeleted?: boolean;
       page?: Amity.Page;
+      parentId?: Amity.Message['parentId'];
+      sortBy?: 'segmentAsc' | 'segmentDesc';
+      tags?: Amity.Taggable['tags'];
     };
 
     type MessagesLiveCollection = Amity.LiveCollectionParams<Omit<QueryMessages, 'page'>>;
 
     type MessageLiveCollectionCache = Amity.LiveCollectionCache<
-      Amity.Message['channelId'],
+      Amity.Message['subChannelId'],
       Pick<QueryMessages, 'page'>
     >;
   }

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

@@ -39,7 +39,7 @@ declare global {
       hasFlaggedChildren: false;
       hasFlaggedComment: false;
       editedAt: Amity.timestamp;
-    } & Amity.Content<T, 'dataType'> &
+    } & Amity.Content<T> &
       Amity.Metadata &
       Amity.Flaggable &
       Amity.Reactable &
@@ -53,7 +53,7 @@ declare global {
       targetId: string;
       targetType: Amity.Post['targetType'];
       sortBy?: 'lastCreated' | 'firstCreated' | 'lastUpdated' | 'firstUpdated';
-      dataType?: Exclude<Amity.PostContentType, 'text'>;
+      dataTypes?: Exclude<Amity.PostContentType, 'text'>[];
       isDeleted?: Amity.Post['isDeleted'];
       hasFlag?: boolean;
       feedType?: 'reviewing' | 'published';

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

@@ -28,3 +28,17 @@ declare global {
 
   type ValueOf<T extends Record<any, any>> = T[keyof T];
 }
+
+/*
+ * Extented to pass token expiry into request config, for internal use only.
+ * Since it's in the request config, it does not get sent for the server, and
+ * allows us to intercept the tokenExpiry value to check if the token has not
+ * expired & cancel the request if yes.
+ *
+ */
+declare module 'axios' {
+  export interface AxiosRequestConfig {
+    // expires at iso string for access token
+    metadata?: { tokenExpiry: string };
+  }
+}

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