@amityco/ts-sdk 7.5.1-1d67f17.0 → 7.5.1-3566b16.0

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

@@ -27,6 +27,9 @@ declare global {
       semanticSearchPost: Amity.SemanticSearchPostPayload;
       semanticSearchCommunity: Amity.SemanticSearchCommunityPayload;
       notificationTrayItem: Amity.NotificationTrayPayload;
+      invitation: Amity.InvitationPayload;
+      myInvitation: Amity.MyInvitationsPayload;
+      joinRequest: Amity.CommunityJoinRequestPayload;
     };
 
     type UserPayload = {
@@ -225,7 +228,7 @@ declare global {
     type SubChannelPayload<T extends Amity.MessageContentType = any> = {
       messageFeeds: Amity.RawSubChannel[];
       messages: Amity.RawMessage<T>[];
-      users: Amity.InternalUser[];
+      users: Amity.RawUser[];
       files: Amity.File[];
     };
 
@@ -297,6 +300,12 @@ declare global {
       files: Amity.File[];
     };
 
+    type CommunityJoinRequestPayload = {
+      joinRequests: Amity.RawJoinRequest[];
+      users: Amity.RawUser[];
+      files: Amity.File[];
+    };
+
     type RecommendedCommunityPayload = Amity.CommunityPayload;
     type TrendingCommunityPayload = Amity.CommunityPayload;
 
@@ -306,8 +315,18 @@ declare global {
      * - communityUsers: `Amity.RawMembership` -> `Amity.Membership` (Add user getter prop)
      */
     type ProcessedCommunityPayload = Omit<CommunityPayload, 'communities' | 'communityUsers'> & {
-      communities: Amity.Community[];
+      communities: Amity.InternalCommunity[];
       communityUsers: Amity.Membership<'community'>[];
+      users: Amity.InternalUser[];
+    };
+
+    type ProcessedJoinRequestPayload = Omit<
+      CommunityJoinRequestPayload,
+      'communities' | 'communityUsers' | 'joinRequests' | 'users'
+    > & {
+      joinRequests: Amity.InternalJoinRequest[];
+      files: Amity.File[];
+      users: Amity.InternalUser[];
     };
 
     type CategoryPayload = {
@@ -333,7 +352,7 @@ declare global {
       CommunityMembershipPayload,
       'communities' | 'communityUsers'
     > & {
-      communities: Amity.Community[];
+      communities: Amity.InternalCommunity[];
       communityUsers: Amity.Membership<'community'>[];
     };
 
@@ -383,7 +402,7 @@ declare global {
       Amity.StoryTargetPayload;
 
     type ProcessedGlobalStoryFeed = Omit<GlobalStoryFeedPayload, 'communities'> & {
-      communities: Amity.Community[];
+      communities: Amity.InternalCommunity[];
     };
 
     // Original Payload form BE
@@ -436,7 +455,7 @@ declare global {
      */
     type ProcessedPostPayload = Omit<PostPayload, 'communities' | 'communityUsers' | 'posts'> & {
       posts: Amity.InternalPost[];
-      communities: Amity.Community[];
+      communities: Amity.InternalCommunity[];
       communityUsers: Amity.Membership<'community'>[];
     };
 
@@ -545,5 +564,29 @@ declare global {
       Amity.Flaggable &
       Amity.Taggable &
       Amity.Timestamps;
+
+    type InvitationPayload = {
+      invitations: Amity.RawInvitation[];
+      users: Amity.RawUser[];
+    };
+
+    type ProcessedInvitationPayload = {
+      invitations: Amity.InternalInvitation[];
+      users: Amity.InternalUser[];
+    };
+
+    type MyInvitationsPayload = {
+      invitations: Amity.RawInvitation[];
+      users: Amity.RawUser[];
+    };
+
+    type ProcessedMyInvitationsPayload = {
+      invitations: Amity.InternalInvitation[];
+      users: Amity.InternalUser[];
+    };
+
+    type JoinRequestPayload = {
+      joinRequests: Amity.RawJoinRequest[];
+    };
   }
 }

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

@@ -1,10 +1,17 @@
 import { AxiosInstance } from 'axios';
 import { Emitter } from 'mitt';
 
+export const enum MembershipAcceptanceTypeEnum {
+  AUTOMATIC = 'automatic',
+  INVITATION = 'invitation',
+}
+
 declare global {
   namespace Amity {
     type Logger = (topic: string, ...args: any[]) => void;
 
+    type MembershipAcceptanceType = MembershipAcceptanceTypeEnum;
+
     const enum TokenTerminationReason {
       GLOBAL_BAN = 'globalBan',
       USER_DELETED = 'userDeleted',
@@ -124,7 +131,12 @@ declare global {
         showMyPost: boolean;
         showOnlyMyFeed: boolean;
       };
+      story: {
+        allowAllUserToCreateStory: boolean;
+        expiryTimeMinutes: number;
+      };
       userPrivacySetting: 'public' | 'private';
+      membershipAcceptance: Amity.MembershipAcceptanceType;
     };
 
     type ConnectClientParams = {

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

@@ -95,17 +95,25 @@ declare global {
       hasFlaggedPost: boolean;
 
       allowCommentInStory?: boolean;
+
+      isDiscoverable?: boolean;
+      requiresJoinApproval?: boolean;
     } & Amity.Taggable &
       Amity.Metadata &
       Amity.Timestamps &
       Amity.SoftDelete &
       Amity.Subscribable;
 
-    type Community = Omit<Amity.RawCommunity, 'onlyAdminCanPost' | 'needApprovalOnPostCreation'> &
+    type InternalCommunity = Omit<
+      Amity.RawCommunity,
+      'onlyAdminCanPost' | 'needApprovalOnPostCreation'
+    > &
       Amity.CommunityStorySettings & {
         postSetting?: ValueOf<typeof CommunityPostSettings>;
       };
 
+    type Community = Amity.InternalCommunity & Amity.CommunityLinkedObject;
+
     type QueryCommunities = {
       membership?: 'all' | 'member' | 'notMember';
       categoryId?: Amity.InternalCategory['categoryId'];
@@ -116,6 +124,16 @@ declare global {
       limit?: number;
     };
 
+    type QueryJoinCommunity = {
+      communityId: string;
+      status: Amity.JoinRequestStatus;
+      sortBy?: Amity.CommunitySortBy | Amity.CommunitySortByEnum;
+      options?: {
+        limit?: number;
+        token?: string;
+      };
+    };
+
     type SearchQueryCommunities = {
       displayName?: string;
       membership?: 'all' | 'member' | 'notMember';
@@ -125,6 +143,30 @@ declare global {
       sortBy?: Amity.SearchCommunitySortBy | Amity.SearchCommunitySortByEnum;
       page?: string;
       limit?: number;
+      includeDiscoverablePrivateCommunity?: boolean;
+    };
+
+    type QueryJoinRequest = {
+      communityId: string;
+      status: Amity.JoinRequestStatus;
+      targetType: 'community';
+      type: Amity.JoinRequestType;
+      sortBy?: Amity.CommunitySortBy | Amity.CommunitySortByEnum;
+      options?: {
+        limit?: number;
+        token?: string;
+      };
+      page?: string;
+    };
+
+    type QueryJoinRequestList = {
+      communityIds: string[];
+      sortBy?: Amity.CommunitySortBy | Amity.CommunitySortByEnum;
+      options?: {
+        limit?: number;
+        token?: string;
+      };
+      page?: string;
     };
 
     type CommunityLiveCollection = Amity.LiveCollectionParams<Omit<QueryCommunities, 'page'>>;
@@ -132,6 +174,10 @@ declare global {
     type RecommendedCommunityLiveCollection = Amity.LiveCollectionParams<{ limit?: number }>;
     type TrendingCommunityLiveCollection = Amity.LiveCollectionParams<{ limit?: number }>;
 
+    type JoinRequestLiveCollection = Amity.LiveCollectionParams<QueryJoinRequest>;
+
+    type JoinRequestListLiveCollection = Amity.LiveCollectionParams<QueryJoinRequestList>;
+
     type SearchCommunityLiveCollection = Amity.LiveCollectionParams<
       Omit<SearchQueryCommunities, 'page'>
     >;
@@ -149,6 +195,16 @@ declare global {
       Pick<SearchQueryCommunities, 'page'>
     >;
 
+    type JoinRequestLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.JoinRequest['joinRequestId'],
+      Pick<QueryJoinRequest, 'page'>
+    >;
+
+    type JoinRequestListLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.JoinRequest['joinRequestId'],
+      Pick<QueryJoinRequestList, 'page'>
+    >;
+
     type QueryCommunityMembers = {
       communityId: string;
       memberships?: ('banned' | 'member')[];
@@ -197,6 +253,7 @@ declare global {
         token?: string;
       };
       tags?: string[];
+      includeDiscoverablePrivateCommunity?: boolean;
     };
 
     type SemanticSearchCommunityLiveCollection = Amity.LiveCollectionParams<
@@ -209,5 +266,20 @@ declare global {
       Amity.Community['communityId'], // communityId:score
       QuerySemanticSearchCommunity
     >;
+
+    type CommunityLinkedObject = {
+      createInvitations: (userIds: string[]) => Promise<void>;
+      getMemberInvitations: (
+        params: Pick<Amity.InvitationLiveCollection, 'limit' | 'sortBy' | 'statuses'>,
+        callback: Amity.LiveCollectionCallback<Amity.Invitation>,
+      ) => Amity.Unsubscriber;
+      getInvitation: () => Promise<Amity.Invitation | undefined>;
+      join: () => Promise<Amity.JoinResult>;
+      getJoinRequests: (
+        params: QueryJoinRequest,
+        callback: Amity.LiveCollectionCallback<Amity.JoinRequest>,
+      ) => Amity.Unsubscriber;
+      getMyJoinRequest: () => Promise<Amity.JoinRequest | undefined>;
+    };
   }
 }

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

@@ -0,0 +1,119 @@
+export {};
+
+export const enum InvitationTypeEnum {
+  CommunityMemberInvite = 'communityMemberInvite',
+  LivestreamInvite = 'livestreamInvite',
+}
+
+export const enum InvitationStatusEnum {
+  Pending = 'pending',
+  Approved = 'approved',
+  Rejected = 'rejected',
+  Cancelled = 'cancelled',
+}
+
+export const enum InvitationSortByEnum {
+  FirstCreated = 'firstCreated',
+  LastCreated = 'lastCreated',
+}
+
+declare global {
+  namespace Amity {
+    type InvitationType = InvitationTypeEnum;
+
+    type InvitationStatus = InvitationStatusEnum;
+
+    type InvitationTargetType = Extract<Amity.Domain, 'community'>;
+
+    type InvitationTargetMap = {
+      community: Amity.InternalCommunity;
+    };
+
+    type InvitationTarget<T extends InvitationTargetType> = InvitationTargetMap[T];
+
+    type InvitationSortBy = InvitationSortByEnum;
+
+    type InvitationDomain<T extends Amity.InvitationTargetType = Amity.InvitationTargetType> =
+      T extends 'community' ? { communityId: string } : { communityId?: string };
+
+    type RawInvitation = {
+      _id: string;
+      networkId: string;
+      type: Amity.InvitationType;
+      targetId: string;
+      targetType: Amity.InvitationTargetType;
+      userId: string;
+      status: Amity.InvitationStatus;
+      respondedAt: Amity.timestamp;
+      createdBy: string;
+      invitationId: string;
+      invitedUserId: string;
+      invitedUserInternalId: string;
+      invitedUserPublicId: string;
+      inviterUserId: string;
+      inviterUserInternalId: string;
+      inviterUserPublicId: string;
+    } & Amity.Timestamps &
+      Amity.InvitationDomain<Amity.InvitationTargetType>;
+
+    type InternalInvitation = Omit<RawInvitation, 'createdBy'> & {
+      createdById: string;
+    };
+
+    type Invitation = Omit<Amity.InternalInvitation, 'createdBy'> &
+      Amity.InvitationLinkedObject & {
+        user?: Amity.User;
+        createdById: string;
+        createdBy?: Amity.User;
+        target?: Amity.InvitationTarget<Amity.InvitationTargetType>;
+      };
+
+    type QueryInvitations = {
+      targetId: string;
+      statuses?: string[];
+      token?: Amity.Token;
+      type: Amity.InvitationType;
+      sortBy?: Amity.InvitationSortBy;
+      limit?: Amity.PageLimit['limit'];
+      targetType: Amity.InvitationTargetType;
+    };
+
+    type InvitationLiveCollection = Amity.LiveCollectionParams<Omit<QueryInvitations, 'limit'>>;
+
+    type InvitationLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.InternalInvitation['_id'],
+      Pick<QueryInvitations, 'limit'>
+    >;
+
+    type QueryMyInvitations = {
+      targetId?: string;
+      token?: Amity.Token;
+      type?: Amity.InvitationType;
+      sortBy?: Amity.InvitationSortBy;
+      limit?: Amity.PageLimit['limit'];
+      statuses?: InvitationStatusEnum[];
+      targetType?: Amity.InvitationTargetType;
+    };
+
+    type MyInvitationsLiveCollection = Amity.LiveCollectionParams<
+      Omit<QueryMyInvitations, 'limit'>
+    >;
+
+    type MyInvitationsLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.InternalInvitation['_id'],
+      Pick<QueryMyInvitations, 'limit'>
+    >;
+
+    type InvitationLinkedObject = {
+      accept: () => Promise<void>;
+      reject: () => Promise<void>;
+    };
+
+    type CreateInvitations = {
+      type: Amity.InvitationType;
+      targetType: Amity.InvitationTargetType;
+      targetId: string;
+      userIds: string[];
+    };
+  }
+}

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

@@ -0,0 +1,66 @@
+export {};
+
+export const enum JoinRequestStatusEnum {
+  Pending = 'pending',
+  Approved = 'approved',
+  Rejected = 'rejected',
+  Cancelled = 'cancelled',
+}
+
+export const enum JoinResultStatusEnum {
+  Success = 'success',
+  Pending = 'pending',
+}
+
+declare global {
+  namespace Amity {
+    type JoinRequestStatus = JoinRequestStatusEnum;
+
+    type JoinResultStatus = JoinResultStatusEnum;
+
+    type JoinRequestType = 'communityJoinRequest';
+
+    type JoinResult = {
+      status: Amity.JoinResultStatus;
+      request?: Amity.JoinRequest;
+    };
+
+    type RawJoinRequest = {
+      _id: string;
+      createdAt: Amity.timestamp;
+      joinRequestId: string;
+      networkId: string;
+
+      requestorId: string;
+      requestorInternalId: string;
+      requestorPublicId: string;
+
+      respondedAt: Amity.timestamp | null;
+      responderId: string | null;
+      responderInternalId: string | null;
+      responderPublicId: string | null;
+
+      status: Amity.JoinRequestStatus;
+      targetId: string;
+      targetType: string;
+      type: Amity.JoinRequestType;
+      updatedAt: Amity.timestamp;
+      userId: string;
+    };
+
+    type InternalJoinRequest = Omit<RawJoinRequest, '_id'>;
+
+    type JoinRequest = Omit<Amity.InternalJoinRequest, 'responderId'> &
+      Amity.JoinRequestLinkedObject & {
+        user?: Amity.User;
+        feeds?: Amity.Feed[];
+        files?: Amity.File[];
+      };
+
+    type JoinRequestLinkedObject = {
+      cancel: () => Promise<void>;
+      approve: () => Promise<void>;
+      reject: () => Promise<void>;
+    };
+  }
+}

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

@@ -10,6 +10,7 @@ declare global {
       POST_REACT = 'reaction_on_post',
       COMMENT_REACT = 'reaction_on_comment',
       REPLY_REACT = 'reaction_on_reply',
+      RESPONSE_JOIN_REQUEST = 'respond_on_join_request',
     }
 
     const enum TrayAction {
@@ -19,6 +20,7 @@ declare global {
       REACTION = 'reaction',
       MENTION = 'mention',
       REPLY = 'reply',
+      JOIN_REQUEST = 'join_request',
     }
 
     type RawNotificationTrayItem = {

package/src/@types/index.ts

@@ -38,3 +38,6 @@ export * from './domains/post';
 export * from './domains/story';
 export * from './domains/ad';
 export * from './domains/notification';
+export * from './domains/client';
+export * from './domains/invitation';
+export * from './domains/joinRequest';

package/src/channelRepository/observers/getChannel.ts

@@ -297,7 +297,17 @@ export const getChannel = (
       ),
       convertEventPayload(onSubChannelCreated, 'channelId', 'channel'),
       convertEventPayload(onChannelUnreadInfoUpdatedLocal, 'channelId', 'channel'),
-      convertEventPayload(onChannelUnreadUpdatedLocal, 'channelId', 'channel'),
+      convertEventPayload(
+        (callback: Amity.Listener<Amity.ChannelUnread>) => {
+          const processPayload = (payloads: Amity.ChannelUnread[]) => {
+            payloads.forEach(callback);
+          };
+
+          return onChannelUnreadUpdatedLocal(processPayload);
+        },
+        'channelId',
+        'channel',
+      ),
     ],
     {
       forceDispatch: true,

package/src/channelRepository/observers/getChannels/ChannelLiveCollectionController.ts

@@ -572,7 +572,16 @@ export class ChannelLiveCollectionController extends LiveCollectionController<
         action: Amity.ChannelActionType.OnUpdate,
       },
       {
-        fn: convertEventPayload(onChannelUnreadUpdatedLocal, 'channelId', 'channel'),
+        fn: convertEventPayload(
+          (callback: Amity.Listener<Amity.ChannelUnread>) => {
+            const processPayload = (payloads: Amity.ChannelUnread[]) => {
+              payloads.forEach(callback);
+            };
+            return onChannelUnreadUpdatedLocal(processPayload);
+          },
+          'channelId',
+          'channel',
+        ),
         action: Amity.ChannelActionType.OnUpdate,
       },
     ];

package/src/channelRepository/observers/getTotalChannelsUnread.ts

@@ -82,7 +82,9 @@ export const getTotalChannelsUnread = (
     });
   };
 
-  const realtimeRouter = (userUnread: Amity.UserUnread) => {
+  const realtimeRouter = (_: Amity.ChannelUnread[]) => {
+    const { data: userUnread } = _getTotalChannelsUnread();
+
     if (isEqual(model, userUnread)) return;
 
     dispatcher({

package/src/channelRepository/utils/prepareChannelPayload.ts

@@ -7,6 +7,7 @@ import { getActiveClient } from '~/client/api/activeClient';
 import { pullFromCache } from '~/cache/api/pullFromCache';
 import { convertRawUserToInternalUser } from '~/userRepository/utils/convertRawUserToInternalUser';
 import { pushToCache } from '~/cache/api';
+import { fireEvent } from '~/core/events';
 
 export const MARKER_INCLUDED_CHANNEL_TYPE = ['broadcast', 'conversation', 'community'];
 export const isUnreadCountSupport = ({ type }: Pick<Amity.RawChannel, 'type'>) =>
@@ -56,6 +57,8 @@ const updateChannelUnread = ({
   channels: Amity.RawChannel[];
   channelUsers: Amity.RawMembership<'channel'>[];
 }) => {
+  const channelsUnread: Amity.ChannelUnread[] = [];
+
   for (let i = 0; i < channels.length; i += 1) {
     const cacheKey = ['channelUnread', 'get', channels[i].channelId];
     const channelUser = channelUsers.find(
@@ -84,9 +87,11 @@ const updateChannelUnread = ({
       isMentioned,
       isDeleted: channels[i].isDeleted || false,
     };
-
     pushToCache(cacheKey, cacheChannelUnread);
+
+    channelsUnread.push(cacheChannelUnread);
   }
+  fireEvent('local.channelUnread.updated', channelsUnread);
 };
 
 export const prepareChannelPayload = async (

package/src/client/utils/ReadReceiptSync/readReceiptSyncEngine.ts

@@ -167,7 +167,7 @@ export class MessageReadReceiptSyncEngine {
       channelUnread.unreadCount = Math.max(channelUnread.lastSegment - segment, 0);
 
       pushToCache(cacheKey, channelUnread);
-      fireEvent('local.channelUnread.updated', channelUnread);
+      fireEvent('local.channelUnread.updated', [channelUnread]);
     }
 
     // Step 2: Enqueue the read receipt

package/src/communityRepository/api/createCommunity.ts

@@ -1,3 +1,4 @@
+import { LinkedObject } from '~/utils/linkedObject';
 import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
@@ -11,7 +12,7 @@ import { prepareCommunityPayload, prepareCommunityRequest } from '../utils';
 /**
  * ```js
  * import { createCommunity } from '@amityco/ts-sdk'
- * const created = await createCommunity({ communityId: 'foobar', displayName: 'foobar' })
+ * const created = await createCommunity({ communityId: 'foobar', displayName: 'foobar', isDiscoverable: true, requiresJoinApproval: false })
  * ```
  *
  * Creates an {@link Amity.Community}
@@ -33,6 +34,8 @@ export const createCommunity = async (
     | 'postSetting'
     | 'tags'
     | 'metadata'
+    | 'isDiscoverable'
+    | 'requiresJoinApproval'
   > &
     Amity.CommunityStorySettings & {
       userIds?: string[];
@@ -60,7 +63,7 @@ export const createCommunity = async (
 
   const { communities } = data;
   return {
-    data: communities[0],
+    data: LinkedObject.community(communities[0]),
     cachedAt,
   };
 };

package/src/communityRepository/api/getCommunities.ts

@@ -5,6 +5,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 
 import { saveCommunityUsers } from '~/communityRepository/utils/saveCommunityUsers';
 import { prepareCommunityPayload } from '../utils';
+import { LinkedObject } from '~/utils/linkedObject';
 
 /**
  * ```js
@@ -22,15 +23,21 @@ import { prepareCommunityPayload } from '../utils';
  */
 export const getCommunities = async (
   communityIds: Amity.Community['communityId'][],
+  includeDiscoverablePrivateCommunity?: boolean,
 ): Promise<Amity.Cached<Amity.Community[]>> => {
   const client = getActiveClient();
   client.log('community/getCommunities', communityIds);
 
+  const encodedCommunityIds = communityIds.map(communityId => encodeURIComponent(communityId));
+
   // API-FIX: endpoint should not be /list, parameters should be querystring.
   const { data: payload } = await client.http.get<Amity.CommunityPayload>(
     `/api/v3/communities/list`,
     {
-      params: { communityIds },
+      params: {
+        communityIds: encodedCommunityIds,
+        includeDiscoverablePrivateCommunity: includeDiscoverablePrivateCommunity ?? true,
+      },
     },
   );
 
@@ -43,7 +50,7 @@ export const getCommunities = async (
   }
 
   return {
-    data: data.communities,
+    data: data.communities.map(community => LinkedObject.community(community)),
     cachedAt,
   };
 };

package/src/communityRepository/api/getCommunity.ts

@@ -5,6 +5,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 
 import { saveCommunityUsers } from '~/communityRepository/utils/saveCommunityUsers';
 import { prepareCommunityPayload } from '../utils';
+import { LinkedObject } from '~/utils/linkedObject';
 
 /**
  * ```js
@@ -22,6 +23,8 @@ import { prepareCommunityPayload } from '../utils';
  */
 export const getCommunity = async (
   communityId: Amity.Community['communityId'],
+  type?: Amity.JoinRequestType,
+  includeDiscoverablePrivateCommunity?: boolean,
 ): Promise<Amity.Cached<Amity.Community>> => {
   const client = getActiveClient();
   client.log('community/getCommunity', communityId);
@@ -29,6 +32,12 @@ export const getCommunity = async (
   // API-FIX: endpoint should not be /list, parameters should be querystring.
   const { data: payload } = await client.http.get<Amity.CommunityPayload>(
     `/api/v3/communities/${communityId}`,
+    {
+      params: {
+        type: 'communityJoinRequest',
+        includeDiscoverablePrivateCommunity: includeDiscoverablePrivateCommunity ?? true,
+      },
+    },
   );
 
   const data = prepareCommunityPayload(payload);
@@ -42,7 +51,9 @@ export const getCommunity = async (
   const { communities } = data;
 
   return {
-    data: communities.find(community => community.communityId === communityId)!,
+    data: LinkedObject.community(
+      communities.find(community => community.communityId === communityId)!,
+    ),
     cachedAt,
   };
 };
@@ -73,7 +84,7 @@ getCommunity.locally = (
   if (!cached) return;
 
   return {
-    data: cached.data,
+    data: LinkedObject.community(cached.data),
     cachedAt: cached.cachedAt,
   };
 };