@amityco/ts-sdk 6.17.3-beac0a2.0 → 6.17.3-e382dbe.0

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,94 @@
+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.GlobalStoryFeedPayload;
+
+  private paginationController: GlobalStoryPageController;
+
+  constructor(
+    query: Amity.LiveCollectionParams<Amity.StoryGlobalQuery>,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    paginationController: GlobalStoryPageController,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.paginationController = paginationController;
+
+    // Fix ESLint, "Expected 'this' to be used by class method"
+    this.preparePayload = payload => payload;
+  }
+
+  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';

package/src/storyRepository/observers/getStoriesByTargetIds/StoryPaginationNoPageController.ts

@@ -1,5 +1,3 @@
-/* eslint-disable no-use-before-define */
-
 import { PaginationNoPageController } from '~/core/liveCollection/PaginationNoPageController';
 
 export class StoryPaginationNoPageController extends PaginationNoPageController<

package/src/storyRepository/observers/index.ts

@@ -3,3 +3,4 @@ export * from './getStoryByStoryId';
 export * from './getTargetById';
 export * from './getTargetsByTargetIds';
 export * from './getStoriesByTargetIds';
+export * from './getGlobalStoryTargets';

package/src/storyRepository/utils/StoryComputedValue.ts

@@ -0,0 +1,144 @@
+import { pullFromCache, queryCache } from '~/cache/api';
+import { STORY_KEY_CACHE } from '~/storyRepository/constants';
+
+export class StoryComputedValue {
+  private readonly _targetId: string;
+
+  private readonly _lastStoryExpiresAt?: Amity.timestamp;
+
+  private readonly _lastStorySeenExpiresAt?: Amity.timestamp;
+
+  private cacheStoryExpireTime?: Amity.Cached<Amity.timestamp>;
+
+  private cacheStoreSeenTime?: Amity.Cached<Amity.timestamp>;
+
+  private _syncingStoriesCount = 0;
+
+  private _syncedStoriesCount = 0;
+
+  private _errorStoriesCount = 0;
+
+  constructor(
+    targetId: string,
+    lastStoryExpiresAt?: Amity.timestamp,
+    lastStorySeenExpiresAt?: Amity.timestamp,
+  ) {
+    this._targetId = targetId;
+
+    this._lastStoryExpiresAt = lastStoryExpiresAt;
+
+    this._lastStorySeenExpiresAt = lastStorySeenExpiresAt;
+
+    this.cacheStoryExpireTime = pullFromCache<Amity.timestamp>([
+      STORY_KEY_CACHE.EXPIRE,
+      this._targetId,
+    ]);
+
+    this.cacheStoreSeenTime = pullFromCache<Amity.timestamp>([
+      STORY_KEY_CACHE.LAST_SEEN,
+      this._targetId,
+    ]);
+
+    this.getTotalStoryByStatus();
+  }
+
+  get lastStoryExpiresAt(): number {
+    return this._lastStoryExpiresAt ? new Date(this._lastStoryExpiresAt).getTime() : 0;
+  }
+
+  get lastStorySeenExpiresAt(): number {
+    return this._lastStorySeenExpiresAt ? new Date(this._lastStorySeenExpiresAt).getTime() : 0;
+  }
+
+  get localLastStoryExpires(): number {
+    return this.cacheStoryExpireTime?.data
+      ? new Date(this.cacheStoryExpireTime?.data).getTime()
+      : 0;
+  }
+
+  get localLastStorySeenExpiresAt(): number {
+    return this.cacheStoreSeenTime?.data ? new Date(this.cacheStoreSeenTime?.data).getTime() : 0;
+  }
+
+  get isContainUnSyncedStory(): boolean {
+    const currentSyncingState = pullFromCache<Amity.SyncState>([
+      STORY_KEY_CACHE.SYNC_STATE,
+      this._targetId,
+    ]);
+
+    if (!currentSyncingState?.data) return false;
+
+    return [Amity.SyncState.Syncing, Amity.SyncState.Error].includes(currentSyncingState.data);
+  }
+
+  getLocalLastSortingDate(): number {
+    if (this.isContainUnSyncedStory) {
+      return this.localLastStoryExpires;
+    }
+
+    return this.lastStoryExpiresAt;
+  }
+
+  getHasUnseenFlag(): boolean {
+    const now = new Date().getTime();
+
+    const highestSeen = Math.max(this.lastStorySeenExpiresAt, this.localLastStorySeenExpiresAt);
+
+    const currentSyncingState = pullFromCache<Amity.SyncState>([
+      STORY_KEY_CACHE.SYNC_STATE,
+      this._targetId,
+    ]);
+
+    if (this.isContainUnSyncedStory) {
+      return this.localLastStoryExpires > now && this.localLastStoryExpires > highestSeen;
+    }
+
+    return this.lastStoryExpiresAt > now && this.lastStoryExpiresAt > highestSeen;
+  }
+
+  getTotalStoryByStatus(): void {
+    const stories = queryCache<Amity.InternalStory>([STORY_KEY_CACHE.STORY, 'get']);
+
+    if (!stories) {
+      this._errorStoriesCount = 0;
+      this._syncedStoriesCount = 0;
+      this._syncingStoriesCount = 0;
+      return;
+    }
+
+    const groupByType = stories.reduce(
+      (acc, story) => {
+        const {
+          data: { targetId, syncState },
+        } = story;
+
+        if (targetId === this._targetId) {
+          acc[syncState!] += 1;
+        }
+
+        return acc;
+      },
+      {
+        syncing: 0,
+        error: 0,
+        synced: 0,
+      },
+    );
+
+    this._errorStoriesCount = groupByType.error;
+    this._syncedStoriesCount = groupByType.synced;
+    this._syncingStoriesCount = groupByType.syncing;
+  }
+
+  get syncedStoriesCount(): number {
+    return this._syncedStoriesCount;
+  }
+
+  get syncingStoriesCount(): number {
+    return this._syncingStoriesCount;
+  }
+
+  get failedStoriesCount(): number {
+    return this._errorStoriesCount;
+  }
+}

