@amityco/ts-sdk-react-native 7.8.1-a583f03.0 → 7.8.1

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 */

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

@@ -0,0 +1,91 @@
+import hash from 'object-hash';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { GlobalFeedPaginationController } from './PaginationController';
+import { GlobalFeedQueryStreamController } 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 GlobalFeedLiveCollectionController extends LiveCollectionController<
+  'post',
+  Amity.GlobalFeedLiveCollection,
+  Amity.Post,
+  GlobalFeedPaginationController
+> {
+  private queryStreamController: GlobalFeedQueryStreamController;
+
+  private query: Amity.GlobalFeedLiveCollection;
+
+  constructor(
+    query: Amity.GlobalFeedLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.Post>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['globalFeed', 'collection', queryStreamId];
+    const paginationController = new GlobalFeedPaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new GlobalFeedQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      preparePostPayload,
+    );
+
+    this.callback = callback.bind(this);
+    this.loadPage({ initial: true });
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.GlobalFeedLiveCollectionCache>(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.GlobalFeedLiveCollectionCache>(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/getGlobalFeed/PaginationController.ts

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

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

@@ -0,0 +1,99 @@
+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 GlobalFeedQueryStreamController extends QueryStreamController<
+  Amity.PostPayload,
+  Amity.GlobalFeedLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (response: Amity.PostPayload) => Amity.ProcessedPostPayload;
+
+  constructor(
+    query: Amity.GlobalFeedLiveCollection,
+    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.GlobalFeedLiveCollectionCache>(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/getGlobalFeed.ts

@@ -0,0 +1,56 @@
+import { getActiveClient } from '~/client/api';
+import { dropFromCache } from '~/cache/api';
+
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { GlobalFeedLiveCollectionController } from './getGlobalFeed/LiveCollectionController';
+
+/* begin_public_function
+  id: feed.query.global_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 global feed
+ * @param params.dataTypes array of data types for the posts
+ * @param params.resolveParent
+ * @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 getGlobalFeed = (
+  params: Amity.GlobalFeedLiveCollection,
+  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(`getGlobalFeed(tmpid: ${timestamp}) > listen`);
+
+  const liveCollection = new GlobalFeedLiveCollectionController(params, callback);
+  const disposers = liveCollection.startSubscription();
+
+  const cacheKey = liveCollection.getCacheKey();
+
+  disposers.push(() => dropFromCache(cacheKey));
+
+  return () => {
+    log(`getGlobalFeed(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};
+/* end_public_function */