@amityco/ts-sdk 7.8.1-5d16a58a.0 → 7.8.1-81d2bbf3.0

package/src/feedRepository/api/getCustomRankingGlobalFeed.ts

@@ -1,115 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient';
-import { ingestInCache } from '~/cache/api/ingestInCache';
-import { pullFromCache, pushToCache } from '~/cache/api';
-import { getResolver } from '~/core/model';
-import { prepareMembershipPayload } from '~/group/utils';
-import { LinkedObject } from '~/utils/linkedObject';
-
-/* begin_public_function
-  id: feed.query.custom_ranking_feed
-*/
-/**
- * ```js
- * import { FeedRepository } from '@amityco/ts-sdk'
- * const posts = await FeedRepository.getCustomRankingGlobalFeed()
- * ```
- *
- * Queries a paginable list of {@link Amity.Post} objects
- *
- * @param query The query parameters
- * @returns A page of {@link Amity.Post} objects
- *
- * @category Feed API
- * @async
- * */
-export const getCustomRankingGlobalFeed = async (query?: {
-  dataTypes?: ('video' | 'image' | 'file' | 'liveStream' | 'clip')[];
-  limit?: number;
-  queryToken?: string;
-}): Promise<
-  Omit<Amity.Cached<Amity.Paged<Amity.Post>> & Amity.Pagination, 'nextPage' | 'prevPage'>
-> => {
-  const client = getActiveClient();
-  client.log('feed/getCustomRankingGlobalFeed', query);
-
-  const { queryToken, limit, ...params } = query ?? {};
-
-  const options = (() => {
-    if (queryToken) return { token: queryToken };
-    return undefined;
-  })();
-
-  const { data: queryPayload } = await client.http.get<Amity.PostPayload & Amity.Pagination>(
-    `/api/v5/me/global-feeds`,
-    {
-      params: {
-        ...params,
-        limit: !queryToken ? limit : undefined,
-        options,
-      },
-    },
-  );
-
-  const { paging, ...payload } = queryPayload;
-
-  const data = prepareMembershipPayload(payload, 'communityUsers');
-
-  const { posts } = data;
-
-  const cachedAt = client.cache && Date.now();
-
-  if (client.cache) {
-    ingestInCache(data);
-
-    const cacheKey = ['customGlobalFeed', 'query', { ...params, options } as Amity.Serializable];
-    pushToCache(cacheKey, { posts: posts.map(getResolver('post')), paging });
-  }
-
-  return { data: posts.map(LinkedObject.post), cachedAt, paging };
-};
-/* end_public_function */
-
-/**
- * ```js
- * import { FeedRepository } from '@amityco/ts-sdk'
- * const posts = await FeedRepository.getCustomRankingGlobalFeed.locally()
- * ```
- *
- * Queries a paginable list of {@link Amity.Post} objects from cache
- *
- * @param query The query parameters
- * @returns A page of {@link Amity.Post} objects
- *
- * @category Feed API
- * @async
- * */
-getCustomRankingGlobalFeed.locally = (
-  query?: Parameters<typeof getCustomRankingGlobalFeed>[0],
-):
-  | Omit<Amity.Cached<Amity.Paged<Amity.Post>> & Amity.Pagination, 'nextPage' | 'prevPage'>
-  | undefined => {
-  const client = getActiveClient();
-  client.log('post/getCustomRankingGlobalFeed.locally', query);
-
-  if (!client.cache) return;
-
-  const { ...params } = query ?? {};
-
-  const queryKey = ['customGlobalFeed', 'query', { ...params } as Amity.Serializable];
-
-  const { data, cachedAt } =
-    pullFromCache<{ posts: Amity.Post['postId'][] } & Amity.Pagination>(queryKey) ?? {};
-
-  if (!data?.posts.length) return;
-
-  const posts: Amity.InternalPost[] = data.posts
-    .map(postId => pullFromCache<Amity.InternalPost>(['post', 'get', postId])!)
-    .filter(Boolean)
-    .map(({ data }) => data);
-
-  const { paging } = data;
-
-  return posts.length === data?.posts?.length
-    ? { data: posts.map(LinkedObject.post), cachedAt, paging }
-    : undefined;
-};

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