package/src/utils/linkedObject/storyLinkedObject.ts

@@ -8,10 +8,11 @@ export const storyLinkedObject = (story: Amity.InternalStory): Amity.Story => {
   const analyticsEngineInstance = AnalyticsEngine.getInstance();
 
   const storyTargetCache = pullFromCache<Amity.RawStoryTarget>([
-    'storyTarget',
+    STORY_KEY_CACHE.STORY_TARGET,
     'get',
     story.targetId,
   ]);
+
   const communityCacheData = pullFromCache<Amity.Community>(['community', 'get', story.targetId]);
 
   return {

package/src/utils/linkedObject/storyTargetLinkedObject.ts

@@ -1,13 +1,36 @@
-import { calculateHasUnseenFlag } from '~/storyRepository/utils/calculateHasUnseenFlag';
+import { StoryComputedValue } from '~/storyRepository/utils/StoryComputedValue';
 
 export const storyTargetLinkedObject = (storyTarget: Amity.RawStoryTarget): Amity.StoryTarget => {
-  const { targetType, targetId, lastStoryExpiresAt, lastStorySeenExpiresAt, targetUpdatedAt } =
-    storyTarget;
+  const {
+    targetType,
+    targetId,
+    lastStoryExpiresAt,
+    lastStorySeenExpiresAt,
+    targetUpdatedAt,
+    localFilter,
+  } = storyTarget;
+
+  const computedValue = new StoryComputedValue(
+    targetId,
+    lastStoryExpiresAt,
+    lastStorySeenExpiresAt,
+  );
 
   return {
     targetType,
     targetId,
+    lastStoryExpiresAt,
     updatedAt: targetUpdatedAt,
-    hasUnseen: calculateHasUnseenFlag({ targetId, lastStoryExpiresAt, lastStorySeenExpiresAt }),
+
+    // Additional data
+    hasUnseen: computedValue.getHasUnseenFlag(),
+    syncedStoriesCount: computedValue.syncedStoriesCount,
+    syncingStoriesCount: computedValue.syncingStoriesCount,
+    failedStoriesCount: computedValue.failedStoriesCount,
+
+    localFilter,
+    localLastExpires: computedValue.localLastStoryExpires,
+    localLastSeen: computedValue.localLastStorySeenExpiresAt,
+    localSortingDate: computedValue.getLocalLastSortingDate(),
   };
 };

package/dist/storyRepository/utils/calculateHasUnseenFlag.d.ts

@@ -1,6 +0,0 @@
-export declare const calculateHasUnseenFlag: (params: {
-    targetId: Amity.Story['targetId'];
-    lastStoryExpiresAt: Amity.RawStoryTarget['lastStoryExpiresAt'];
-    lastStorySeenExpiresAt: Amity.RawStoryTarget['lastStorySeenExpiresAt'];
-}) => boolean;
-//# sourceMappingURL=calculateHasUnseenFlag.d.ts.map

package/dist/storyRepository/utils/calculateHasUnseenFlag.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"calculateHasUnseenFlag.d.ts","sourceRoot":"","sources":["../../../src/storyRepository/utils/calculateHasUnseenFlag.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,sBAAsB,WAAY;IAC7C,QAAQ,EAAE,MAAM,KAAK,CAAC,UAAU,CAAC,CAAC;IAClC,kBAAkB,EAAE,MAAM,cAAc,CAAC,oBAAoB,CAAC,CAAC;IAC/D,sBAAsB,EAAE,MAAM,cAAc,CAAC,wBAAwB,CAAC,CAAC;CACxE,KAAG,OAuCH,CAAC"}

package/src/storyRepository/utils/calculateHasUnseenFlag.ts

@@ -1,47 +0,0 @@
-import { pullFromCache } from '~/cache/api';
-import { STORY_KEY_CACHE } from '~/storyRepository/constants';
-
-export const calculateHasUnseenFlag = (params: {
-  targetId: Amity.Story['targetId'];
-  lastStoryExpiresAt: Amity.RawStoryTarget['lastStoryExpiresAt'];
-  lastStorySeenExpiresAt: Amity.RawStoryTarget['lastStorySeenExpiresAt'];
-}): boolean => {
-  const cacheStoryExpireTime = pullFromCache<Amity.timestamp>([
-    STORY_KEY_CACHE.EXPIRE,
-    params.targetId,
-  ]);
-
-  const cacheStoreSeenTime = pullFromCache<Amity.timestamp>([
-    STORY_KEY_CACHE.LAST_SEEN,
-    params.targetId,
-  ]);
-
-  const now = new Date().getTime();
-  const lastStoryExpiresAt = params.lastStoryExpiresAt
-    ? new Date(params.lastStoryExpiresAt).getTime()
-    : 0;
-  const lastStorySeenExpiresAt = params.lastStorySeenExpiresAt
-    ? new Date(params.lastStorySeenExpiresAt).getTime()
-    : 0;
-  const localLastStoryExpires = cacheStoryExpireTime?.data
-    ? new Date(cacheStoryExpireTime?.data).getTime()
-    : 0;
-  const localLastStorySeenExpiresAt = cacheStoreSeenTime?.data
-    ? new Date(cacheStoreSeenTime?.data).getTime()
-    : 0;
-
-  const highestSeen = Math.max(lastStorySeenExpiresAt, localLastStorySeenExpiresAt);
-
-  const currentSyncingState = pullFromCache<Amity.SyncState>([
-    STORY_KEY_CACHE.SYNC_STATE,
-    params.targetId,
-  ]);
-
-  if (currentSyncingState?.data) {
-    if ([Amity.SyncState.Syncing, Amity.SyncState.Error].includes(currentSyncingState.data)) {
-      return localLastStoryExpires > now && localLastStoryExpires > highestSeen;
-    }
-  }
-
-  return lastStoryExpiresAt > now && lastStoryExpiresAt > highestSeen;
-};