@amityco/ts-sdk 7.6.1-316d940a.0 → 7.6.1-63bd9d56.0

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

@@ -73,13 +73,6 @@ declare global {
        */
       targetId?: string; // communityId, userId, etc..
       targetType?: string; // 'community', 'user', etc..
-
-      /*
-       * when stream linked with a post and a live channel.
-       */
-      postId?: string;
-      channelId?: string;
-      channelEnabled?: boolean;
     } & Amity.Metadata &
       Amity.Timestamps &
       Amity.SoftDelete;
@@ -88,14 +81,9 @@ declare global {
 
     type StreamLinkedObject = {
       moderation?: Amity.StreamModeration;
-      post?: Amity.InternalPost;
-      getLiveChat: () => Promise<Amity.Channel<'live'> | undefined>;
     };
 
-    type Stream = Omit<Amity.InternalStream & Amity.StreamLinkedObject, 'watcherUrl'> & {
-      isBanned: boolean;
-      watcherUrl: null;
-    };
+    type Stream = Amity.InternalStream & Amity.StreamLinkedObject;
 
     type QueryStreams = {
       isLive?: boolean;

package/src/@types/index.ts

@@ -43,4 +43,3 @@ export * from './domains/invitation';
 export * from './domains/joinRequest';
 export * from './domains/pin';
 export * from './domains/pinnedPost';
-export * from './domains/liveReaction';

package/src/channelRepository/api/createChannel.ts

@@ -1,9 +1,9 @@
-import { getActiveClient } from '~/client/api/activeClient';
+import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
 import { prepareChannelPayload } from '../utils';
-import { constructChannelObject } from '../utils/constructChannelObject';
+import { constructChannelDynamicValue } from '../utils/constructChannelDynamicValue';
 
 /* begin_public_function
   id: channel.create
@@ -23,14 +23,11 @@ import { constructChannelObject } from '../utils/constructChannelObject';
  * @async
  */
 export const createChannel = async <T extends Amity.ChannelType>(
-  bundle: {
-    type: T;
-    userIds?: Amity.InternalUser['userId'][];
-    // For live channel linked with a livestream post
-    videoStreamId?: string;
-    postId?: string;
-  } & Pick<Amity.Channel<T>, 'displayName' | 'avatarFileId' | 'tags' | 'metadata' | 'isPublic'>,
-): Promise<Amity.Cached<Amity.Channel<T>>> => {
+  bundle: { type: T; userIds?: Amity.InternalUser['userId'][] } & Pick<
+    Amity.Channel<T>,
+    'displayName' | 'avatarFileId' | 'tags' | 'metadata' | 'isPublic'
+  >,
+): Promise<Amity.Cached<Amity.InternalChannel>> => {
   const client = getActiveClient();
   client.log('user/createChannel', bundle);
 
@@ -56,7 +53,7 @@ export const createChannel = async <T extends Amity.ChannelType>(
 
   const { channels } = data;
   return {
-    data: constructChannelObject(channels[0]),
+    data: constructChannelDynamicValue(channels[0]),
     cachedAt,
   };
 };

package/src/channelRepository/channelMembership/observers/getMembers/ChannelMemberLiveCollectionController.ts

@@ -24,7 +24,6 @@ import {
 import { prepareChannelPayload } from '~/channelRepository/utils';
 import { onUserDeleted } from '~/channelRepository/events/onUserDeleted';
 import { LinkedObject } from '~/utils/linkedObject';
-import { onChannelSetUserMuted } from '~/channelRepository/events/onChannelSetUserMuted';
 
 export class ChannelMemberLiveCollectionController extends LiveCollectionController<
   'channelUser',
@@ -90,7 +89,6 @@ export class ChannelMemberLiveCollectionController extends LiveCollectionControl
       { fn: onChannelMemberUnbanned, action: 'onChannelMemberUnbanned' },
       { fn: onChannelMemberRoleAdded, action: 'onChannelMemberRoleAdded' },
       { fn: onChannelMemberRoleRemoved, action: 'onChannelMemberRoleRemoved' },
-      { fn: onChannelSetUserMuted, action: 'onChannelSetUserMuted' },
       { fn: onUserDeleted(this.query.channelId), action: 'onChannelMemberChanged' },
     ]);
   }

package/src/channelRepository/events/index.ts

@@ -4,7 +4,7 @@ export * from './onChannelDeleted';
 
 export * from './onChannelJoined';
 export * from './onChannelLeft';
-export * from './onChannelSetMuted';
+export * from './onChannelMuted';
 
 export * from './onChannelMemberAdded';
 export * from './onChannelMemberRemoved';

package/src/channelRepository/events/onChannelMuted.ts

@@ -0,0 +1,39 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '../utils';
+import { constructChannelDynamicValue } from '../utils/constructChannelDynamicValue';
+
+type CallbackFn = Amity.Listener<Amity.StaticInternalChannel>;
+const callbacks: CallbackFn[] = [];
+let mainDisposer: (() => void) | null = null;
+
+const dispose = (cb: CallbackFn) => {
+  const index = callbacks.indexOf(cb);
+  if (index > -1) {
+    callbacks.splice(index, 1);
+  }
+  if (callbacks.length === 0) {
+    mainDisposer?.();
+  }
+};
+
+export const onChannelMuted = (callback: Amity.Listener<Amity.StaticInternalChannel>) => {
+  if (callbacks.length === 0) {
+    const client = getActiveClient();
+
+    const filter = async (payload: Amity.ChannelPayload) => {
+      const data = await prepareChannelPayload(payload);
+
+      ingestInCache(data);
+      callbacks.forEach(cb => cb(data.channels[0]));
+    };
+
+    mainDisposer = createEventSubscriber(client, 'onChannelMuted', 'channel.setMuted', filter);
+  }
+
+  callbacks.push(callback);
+  return () => dispose(callback);
+};

package/src/channelRepository/internalApi/getChannel.ts

@@ -9,6 +9,7 @@ import { pushToTombstone } from '~/cache/api/pushToTombstone';
 
 import { prepareChannelPayload } from '../utils';
 import { prepareUnreadCountInfo } from '../utils/prepareUnreadCountInfo';
+import { constructChannelDynamicValue } from '../utils/constructChannelDynamicValue';
 
 /**
  * ```js

package/src/channelRepository/observers/getChannel.ts

@@ -10,7 +10,7 @@ import {
   onChannelMemberBanned,
   onChannelMemberRemoved,
   onChannelMemberUnbanned,
-  onChannelSetMuted,
+  onChannelMuted,
   onChannelUpdated,
 } from '../events';
 import { dropFromCache, pullFromCache } from '~/cache/api';
@@ -104,7 +104,7 @@ export const getChannel = (
       onChannelMemberRemoved,
       onChannelMemberBanned,
       onChannelMemberUnbanned,
-      onChannelSetMuted,
+      onChannelMuted,
       convertEventPayload(onChannelMarkerFetched, 'entityId', 'channel'),
       convertEventPayload(onChannelMarkerUpdated, 'entityId', 'channel'),
       convertEventPayload(

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

@@ -11,6 +11,7 @@ import {
   onChannelLeft,
   onChannelMemberAdded,
   onChannelMemberRemoved,
+  onChannelMuted,
   onChannelUpdated,
 } from '~/channelRepository/events';
 import {
@@ -57,7 +58,6 @@ import { onUserMessageFeedMarkerResolved } from '~/marker/events/onUserMessageFe
 import { onChannelUnreadInfoUpdatedLocal } from '~/marker/events/onChannelUnreadInfoUpdatedLocal';
 import { constructChannelObject } from '~/channelRepository/utils/constructChannelObject';
 import { onChannelUnreadUpdatedLocal } from '~/channelRepository/events/onChannelUnreadUpdatedLocal';
-import { onChannelSetMuted } from '~/channelRepository/events/onChannelSetMuted';
 
 export class ChannelLiveCollectionController extends LiveCollectionController<
   'channel',
@@ -313,7 +313,7 @@ export class ChannelLiveCollectionController extends LiveCollectionController<
       },
       { fn: onChannelDeleted, action: Amity.ChannelActionType.OnDelete },
       { fn: onChannelUpdated, action: Amity.ChannelActionType.OnUpdate },
-      { fn: onChannelSetMuted, action: Amity.ChannelActionType.OnMute },
+      { fn: onChannelMuted, action: Amity.ChannelActionType.OnMute },
       {
         fn: (callback: Amity.Listener<Amity.StaticInternalChannel>) => {
           return onChannelJoined(channel => {

package/src/channelRepository/utils/constructChannelObject.ts

@@ -1,6 +1,6 @@
 import { getChannelMessagePreviewWithUser } from '~/messagePreview/utils';
 import { constructChannelDynamicValue } from './constructChannelDynamicValue';
-import { channelLinkedObject } from '~/utils/linkedObject/channelLinkedObject';
+import { LinkedObject } from '~/utils/linkedObject';
 
 export const constructChannelObject = (channel: Amity.StaticInternalChannel): Amity.Channel => {
   /**
@@ -10,7 +10,7 @@ export const constructChannelObject = (channel: Amity.StaticInternalChannel): Am
    * 3. [LinkedObject.channel] add markAsRead >> Amity.InternalChannel -> Amity.Channel
    */
 
-  return channelLinkedObject(
+  return LinkedObject.channel(
     constructChannelDynamicValue(getChannelMessagePreviewWithUser(channel)),
   );
 };

package/src/client/api/login.ts

@@ -13,7 +13,6 @@ import analyticsEngineOnLoginHandler from '~/analytic/utils/analyticsEngineOnLog
 import readReceiptSyncEngineOnLoginHandler from '~/client/utils/ReadReceiptSync/readReceiptSyncEngineOnLoginHandler';
 import legacyReadReceiptSyncEngineOnLoginHandler from '~/client/utils/ReadReceiptSync/legacyReadReceiptSyncEngineOnLoginHandler';
 import objectResolverEngineOnLoginHandler from '~/client/utils/ObjectResolver/objectResolverEngineOnLoginHandler';
-import reactionSyncEngineOnLoginHandler from '~/liveReactionRepository/utils/ReactionSyncEngineOnLoginHandler';
 import { logout } from './logout';
 
 import { getActiveClient } from './activeClient';
@@ -202,7 +201,6 @@ export const login = async (
       markReadEngineOnLoginHandler(),
       analyticsEngineOnLoginHandler(),
       objectResolverEngineOnLoginHandler(),
-      reactionSyncEngineOnLoginHandler(),
     );
 
     if (client.useLegacyUnreadCount) {

package/src/commentRepository/api/deleteComment.ts

@@ -49,6 +49,12 @@ export const deleteComment = async (
   // to support hard deletion
   const deleted = { ...comment.data, isDeleted: true };
 
+  if (permanent) {
+    scheduleTask(() => pushToTombstone('comment', commentId));
+  } else {
+    upsertInCache(['comment', 'get', commentId], { isDeleted: true });
+  }
+
   if (comment.data.referenceType === 'story') {
     const story = await getStoryByStoryId(comment.data.referenceId);
 
@@ -96,12 +102,6 @@ export const deleteComment = async (
     communityUsers: [],
   });
 
-  if (permanent) {
-    scheduleTask(() => pushToTombstone('comment', commentId));
-  } else {
-    upsertInCache(['comment', 'get', commentId], { isDeleted: true });
-  }
-
   return deleted;
 };
 /* end_public_function */

package/src/communityRepository/api/getCommunity.ts

@@ -5,7 +5,6 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 
 import { saveCommunityUsers } from '~/communityRepository/utils/saveCommunityUsers';
 import { prepareCommunityPayload } from '../utils';
-import { LinkedObject } from '~/utils/linkedObject';
 
 /**
  * ```js
@@ -23,8 +22,6 @@ import { LinkedObject } from '~/utils/linkedObject';
  */
 export const getCommunity = async (
   communityId: Amity.Community['communityId'],
-  type?: Amity.JoinRequestType,
-  includeDiscoverablePrivateCommunity?: boolean,
 ): Promise<Amity.Cached<Amity.InternalCommunity>> => {
   const client = getActiveClient();
   client.log('community/getCommunity', communityId);
@@ -32,12 +29,6 @@ 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);

package/src/core/events.ts

@@ -32,10 +32,7 @@ const MQTT_EVENTS = [
   'video-streaming.didFlag',
   'video-streaming.didTerminate',
 
-  'video-streaming.viewerDidBan',
-  'video-streaming.viewerDidUnban',
-
-  'liveReaction.created',
+  // 'user.didGlobalBan' remove due to message event,
 ] as const;
 
 /** @hidden */

package/src/core/model/index.ts

@@ -61,7 +61,8 @@ export const PAYLOAD2MODEL: Record<string, Amity.Domain> = {
 
 /** hidden */
 export const isOutdated = <T extends Amity.UpdatedAt>(prevData: T, nextData: T): boolean => {
-  if ('updatedAt' in nextData && 'updatedAt' in nextData) {
+  // Check if the new value is outdated.
+  if ('updatedAt' in nextData && 'updatedAt' in prevData) {
     return new Date(nextData.updatedAt!) < new Date(prevData.updatedAt!);
   }
 

package/src/core/subscription.ts

@@ -154,16 +154,6 @@ export const getSmartFeedMessageTopic = (): string => {
   return `${getNetworkId(user)}/smartfeed/${user._id}/messages`;
 };
 
-export const getLiveStreamTopic = (): string => {
-  const user = getActiveUser();
-
-  return `${getNetworkId(user)}/videostreaming`;
-};
-
-export const getLiveReactionTopic = (post: Amity.Post) => {
-  return `${post.path}/liveReaction`;
-};
-
 let mqttAccessToken: string;
 let mqttUserId: string;
 
@@ -178,3 +168,9 @@ export function subscribeTopic(
 
   return mqtt.subscribe(topic, callback);
 }
+
+export const getLiveStreamTopic = (): string => {
+  const user = getActiveUser();
+
+  return `${getNetworkId(user)}/videostreaming`;
+};

package/src/feedRepository/api/index.ts

@@ -1,2 +1 @@
 export * from './queryGlobalFeed';
-export * from './getCustomRankingGlobalFeed';

package/src/feedRepository/api/queryGlobalFeed.ts

@@ -11,6 +11,9 @@ import { prepareCommunityPayload } from '~/communityRepository/utils';
   id: feed.query.global_feed
 */
 /**
+ *
+ * @deprecated This function will to be deprecated. Please use getGlobalFeed instead.
+ *
  * ```js
  * import { queryGlobalFeed } from '@amityco/ts-sdk'
  * const posts = await queryGlobalFeed()
@@ -32,7 +35,7 @@ export const queryGlobalFeed = async (
   const client = getActiveClient();
   client.log('feed/queryGlobalFeed', query);
 
-  const { queryToken, ...params } = query ?? {};
+  const { queryToken, dataTypes, resolveParent, ...params } = query ?? {};
 
   const options = (() => {
     if (queryToken) return { token: queryToken };
@@ -44,6 +47,8 @@ export const queryGlobalFeed = async (
     {
       params: {
         ...params,
+        dataTypes,
+        resolveParent: resolveParent ?? true,
         options,
       },
     },

package/src/feedRepository/index.ts

@@ -1 +1,2 @@
-export * from './api';
+export { queryGlobalFeed } from './api';
+export { getCustomRankingGlobalFeed, getGlobalFeed } from './observers';

package/src/feedRepository/observers/getCustomRankingGlobalFeed/LiveCollectionController.ts

@@ -0,0 +1,95 @@
+import hash from 'object-hash';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { CustomRankingGlobalFeedPaginationController } from './PaginationController';
+import { CustomRankingGlobalFeedQueryStreamController } from './QueryStreamController';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import { isNonNullable } from '~/utils';
+import { LinkedObject } from '~/utils/linkedObject';
+import { preparePostPayload } from '~/postRepository/utils/payload';
+import { getGlobalFeedSubscriptions } from '../utils';
+
+export class CustomRankingGlobalFeedLiveCollectionController extends LiveCollectionController<
+  'post',
+  Amity.CustomRankingGlobalFeedLiveCollection,
+  Amity.Post,
+  CustomRankingGlobalFeedPaginationController
+> {
+  private queryStreamController: CustomRankingGlobalFeedQueryStreamController;
+
+  private query: Amity.CustomRankingGlobalFeedLiveCollection;
+
+  constructor(
+    query: Amity.CustomRankingGlobalFeedLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.Post>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['customRankingGlobalFeed', 'collection', queryStreamId];
+    const paginationController = new CustomRankingGlobalFeedPaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new CustomRankingGlobalFeedQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      preparePostPayload,
+    );
+
+    this.callback = callback.bind(this);
+    this.loadPage({ initial: true });
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.CustomRankingGlobalFeedLiveCollectionCache>(
+      this.cacheKey,
+    )?.data;
+
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        params: {},
+      });
+    }
+  }
+
+  protected async persistModel(queryPayload: Amity.PostPayload & Amity.Pagination) {
+    await this.queryStreamController.saveToMainDB(queryPayload);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'post'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
+
+  startSubscription() {
+    return this.queryStreamController.subscribeRTE(getGlobalFeedSubscriptions(this.cacheKey));
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.CustomRankingGlobalFeedLiveCollectionCache>(
+      this.cacheKey,
+    )?.data;
+    if (!collection) return;
+
+    const data = (
+      collection.data
+        .map(id => pullFromCache<Amity.InternalPost>(['post', 'get', id])!)
+        .filter(isNonNullable)
+        .map(({ data }) => data) ?? []
+    ).map(LinkedObject.post);
+
+    if (!this.shouldNotify(data) && origin === 'event') return;
+
+    this.callback({
+      onNextPage: () => this.loadPage({ direction: Amity.LiveCollectionPageDirection.NEXT }),
+      data,
+      hasNextPage: !!this.paginationController.getNextToken(),
+      loading,
+      error,
+    });
+  }
+}

package/src/feedRepository/observers/getCustomRankingGlobalFeed/PaginationController.ts

@@ -0,0 +1,25 @@
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+
+export class CustomRankingGlobalFeedPaginationController extends PaginationController<
+  'post',
+  Amity.CustomRankingGlobalFeedLiveCollection
+> {
+  async getRequest(
+    queryParams: Amity.CustomRankingGlobalFeedLiveCollection,
+    token: string | undefined,
+  ) {
+    const { limit, ...params } = queryParams;
+    const options = token ? { token } : { limit };
+
+    const { data: queryResponse } = await this.http.get<Amity.PostPayload & Amity.Pagination>(
+      `/api/v5/me/global-feeds`,
+      {
+        params: {
+          ...params,
+          options,
+        },
+      },
+    );
+    return queryResponse;
+  }
+}

package/src/feedRepository/observers/getCustomRankingGlobalFeed/QueryStreamController.ts

@@ -0,0 +1,101 @@
+import { QueryStreamController } from '~/core/liveCollection/QueryStreamController';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getResolver } from '~/core/model';
+import { getActiveClient } from '~/client';
+import { EnumPostActions } from '~/postRepository/observers/enums';
+
+export class CustomRankingGlobalFeedQueryStreamController extends QueryStreamController<
+  Amity.PostPayload,
+  Amity.CustomRankingGlobalFeedLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (response: Amity.PostPayload) => Amity.ProcessedPostPayload;
+
+  constructor(
+    query: Amity.CustomRankingGlobalFeedLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    preparePayload: (response: Amity.PostPayload) => Amity.ProcessedPostPayload,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.preparePayload = preparePayload;
+  }
+
+  async saveToMainDB(response: Amity.PostPayload) {
+    const processedPayload = await this.preparePayload(response);
+
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    if (client.cache) {
+      ingestInCache(processedPayload, { cachedAt });
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.PostPayload & Partial<Amity.Pagination>,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: response.posts.map(getResolver('post')),
+      });
+    } else {
+      const collection = pullFromCache<Amity.CommunityLiveCollectionCache>(this.cacheKey)?.data;
+
+      const posts = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data: [...new Set([...posts, ...response.posts.map(getResolver('post'))])],
+      });
+    }
+  }
+
+  reactor(action: EnumPostActions) {
+    return (post: Amity.InternalPost) => {
+      const collection = pullFromCache<Amity.CustomRankingGlobalFeedLiveCollectionCache>(
+        this.cacheKey,
+      )?.data;
+
+      if (!collection) return;
+
+      if (post.parentPostId && !collection.data.includes(post.parentPostId)) return;
+
+      // Delete Action
+      if (action === EnumPostActions.OnPostDeleted) {
+        // Parent Post - Remove from collection
+        collection.data = collection.data.filter(postId => postId !== post.postId);
+      }
+
+      if (action === EnumPostActions.OnPostCreated || action === EnumPostActions.OnPostApproved) {
+        // If the query has dataTypes array with value, check if post.dataType is include in the array
+        if (this.query.dataTypes && this.query.dataTypes.length > 0) {
+          if (!this.query.dataTypes.includes(post.dataType)) return;
+        }
+
+        collection.data = [...new Set([post.postId, ...collection.data])];
+      }
+
+      if (action === EnumPostActions.OnPostDeclined) {
+        collection.data = collection.data.filter(postId => postId !== post.postId);
+      }
+
+      pushToCache(this.cacheKey, collection);
+      this.notifyChange({ origin: Amity.LiveDataOrigin.EVENT, loading: false });
+    };
+  }
+
+  subscribeRTE(
+    createSubscriber: {
+      fn: (reactor: (post: Amity.InternalPost) => void) => Amity.Unsubscriber;
+      action: EnumPostActions;
+    }[],
+  ) {
+    return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+  }
+}

package/src/feedRepository/observers/getCustomRankingGlobalFeed.ts

@@ -0,0 +1,56 @@
+import { getActiveClient } from '~/client/api';
+import { dropFromCache } from '~/cache/api';
+
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { CustomRankingGlobalFeedLiveCollectionController } from './getCustomRankingGlobalFeed/LiveCollectionController';
+
+/* begin_public_function
+  id: feed.query.custom_ranking_feed
+*/
+/**
+ * ```js
+ * import { FeedRepository } from '@amityco/ts-sdk'
+ *
+ * let posts = []
+ * const unsub = FeedRepository.getGlobalFeed({
+ *   dataTypes: ['video','image'],
+ *   resolveParent: true,
+ * }, response => processResponse(response))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Post} for a given target object
+ *
+ * @param params.dataTypes array of data types for the posts
+ * @param callback the function to call when new data are available
+ * @param config
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the messages
+ *
+ * @category Posts Live Collection
+ */
+export const getCustomRankingGlobalFeed = (
+  params: Amity.CustomRankingGlobalFeedLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Post>,
+  config?: Amity.LiveCollectionConfig,
+): Amity.Unsubscriber => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`getCustomRankingGlobalFeed(tmpid: ${timestamp}) > listen`);
+
+  const liveCollection = new CustomRankingGlobalFeedLiveCollectionController(params, callback);
+  const disposers = liveCollection.startSubscription();
+
+  const cacheKey = liveCollection.getCacheKey();
+
+  disposers.push(() => dropFromCache(cacheKey));
+
+  return () => {
+    log(`getCustomRankingGlobalFeed(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};
+/* end_public_function */