@amityco/ts-sdk 0.0.1-e5fb0d2.0 → 0.0.1-e643f6f.0

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

@@ -0,0 +1,34 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type LiveObject<T extends any> = {
+      data: T;
+      error?: any;
+      loading: boolean;
+      origin?: 'local' | 'server' | 'event';
+    };
+
+    type LiveObjectCallback<T extends any> = Amity.Listener<LiveObject<T>>;
+
+    type LiveCollection<T extends any> = LiveObject<T[]> & {
+      onNextPage: () => void;
+      hasNextPage: boolean;
+    };
+
+    type LiveCollectionCallback<T extends any> = Amity.Listener<LiveCollection<T>>;
+
+    type LiveCollectionConfig = {
+      policy?: Exclude<Amity.QueryPolicy, 'no_fetch'>;
+    };
+
+    type LiveCollectionParams<T extends any> = T & {
+      limit?: number;
+    };
+
+    type LiveCollectionCache<T extends any, U extends any> = Pick<
+      LiveCollection<T>,
+      'data' | 'error' | 'loading'
+    > & { params: U };
+  }
+}

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

@@ -1,4 +1,4 @@
-export {}
+export {};
 
 declare global {
   namespace Amity {
@@ -6,22 +6,35 @@ declare global {
      * type map of "domain name -> ASC model"
      * @hidden
      */
-    type Model = {
-      'user': Amity.User
-      'file': Amity.File
-      'role': Amity.Role
+    type Models = {
+      user: Amity.User;
+      file: Amity.File;
+      role: Amity.Role;
 
-      'channel': Amity.Channel
-      'channelUsers': Amity.Membership<'channel'>
-      'message': Amity.Message
+      channel: Amity.Channel;
+      subChannel: Amity.SubChannel;
+      channelUsers: Amity.Membership<'channel'>;
+      message: Amity.Message;
 
-      'community': Amity.Community
-      'communityUsers': Amity.Membership<'community'>
-      'post': Amity.Post
-      'comment': Amity.Comment
+      community: Amity.Community;
+      category: Amity.Category;
+      communityUsers: Amity.Membership<'community'>;
+      post: Amity.Post;
+      comment: Amity.Comment;
+      poll: Amity.Poll;
+      reaction: Amity.Reaction;
 
-      'stream': Amity.Stream
-    }
+      stream: Amity.Stream;
+
+      follow: Amity.FollowStatus;
+      followInfo: Amity.FollowInfo;
+      followCount: Amity.FollowCount;
+
+      feed: Amity.Feed;
+    };
+
+    type Model = ValueOf<Models>;
+    type Domain = keyof Models;
 
     /**
      * Definition of the minimal set of properties necessary to identify
@@ -29,23 +42,30 @@ declare global {
      * @hidden
      */
     type Minimal = {
-      'user': Pick<Amity.User, 'userId'>
-      'file': Pick<Amity.File, 'fileId'>
-      'role': Pick<Amity.Role, 'roleId'>
-
-      'channel': Pick<Amity.Channel, 'channelId'>
-      'channelUsers': Pick<Amity.Membership<'channel'>, 'channelId' | 'userId'>
-      'message': Pick<Amity.Message, 'messageId'>
-
-      'community': Pick<Amity.Community, 'communityId'>
-      'communityUsers': Pick<
-        Amity.Membership<'community'>,
-        'communityId' | 'userId'
-      >
-      'post': Pick<Amity.Post, 'postId'>
-      'comment': Pick<Amity.Comment, 'commentId'>
-
-      'stream': Pick<Amity.Stream, 'streamId'>
-    }
+      user: Pick<Amity.User, 'userId'>;
+      file: Pick<Amity.File, 'fileId'>;
+      role: Pick<Amity.Role, 'roleId'>;
+
+      channel: Pick<Amity.Channel, 'channelId'>;
+      subChannel: Pick<Amity.SubChannel, 'subChannelId'>;
+      channelUsers: Pick<Amity.Membership<'channel'>, 'channelId' | 'userId'>;
+      message: Pick<Amity.Message, 'messageId'>;
+
+      community: Pick<Amity.Community, 'communityId'>;
+      category: Pick<Amity.Category, 'categoryId'>;
+      communityUsers: Pick<Amity.Membership<'community'>, 'communityId' | 'userId'>;
+      post: Pick<Amity.Post, 'postId'>;
+      comment: Pick<Amity.Comment, 'commentId'>;
+      poll: Pick<Amity.Poll, 'pollId'>;
+      reaction: Pick<Amity.Reaction, 'reactionId'>;
+
+      stream: Pick<Amity.Stream, 'streamId'>;
+
+      follow: Pick<Amity.FollowStatus, 'from' | 'to'>;
+      followInfo: Pick<Amity.FollowInfo, 'userId' | 'status'>;
+      followCount: Pick<Amity.FollowInfo, 'userId' | 'followerCount'>;
+
+      feed: Pick<Amity.Feed, 'targetId' | 'feedId'>;
+    };
   }
 }

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