@@ -1,192 +0,0 @@
-import hash from 'object-hash';
-import { pullFromCache, pushToCache } from '~/cache/api';
-import { UserFeedPaginationController } from './PaginationController';
-import { UserFeedQueryStreamController } from './QueryStreamController';
-import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
-import {
-  onPostCreated,
-  onPostUpdated,
-  onPostDeleted,
-  onPostFlagged,
-  onPostUnflagged,
-  onPostReactionAdded,
-  onPostReactionRemoved,
-  onPostApproved,
-  onPostDeclined,
-} from '~/postRepository/events';
-import {
-  filterByPostDataTypes,
-  filterByPropEquality,
-  sortByFirstCreated,
-  sortByLastCreated,
-} from '~/core/query';
-import { isNonNullable } from '~/utils';
-import { EnumPostActions } from '~/postRepository/observers/enums';
-import { LinkedObject } from '~/utils/linkedObject';
-import { preparePostPayload } from '~/postRepository/utils/payload';
-import { convertEventPayload } from '~/utils/event';
-import { onCommentCreated, onCommentDeleted } from '~/commentRepository';
-import { getPost } from '~/postRepository/internalApi/getPost';
-import { onPostUpdatedLocal } from '~/postRepository/events/onPostUpdatedLocal';
-import { onLocalPostReactionAdded } from '~/postRepository/events/onLocalPostReactionAdded';
-import { onLocalPostReactionRemoved } from '~/postRepository/events/onLocalPostReactionRemoved';
-import { onLocalPostDeleted } from '~/postRepository/events/onLocalPostDeleted';
-
-export class UserFeedLiveCollectionController extends LiveCollectionController<
-  'post',
-  Amity.UserFeedLiveCollection,
-  Amity.Post,
-  UserFeedPaginationController
-> {
-  private queryStreamController: UserFeedQueryStreamController;
-
-  private query: Amity.UserFeedLiveCollection;
-
-  constructor(
-    query: Amity.UserFeedLiveCollection,
-    callback: Amity.LiveCollectionCallback<Amity.Post>,
-  ) {
-    const queryStreamId = hash(query);
-    const cacheKey = ['userFeed', 'collection', queryStreamId];
-    const paginationController = new UserFeedPaginationController(query);
-
-    super(paginationController, queryStreamId, cacheKey, callback);
-
-    this.query = query;
-    this.queryStreamController = new UserFeedQueryStreamController(
-      this.query,
-      this.cacheKey,
-      this.notifyChange.bind(this),
-      preparePostPayload,
-    );
-
-    this.callback = callback.bind(this);
-    this.loadPage({ initial: true });
-  }
-
-  protected setup() {
-    const collection = pullFromCache<Amity.UserFeedLiveCollectionCache>(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([
-      { fn: onPostCreated, action: EnumPostActions.OnPostCreated },
-      { fn: onPostUpdated, action: EnumPostActions.OnPostUpdated },
-      { fn: onPostUpdatedLocal, action: EnumPostActions.OnPostUpdated },
-      { fn: onPostDeleted, action: EnumPostActions.OnPostDeleted },
-      { fn: onPostFlagged, action: EnumPostActions.OnPostFlagged },
-      { fn: onPostUnflagged, action: EnumPostActions.OnPostUnflagged },
-      { fn: onPostApproved, action: EnumPostActions.OnPostApproved },
-      { fn: onPostDeclined, action: EnumPostActions.OnPostDeclined },
-      { fn: onPostReactionAdded, action: EnumPostActions.OnPostReactionAdded },
-      { fn: onPostReactionRemoved, action: EnumPostActions.OnPostReactionRemoved },
-      { fn: onLocalPostReactionAdded, action: EnumPostActions.OnPostReactionAdded },
-      { fn: onLocalPostReactionRemoved, action: EnumPostActions.OnPostReactionRemoved },
-      { fn: onLocalPostDeleted, action: EnumPostActions.OnPostDeleted },
-      {
-        fn: convertEventPayload(
-          (callback: Amity.Listener<Amity.InternalComment>) => {
-            return onCommentCreated(async (comment: Amity.InternalComment) => {
-              const currentCollection = pullFromCache<Amity.UserFeedLiveCollectionCache>(
-                this.cacheKey,
-              )?.data;
-
-              if (!currentCollection || currentCollection.data.includes(comment.referenceId))
-                return;
-
-              await getPost(comment.referenceId);
-              callback(comment);
-            });
-          },
-          'referenceId',
-          'post',
-        ),
-        action: EnumPostActions.OnPostUpdated,
-      },
-      {
-        fn: convertEventPayload(
-          (callback: Amity.Listener<Amity.InternalComment>) => {
-            return onCommentDeleted(async (comment: Amity.InternalComment) => {
-              const currentCollection = pullFromCache<Amity.UserFeedLiveCollectionCache>(
-                this.cacheKey,
-              )?.data;
-
-              if (!currentCollection || currentCollection.data.includes(comment.referenceId))
-                return;
-
-              await getPost(comment.referenceId);
-              callback(comment);
-            });
-          },
-          'referenceId',
-          'post',
-        ),
-        action: EnumPostActions.OnPostUpdated,
-      },
-    ]);
-  }
-
-  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
-    const collection = pullFromCache<Amity.UserFeedLiveCollectionCache>(this.cacheKey)?.data;
-    if (!collection) return;
-
-    const data = this.applyFilter(
-      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,
-    });
-  }
-
-  applyFilter(data: Amity.InternalPost[]) {
-    let posts = data;
-
-    if (!this.query.includeDeleted) {
-      posts = filterByPropEquality(posts, 'isDeleted', false);
-    }
-
-    if (this.query.dataTypes?.length) {
-      posts = filterByPostDataTypes(posts, this.query.dataTypes);
-    }
-
-    switch (this.query.sortBy) {
-      case 'firstCreated':
-        posts = posts.sort(sortByFirstCreated);
-        break;
-      case 'lastCreated':
-      default:
-        posts = posts.sort(sortByLastCreated);
-        break;
-    }
-
-    return posts;
-  }
-}

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

