@amityco/ts-sdk-react-native 6.14.2-5d7d534.0 → 6.15.1-fee6c8f.0

package/src/storyRepository/observers/getActiveStoriesByTarget.ts

@@ -0,0 +1,163 @@
+import { getActiveClient } from '~/client';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { dropFromCache, pullFromCache, pushToCache } from '~/cache/api';
+import {
+  createQuery,
+  runQuery,
+  sortByFirstCreated,
+  sortByFirstUpdated,
+  sortByLastCreated,
+  sortByLastUpdated,
+} from '~/core/query';
+import { getResolver } from '~/core/model';
+import { LinkedObject } from '~/utils/linkedObject';
+import { getStoryCache } from '../utils/getStoryCache';
+import { getActiveStoriesByTarget as _getActiveStoriesByTarget } from '../internalApi/getActiveStoriesByTarget';
+import { onStoryCreated } from '../events/onStoryCreated';
+import { onStoryDeleted } from '../events/onStoryDeleted';
+import { onStoryError } from '../events/onStoryError';
+
+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,
+    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) {
+      data.data = initial
+        ? result.map(getResolver('story'))
+        : [...new Set([...data.data, ...result.map(getResolver('story'))])];
+    }
+
+    pushToCache(cacheKey, data.data);
+
+    responder(data);
+  };
+
+  const realtimeRouter = (event: Amity.StoryActionType) => (story: Amity.InternalStory[]) => {
+    processNewData(story);
+  };
+
+  const onFetch = (initial: boolean) => {
+    const query = createQuery(
+      _getActiveStoriesByTarget,
+      params.targetType,
+      params.targetId,
+      params.options,
+    );
+
+    runQuery(query, ({ data: result, error, loading }) => {
+      processNewData(result, initial, loading, error);
+    });
+  };
+
+  onFetch(true);
+  disposers.push(
+    onStoryCreated(realtimeRouter(Amity.StoryActionType.OnCreate)),
+    onStoryDeleted(realtimeRouter(Amity.StoryActionType.OnDelete)),
+    onStoryError(realtimeRouter(Amity.StoryActionType.OnError)),
+    () => dropFromCache(cacheKey),
+  );
+
+  return () => {
+    log(`getActiveStoriesByTarget(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/storyRepository/observers/index.ts

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

package/src/storyRepository/utils/convertRawToStory.ts

@@ -0,0 +1,16 @@
+// 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 => {
+  const { storyId, referenceId } = rawData;
+
+  if (referenceId) return { ...rawData, syncState: Amity.SyncState.Synced };
+  return { ...rawData, syncState: Amity.SyncState.Synced, referenceId: storyId };
+};
+
+export const convertStoryRawToInternal = (
+  data: Amity.StoryPayload,
+): Amity.StoryWithOptimisticPayload => {
+  const { stories } = data;
+  const storiesData = stories.map(convertRawStoryToInternalStory);
+  return { ...data, stories: storiesData };
+};

package/src/storyRepository/utils/convertStoryPayloadToRaw.ts

@@ -0,0 +1,43 @@
+import { getActiveClient } from '~/client';
+import { YEAR } from '~/utils/constants';
+
+export const convertStoryPayloadToRaw = (
+  payload: Amity.StoryCreatePayload,
+): Amity.StoryWithOptimisticPayload => {
+  const client = getActiveClient();
+
+  const now = new Date();
+  const expiresAt = now.getTime() + YEAR;
+
+  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,
+        commentsCount: 0,
+        isDeleted: false,
+        hasFlaggedComment: false,
+        mentionedUsers: [],
+        impression: 0,
+        reach: 0,
+        expiresAt: new Date(expiresAt).toISOString(),
+        ...payload,
+      },
+    ],
+    categories: [],
+    communityUsers: [],
+    comments: [],
+    files: [],
+    users: [],
+    communities: [],
+  };
+};

package/src/storyRepository/utils/createOptimisticEvent.ts

@@ -0,0 +1,63 @@
+import { convertStoryPayloadToRaw } from '~/storyRepository/utils/convertStoryPayloadToRaw';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+const saveOptimisticToCache = (payload: Amity.StoryCreatePayload) => {
+  const optimisticData = convertStoryPayloadToRaw(payload);
+  ingestInCache(optimisticData);
+  return optimisticData;
+};
+
+export const createOptimisticEvent = (
+  {
+    payload,
+    formData = undefined,
+    isVideo = false,
+  }: {
+    payload: Amity.StoryCreatePayload;
+    formData?: FormData;
+    isVideo?: boolean;
+  },
+  callback: (optimisticData: Amity.StoryPayload) => void,
+) => {
+  if (formData) {
+    const fileObject = formData.get('files');
+    const fileData = new FileReader();
+
+    // @ts-ignore
+    fileData.readAsDataURL(fileObject);
+    fileData.onload = () => {
+      return callback(
+        saveOptimisticToCache(
+          isVideo
+            ? {
+                ...payload,
+                data: {
+                  ...payload.data,
+                  fileId: undefined,
+                  videoFileId: { original: undefined },
+                  fileData: fileData?.result,
+                },
+              }
+            : {
+                ...payload,
+                data: {
+                  ...payload.data,
+                  fileId: undefined,
+                  fileData: fileData?.result,
+                },
+              },
+        ),
+      );
+    };
+  }
+
+  return callback(
+    saveOptimisticToCache({
+      ...payload,
+      data: {
+        ...payload.data,
+        fileData: null,
+      },
+    }),
+  );
+};

package/src/storyRepository/utils/getStoryCache.ts

@@ -0,0 +1,6 @@
+import { pullFromCache } from '~/cache/api';
+
+export const getStoryCache = (storyId: Amity.Story['storyId'] | undefined) => {
+  if (!storyId) return { data: undefined, cachedAt: undefined };
+  return pullFromCache<Amity.InternalStory>(['story', 'get', storyId]);
+};

package/src/streamRepository/api/index.ts

@@ -2,7 +2,7 @@ export * from './createStream';
 export * from './updateStream';
 export * from './deleteStream';
 export * from './disposeStream';
-export * from './queryStreams';
 
 // deprecated
+export * from './queryStreams';
 export * from './getStream';

package/src/streamRepository/api/queryStreams.ts

@@ -7,6 +7,8 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
   id: stream.query
 */
 /**
+ * @deprecated This API renamed to `getStreams`.
+ * Please use getStreams() instead.
  * ```js
  * import { getStreams } from '@amityco/ts-sdk-react-native'
  * const streams = await getStreams()

package/src/streamRepository/internalApi/queryStreams.ts

@@ -0,0 +1,57 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/* begin_public_function
+  id: stream.query
+*/
+/**
+ * ```js
+ * import { getStreams } from '@amityco/ts-sdk-react-native'
+ * const streams = await getStreams()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Stream} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Stream} objects
+ *
+ * @category Stream API
+ * @async
+ */
+export const queryStreams = async (
+  query?: Amity.QueryStreams,
+): Promise<Amity.Cached<Amity.PageToken<Amity.Stream>>> => {
+  const client = getActiveClient();
+  client.log('stream/queryStreams', query);
+
+  const { page, limit, ...params } = query ?? {};
+
+  const options = (() => {
+    if (page) return { token: page };
+    if (limit) return { limit };
+
+    return undefined;
+  })();
+
+  const { data } = await client.http.get<{ results: Amity.StreamPayload } & Amity.Pagination>(
+    `/api/v3/video-streaming`,
+    {
+      params: {
+        ...params,
+        options,
+      },
+    },
+  );
+
+  // API-FIX: backend to response Amity.Response: const { paging, videoStreamings } = unwrapPayload(data)
+  // API-FIX: seems returned data has a results identifier on top of data, like no other apis, and this is beautiful
+  const { paging, results: payload } = data;
+  const { videoStreamings } = payload;
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(payload as Amity.StreamPayload, { cachedAt });
+
+  return { data: videoStreamings, cachedAt, paging };
+};
+/* end_public_function */

package/src/streamRepository/observers/getStreams.ts

@@ -18,7 +18,7 @@ import {
   ENABLE_CACHE_MESSAGE,
 } from '~/utils/constants';
 
-import { queryStreams as _queryStreams } from '../api/queryStreams';
+import { queryStreams as _queryStreams } from '../internalApi/queryStreams';
 import { onStreamRecorded, onStreamStarted, onStreamStopped } from '../events';
 
 /* begin_public_function
@@ -27,7 +27,7 @@ import { onStreamRecorded, onStreamStarted, onStreamStopped } from '../events';
 /**
  * ```js
  * import { StreamRepository } from '@amityco/ts-sdk-react-native'
- * const streams = await StreamRepository.queryStreams()
+ * const streams = await StreamRepository.getStreams()
  * ```
  *
  * Observe all mutations on a list of {@link Amity.Stream}s
@@ -111,16 +111,17 @@ export const getStreams = (
 
     const query = createQuery(_queryStreams, {
       ...queryParams,
-      page: (!initial ? collection?.params.page : undefined) ?? { limit },
+      limit: initial ? limit : undefined,
+      page: !initial ? collection?.params.page : undefined,
     });
 
     runQuery(
       query,
-      ({ data: result, error, loading, nextPage: page }) => {
+      ({ data: result, error, loading, paging }) => {
         const data = {
           loading,
           error,
-          params: { page },
+          params: { page: paging?.next },
           data: streams,
         };
 

package/src/subChannelRepository/observers/getSubChannels.ts

@@ -19,7 +19,7 @@ import { CACHE_SHORTEN_LIFESPAN } from '~/cache/utils';
 import { convertEventPayload } from '~/utils/event';
 import { convertGetterPropsToStatic } from '~/utils/object';
 import { onMessageCreated } from '~/messageRepository/events/onMessageCreated';
-import { pullFromCache, pushToCache } from '~/cache/api';
+import { dropFromCache, pullFromCache, pushToCache } from '~/cache/api';
 import { onSubChannelCreated, onSubChannelDeleted, onSubChannelUpdated } from '../events';
 import { querySubChannels } from '../api/querySubChannels';
 import { getSubChannelMessagePreview } from '../../messagePreview/utils/getSubChannelMessagePreview';
@@ -31,6 +31,7 @@ import {
 import { onMessageDeleted, onMessageUpdated } from '~/messageRepository';
 import { getSubChannel } from '../api/getSubChannel';
 import { getSubChannelMessagePreviewWithUser } from '~/messagePreview/utils';
+import { SubChannelLiveCollectionController } from './liveCollection/SubChannelLiveCollectionController';
 
 /* begin_public_function
   id: subchannel.query
@@ -67,235 +68,14 @@ export const getSubChannels = (
     console.log(ENABLE_CACHE_MESSAGE);
   }
 
-  const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, ...queryParams } = params;
-  const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
+  const subChannelLiveCollection = new SubChannelLiveCollectionController(params, callback);
+  const disposers = subChannelLiveCollection.startSubscription();
 
-  const { page, channelId, includeDeleted, ...rest } = convertQueryParams(params);
+  const cacheKey = subChannelLiveCollection.getCacheKey();
 
-  const cacheKey = [
-    'subChannel',
-    'query',
-    { channelId, ...rest, options: { ...page } } as Amity.Serializable,
-  ];
-
-  let snapshot: Amity.SubChannelLiveCollectionCache;
-  const disposers: Amity.Unsubscriber[] = [];
-
-  const responder = (data: Amity.SubChannelLiveCollectionCache) => {
-    let subChannels: Amity.SubChannel[] = data.data.map(getSubChannelMessagePreviewWithUser);
-
-    if (!params.includeDeleted) {
-      subChannels = filterByPropEquality(subChannels, 'isDeleted', false);
-    }
-
-    subChannels.sort(sortByLastActivity);
-
-    callback({
-      onNextPage: onFetch,
-      data: subChannels,
-      hasNextPage: !!data.params?.paging?.next,
-      loading: data.loading,
-      error: data.error,
-    });
-  };
-
-  const realtimeRouter =
-    (action: Amity.ChannelActionType) => (subChannel: Amity.SubChannel | Amity.SubChannel[]) => {
-      if (!Array.isArray(subChannel)) {
-        if (
-          params.channelId !== subChannel.channelId ||
-          !snapshot ||
-          !shouldDispatchCollection(snapshot.data, subChannel, action)
-        ) {
-          return;
-        }
-
-        if (action === 'onCreate') {
-          snapshot.data = [subChannel, ...snapshot.data];
-        } else {
-          snapshot.data = snapshot.data.map(x =>
-            x.subChannelId === subChannel.subChannelId ? subChannel : x,
-          );
-        }
-
-        snapshot.data = snapshot.data.map(convertGetterPropsToStatic);
-      } else {
-        /**
-         * In case of `onUpdate` event with array of subChannel
-         */
-        snapshot.data = snapshot.data.map(x => {
-          const targetSubChannel = subChannel.find(item => item.subChannelId === x.subChannelId);
-          return targetSubChannel ?? x;
-        });
-      }
-      responder(snapshot);
-    };
-
-  const onFetch = () => {
-    const subChannels = snapshot ? snapshot.data : [];
-
-    if (subChannels.length > 0 && !snapshot?.params?.paging?.next) {
-      return;
-    }
-
-    const query = createQuery(querySubChannels, {
-      ...queryParams,
-      page: snapshot?.params.page ? { ...snapshot?.params.page, limit } : { limit },
-      pageToken: snapshot?.params?.paging?.next,
-    });
-
-    runQuery(
-      query,
-      ({ data: result, error, loading, nextPage: page, paging }) => {
-        snapshot = {
-          loading,
-          error,
-          params: { page, paging },
-          data: result ? merge(subChannels, result.map(convertGetterPropsToStatic)) : subChannels,
-        };
-
-        responder(snapshot);
-      },
-      queryOptions(policy, CACHE_SHORTEN_LIFESPAN),
-    );
-  };
-
-  disposers.push(
-    onMessageCreated(async message => {
-      const cacheData = pullFromCache<Amity.SubChannel>([
-        'subChannel',
-        'get',
-        message.subChannelId,
-      ]);
-
-      if (!cacheData) return;
-
-      const targetSubChannel = snapshot.data?.find(item => {
-        return item.subChannelId === message.subChannelId;
-      });
-
-      if (!targetSubChannel) return;
-
-      const client = getActiveClient();
-      const messagePreviewSetting = await client.getMessagePreviewSetting(false);
-
-      if (messagePreviewSetting === Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW) return;
-
-      handleMessageCreated(message);
-
-      realtimeRouter('onUpdate')({
-        ...cacheData.data,
-        messagePreviewId: message.messageId,
-        subChannelId: message.subChannelId,
-        lastActivity: message.createdAt,
-      });
-    }),
-    onSubChannelCreated(realtimeRouter('onCreate')),
-    onSubChannelDeleted(realtimeRouter('onDelete')),
-    onSubChannelFetched(realtimeRouter('onFetch')),
-    onSubChannelUpdated(async (subChannel: Amity.SubChannel) => {
-      const client = getActiveClient();
-      const messagePreviewSetting = await client.getMessagePreviewSetting(false);
-
-      if (messagePreviewSetting === Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW) return false;
-
-      const targetSubChannel = snapshot.data?.find(async item => {
-        const messagePreview = getSubChannelMessagePreview(item.subChannelId);
-
-        if (messagePreview?.subChannelId === item.subChannelId) {
-          pushToCache(['messagePreviewSubChannel', 'get', item.subChannelId], {
-            ...messagePreview,
-            subChannelName: subChannel.displayName,
-            subChannelUpdatedAt: subChannel.updatedAt,
-          });
-          return true;
-        }
-
-        return false;
-      });
-
-      if (!targetSubChannel) return;
-
-      return realtimeRouter('onUpdate')(subChannel);
-    }),
-    convertEventPayload(
-      onSubChannelMarkerFetched,
-      'feedId',
-      'subChannel',
-    )(realtimeRouter('onUpdate')),
-    onSubChannelMarkerUpdated((subChannelMarkers: Amity.SubChannelMarker[]) => {
-      const subChannelWithMarkerUpdated =
-        subChannelMarkers
-          .map(({ feedId }) => pullFromCache<Amity.SubChannel>(['subChannel', 'get', feedId])!)
-          .filter(Boolean)
-          .map(({ data }) => data) ?? [];
-
-      if (subChannelWithMarkerUpdated.length === 0) return;
-      realtimeRouter('onUpdate')(subChannelWithMarkerUpdated);
-    }),
-    convertEventPayload(
-      (callback: Amity.Listener<Amity.Message>) => {
-        const updateMessagePreview = async (message: Amity.Message) => {
-          const client = getActiveClient();
-          const messagePreviewSetting = await client.getMessagePreviewSetting(false);
-
-          if (messagePreviewSetting === Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW) return;
-
-          const subChannel = snapshot.data?.find(item => {
-            if (item.subChannelId === message.subChannelId) {
-              return true;
-            }
-            return false;
-          });
-          if (!subChannel) return;
-
-          handleMessageUpdated(message);
-
-          callback(message);
-        };
-
-        return onMessageUpdated(updateMessagePreview);
-      },
-      'subChannelId',
-      'subChannel',
-    )(realtimeRouter('onUpdate')),
-    convertEventPayload(
-      (callback: Amity.Listener<Amity.Message>) => {
-        const updateMessagePreview = async (message: Amity.Message) => {
-          const client = getActiveClient();
-          const messagePreviewSetting = await client.getMessagePreviewSetting(false);
-
-          if (messagePreviewSetting === Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW) return;
-
-          const subChannel = snapshot.data?.find(item => {
-            if (item.subChannelId === message.subChannelId) {
-              return true;
-            }
-            return false;
-          });
-
-          if (!subChannel) return;
-
-          if (
-            messagePreviewSetting ===
-            Amity.MessagePreviewSetting.MESSAGE_PREVIEW_NOT_INCLUDE_DELETED
-          ) {
-            await getSubChannel(message.subChannelId);
-          } else {
-            await handleMessageUpdated(message);
-          }
-
-          callback(message);
-        };
-
-        return onMessageDeleted(updateMessagePreview);
-      },
-      'subChannelId',
-      'subChannel',
-    )(realtimeRouter('onUpdate')),
-  );
-
-  onFetch();
+  disposers.push(() => {
+    dropFromCache(cacheKey);
+  });
 
   return () => {
     log(`getSubChannels(tmpid: ${timestamp}) > dispose`);