@@ -0,0 +1,60 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type PaginationStyles = 'skiplimit' | 'afterbefore' | 'afterbeforeraw';
+
+    type PageLimit = {
+      limit: number;
+    };
+
+    type PrevPage<T extends number | string> = PageLimit & {
+      after?: never;
+      before?: T;
+    };
+
+    type NextPage<T extends number | string> = PageLimit & {
+      after?: T;
+      before?: never;
+    };
+
+    type Page<T extends number | string = number> = PrevPage<T> | NextPage<T>;
+
+    /*
+      updatedAt is here because if you need sort by updatedAt you
+      need to include this data in query also
+    */
+    type PageRaw = (PrevPage<string> | NextPage<string>) & {
+      updatedAt?: string;
+    };
+
+    type SkipLimitPagination = {
+      skip?: number;
+      limit?: number;
+    };
+
+    /*
+      WARNING:
+      in traditional "before/after" pagination, 'before' and 'after'
+      normally should be strings representing the unique id of the
+      resource. for some reason, our backend uses a number instead,
+      bound to "channelSegment" (for message) and "segmentNumber" (
+      for comments). so we have to cast this as number.
+    */
+    type AfterBeforePagination = {
+      before?: number;
+      after?: number;
+      first?: number;
+      last?: number;
+    };
+
+    type AfterBeforeRawPagination = PageRaw;
+
+    type Pages<T extends Page | PageRaw> = {
+      nextPage?: T;
+      prevPage?: T;
+    };
+
+    type Paged<T, K extends Page | PageRaw = Page> = { data: T[] } & Pages<K>;
+  }
+}

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

@@ -1,102 +1,213 @@
-export {}
+export {};
 
 declare global {
   namespace Amity {
     type Payloads = {
-      user: Amity.UserPayload
-      file: Amity.FilePayload
-      role: Amity.RolePayload
-      channel: Amity.ChannelPayload
-      channelUser: Amity.ChannelMembershipPayload
-      message: Amity.MessagePayload
-      community: Amity.CommunityPayload
-      communityUser: Amity.CommunityMembershipPayload
-      post: Amity.PostPayload
-      comment: Amity.CommentPayload
-      stream: Amity.StreamPayload
-    }
+      user: Amity.UserPayload;
+      file: Amity.FilePayload;
+      role: Amity.RolePayload;
+      channel: Amity.ChannelPayload;
+      subChannel: Amity.SubChannelPayload;
+      channelUser: Amity.ChannelMembershipPayload;
+      message: Amity.MessagePayload;
+      community: Amity.CommunityPayload;
+      category: Amity.CategoryPayload;
+      communityUser: Amity.CommunityMembershipPayload;
+      post: Amity.PostPayload;
+      comment: Amity.CommentPayload;
+      poll: Amity.PollPayload;
+      stream: Amity.StreamPayload;
+      reaction: Amity.ReactionPayload;
+    };
 
     type UserPayload = {
-      users: Amity.User[]
-      files: Amity.File<'image'>[]
-    }
+      users: Amity.User[];
+      files: Amity.File<'image'>[];
+    };
+
+    type FeedSettingPayload = {
+      feedSettings: {
+        contentSettings: Amity.ContentSetting[];
+        feedType: Amity.ContentFeedType;
+      }[];
+    };
 
     // API-FIX: backend should return a payload like { files: Amity.File<T>[] }
