@amityco/ts-sdk 7.7.1-47be9e51.0 → 7.7.1-4fc282b6.0

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/QueryStreamController.ts

@@ -1,119 +0,0 @@
-import { getResolver } from '~/core/model';
-import { getActiveClient } from '~/client';
-import { pullFromCache, pushToCache } from '~/cache/api';
-import { ingestInCache } from '~/cache/api/ingestInCache';
-import { EnumPostActions } from '~/postRepository/observers/enums';
-import { QueryStreamController } from '~/core/liveCollection/QueryStreamController';
-
-export class UserFeedQueryStreamController extends QueryStreamController<
-  Amity.PostPayload,
-  Amity.UserFeedLiveCollection
-> {
-  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
-
-  private preparePayload: (response: Amity.PostPayload) => Amity.ProcessedPostPayload;
-
-  constructor(
-    query: Amity.UserFeedLiveCollection,
-    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.UserFeedLiveCollectionCache>(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.UserFeedLiveCollectionCache>(this.cacheKey)?.data;
-
-      if (!collection) return;
-
-      // if the collection is parent post collection and
-      // post is not included in the collection or post is child post
-      if (
-        (!this.query.dataTypes || this.query.dataTypes.length === 0) &&
-        !collection.data.includes(post.parentPostId ? post.parentPostId : post.postId)
-      )
-        return;
-
-      if (action === EnumPostActions.OnPostDeleted) {
-        collection.data = collection.data.filter(postId => postId !== post.postId);
-      }
-
-      if (post.parentPostId && post.isDeleted) {
-        const parentPost = pullFromCache<Amity.InternalPost>([
-          'post',
-          'get',
-          post.parentPostId,
-        ])?.data;
-
-        if (!parentPost) return;
-
-        parentPost.children = parentPost.children.filter(childId => childId !== post.postId);
-        pushToCache(['post', 'get', parentPost.postId], parentPost);
-      }
-
-      if (action === EnumPostActions.OnPostDeclined) {
-        collection.data = collection.data.filter(postId => postId !== post.postId);
-      }
-
-      if (action === EnumPostActions.OnPostCreated || action === EnumPostActions.OnPostApproved) {
-        if (
-          this.query.dataTypes &&
-          this.query.dataTypes.length > 0 &&
-          !this.query.dataTypes.includes(post.dataType)
-        ) {
-          return;
-        }
-
-        collection.data = [...new Set([post.postId, ...collection.data])];
-      }
-
-      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/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 */

package/src/feedRepository/observers/index.ts

@@ -1 +0,0 @@
-export * from './getUserFeed';