@amityco/ts-sdk 6.17.3 → 6.18.0

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

@@ -0,0 +1,152 @@
+import hash from 'object-hash';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import { pullFromCache, pushToCache } 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';
+
+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,
+    );
+
+    this.paginationController = paginationController;
+    this.callback = callback.bind(this);
+    this.loadPage(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;
+
+    let data = collection.data
+      .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)
+      // Remove internal fields
+      .map(
+        ({ localFilter, localLastExpires, localLastSeen, localSortingDate, ...rest }) => rest,
+      ) as Amity.StoryTarget[];
+
+    this.callback({
+      onNextPage: () => this.loadPage(false, 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,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/getStoriesByTargetIds/StoryQueryStreamController.ts

@@ -4,7 +4,7 @@ import { getActiveClient } from '~/client';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { updateLocalLastStoryExpires } from '~/storyRepository/utils/updateLocalLastStoryExpires';
 import { mappingStoryIdToReferenceId } from '~/storyRepository/utils/mappingStoryIdToReferenceId';
-import { convertStoryRawToInternal } from '~/storyRepository/utils/convertRawToStory';
+import { convertRawStoryToInternal } from '~/storyRepository/utils/convertRawToStory';
 import { StoryPaginationNoPageController } from './StoryPaginationNoPageController';
 
 export class StoryQueryStreamController extends QueryStreamController<
@@ -31,7 +31,7 @@ export class StoryQueryStreamController extends QueryStreamController<
     const client = getActiveClient();
     const cachedAt = client.cache && Date.now();
 
-    const convertedData: Amity.StoryPayload = convertStoryRawToInternal(response);
+    const convertedData: Amity.StoryPayload = convertRawStoryToInternal(response);
 
     if (client.cache) {
       ingestInCache(convertedData, { cachedAt });

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,136 @@
+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 _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._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._syncingStoriesCount = groupByType.syncing;
+  }
+
+  get syncingStoriesCount(): number {
+    return this._syncingStoriesCount;
+  }
+
+  get failedStoriesCount(): number {
+    return this._errorStoriesCount;
+  }
+}

package/src/storyRepository/utils/convertRawToStory.ts

@@ -1,16 +1,23 @@
 // Due to we have optimistic logic, we will use referenceId as a id in SDK instead of storyId
 
-export const convertRawStoryToInternalStory = (rawData: Amity.RawStory): Amity.InternalStory => {
+export const applyMissingField = (
+  rawData: Amity.RawStory,
+  isCreated = false,
+): Amity.InternalStory => {
   const { storyId, referenceId } = rawData;
 
-  if (referenceId) return { ...rawData, syncState: Amity.SyncState.Synced };
+  if (!isCreated) {
+    if (referenceId) return { ...rawData, syncState: Amity.SyncState.Synced };
+  }
+
   return { ...rawData, syncState: Amity.SyncState.Synced, referenceId: storyId };
 };
 
-export const convertStoryRawToInternal = (
+export const convertRawStoryToInternal = (
   data: Amity.StoryPayload,
+  isCreated = false,
 ): Amity.StoryWithOptimisticPayload => {
   const { stories } = data;
-  const storiesData = stories.map(convertRawStoryToInternalStory);
+  const storiesData = stories.map(story => applyMissingField(story, isCreated));
   return { ...data, stories: storiesData };
 };

package/src/storyRepository/utils/convertStoryPayloadToRaw.ts

@@ -1,5 +1,8 @@
 import { getActiveClient } from '~/client';
 import { YEAR } from '~/utils/constants';
+import { pullFromCache } from '~/cache/api';
+import { STORY_KEY_CACHE } from '~/storyRepository/constants';
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 export const convertStoryPayloadToRaw = (
   payload: Amity.StoryCreatePayload,
@@ -8,6 +11,26 @@ export const convertStoryPayloadToRaw = (
 
   const now = new Date();
   const expiresAt = now.getTime() + YEAR;
+  const expiresAtDate = new Date(expiresAt).toISOString();
+
+  let storyTarget = pullFromCache<Amity.RawStoryTarget>([
+    STORY_KEY_CACHE.STORY_TARGET,
+    'get',
+    payload.targetId,
+  ])?.data;
+
+  if (!storyTarget) {
+    // Save mock story target to cache
+    storyTarget = {
+      targetType: payload.targetType,
+      targetId: payload.targetId,
+      lastStoryExpiresAt: expiresAtDate,
+      targetPublicId: payload.targetId,
+      targetUpdatedAt: now.toISOString(),
+    };
+
+    ingestInCache({ storyTargets: [storyTarget] });
+  }
 
   return {
     stories: [

package/src/subChannelRepository/api/markAsReadBySegment.ts

@@ -0,0 +1,35 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+/**
+ *
+ * Mark subChannel as read by readToSegment
+ *
+ * @param subChannelIds the IDs of the {@link Amity.SubChannel} to update
+ * @param readToSegment the segment to mark as read
+ * @returns a success boolean if the {@link Amity.SubChannel} was updated
+ *
+ * @category Channel API
+ * @async
+ */
+
+export const markAsReadBySegment = async ({
+  subChannelId,
+  readToSegment,
+}: {
+  subChannelId: Amity.SubChannel['subChannelId'];
+  readToSegment: number;
+}): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('subChannel/markAsReadBySegment', subChannelId);
+
+  try {
+    await client.http.put<Amity.MarkAsReadPayload>(
+      `/api/v1/markers/message-feeds/${subChannelId}/mark-read`,
+      { readToSegment },
+    );
+
+    return true;
+  } catch (e) {
+    return false;
+  }
+};

package/src/subChannelRepository/api/readingAPI.ts

@@ -1,11 +1,7 @@
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getActiveClient } from '~/client/api/activeClient';
 import { fireEvent } from '~/core/events';
-import {
-  convertChannelMarkerResponse,
-  convertSubChannelMarkerResponse,
-  convertUserMarkerResponse,
-} from '~/utils/marker';
+import { convertChannelMarkerResponse, convertSubChannelMarkerResponse } from '~/utils/marker';
 
 /**
  * ```js
@@ -37,10 +33,9 @@ export const readingAPI = async (
     userEntityMarkers: userEntityMarkersPayload,
     userFeedMarkers: userFeedMarkersPayload,
     feedMarkers,
-    userMarkers: userMarkersPayload,
+    userMarkers,
   } = payload;
 
-  const userMarkers = convertUserMarkerResponse(userMarkersPayload);
   const userEntityMarkers = convertChannelMarkerResponse(userEntityMarkersPayload);
   const userFeedMarkers = convertSubChannelMarkerResponse(userFeedMarkersPayload);
 

package/src/subChannelRepository/api/startReadingAPI.ts

@@ -1,11 +1,7 @@
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getActiveClient } from '~/client/api/activeClient';
 import { fireEvent } from '~/core/events';
-import {
-  convertChannelMarkerResponse,
-  convertSubChannelMarkerResponse,
-  convertUserMarkerResponse,
-} from '~/utils/marker';
+import { convertChannelMarkerResponse, convertSubChannelMarkerResponse } from '~/utils/marker';
 
 /**
  * ```js
@@ -36,10 +32,9 @@ export const startReadingAPI = async (
     userEntityMarkers: userEntityMarkersPayload,
     userFeedMarkers: userFeedMarkersPayload,
     feedMarkers,
-    userMarkers: userMarkersPayload,
+    userMarkers,
   } = payload;
 
-  const userMarkers = convertUserMarkerResponse(userMarkersPayload);
   const userEntityMarkers = convertChannelMarkerResponse(userEntityMarkersPayload);
   const userFeedMarkers = convertSubChannelMarkerResponse(userFeedMarkersPayload);