-    type CreateFilePayload<T extends Amity.FileType = any> = Amity.File<T>[]
-    type FilePayload<T extends Amity.FileType = any> = Amity.File<T>
+    type CreateFilePayload<T extends Amity.FileType = any> = Amity.File<T>[];
+    type FilePayload<T extends Amity.FileType = any> = Amity.File<T>;
 
     type RolePayload = {
-      roles: Amity.Role[]
-    }
+      roles: Amity.Role[];
+    };
 
     type ChannelPayload<T extends Amity.ChannelType = any> = {
-      channels: Amity.Channel<T>[]
-      channelUsers?: Amity.Membership<'channel'>[]
-      users?: Amity.User[]
-      files?: Amity.File[]
-    }
+      channels: Amity.RawChannel<T>[];
+      channelUsers: Amity.RawMembership<'channel'>[];
+    } & Amity.UserPayload;
+
+    /**
+     * 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.Channel[]
-      channelUsers: Amity.Membership<'channel'>[]
-      users?: Amity.User[]
-      files?: Amity.File[]
-    }
-
-    type MessagePayload<T extends Amity.MessageContentType = any> = {
-      messages: Amity.Message<T>[]
-      users?: Amity.User[]
-      files?: Amity.File[]
-    }
+      channels: Amity.RawChannel[];
+      channelUsers: Amity.RawMembership<'channel'>[];
+    } & Amity.UserPayload;
+
+    /**
+     * 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[];
+    };
+
+    type MessagePayload<T extends Amity.MessageContentType = any> = Omit<
+      ProcessedMessagePayload<T>,
+      'messages'
+    > & {
+      messages: Amity.RawMessage<T>[];
+    };
 
     type StreamPayload = {
-      videoStreamings: Amity.Stream[]
-      users?: Amity.User[]
-      files?: Amity.File<'image'>[]
-    }
+      videoStreamings: Amity.Stream[];
+      users: Amity.User[];
+      files: Amity.File<'image'>[];
+    };
 
     type CommunityPayload = {
-      communities: Amity.Community[]
-      communityUsers?: Amity.Membership<'community'>[]
-      categories?: Amity.Category[]
-      feeds?: Amity.Feed[]
-      users?: Amity.User[]
-      files?: Amity.File[]
-    }
+      communities: Amity.RawCommunity[];
+      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 = {
-      categories: Amity.Category[]
-      files: Amity.File[]
-    }
+      categories: Amity.Category[];
+      files: Amity.File[];
+    };
 
     type CommunityMembershipPayload = {
-      communities?: Amity.Community[]
-      communityUsers: Amity.Membership<'community'>[]
-      categories?: Amity.Category[]
-      feeds?: Amity.Feed[]
-      users?: Amity.User[]
-      files?: Amity.File[]
-    }
+      communities: Amity.RawCommunity[];
+      communityUsers: Amity.RawMembership<'community'>[];
+      categories: Amity.Category[];
+      feeds: Amity.Feed[];
+      users: Amity.User[];
+      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.Community[]
-      communityUsers?: Amity.Membership<'community'>[]
-      categories?: Amity.Category[]
-      comments?: Amity.Comment[]
-      feeds?: Amity.Feed[]
-      users?: Amity.User[]
-      files?: Amity.File[]
-    }
+      posts: Amity.Post<T>[];
+      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[]
-    }
+      comments: Amity.Comment<T>[];
+      commentChildren: Amity.Comment[];
+      users: Amity.User[];
+      files: Amity.File[];
+    };
+
+    type PollPayload = {
+      users: Amity.User[];
+      polls: Amity.Poll[];
+    };
+
+    type ReactionPayload = {
+      reactions: Amity.ReactionQuery[];
+      users: Amity.User[];
+    };
+
+    type GlobalFeedPayload = Amity.PostPayload;
+
+    type FollowStatusPayload = {
+      follows: Amity.FollowStatus[];
+    };
+
+    type FollowInfoMePayload = {
+      followCounts: Amity.FollowCount[];
+    };
+
+    type FollowersPayload = Amity.FollowStatusPayload & UserPayload;
 
-    type GlobalFeedPayload = Amity.PostPayload
+    type FollowInfoPayload = FollowInfoMePayload & Amity.FollowStatusPayload;
   }
 }

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

@@ -1,4 +1,4 @@
-export {}
+export {};
 
 declare global {
   namespace Amity {
@@ -65,12 +65,10 @@ declare global {
     }
 
     type Role = {
-      roleId: string
-      displayName: string
-      permissions: Permission[]
-    }
-    & Amity.Timestamps
-    & Amity.SoftDelete
-    & Amity.Syncable
+      roleId: string;
+      displayName: string;
+      permissions: Permission[];
+    } & Amity.Timestamps &
+      Amity.SoftDelete;
   }
 }

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

@@ -1,95 +1,63 @@
-export {}
+export {};
 
 declare global {
   namespace Amity {
-    type Syncable = {
-      localId: string
-      syncedAt: number
-    }
+    type Cachable = {
+      cachedAt: number;
+    };
 
     type Local = {
-      localId: string
-      syncedAt: -1
-    }
+      cachedAt: -1;
+    };
 
     type AsyncFunc<Args extends any[], Returned extends any> = {
-      (...args: Args): Promise<Returned>
-    }
+      (...args: Args): Promise<Returned>;
+    };
 
     type FetcherFunc<Args extends any[], Returned extends any> = {
-      (...args: Args): Promise<Returned>
-      locally: (...args: Args) => Returned
-    }
+      (...args: Args): Promise<Returned>;
+      locally: (...args: Args) => Returned | undefined;
+    };
 
     type MutatorFunc<Args extends any[], Returned extends any> = {
-      (...args: Args): Promise<Returned>
-      optimistically: (...args: Args) => Returned
-    }
+      (...args: Args): Promise<Returned>;
+      optimistically: (...args: Args) => Returned | undefined;
+    };
 
-    type OfflineFunc<Args extends any[], Returned extends any> = (
-      FetcherFunc<Args, Returned> | MutatorFunc<Args, Returned>
-    )
+    type OfflineFunc<Args extends any[], Returned extends any> =
+      | FetcherFunc<Args, Returned>
+      | MutatorFunc<Args, Returned>;
 
     type Query<Args extends any[], Returned extends any> = {
-      func: AsyncFunc<Args, Returned> | OfflineFunc<Args, Returned>
-      args: Args
-    }
+      func: AsyncFunc<Args, Returned> | OfflineFunc<Args, Returned>;
+      args: Args;
+    };
 
-    type QueryPolicy = 'server_only' | 'cache_only' | 'cache_then_server' | 'no_fetch'
+    type QueryPolicy = 'cache_only' | 'cache_then_server' | 'no_fetch';
 
     type QueryOptions = {
-      lifeSpan: number
-    }
-
-    type QueryMetadata = {
-      origin?: 'local' | 'server',
-      loading?: boolean,
-      error?: Error,
-    }
-
-    type QueryResult<T> = T extends Amity.Paged<infer U>
-      ? { data?: U } & Amity.Pages & QueryMetadata
-      : { data?: T } & QueryMetadata
-
-    type SkipLimitPagination = {
-      skip?: number
-      limit?: number
-    }
-
-    /*
-      WARNING:
-      in traditional "before/after" pagination, 'before' and 'after'
-      normally should be strings representing the unique id of the
-      resource. for some reason, our backend uses a number instead,
-      bound to "channelSegment" (for message) and "segmentNumber" (
-      for comments). so we have to cast this as number.
-    */
-    type AfterBeforePagination = {
-      before?: number
-      after?: number
-      first?: number
-      last?: number
-    }
-
-    type PrevPage = {
-      after?: never
-      before?: number
-      limit: number
-    }
-
-    type NextPage = {
-      after?: number
-      before?: never
-      limit: number
-    }
-
-    type Page = (PrevPage | NextPage)
-
-    type Pages = {
-      nextPage: Page | null
-      prevPage: Page | null
-    }
-
-    type Paged<T> = { data: T } & Pages
+      lifeSpan: number;
+    };
+
+    type SnapshotOptions = {
+      origin: 'local' | 'server' | 'event';
+      loading: boolean;
+      error?: any;
+    };
+
+    type Snapshot<T> = (T extends Amity.Cached<infer T2>
+      ? T2 extends Amity.Paged<infer T3, infer T4>
+        ? { data: T3[] | undefined } & Amity.Pages<T4> & {
+              cachedAt?: Amity.CacheOptions['cachedAt'];
+            }
+        : { data: T2 } & { cachedAt?: Amity.CacheOptions['cachedAt'] }
+      : T extends Amity.Paged<infer T3, infer T4>
+      ? { data: T3[] | undefined } & Amity.Pages<T4>
+      : { data: T | undefined }) &
+      SnapshotOptions;
+
+    type RunQueryOptions<T> = T extends Amity.AsyncFunc<infer Args, infer Returned>
+      ? Omit<Amity.Snapshot<Returned>, 'data'>
+      : never;
   }
 }