@@ -1,37 +0,0 @@
-import { PaginationController } from '~/core/liveCollection/PaginationController';
-import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
-import { inferIsDeleted } from '~/utils/inferIsDeleted';
-
-export class UserFeedPaginationController extends PaginationController<
-  'post',
-  Amity.UserFeedLiveCollection
-> {
-  async getRequest(queryParams: Amity.UserFeedLiveCollection, token: string | undefined) {
-    const {
-      userId,
-      feedSources,
-      dataTypes,
-      includeDeleted,
-      matchingOnlyParentPost,
-      limit = COLLECTION_DEFAULT_PAGINATION_LIMIT,
-      ...params
-    } = queryParams;
-
-    const options = token ? { token } : { limit };
-
-    const { data: queryResponse } = await this.http.get<Amity.PostPayload & Amity.Pagination>(
-      `/api/v4/user-feeds/${userId}`,
-      {
-        params: {
-          ...params,
-          options,
-          dataTypes: dataTypes?.length ? dataTypes : undefined,
-          includePostedFeed: feedSources,
-          isDeleted: inferIsDeleted(includeDeleted),
-          matchingOnlyParentPost: matchingOnlyParentPost ?? !dataTypes?.length,
-        },
-      },
-    );
-    return queryResponse;
-  }
-}

package/src/feedRepository/observers/getUserFeed.ts

@@ -1,56 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient';
-import { dropFromCache } from '~/cache/api/dropFromCache';
-import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
-import { UserFeedLiveCollectionController } from './getUserFeed/LiveCollectionController';
-
-/* begin_public_function
-  id: feed.query.user_feed
-*/
-/**
- * ```js
- * import { FeedRepository } from '@amityco/ts-sdk'
- *
- * let posts = []
- * const unsubscribe = FeedRepository.getUserFeed({
- *   userId: string,
- *   feedSources: ['user', 'community'],
- * }, response => response => processResponse(response))
- * ```
- *
- * Observe all mutations on a list of {@link Amity.Post} for a given user and feedSources
- *
- * @param params.userId the ID of the user
- * @param params.feedSources the sources of the feed
- * @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 getUserFeed = (
-  params: Amity.UserFeedLiveCollection,
-  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(`getUserFeed(tmpid: ${timestamp}) > listen`);
-
-  const userFeedLiveCollection = new UserFeedLiveCollectionController(params, callback);
-  const disposers = userFeedLiveCollection.startSubscription();
-
-  const cacheKey = userFeedLiveCollection.getCacheKey();
-
-  disposers.push(() => dropFromCache(cacheKey));
-
-  return () => {
-    log(`getUserFeed(tmpid: ${timestamp}) > dispose`);
-    disposers.forEach(fn => fn());
-  };
-};
-/* end_public_function */