@amityco/ts-sdk 0.0.1-655cb77.0 → 0.0.1-65645.0

package/src/@types/core/payload.ts

@@ -40,35 +40,66 @@ declare global {
       roles: Amity.Role[];
     };
 
-    type ChannelPayload<
-      T extends Amity.ChannelType = any,
-      U extends Amity.Channel<T> | Amity.ChannelRaw<T> = Amity.ChannelRaw<T>,
-    > = {
-      channels: U[];
-      channelUsers: Amity.MembershipRaw<'channel'>[];
+    type ChannelPayload<T extends Amity.ChannelType = any> = {
+      channels: Amity.RawChannel<T>[];
+      channelUsers: Amity.RawMembership<'channel'>[];
     } & Amity.UserPayload;
 
-    type RawSubChannelPayload = {
-      messageFeeds: Amity.RawSubChannel[];
+    /**
+     * Items that extend from `Amity.Channel`
+     * - channels: `Amity.RawChannel` -> `Amity.Channel` (Added Marker Service related props)
+     * - channelUsers: `Amity.RawMembership` -> `Amity.Membership` (Add user getter prop)
+     */
+    type ProcessedChannelPayload<T extends Amity.ChannelType = any> = Omit<
+      ChannelPayload,
+      'channels' | 'channelUsers'
+    > & {
+      channels: Amity.Channel<T>[];
+      channelUsers: Amity.Membership<'channel'>[];
     };
 
     type SubChannelPayload = {
+      messageFeeds: Amity.RawSubChannel[];
+    };
+
+    /**
+     * Items that extend from `Amity.SubChannelPayload`
+     * - messageFeeds: `Amity.RawSubChannel` -> `Amity.SubChannel` (Model Restructuring)
+     */
+    type ProcessedSubChannelPayload = {
       messageFeeds: Amity.SubChannel[];
     };
 
     type ChannelMembershipPayload = {
-      channels: Amity.ChannelRaw[];
-      channelUsers: Amity.MembershipRaw<'channel'>[];
+      channels: Amity.RawChannel[];
+      channelUsers: Amity.RawMembership<'channel'>[];
     } & Amity.UserPayload;
 
-    type MessagePayload<T extends Amity.MessageContentType = any> = {
+    /**
+     * Items that extend from `Amity.ChannelMembershipPayload`
+     * - channels: `Amity.RawChannel` -> `Amity.Channel` (Added Marker Service related props)
+     * - channelUsers: `Amity.RawMembership` -> `Amity.Membership` (Add user getter prop)
+     */
+    type ProcessedChannelMembershipPayload = Omit<
+      ChannelMembershipPayload,
+      'channels' | 'channelUsers'
+    > & {
+      channels: Amity.Channel[];
+      channelUsers: Amity.Membership<'channel'>[];
+    };
+
+    /**
+     * Items that extend from `Amity.MessagePayload`
+     * - messages: `Amity.RawMessage` -> `Amity.Message` (Model Restructuring)
+     */
+    type ProcessedMessagePayload<T extends Amity.MessageContentType = any> = {
       messages: Amity.Message<T>[];
-      users?: Amity.User[];
-      files?: Amity.File[];
+      users: Amity.User[];
+      files: Amity.File[];
     };
 
-    type RawMessagePayload<T extends Amity.MessageContentType = any> = Omit<
-      MessagePayload<T>,
+    type MessagePayload<T extends Amity.MessageContentType = any> = Omit<
+      ProcessedMessagePayload<T>,
       'messages'
     > & {
       messages: Amity.RawMessage<T>[];
@@ -76,17 +107,27 @@ declare global {
 
     type StreamPayload = {
       videoStreamings: Amity.Stream[];
-      users?: Amity.User[];
-      files?: Amity.File<'image'>[];
+      users: Amity.User[];
+      files: Amity.File<'image'>[];
     };
 
     type CommunityPayload = {
       communities: Amity.RawCommunity[];
-      communityUsers?: Amity.MembershipRaw<'community'>[];
-      categories?: Amity.Category[];
-      feeds?: Amity.Feed[];
-      users?: Amity.User[];
-      files?: Amity.File[];
+      communityUsers: Amity.RawMembership<'community'>[];
+      categories: Amity.Category[];
+      feeds: Amity.Feed[];
+      users: Amity.User[];
+      files: Amity.File[];
+    };
+
+    /**
+     * Items that extend from `Amity.CommunityPayload`
+     * - communities: `Amity.RawCommunity` -> `Amity.Community` (Added Marker Service related props)
+     * - communityUsers: `Amity.RawMembership` -> `Amity.Membership` (Add user getter prop)
+     */
+    type ProcessedCommunityPayload = Omit<CommunityPayload, 'communities' | 'communityUsers'> & {
+      communities: Amity.Community[];
+      communityUsers: Amity.Membership<'community'>[];
     };
 
     type CategoryPayload = {
@@ -96,30 +137,53 @@ declare global {
 
     type CommunityMembershipPayload = {
       communities: Amity.RawCommunity[];
-      communityUsers: Amity.MembershipRaw<'community'>[];
-      categories?: Amity.Category[];
-      feeds?: Amity.Feed[];
+      communityUsers: Amity.RawMembership<'community'>[];
+      categories: Amity.Category[];
+      feeds: Amity.Feed[];
       users: Amity.User[];
-      files?: Amity.File[];
+      files: Amity.File[];
+    };
+
+    /**
+     * Items that extend from `Amity.CommunityMembershipPayload`
+     * - communities: `Amity.RawCommunity` -> `Amity.Community` (Added Marker Service related props)
+     * - communityUsers: `Amity.RawMembership` -> `Amity.Membership` (Add user getter prop)
+     */
+    type ProcessedCommunityMembershipPayload = Omit<
+      CommunityMembershipPayload,
+      'communities' | 'communityUsers'
+    > & {
+      communities: Amity.Community[];
+      communityUsers: Amity.Membership<'community'>[];
     };
 
     type PostPayload<T extends Amity.PostContentType = any> = {
       posts: Amity.Post<T>[];
-      postChildren?: Amity.Post[];
-      communities?: Amity.RawCommunity[];
-      communityUsers?: Amity.MembershipRaw<'community'>[];
-      categories?: Amity.Category[];
-      comments?: Amity.Comment[];
-      feeds?: Amity.Feed[];
-      users?: Amity.User[];
-      files?: Amity.File[];
+      postChildren: Amity.Post[];
+      communities: Amity.RawCommunity[];
+      communityUsers: Amity.RawMembership<'community'>[];
+      categories: Amity.Category[];
+      comments: Amity.Comment[];
+      feeds: Amity.Feed[];
+      users: Amity.User[];
+      files: Amity.File[];
+    };
+
+    /**
+     * Items that extend from `Amity.PostPayload`
+     * - communities: `Amity.RawCommunity` -> `Amity.Community` (Added Marker Service related props)
+     * - communityUsers: `Amity.RawMembership` -> `Amity.Membership` (Add user getter prop)
+     */
+    type ProcessedPostPayload = Omit<PostPayload, 'communities' | 'communityUsers'> & {
+      communities: Amity.Community[];
+      communityUsers: Amity.Membership<'community'>[];
     };
 
     type CommentPayload<T extends Amity.CommentContentType = any> = {
       comments: Amity.Comment<T>[];
-      commentChildren?: Amity.Comment[];
-      users?: Amity.User[];
-      files?: Amity.File[];
+      commentChildren: Amity.Comment[];
+      users: Amity.User[];
+      files: Amity.File[];
     };
 
     type PollPayload = {
@@ -129,7 +193,7 @@ declare global {
 
     type ReactionPayload = {
       reactions: Amity.ReactionQuery[];
-      users: Pick<Amity.User, 'userId' | 'displayName' | 'metadata'>[];
+      users: Amity.User[];
     };
 
     type GlobalFeedPayload = Amity.PostPayload;

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

@@ -48,7 +48,7 @@ declare global {
       messageCount: number; // TODO remove from public interface
       moderatorMemberCount?: number;
 
-      lastActivity?: Amity.timestamp;
+      lastActivity: Amity.timestamp;
 
       defaultSubChannelUnreadCount: number;
       defaultSubChannelHasUnreadMention: boolean;
@@ -60,7 +60,7 @@ declare global {
       Amity.SoftDelete &
       Amity.Subscribable;
 
-    type ChannelRaw<T extends ChannelType = any> = Omit<
+    type RawChannel<T extends ChannelType = any> = Omit<
       Channel<T>,
       | 'defaultSubChannelId'
       | 'defaultSubChannelUnreadCount'
@@ -74,7 +74,7 @@ declare global {
     type QueryChannels = {
       displayName?: string;
       membership?: 'all' | 'member' | 'notMember';
-      sortBy?: 'displayName' | 'firstCreated' | 'lastCreated';
+      sortBy?: 'displayName' | 'firstCreated' | 'lastCreated' | 'lastActivity';
       types?: Amity.ChannelType[];
       isDeleted?: Amity.Channel['isDeleted'];
       tags?: Amity.Taggable['tags'];

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

@@ -59,9 +59,9 @@ declare global {
     type Device = {
       deviceId: string;
       deviceInfo: {
-        version: string;
         kind: 'node' | 'web';
         model?: string;
+        sdkVersion: string;
       };
     };
 

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

@@ -24,6 +24,7 @@ declare global {
       children: Comment['commentId'][];
       segmentNumber: number;
       editedAt: Amity.timestamp;
+      attachments?: Amity.Attachment[];
     } & Amity.Relationship<CommentReferenceType> &
       Amity.Content<T> &
       Amity.Metadata &
@@ -42,6 +43,12 @@ declare global {
       hasFlag?: boolean;
       isDeleted?: Amity.Comment['isDeleted'];
       page?: Amity.Page;
+      dataTypes?: {
+        values: ('image' | 'text')[];
+        // matchType is a query format that you can set to any to query any type of comment
+        // or exact to get a comment with exactly type that defined in dataTypes
+        matchType: 'any' | 'exact';
+      };
     };
 
     type CommentLiveCollection = Amity.LiveCollectionParams<

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

@@ -31,6 +31,13 @@ declare global {
       | 'onLeft'
       | 'onMemberCountChanged';
 
+    type CommunityMemberActionType =
+      | 'onJoin'
+      | 'onLeft'
+      | 'onBan'
+      | 'onUnban'
+      | 'onMemberCountChanged';
+
     type RawCommunity = {
       communityId: string;
 
@@ -80,5 +87,23 @@ declare global {
       Amity.Community['communityId'],
       Pick<QueryCommunities, 'page'>
     >;
+
+    type QueryCommunityMembers = {
+      communityId: string;
+      membership?: ('banned' | 'member')[];
+      roles?: string[];
+      sortBy?: 'firstCreated' | 'lastCreated';
+      search?: Amity.User['displayName'] | Amity.User['userId'];
+      page?: Amity.Page;
+    };
+
+    type CommunityMemberLiveCollection = Amity.LiveCollectionParams<
+      Omit<QueryCommunityMembers, 'page'>
+    >;
+
+    type CommunityMemberLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Membership<'community'>['userId'],
+      Pick<QueryCommunityMembers, 'page'>
+    >;
   }
 }

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

@@ -24,6 +24,12 @@ declare global {
       fileId: Amity.File<'image'>['fileId'];
     };
 
+    type Attachment = {
+      type: 'image' | 'link';
+      url?: string;
+      fileId?: Amity.File<'image'>['fileId'];
+    };
+
     type ContentDataVideo = {
       thumbnailFileId: Amity.File<'image'>['fileId'];
       videoFileId: {
@@ -52,8 +58,10 @@ declare global {
       : never;
 
     type Content<T extends ContentType> = {
+      // dataType still retained to maintain backward compatibility
       dataType?: T;
-      data: ContentData<T>;
+      dataTypes?: T[];
+      data?: ContentData<T>;
     };
 
     type ContentSettingText = {

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

@@ -2,12 +2,10 @@ export {};
 
 declare global {
   namespace Amity {
-    type FeedType = 'community' | 'user';
-
     type Feed = {
       feedId: string;
       feedType: 'reviewing' | 'published';
-      targetType: FeedType;
+      targetType: Extract<Amity.Domain, 'community' | 'user'>;
       targetId: string;
       postCount: number;
     } & Amity.Timestamps;

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

@@ -27,7 +27,7 @@ declare global {
 
     type MemberWithUser<T extends GroupType> = Member<T> & { user: Amity.User | undefined };
 
-    type MembershipRaw<T extends GroupType, WithUser = false> = {
+    type RawMembership<T extends GroupType, WithUser = false> = {
       isBanned: boolean;
       isMuted: boolean;
       muteTimeout: string;
@@ -35,6 +35,6 @@ declare global {
     } & (WithUser extends true ? MemberWithUser<T> : Member<T>) &
       Amity.Accredited;
 
-    type Membership<T extends Amity.GroupType> = Amity.MembershipRaw<T, true>;
+    type Membership<T extends Amity.GroupType> = Amity.RawMembership<T, true>;
   }
 }

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

@@ -76,7 +76,10 @@ declare global {
       excludeTags?: Amity.Taggable['tags'];
       hasFlags?: boolean;
       isDeleted?: boolean;
-      page?: Amity.Page;
+      /*
+       * For messages the after and before values are messageId
+       */
+      page?: Amity.Page<string>;
       parentId?: Amity.Message['parentId'];
       sortBy?: 'segmentAsc' | 'segmentDesc';
       tags?: Amity.Taggable['tags'];

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

@@ -10,7 +10,7 @@ export const PostContentType = Object.freeze({
 declare global {
   namespace Amity {
     // bad hack until we get proper feed objects in backend
-    type PostTargetType = Amity.FeedType | 'content';
+    type PostTargetType = Amity.Feed['targetType'] | 'content';
 
     type PostContentType = ValueOf<typeof PostContentType>;
 

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

@@ -24,5 +24,19 @@ declare global {
       Amity.Timestamps &
       Amity.SoftDelete &
       Amity.Subscribable;
+
+    type QueryUsers = {
+      displayName?: Amity.User['displayName'];
+      filter?: 'all' | 'flagged';
+      sortBy?: 'displayName' | 'firstCreated' | 'lastCreated';
+      page?: Amity.Page;
+    };
+
+    type UserLiveCollection = Amity.LiveCollectionParams<Omit<QueryUsers, 'page'>>;
+
+    type UserLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.User['userId'],
+      Pick<QueryUsers, 'page'>
+    >;
   }
 }

package/src/@types/global.ts

@@ -27,6 +27,16 @@ declare global {
   }
 
   type ValueOf<T extends Record<any, any>> = T[keyof T];
+
+  /**
+   *  Make properties required otherwise optional
+   */
+  type MakeRequired<T, K extends keyof T> = Required<Pick<T, K>> & Partial<T>;
+
+  /**
+   *  Make properties optional otherwise required
+   */
+  type MakeOptional<T, K extends keyof T> = Partial<Pick<T, K>> & Required<T>;
 }
 
 /*

package/src/cache/api/ingestInCache.ts

@@ -12,7 +12,7 @@ import { upsertInCache } from './upsertInCache';
  * @hidden
  */
 export const ingestInCache = (
-  payload: Record<string, Record<string, unknown>[]> = {},
+  payload: Record<keyof typeof PAYLOAD2MODEL, Amity.Model[]> = {},
   options?: Amity.CacheOptions,
 ) => {
   Object.entries(payload).forEach(([key, models]) => {
@@ -20,13 +20,10 @@ export const ingestInCache = (
     if (!type) return;
 
     const resolver = getResolver(type);
+    if (!resolver) return;
 
     models.forEach(model => {
-      upsertInCache(
-        [type, 'get', resolver(model as any)], // this 'any' cannot be avoided, sorry.
-        model,
-        options,
-      );
+      upsertInCache([type, 'get', resolver(model)], model, options);
     });
   });
 };

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

@@ -1,3 +1,4 @@
+import { prepareCommunityPayload } from '~/community/utils';
 import { PAYLOAD2MODEL, getResolver } from '~/core/model';
 
 import {
@@ -7,10 +8,9 @@ import {
   messagePayload,
   communityPayload,
   postPayload,
-  commentPayload,
   pollPayload,
-  reactionPayload,
   followPayload,
+  feedPayload,
   user11,
 } from '~/utils/tests';
 
@@ -21,17 +21,20 @@ describe('ingestInCache', () => {
   beforeAll(enableCache);
   afterAll(disableCache);
 
-  const payloads: [keyof Amity.Model, Record<string, Record<string, unknown>[]>][] = [
+  const payloads: [keyof Amity.Models, Record<string, Amity.Model[]>][] = [
     ['user', userPayload],
     ['role', rolePayload],
     ['channel', channelPayload],
     ['message', messagePayload],
-    ['community', communityPayload],
+    ['community', prepareCommunityPayload(communityPayload)],
     ['post', postPayload],
-    ['comment', commentPayload],
+    // FIXME: add support for commentChildren in model
+    // ['comment', textCommentPayload],
     ['poll', pollPayload],
-    ['reaction', reactionPayload],
+    // FIXME: correct reactions type in model
+    // ['reaction', reactionPayload],
     ['follow', followPayload],
+    ['feed', feedPayload],
   ];
 
   test.each(payloads)('it should add %s payload to cache', (model, payload) => {
@@ -43,9 +46,10 @@ describe('ingestInCache', () => {
 
       expect(type).toBeDefined();
 
-      v.forEach(entity =>
-        expect(pullFromCache([type, 'get', resolver(entity as any)])).toBeDefined(),
-      );
+      v.forEach(entity => {
+        const received = pullFromCache([type, 'get', resolver(entity)]);
+        return expect(received).toBeDefined();
+      });
     });
   });
 
@@ -55,6 +59,7 @@ describe('ingestInCache', () => {
       users: [user11],
     };
 
+    // @ts-ignore
     ingestInCache(invalidPayload);
 
     expect(pullFromCache(['invalid', 'get', 'invalidId'])).toBeUndefined();

package/src/category/api/queryCategories.ts

@@ -6,6 +6,9 @@ import { pullFromCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
 
+/* begin_public_function
+  id: community.category.query
+*/
 /**
  * ```js
  * import { queryCategories } from '@amityco/ts-sdk'

package/src/channel/api/addChannelMembers.ts

@@ -5,6 +5,9 @@ import { fireEvent } from '~/core/events';
 
 import { prepareChannelPayload } from '../utils';
 
+/* begin_public_function
+  id: channel.member.add
+*/
 /**
  * ```js
  * import { addChannelMembers } from '@amityco/ts-sdk'
@@ -32,22 +35,23 @@ export const addChannelMembers = async (
     { channelId, userIds },
   );
 
-  const data = prepareChannelPayload(payload);
-
-  if (client.cache) ingestInCache(data);
-
   /*
    * should fire event for each user that was added
    */
   userIds.forEach(id =>
     fireEvent('channel.membersAdded', {
       ...payload,
-      channelUsers: data.channelUsers.filter(u => u.userId === id),
+      channelUsers: payload.channelUsers.filter(u => u.userId === id),
     }),
   );
 
+  const data = prepareChannelPayload(payload);
+
+  if (client.cache) ingestInCache(data);
+
   const { channelUsers } = data;
   return !!channelUsers.find(
     channelUser => channelUser.channelId === channelId && channelUser.membership === 'member',
   );
 };
+/* end_public_function */

package/src/channel/api/addChannelMembersRole.ts

@@ -4,6 +4,9 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 
 import { prepareChannelPayload } from '../utils';
 
+/* begin_public_function
+  id: channel.moderation.add_roles
+*/
 /**
  * ```js
  * import { addChannelMembersRole } from '@amityco/ts-sdk'
@@ -42,3 +45,4 @@ export const addChannelMembersRole = async (
     channelUser => channelUser.channelId === channelId && channelUser.roles.includes(roleId),
   );
 };
+/* end_public_function */

package/src/channel/api/banChannelMembers.ts

@@ -1,10 +1,12 @@
 import { getActiveClient } from '~/client/api/activeClient';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { prepareMembershipPayload } from '~/group/utils';
 
 import { prepareChannelPayload } from '../utils';
 
+/* begin_public_function
+  id: channel.moderation.ban_members
+*/
 /**
  * ```js
  * import { banChannelMembers } from '@amityco/ts-sdk'
@@ -33,8 +35,7 @@ export const banChannelMembers = async (
     },
   );
 
-  const channelPayload = prepareChannelPayload(payload);
-  const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+  const preparedPayload = prepareChannelPayload(payload);
   const { channelUsers } = preparedPayload;
 
   const cachedAt = client.cache && Date.now();
@@ -45,3 +46,4 @@ export const banChannelMembers = async (
     cachedAt,
   };
 };
+/* end_public_function */

package/src/channel/api/createChannel.ts

@@ -4,6 +4,9 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 
 import { prepareChannelPayload } from '../utils';
 
+/* begin_public_function
+  id: channel.create
+*/
 /**
  * ```js
  * import { createChannel } from '@amityco/ts-sdk'
@@ -49,3 +52,4 @@ export const createChannel = async <T extends Amity.ChannelType>(
     cachedAt,
   };
 };
+/* end_public_function */

package/src/channel/api/getChannel.ts

@@ -9,6 +9,9 @@ import { pushToTombstone } from '~/cache/api/pushToTombstone';
 
 import { prepareChannelPayload } from '../utils';
 
+/* begin_public_function
+  id: channel.get
+*/
 /**
  * ```js
  * import { getChannel } from '@amityco/ts-sdk'
@@ -31,7 +34,7 @@ export const getChannel = async (
 
   isInTombstone('channel', channelId);
 
-  let data: Amity.ChannelPayload<any, Amity.Channel>;
+  let data: Amity.ProcessedChannelPayload;
 
   try {
     const { data: payload } = await client.http.get<Amity.ChannelPayload>(
@@ -57,6 +60,7 @@ export const getChannel = async (
     cachedAt,
   };
 };
+/* end_public_function */
 
 /**
  * ```js

package/src/channel/api/joinChannel.ts

@@ -4,6 +4,9 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 
 import { prepareChannelPayload } from '../utils';
 
+/* begin_public_function
+  id: channel.join
+*/
 /**
  * ```js
  * import { joinChannel } from '@amityco/ts-sdk'
@@ -36,3 +39,4 @@ export const joinChannel = async (channelId: Amity.Channel['channelId']): Promis
     channelUser => channelUser.channelId === channelId && channelUser.membership === 'member',
   );
 };
+/* end_public_function */

package/src/channel/api/leaveChannel.ts

@@ -4,6 +4,9 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 
 import { prepareChannelPayload } from '../utils';
 
+/* begin_public_function
+  id: channel.leave
+*/
 /**
  * ```js
  * import { leaveChannel } from '@amityco/ts-sdk'
@@ -36,3 +39,4 @@ export const leaveChannel = async (channelId: Amity.Channel['channelId']): Promi
     channelUser => channelUser.channelId === channelId && channelUser.membership !== 'member',
   );
 };
+/* end_public_function */