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

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

@@ -0,0 +1,113 @@
+import hash from 'object-hash';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { LinkedObject } from '~/utils/linkedObject';
+import { sortByFirstCreated, sortByLastCreated } from '~/core/query';
+import { onStoryCreated } from '~/storyRepository/events/onStoryCreated';
+import { onStoryUpdated } from '~/storyRepository/events/onStoryUpdated';
+import { onStoryDeleted } from '~/storyRepository/events/onStoryDeleted';
+import { onStoryError } from '~/storyRepository/events/onStoryError';
+import { STORY_KEY_CACHE } from '~/storyRepository/constants';
+import { StoryQueryStreamController } from './StoryQueryStreamController';
+import { StoryPaginationNoPageController } from './StoryPaginationNoPageController';
+
+export class StoryLiveCollectionController extends LiveCollectionController<
+  'story',
+  Amity.StoryLiveCollection,
+  Amity.Story,
+  StoryPaginationNoPageController
+> {
+  private queryStreamController: StoryQueryStreamController;
+
+  private query: Amity.StoryLiveCollection;
+
+  constructor(
+    query: Amity.StoryLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.Story>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = [STORY_KEY_CACHE.STORY_TARGET_IDS, 'collection', queryStreamId];
+    const paginationController = new StoryPaginationNoPageController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+
+    this.queryStreamController = new StoryQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      paginationController,
+    );
+
+    this.paginationController = paginationController;
+    this.callback = callback.bind(this);
+    this.loadPage({ initial: true });
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.StoryLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        params: {},
+      });
+    }
+  }
+
+  protected persistModel(response: Amity.StoryPayload) {
+    this.queryStreamController.saveToMainDB(response);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'story'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.StoryLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) return;
+
+    let data = collection.data
+      .map(
+        referenceId =>
+          pullFromCache<Amity.InternalStory>([STORY_KEY_CACHE.STORY, 'get', referenceId])!, // Story use referenceId instead of storyId
+      )
+      .filter(Boolean)
+      .map(internStory => LinkedObject.story(internStory.data));
+
+    if (!this.shouldNotify(data) && origin === 'event') return;
+
+    data = this.applyFilter(data);
+
+    this.callback({
+      onNextPage: undefined,
+      data,
+      hasNextPage: false,
+      loading,
+      error,
+    });
+  }
+
+  private applyFilter(data: Amity.Story[]) {
+    const internalStories = data;
+
+    const orderBy = this.query?.options?.orderBy || 'desc';
+
+    return orderBy === 'asc'
+      ? internalStories.sort(sortByFirstCreated)
+      : internalStories.sort(sortByLastCreated);
+  }
+
+  startSubscription() {
+    return this.queryStreamController.subscribeRTE([
+      { fn: onStoryCreated, action: Amity.StoryActionType.OnCreate },
+      { fn: onStoryUpdated, action: Amity.StoryActionType.OnUpdate },
+      { fn: onStoryDeleted, action: Amity.StoryActionType.OnDelete },
+      { fn: onStoryError, action: Amity.StoryActionType.OnError },
+    ]);
+  }
+}

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

@@ -0,0 +1,16 @@
+import { PaginationNoPageController } from '~/core/liveCollection/PaginationNoPageController';
+
+export class StoryPaginationNoPageController extends PaginationNoPageController<
+  'story',
+  Pick<Amity.StoryLiveCollection, 'targets'>
+> {
+  async getRequest(queryParams: Pick<Amity.StoryLiveCollection, 'targets'>) {
+    const { data: queryResponse } = await this.http.get<Amity.StoryPayload>(
+      '/api/v4/stories-by-targets',
+      {
+        params: { ...queryParams },
+      },
+    );
+    return queryResponse;
+  }
+}

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

