@amityco/ts-sdk 7.10.1-86aa7706.0 → 7.10.1-9fe9d33d.0

package/src/storyRepository/observers/getActiveStoriesByTarget.ts

@@ -0,0 +1,242 @@
+import { getActiveClient } from '~/client';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { dropFromCache, pullFromCache, pushToCache, queryCache } from '~/cache/api';
+import {
+  createQuery,
+  runQuery,
+  sortByFirstCreated,
+  sortByFirstUpdated,
+  sortByLastCreated,
+  sortByLastUpdated,
+} from '~/core/query';
+import { getResolver } from '~/core/model';
+import { LinkedObject } from '~/utils/linkedObject';
+import { onStoryUpdated, onStoryUpdatedLocal } from '~/storyRepository/events/onStoryUpdated';
+import {
+  onStoryReactionAdded,
+  onStoryReactionAddedLocal,
+} from '~/storyRepository/events/onStoryReactionAdded';
+import {
+  onStoryReactionRemoved,
+  onStoryReactionRemovedLocal,
+} from '~/storyRepository/events/onStoryReactionRemoved';
+import { getStoryCache } from '../utils/getStoryCache';
+import { getActiveStoriesByTarget as _getActiveStoriesByTarget } from '../internalApi/getActiveStoriesByTarget';
+import { onStoryCreated, onStoryCreatedLocal } from '../events/onStoryCreated';
+import { onStoryDeleted, onStoryDeletedLocal } from '../events/onStoryDeleted';
+import { onStoryError } from '../events/onStoryError';
+import { onStoryLocalDataUpdated } from '../events/onStoryLocalDataUpdated';
+import { STORY_KEY_CACHE } from '../constants';
+
+/**
+ * ```js
+ * import { StoryRepository } from '@amityco/js-sdk';
+ * let storiesData;
+ *
+ * const unsubscribe = StoryRepository.getActiveStoriesByTarget({ targetId, targetType }, response => {
+ *  storiesData = response.data;
+ * });
+ *
+ * unsubscribe();
+ * ```
+ *
+ * Observe all mutations on a given {@link Amity.Story}
+ *
+ * @param params for querying stories from a community
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the story
+ *
+ * @category SubChannel Live Object
+ */
+export const getActiveStoriesByTarget = (
+  params: Amity.GetStoriesByTargetParam,
+  callback: Amity.LiveCollectionCallback<Amity.Story | undefined>,
+) => {
+  const { log, cache } = getActiveClient();
+
+  const disposers: Amity.Unsubscriber[] = [];
+  const cacheKey = ['story-target', 'collection', params];
+
+  const timestamp = Date.now();
+  log(`getActiveStoriesByTarget(tmpid: ${timestamp}) > listen`);
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const storySorting = (story: Amity.Story[]): Amity.Story[] => {
+    const sortBy = params.options?.sortBy || 'createdAt';
+    const orderBy = params.options?.orderBy || 'desc';
+
+    if (story.length === 0) return [];
+
+    if (sortBy === 'createdAt') {
+      return orderBy === 'asc' ? story.sort(sortByFirstCreated) : story.sort(sortByLastCreated);
+    }
+
+    return orderBy === 'asc' ? story.sort(sortByFirstUpdated) : story.sort(sortByLastUpdated);
+  };
+
+  const responder = (snapshot: Amity.StoryLiveCollectionCache) => {
+    const stories = snapshot.data
+      .map(referenceId => {
+        const story = getStoryCache(referenceId);
+        if (!story?.data) return undefined;
+        return LinkedObject.story(story.data);
+      })
+      .filter(Boolean)
+      // Remove all deleted stories
+      .filter(item => {
+        if (!item) return false;
+        return !item.isDeleted;
+      });
+
+    const newStoryList: Amity.Story[] = [];
+
+    if (stories.length > 0) {
+      const storiesBySyncState = stories.reduce((acc, story) => {
+        if (!story) return acc;
+        const { syncState } = story;
+
+        if (!syncState) return acc;
+
+        let currentValue = acc.get(syncState);
+
+        if (!currentValue) {
+          currentValue = [];
+        }
+
+        currentValue.push(story);
+
+        acc.set(syncState, currentValue);
+        return acc;
+      }, new Map<Amity.SyncState, Amity.Story[]>());
+
+      if (storiesBySyncState.has(Amity.SyncState.Error)) {
+        const errorStories = storySorting(storiesBySyncState.get(Amity.SyncState.Error) || []);
+        newStoryList.push(...errorStories);
+      }
+
+      if (storiesBySyncState.has(Amity.SyncState.Syncing)) {
+        const syncingStories = storySorting(storiesBySyncState.get(Amity.SyncState.Syncing) || []);
+        newStoryList.push(...syncingStories);
+      }
+
+      if (storiesBySyncState.has(Amity.SyncState.Synced)) {
+        const syncedStories = storySorting(storiesBySyncState.get(Amity.SyncState.Synced) || []);
+        newStoryList.push(...syncedStories);
+      }
+    }
+
+    callback({
+      onNextPage: () => false,
+      data: newStoryList || stories,
+      hasNextPage: !!snapshot.params?.page,
+      loading: snapshot.loading || false,
+    });
+  };
+
+  const processNewData = (
+    result: Amity.InternalStory[] | undefined,
+    event: string,
+    initial = false,
+    loading = false,
+    error = false,
+  ) => {
+    const cached = pullFromCache<Amity.InternalStory['referenceId'][]>(cacheKey);
+
+    const data: Amity.StoryLiveCollectionCache = {
+      loading,
+      error,
+      params: { page: undefined },
+      data: cached?.data || [],
+    };
+
+    if (result) {
+      if (event === Amity.StoryActionType.OnDelete) {
+        const deletedIds = result.map(({ referenceId }) => referenceId);
+        data.data = data.data.filter(refId => !deletedIds.includes(refId!)) || [];
+      } else {
+        data.data = initial
+          ? result.map(getResolver('story'))
+          : [...new Set([...data.data, ...result.map(getResolver('story'))])];
+      }
+    }
+
+    const unSyncedStories = queryCache<Amity.InternalStory>([STORY_KEY_CACHE.STORY, 'get'])
+      ?.filter(
+        story =>
+          story.data.targetId === params.targetId &&
+          story.data.syncState !== Amity.SyncState.Synced,
+      )
+      .map(story => getResolver('story')(story.data));
+
+    if (unSyncedStories && unSyncedStories?.length > 0) {
+      unSyncedStories.forEach(referenceId => {
+        if (!data.data.includes(referenceId)) data.data.push(referenceId);
+      });
+    }
+
+    pushToCache(cacheKey, data.data);
+
+    responder(data);
+  };
+
+  const realtimeRouter = (event: Amity.StoryActionType) => (story: Amity.InternalStory[]) => {
+    processNewData(story, event);
+  };
+
+  const reloadData = () => (newData: { referenceIds: Amity.Story['referenceId'][] }) => {
+    const cached = pullFromCache<Amity.InternalStory['referenceId'][]>(cacheKey);
+
+    if (!cached) return;
+    if (newData.referenceIds.length === 0 || cached?.data.length === 0) return;
+
+    const shouldUpdate = cached?.data.find(referenceId =>
+      newData.referenceIds.includes(referenceId),
+    );
+
+    if (!shouldUpdate) return;
+
+    const data: Amity.StoryLiveCollectionCache = {
+      loading: false,
+      error: false,
+      params: { page: undefined },
+      data: cached?.data || [],
+    };
+
+    responder(data);
+  };
+
+  const onFetch = (initial: boolean) => {
+    const query = createQuery(_getActiveStoriesByTarget, params);
+
+    runQuery(query, ({ data: result, error, loading }) => {
+      processNewData(result, 'fetch', initial, loading, error);
+    });
+  };
+
+  onFetch(true);
+  disposers.push(
+    onStoryCreated(realtimeRouter(Amity.StoryActionType.OnCreate)),
+    onStoryUpdated(realtimeRouter(Amity.StoryActionType.OnUpdate)),
+    onStoryDeleted(realtimeRouter(Amity.StoryActionType.OnDelete)),
+    onStoryReactionAdded(realtimeRouter(Amity.StoryActionType.OnReactionAdded)),
+    onStoryReactionRemoved(realtimeRouter(Amity.StoryActionType.OnReactionRemoved)),
+    onStoryError(realtimeRouter(Amity.StoryActionType.OnError)),
+
+    onStoryCreatedLocal(realtimeRouter(Amity.StoryActionType.OnCreate)),
+    onStoryUpdatedLocal(realtimeRouter(Amity.StoryActionType.OnUpdate)),
+    onStoryDeletedLocal(realtimeRouter(Amity.StoryActionType.OnDelete)),
+    onStoryReactionAddedLocal(realtimeRouter(Amity.StoryActionType.OnReactionAdded)),
+    onStoryReactionRemovedLocal(realtimeRouter(Amity.StoryActionType.OnReactionRemoved)),
+
+    onStoryLocalDataUpdated(reloadData()),
+    () => dropFromCache(cacheKey),
+  );
+
+  return () => {
+    log(`getActiveStoriesByTarget(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/storyRepository/observers/getGlobalStoryTargets/GlobalStoryLiveCollectionController.ts

@@ -0,0 +1,169 @@
+import hash from 'object-hash';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import { pullFromCache, pushToCache, queryCache } from '~/cache/api';
+import { LinkedObject } from '~/utils/linkedObject';
+import { STORY_KEY_CACHE } from '~/storyRepository/constants';
+import { sortByLocalSortingDate } from '~/core/query';
+import { onStoryCreated, onStoryCreatedLocal } from '~/storyRepository/events/onStoryCreated';
+import { onStoryUpdated, onStoryUpdatedLocal } from '~/storyRepository/events/onStoryUpdated';
+import { onStoryDeleted, onStoryDeletedLocal } from '~/storyRepository/events/onStoryDeleted';
+import { onStoryError } from '~/storyRepository/events/onStoryError';
+import { GlobalStoryQueryStreamController } from './GlobalStoryQueryStreamController';
+import { GlobalStoryPageController } from './GlobalStoryPageController';
+import { prepareCommunityPayload } from '~/communityRepository/utils';
+
+type StoryTargetBySeenState = {
+  seen: Amity.StoryTarget[];
+  unseen: Amity.StoryTarget[];
+  unknown: Amity.StoryTarget[];
+};
+
+export class GlobalStoryLiveCollectionController extends LiveCollectionController<
+  'globalStoryFeed',
+  Amity.StoryGlobalQuery,
+  Amity.StoryTarget,
+  GlobalStoryPageController
+> {
+  private queryStreamController: GlobalStoryQueryStreamController;
+
+  private query: Amity.StoryGlobalQuery;
+
+  constructor(
+    query: Amity.StoryGlobalQuery,
+    callback: Amity.LiveCollectionCallback<Amity.StoryTarget>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = [STORY_KEY_CACHE.STORY_GLOBAL_FEED, 'collection', queryStreamId];
+    const paginationController = new GlobalStoryPageController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+
+    this.queryStreamController = new GlobalStoryQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      paginationController,
+      (data: Amity.GlobalStoryFeedPayload) => {
+        const { feeds, ...rest } = prepareCommunityPayload({ ...data, feeds: [] });
+        return { ...data, ...rest };
+      },
+    );
+
+    this.paginationController = paginationController;
+    this.callback = callback.bind(this);
+    this.loadPage({ initial: true });
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.StoryTargetLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        params: {},
+      });
+    }
+  }
+
+  protected persistModel(response: Amity.GlobalStoryFeedPayload) {
+    this.queryStreamController.saveToMainDB(response);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'globalStoryFeed'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.StoryTargetLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) return;
+
+    const targetIds = collection.data;
+
+    const cachedTargets = queryCache<Amity.RawStoryTarget>([STORY_KEY_CACHE.STORY_TARGET]);
+
+    if (cachedTargets && cachedTargets?.length > 0) {
+      cachedTargets?.forEach(({ key }) => {
+        if (!collection.data.includes(key[2] as string)) targetIds.push(key[2] as string);
+      });
+    }
+
+    let data = targetIds
+      .map(
+        targetId =>
+          pullFromCache<Amity.RawStoryTarget>([STORY_KEY_CACHE.STORY_TARGET, 'get', targetId])!,
+      )
+      .filter(Boolean)
+      .map(storyTarget => LinkedObject.storyTarget(storyTarget.data));
+
+    if (!this.shouldNotify(data) && origin === 'event') return;
+
+    data = this.applyFilter(data)
+      // exclude story targets with invalid stories
+      .filter(({ localSortingDate }) => !!localSortingDate)
+      // Remove internal fields
+      .map(
+        ({ localFilter, localLastExpires, localLastSeen, localSortingDate, ...rest }) => rest,
+      ) as Amity.StoryTarget[];
+
+    this.callback({
+      onNextPage: () => this.loadPage({ direction: Amity.LiveCollectionPageDirection.NEXT }),
+      data,
+      hasNextPage: !!this.paginationController.getNextToken(),
+      loading,
+      error,
+    });
+  }
+
+  private applyFilter(data: Amity.StoryTarget[]): Amity.StoryTarget[] {
+    if (this.query.seenState !== Amity.StorySeenQuery.SMART) {
+      return data
+        .filter(({ hasUnseen }) => {
+          if (this.query.seenState === Amity.StorySeenQuery.ALL) return true;
+          if (this.query.seenState === Amity.StorySeenQuery.SEEN && !hasUnseen) return true;
+          return this.query.seenState === Amity.StorySeenQuery.UNSEEN && hasUnseen;
+        })
+        .sort(sortByLocalSortingDate);
+    }
+
+    // Smart Filter - Apply local sorting on each list of data
+    const result = data.reduce<StoryTargetBySeenState>(
+      (acc, storyTarget) => {
+        if (storyTarget.localFilter === Amity.StorySeenQuery.UNSEEN) {
+          acc.unseen.push(storyTarget);
+        } else if (storyTarget.localFilter === Amity.StorySeenQuery.SEEN) {
+          acc.seen.push(storyTarget);
+        } else {
+          acc.unknown.push(storyTarget);
+        }
+        return acc;
+      },
+      { unseen: [], seen: [], unknown: [] },
+    );
+
+    const sortedUnknown = result.unknown.sort(sortByLocalSortingDate) || [];
+    const sortedUnseen = result.unseen.sort(sortByLocalSortingDate) || [];
+    const sortedSeen = result.seen.sort(sortByLocalSortingDate) || [];
+
+    // Merge all status and remove internal fields
+    return sortedUnknown.concat(sortedUnseen, sortedSeen);
+  }
+
+  startSubscription() {
+    return this.queryStreamController.subscribeRTE([
+      { fn: onStoryCreated, action: Amity.StoryActionType.OnCreate },
+      { fn: onStoryUpdated, action: Amity.StoryActionType.OnUpdate },
+      { fn: onStoryDeleted, action: Amity.StoryActionType.OnDelete },
+
+      { fn: onStoryCreatedLocal, action: Amity.StoryActionType.OnCreate },
+      { fn: onStoryUpdatedLocal, action: Amity.StoryActionType.OnUpdate },
+      { fn: onStoryDeletedLocal, action: Amity.StoryActionType.OnDelete },
+
+      { fn: onStoryError, action: Amity.StoryActionType.OnError },
+    ]);
+  }
+}

package/src/storyRepository/observers/getGlobalStoryTargets/GlobalStoryPageController.ts

@@ -0,0 +1,73 @@
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+
+type GlobalStoryFeedResult = Amity.GlobalStoryFeedPayload & Amity.Pagination;
+
+const mergeResult = (
+  resultA: GlobalStoryFeedResult,
+  resultB: GlobalStoryFeedResult,
+): GlobalStoryFeedResult => {
+  return {
+    categories: resultA.categories.concat(resultB.categories),
+    communities: resultA.communities.concat(resultB.communities),
+    communityUsers: resultA.communityUsers.concat(resultB.communityUsers),
+    files: resultA.files.concat(resultB.files),
+    storyTargets: resultA.storyTargets.concat(resultB.storyTargets),
+    users: resultA.users.concat(resultB.users),
+    paging: resultB.paging,
+  };
+};
+
+const addFlagLocalFilter = (
+  payload: GlobalStoryFeedResult,
+  filter: Amity.StorySeenQuery,
+): GlobalStoryFeedResult => {
+  return {
+    ...payload,
+    storyTargets: payload.storyTargets.map(item => ({ ...item, localFilter: filter })) || [],
+  };
+};
+
+export class GlobalStoryPageController extends PaginationController<
+  'globalStoryFeed',
+  Amity.LiveCollectionParams<Amity.StoryGlobalQuery>
+> {
+  private smartFilterState = Amity.StorySeenQuery.UNSEEN;
+
+  async getRequest(
+    queryParams: Amity.LiveCollectionParams<Amity.StoryGlobalQuery>,
+    token: string | undefined,
+  ) {
+    // Apply default values for parameters
+    const { limit = 10, seenState = Amity.StorySeenQuery.UNSEEN } = queryParams;
+
+    const result = await this.createRequest({
+      seenState: seenState === Amity.StorySeenQuery.SMART ? this.smartFilterState : seenState,
+      limit,
+      token,
+    });
+
+    // Use Early return to reduce condition complexity
+    if (result.paging?.next) return result;
+    if (seenState !== Amity.StorySeenQuery.SMART) return result;
+    if (this.smartFilterState === Amity.StorySeenQuery.SEEN) return result;
+
+    this.smartFilterState = Amity.StorySeenQuery.SEEN;
+    const additionalResult = await this.createRequest({
+      seenState: this.smartFilterState,
+      limit,
+    });
+
+    return mergeResult(result, additionalResult);
+  }
+
+  async createRequest(params: { seenState: Amity.StorySeenQuery; limit: number; token?: string }) {
+    const { data: queryResponse } = await this.http.get<GlobalStoryFeedResult>(
+      '/api/v5/me/global-story-targets',
+      {
+        params,
+      },
+    );
+
+    return addFlagLocalFilter(queryResponse, params.seenState);
+  }
+}

package/src/storyRepository/observers/getGlobalStoryTargets/GlobalStoryQueryStreamController.ts

@@ -0,0 +1,97 @@
+import { QueryStreamController } from '~/core/liveCollection/QueryStreamController';
+import { getActiveClient } from '~/client';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { GlobalStoryPageController } from './GlobalStoryPageController';
+
+const updateLocalList = (cacheKey: string[], targetIds: Amity.StoryTarget['targetId'][]) => {
+  const collection = pullFromCache<Amity.StoryLiveCollectionCache>(cacheKey)?.data;
+  const storyTargets = collection?.data ?? [];
+
+  pushToCache(cacheKey, {
+    ...collection,
+    data: [...new Set([...storyTargets, ...targetIds])],
+  });
+};
+
+export class GlobalStoryQueryStreamController extends QueryStreamController<
+  Amity.GlobalStoryFeedPayload,
+  Amity.LiveCollectionParams<Amity.StoryGlobalQuery>
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (
+    response: Amity.GlobalStoryFeedPayload,
+  ) => Amity.ProcessedGlobalStoryFeed;
+
+  private paginationController: GlobalStoryPageController;
+
+  constructor(
+    query: Amity.LiveCollectionParams<Amity.StoryGlobalQuery>,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    paginationController: GlobalStoryPageController,
+    preparePayload: (response: Amity.GlobalStoryFeedPayload) => Amity.ProcessedGlobalStoryFeed,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.paginationController = paginationController;
+
+    // Fix ESLint, "Expected 'this' to be used by class method"
+    this.preparePayload = preparePayload;
+  }
+
+  saveToMainDB(response: Amity.GlobalStoryFeedPayload) {
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    // Fix Eslint error for "Expected 'this' to be used by class method"
+    const data = this.preparePayload(response);
+
+    if (client.cache) {
+      ingestInCache(data, { cachedAt });
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.GlobalStoryFeedPayload,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: response.storyTargets.map(({ targetId }) => targetId),
+      });
+    } else {
+      updateLocalList(
+        this.cacheKey,
+        response.storyTargets.map(({ targetId }) => targetId),
+      );
+    }
+  }
+
+  reactor(actionType: Amity.StoryActionType) {
+    return (payload: Amity.InternalStory[]) => {
+      if (
+        actionType === Amity.StoryActionType.OnCreate &&
+        this.query.seenState !== Amity.StorySeenQuery.SEEN
+      ) {
+        updateLocalList(
+          this.cacheKey,
+          payload.map(({ targetId }) => targetId),
+        );
+      }
+
+      this.notifyChange({ origin: Amity.LiveDataOrigin.EVENT, loading: false });
+    };
+  }
+
+  subscribeRTE(
+    createSubscriber: {
+      fn: (reactor: Amity.Listener<Amity.InternalStory[]>) => Amity.Unsubscriber;
+      action: Amity.StoryActionType;
+    }[],
+  ) {
+    return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+  }
+}

package/src/storyRepository/observers/getGlobalStoryTargets/getGlobalStoryTargets.ts

@@ -0,0 +1,32 @@
+import { getActiveClient } from '~/client';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { dropFromCache } from '~/cache/api';
+import { GlobalStoryLiveCollectionController } from './GlobalStoryLiveCollectionController';
+
+export const getGlobalStoryTargets = (
+  params: Amity.LiveCollectionParams<Amity.StoryGlobalQuery>,
+  callback: Amity.LiveCollectionCallback<Amity.StoryTarget>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache, userId } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`getGlobalStoryTarget(tmpid: ${timestamp}) > listen`);
+
+  const storyLiveCollection = new GlobalStoryLiveCollectionController(params, callback);
+  const disposers = storyLiveCollection.startSubscription();
+  const cacheKey = storyLiveCollection.getCacheKey();
+
+  disposers.push(() => {
+    dropFromCache(cacheKey);
+  });
+
+  return () => {
+    log(`getGlobalStoryTarget(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/storyRepository/observers/getGlobalStoryTargets/index.ts

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