@@ -0,0 +1,97 @@
+import { QueryStreamController } from '~/core/liveCollection/QueryStreamController';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { getActiveClient } from '~/client';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { updateLocalLastStoryExpires } from '~/storyRepository/utils/updateLocalLastStoryExpires';
+import { mappingStoryIdToReferenceId } from '~/storyRepository/utils/mappingStoryIdToReferenceId';
+import { convertRawStoryToInternal } from '~/storyRepository/utils/convertRawToStory';
+import { StoryPaginationNoPageController } from './StoryPaginationNoPageController';
+
+export class StoryQueryStreamController extends QueryStreamController<
+  Amity.StoryPayload,
+  Amity.StoryLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private paginationController: StoryPaginationNoPageController;
+
+  constructor(
+    query: Amity.StoryLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    paginationController: StoryPaginationNoPageController,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.paginationController = paginationController;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  saveToMainDB(response: Amity.StoryPayload) {
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    const convertedData: Amity.StoryPayload = convertRawStoryToInternal(response);
+
+    if (client.cache) {
+      ingestInCache(convertedData, { cachedAt });
+
+      // Update local last story expires
+      updateLocalLastStoryExpires(convertedData.stories);
+
+      // Map storyId to referenceId
+      mappingStoryIdToReferenceId(convertedData.stories);
+    }
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  getStoryReferenceIds(story: Amity.RawStory) {
+    if (story?.referenceId) {
+      return story.referenceId;
+    }
+    return story.storyId;
+  }
+
+  appendToQueryStream(
+    response: Amity.StoryPayload,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: response.stories.map(this.getStoryReferenceIds),
+      });
+    } else {
+      const collection = pullFromCache<Amity.StoryLiveCollectionCache>(this.cacheKey)?.data;
+      const stories = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data: [...new Set([...stories, ...response.stories.map(this.getStoryReferenceIds)])],
+      });
+    }
+  }
+
+  reactor(action: Amity.StoryActionType) {
+    return (payload: Amity.InternalStory[]) => {
+      const collection = pullFromCache<Amity.StoryLiveCollectionCache>(this.cacheKey)?.data;
+      if (!collection) return;
+
+      const newReferenceIds = payload.map(({ referenceId }) => referenceId);
+
+      collection.data = [...new Set([...newReferenceIds, ...collection.data])];
+      pushToCache(this.cacheKey, collection);
+
+      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/getStoriesByTargetIds/getStoriesByTargetIds.ts

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

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

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

package/src/storyRepository/observers/getStoryByStoryId.ts

@@ -0,0 +1,53 @@
+import { liveObject } from '~/utils/liveObject';
+import { onStoryError } from '~/storyRepository/events/onStoryError';
+import { LinkedObject } from '~/utils/linkedObject';
+import { onStoryDeleted, onStoryDeletedLocal } from '~/storyRepository/events/onStoryDeleted';
+import {
+  onStoryReactionAdded,
+  onStoryReactionAddedLocal,
+} from '~/storyRepository/events/onStoryReactionAdded';
+import {
+  onStoryReactionRemoved,
+  onStoryReactionRemovedLocal,
+} from '~/storyRepository/events/onStoryReactionRemoved';
+import { onStoryUpdated, onStoryUpdatedLocal } from '~/storyRepository/events/onStoryUpdated';
+import { getStoryByStoryId as _getStoryByStoryId } from '../internalApi/getStoryByStoryId';
+
+const getSingleItemFromArray =
+  (func: Amity.Subscriber<Amity.InternalStory[]>) =>
+  (callback: Amity.Listener<Amity.InternalStory>) =>
+    func((result: Amity.InternalStory[]) => callback(result[0]));
+
+export const getStoryByStoryId = (
+  storyId: Amity.Story['storyId'],
+  callback: Amity.LiveObjectCallback<Amity.Story>,
+): Amity.Unsubscriber => {
+  return liveObject(
+    storyId,
+    data => {
+      if (!data?.data) {
+        callback(data);
+        return;
+      }
+
+      callback({
+        ...data,
+        data: LinkedObject.story(data.data),
+      });
+    },
+    'storyId',
+    _getStoryByStoryId,
+    [
+      getSingleItemFromArray(onStoryUpdated),
+      getSingleItemFromArray(onStoryDeleted),
+      getSingleItemFromArray(onStoryReactionAdded),
+      getSingleItemFromArray(onStoryReactionRemoved),
+      getSingleItemFromArray(onStoryError),
+
+      getSingleItemFromArray(onStoryUpdatedLocal),
+      getSingleItemFromArray(onStoryDeletedLocal),
+      getSingleItemFromArray(onStoryReactionAddedLocal),
+      getSingleItemFromArray(onStoryReactionRemovedLocal),
+    ],
+  );
+};

package/src/storyRepository/observers/getTargetById.ts

@@ -0,0 +1,30 @@
+import { liveObject } from '~/utils/liveObject';
+import { getTargetsByTargetIds } from '~/storyRepository/internalApi/getTargetsByTargetIds';
+import { LinkedObject } from '~/utils/linkedObject';
+
+export const getTargetById = (
+  params: Amity.StoryTargetLiveObjectParam['query'],
+  callback: Amity.LiveObjectCallback<Amity.StoryTarget>,
+): Amity.Unsubscriber => {
+  return liveObject(
+    // @TODO: Now I put @ts-ignore here because I don't know how to fix this, it always say that params is not assignable to `NEVER`
+    // @ts-ignore
+    params,
+    result => {
+      if (!result?.data) {
+        callback(result);
+        return;
+      }
+
+      callback({
+        ...result,
+        data: LinkedObject.storyTarget(result.data[0]),
+      });
+    },
+    'query',
+    param => {
+      return getTargetsByTargetIds([param]);
+    },
+    [],
+  );
+};

package/src/storyRepository/observers/getTargetsByTargetIds.ts

@@ -0,0 +1,88 @@
+import { getActiveClient } from '~/client';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { dropFromCache, pullFromCache, pushToCache } from '~/cache/api';
+import { createQuery, runQuery } from '~/core/query';
+import { getResolver } from '~/core/model';
+import { LinkedObject } from '~/utils/linkedObject';
+import { getTargetsByTargetIds as _getTargetsByTargetIds } from '../internalApi/getTargetsByTargetIds';
+
+export const getTargetsByTargetIds = (
+  params: Amity.StoryTargetQueryParam[],
+  callback: Amity.LiveCollectionCallback<Amity.StoryTarget | undefined>,
+) => {
+  const { log, cache } = getActiveClient();
+
+  const disposers: Amity.Unsubscriber[] = [];
+  const cacheKey = ['storyTargets', 'collection', params];
+
+  const timestamp = Date.now();
+  log(`getTargetsByTargetIds(tmpid: ${timestamp}) > listen`);
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const responder = (snapshot: Amity.StoryTargetLiveCollectionCache) => {
+    const storyTargets = snapshot.data
+      .map(targetId => {
+        const storyTargetCache = pullFromCache<Amity.RawStoryTarget>([
+          'storyTarget',
+          'get',
+          targetId,
+        ]);
+
+        if (!storyTargetCache?.data) return undefined;
+        return LinkedObject.storyTarget(storyTargetCache.data);
+      })
+      .filter(Boolean);
+
+    callback({
+      onNextPage: undefined,
+      data: storyTargets,
+      hasNextPage: !!snapshot.params?.page,
+      loading: snapshot.loading || false,
+    });
+  };
+
+  const processNewData = (
+    result: Amity.RawStoryTarget[] | undefined,
+    initial = false,
+    loading = false,
+    error = false,
+  ) => {
+    const cached = pullFromCache<Amity.RawStoryTarget['targetId']>(cacheKey);
+
+    const data: Amity.StoryTargetLiveCollectionCache = {
+      loading,
+      error,
+      params: { page: undefined },
+      data: [],
+    };
+
+    if (result) {
+      data.data = initial
+        ? result.map(getResolver('storyTarget'))
+        : [...new Set([...(cached?.data || []), ...result.map(getResolver('storyTarget'))])];
+    }
+
+    pushToCache(cacheKey, data.data);
+
+    responder(data);
+  };
+
+  const onFetch = (initial: boolean) => {
+    const query = createQuery(_getTargetsByTargetIds, params);
+
+    runQuery(query, ({ data: result, error, loading }) => {
+      processNewData(result, initial, loading, error);
+    });
+  };
+
+  onFetch(true);
+  disposers.push(() => dropFromCache(cacheKey));
+
+  return () => {
+    log(`getTargetsByTargetIds(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/storyRepository/observers/index.ts

@@ -0,0 +1,6 @@
+export * from './getActiveStoriesByTarget';
+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, isDeleted },
+        } = story;
+
+        if (targetId === this._targetId && !isDeleted) {
+          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

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

package/src/storyRepository/utils/convertStoryPayloadToRaw.ts

@@ -0,0 +1,67 @@
+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,
+): Amity.StoryWithOptimisticPayload => {
+  const client = getActiveClient();
+
+  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: [
+      {
+        createdAt: now.toISOString(),
+        updatedAt: now.toISOString(),
+        flagCount: 0,
+        hashFlag: null,
+        reactions: {},
+        reactionsCount: 0,
+        storyId: payload.referenceId,
+        path: '',
+        creatorId: client.userId || '',
+        creatorPublicId: client.userId || '',
+        targetPublicId: payload.targetId,
+        comments: [],
+        commentsCount: 0,
+        isDeleted: false,
+        hasFlaggedComment: false,
+        mentionedUsers: [],
+        impression: 0,
+        reach: 0,
+        expiresAt: new Date(expiresAt).toISOString(),
+        ...payload,
+      },
+    ],
+    categories: [],
+    communityUsers: [],
+    comments: [],
+    files: [],
+    users: [],
+    communities: [],
+  };
+};