@amityco/ts-sdk-react-native 6.23.1-d8b4c4c.0 → 6.24.0

package/src/communityRepository/communityMembership/observers/getMembers.ts

@@ -1,13 +1,32 @@
+/* eslint-disable no-use-before-define */
+import { getResolver } from '~/core/model';
+import { pullFromCache, pushToCache } from '~/cache/api';
 import { getActiveClient } from '~/client/api';
 import {
+  createQuery,
   filterByPropIntersection,
   filterBySearchTerm,
+  queryOptions,
+  runQuery,
   sortByFirstCreated,
   sortByLastCreated,
 } from '~/core/query';
-import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
-import { CommunityMembersLiveCollectionController } from './getMembers/CommunityMembersLiveCollectionController';
-import { dropFromCache } from '~/cache/api';
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+  ENABLE_CACHE_MESSAGE,
+} from '~/utils/constants';
+import { isNonNullable } from '~/utils';
+import {
+  onCommunityJoined,
+  onCommunityLeft,
+  onCommunityUserBanned,
+  onCommunityUserChanged,
+  onCommunityUserRoleAdded,
+  onCommunityUserRoleRemoved,
+  onCommunityUserUnbanned,
+} from '../events';
+import { queryCommunityMembers } from '../api/queryCommunityMembers';
 
 /*
  * Exported for testing
@@ -73,20 +92,114 @@ export const getMembers = (
   const timestamp = Date.now();
   log(`getMembers(tmpid: ${timestamp}) > listen`);
 
-  const communityMemberLiveCollection = new CommunityMembersLiveCollectionController(
-    params,
-    resp => {
-      console.log('resp', resp);
-      callback(resp);
-    },
-  );
-  const disposers = communityMemberLiveCollection.startSubscription();
+  const { limit: queryLimit, ...queryParams } = params;
+
+  const limit = queryLimit ?? COLLECTION_DEFAULT_PAGINATION_LIMIT;
+  const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
+
+  const disposers: Amity.Unsubscriber[] = [];
+  const cacheKey = ['communityUsers', 'collection', queryParams as unknown as Amity.Serializable];
+  const cacheByCommunityIdKey = [
+    'communityUsers',
+    'collection',
+    { communityId: params.communityId },
+  ];
+
+  const responder = (data: Amity.CommunityMemberLiveCollectionCache, isEventModel = false) => {
+    const communityMembers: Amity.Membership<'community'>[] =
+      data.data
+        .map(id => pullFromCache<Amity.Membership<'community'>>(['communityUsers', 'get', id])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    callback({
+      onNextPage: onFetch,
+      data: isEventModel ? applyFilter(communityMembers, params) : communityMembers,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter =
+    (_: Amity.CommunityMemberActionType) =>
+    (_: Amity.Community, communityMembers: Amity.Membership<'community'>[]) => {
+      const collection = pullFromCache<Amity.CommunityMemberLiveCollectionCache>(cacheKey)?.data;
+      if (!collection) {
+        return;
+      }
+
+      const communityMemberCacheIds = communityMembers
+        .map(communityMember => {
+          if (params.communityId !== communityMember.communityId) {
+            return;
+          }
+
+          const communityMemberCacheId = getResolver('communityUsers')({
+            communityId: params.communityId,
+            userId: communityMember.userId,
+          });
+
+          return communityMemberCacheId;
+        })
+        .filter(isNonNullable);
 
-  const cacheKey = communityMemberLiveCollection.getCacheKey();
+      collection.data = [...new Set([...communityMemberCacheIds, ...collection.data])];
+
+      pushToCache(cacheKey, collection);
+      pushToCache(cacheByCommunityIdKey, collection);
+      responder(collection, true);
+    };
+
+  const onFetch = (initial = false) => {
+    const collection = pullFromCache<Amity.CommunityMemberLiveCollectionCache>(cacheKey)?.data;
+
+    const communityMembers = collection?.data ?? [];
+
+    if (!initial && communityMembers.length > 0 && !collection?.params.page) return;
+
+    const query = createQuery(queryCommunityMembers, {
+      ...queryParams,
+      limit: initial ? limit : undefined,
+      page: !initial ? collection?.params.page : undefined,
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, paging }) => {
+        const data = {
+          loading,
+          error,
+          params: { page: paging?.next },
+          data: communityMembers,
+        };
+
+        if (result) {
+          data.data = [
+            ...new Set([...communityMembers, ...result.map(getResolver('communityUsers'))]),
+          ];
+        }
+
+        pushToCache(cacheKey, data);
+        pushToCache(cacheByCommunityIdKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onCommunityLeft(realtimeRouter('onLeft')),
+    onCommunityJoined(realtimeRouter('onJoin')),
+    onCommunityUserBanned(realtimeRouter('onBan')),
+    onCommunityUserUnbanned(realtimeRouter('onUnban')),
+    onCommunityUserChanged(realtimeRouter('onMemberCountChanged')),
+    onCommunityUserRoleAdded(realtimeRouter('onMemberCountChanged')),
+    onCommunityUserRoleRemoved(realtimeRouter('onMemberCountChanged')),
+  );
 
-  disposers.push(() => {
-    dropFromCache(cacheKey);
-  });
+  onFetch(true);
 
   return () => {
     log(`getMembers(tmpid: ${timestamp}) > dispose`);

package/src/communityRepository/communityMembership/observers/index.ts

@@ -1,2 +1 @@
 export * from './getMembers';
-export * from './searchMembers';

package/src/communityRepository/observers/getCommunities.ts

@@ -1,7 +1,31 @@
-import { dropFromCache } from '~/cache/api';
+/* eslint-disable no-use-before-define */
+import { getResolver } from '~/core/model';
+import { dropFromCache, pullFromCache, pushToCache } from '~/cache/api';
 import { getActiveClient } from '~/client/api';
-import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
-import { CommunityLiveCollectionController } from './getCommunities/CommunitiesLiveCollectionController';
+import {
+  createQuery,
+  filterByCommunityMembership,
+  filterByPropEquality,
+  filterByStringComparePartially,
+  queryOptions,
+  runQuery,
+  sortByDisplayName,
+  sortByFirstCreated,
+  sortByLastCreated,
+} from '~/core/query';
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+  ENABLE_CACHE_MESSAGE,
+} from '~/utils/constants';
+import { CACHE_SHORTEN_LIFESPAN } from '~/cache/utils';
+import { onCommunityCreated, onCommunityDeleted, onCommunityUpdated } from '../events';
+import {
+  onCommunityJoined,
+  onCommunityLeft,
+  onCommunityUserChanged,
+} from '../communityMembership/events';
+import { queryCommunities } from '../api/queryCommunities';
 
 /* begin_public_function
   id: community.query
@@ -29,7 +53,7 @@ export const getCommunities = (
   callback: Amity.LiveCollectionCallback<Amity.Community>,
   config?: Amity.LiveCollectionConfig,
 ) => {
-  const { log, cache } = getActiveClient();
+  const { log, cache, userId } = getActiveClient();
 
   if (!cache) {
     console.log(ENABLE_CACHE_MESSAGE);
@@ -38,11 +62,130 @@ export const getCommunities = (
   const timestamp = Date.now();
   log(`getCommunities(tmpid: ${timestamp}) > listen`);
 
-  const communitiesLiveCollection = new CommunityLiveCollectionController(params, callback);
-  const disposers = communitiesLiveCollection.startSubscription();
+  const { limit: queryLimit, ...queryParams } = params;
 
-  const cacheKey = communitiesLiveCollection.getCacheKey();
+  const limit = queryLimit ?? COLLECTION_DEFAULT_PAGINATION_LIMIT;
+  const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
 
+  const disposers: Amity.Unsubscriber[] = [];
+  const cacheKey = ['community', 'collection', queryParams as Amity.Serializable];
+
+  const responder = (data: Amity.CommunityLiveCollectionCache) => {
+    let communities: Amity.Community[] =
+      data.data
+        .map(communityId => pullFromCache<Amity.Community>(['community', 'get', communityId])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    communities = filterByStringComparePartially(communities, 'displayName', params.displayName);
+
+    if (!params.includeDeleted) {
+      communities = filterByPropEquality(communities, 'isDeleted', false);
+    }
+
+    if (params.categoryId) {
+      communities = communities.filter(c => c.categoryIds?.includes(params.categoryId!));
+    }
+
+    if (params.tags) {
+      communities = communities.filter(c => c.tags?.some(t => params.tags?.includes(t)));
+    }
+
+    if (params.membership && userId) {
+      communities = filterByCommunityMembership(communities, params.membership, userId);
+    }
+
+    const sortBy = params.sortBy || 'lastCreated';
+
+    if (sortBy === 'lastCreated' || sortBy === 'firstCreated') {
+      communities = communities.sort(
+        sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated,
+      );
+    }
+
+    /*
+     * The server returns communities with empty | null displayName's first before
+     * returning sorted list of communities with displayNames
+     *
+     * This section needs to be updated as displayNames can be null as well
+     */
+    if (sortBy === 'displayName') {
+      communities = communities
+        // this needs to be aligned with the backend data type
+        .map(c => (c.displayName ? c : { ...c, displayName: '' }))
+        // @ts-ignore
+        .sort(sortByDisplayName);
+    }
+
+    callback({
+      onNextPage: onFetch,
+      data: communities,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (_: Amity.CommunityActionType) => (community: Amity.Community) => {
+    const collection = pullFromCache<Amity.CommunityLiveCollectionCache>(cacheKey)?.data;
+    if (!collection) return;
+
+    /*
+     * Simply update collection and let responder decide what to do with data
+     */
+    collection.data = [...new Set([community.communityId, ...collection.data])];
+
+    pushToCache(cacheKey, collection);
+    responder(collection);
+  };
+
+  const onFetch = (initial = false) => {
+    const collection = pullFromCache<Amity.CommunityLiveCollectionCache>(cacheKey)?.data;
+
+    const communities = collection?.data ?? [];
+
+    if (!initial && communities.length > 0 && !collection?.params.page) return;
+
+    const query = createQuery(queryCommunities, {
+      ...queryParams,
+      limit: initial ? limit : undefined,
+      page: !initial ? collection?.params.page : undefined,
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, paging }) => {
+        const data = {
+          loading,
+          error,
+          params: { page: paging?.next },
+          data: communities,
+        };
+
+        if (result) {
+          data.data = initial
+            ? result.map(getResolver('community'))
+            : [...new Set([...communities, ...result.map(getResolver('community'))])];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy, CACHE_SHORTEN_LIFESPAN),
+    );
+  };
+
+  disposers.push(
+    onCommunityCreated(realtimeRouter('onCreate')),
+    onCommunityDeleted(realtimeRouter('onDelete')),
+    onCommunityUpdated(realtimeRouter('onUpdate')),
+    onCommunityJoined(realtimeRouter('onJoin')),
+    onCommunityLeft(realtimeRouter('onLeft')),
+    onCommunityUserChanged(realtimeRouter('onMemberCountChanged')),
+  );
+
+  onFetch(true);
   disposers.push(() => dropFromCache(cacheKey));
 
   return () => {

package/src/communityRepository/observers/searchCommunities.ts

@@ -8,7 +8,7 @@ import { SearchCommunityLiveCollectionController } from './searchCommunities/Sea
 */
 /**
  * ```js
- * import { CommunityRepository } from '@amityco/ts-sdk-react-native'
+ * import { CommunityRepository } from '@amityco/ts-sdk'
  *
  * let communities = []
  * const unsub = CommunityRepository.searchCommunities({

package/src/communityRepository/utils/payload.ts

@@ -1,5 +1,4 @@
 import { CommunityPostSettingMaps, DefaultCommunityPostSetting } from '~/@types';
-import { pullFromCache } from '~/cache/api';
 import { withUsers } from '~/group/utils';
 import { updateMembershipStatus } from './communityWithMembership';
 
@@ -14,22 +13,6 @@ const getMatchPostSetting = (value: {
       value.onlyAdminCanPost === CommunityPostSettingMaps[key].onlyAdminCanPost,
   ) ?? DefaultCommunityPostSetting;
 
-const convertCommunityUsersToUniqueObject = (
-  communityUsers: Amity.RawMembership<'community'>[],
-) => {
-  if (!communityUsers) return communityUsers;
-
-  const result: {
-    [key: Amity.RawMembership<'community'>['userId']]: Amity.RawMembership<'community'>;
-  } = {};
-
-  communityUsers.forEach(user => {
-    result[user.userId] = user;
-  });
-
-  return result;
-};
-
 export const prepareCommunityPayload = (
   rawPayload: Amity.CommunityPayload,
 ): Amity.ProcessedCommunityPayload => {
@@ -44,24 +27,7 @@ export const prepareCommunityPayload = (
     }),
   );
 
-  const mergeCommunityUsers = communities.reduce<{
-    [key: string]: Amity.RawMembership<'community'>;
-  }>((acc, { communityId }) => {
-    const users = pullFromCache<Amity.RawMembership<'community'>[]>([
-      'communityUsers',
-      'collection',
-      communityId,
-    ])?.data;
-
-    if (!users) return acc;
-
-    return {
-      ...convertCommunityUsersToUniqueObject(users),
-      ...acc,
-    };
-  }, convertCommunityUsersToUniqueObject(rawPayload.communityUsers));
-
-  const communityUsers = withUsers(Object.values(mergeCommunityUsers));
+  const communityUsers = withUsers(rawPayload.communityUsers);
 
   const communityWithMembershipStatus = updateMembershipStatus(communities, communityUsers);
 

package/src/core/model/idResolvers.ts

@@ -44,7 +44,6 @@ const idResolvers: Resolvers = {
   reactor: ({ reactionId }) => reactionId,
 
   stream: ({ streamId }) => streamId,
-  streamModeration: ({ streamId }) => streamId,
 
   follow: ({ from, to }) => `${from}#${to}`,
   followInfo: ({ userId }) => userId,

package/src/core/model/index.ts

@@ -41,7 +41,6 @@ export const PAYLOAD2MODEL: Record<string, Amity.Domain> = {
   reactions: 'reaction',
 
   videoStreamings: 'stream',
-  videoStreamModerations: 'streamModeration',
 
   follows: 'follow',
   followCounts: 'followCount',

package/src/streamRepository/api/createStream.ts

@@ -1,7 +1,6 @@
 import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { LinkedObject } from '~/utils/linkedObject';
 
 /* begin_public_function
   id: stream.create
@@ -12,18 +11,16 @@ import { LinkedObject } from '~/utils/linkedObject';
  * const created = await createStream({ title: 'my stream', 'thumbnailFileId': fileId  })
  * ```
  *
- * Creates an {@link Amity.InternalStream}
+ * Creates an {@link Amity.Stream}
  *
- * @param bundle The data necessary to create a new {@link Amity.InternalStream}
- * @returns The newly created {@link Amity.InternalStream}
+ * @param bundle The data necessary to create a new {@link Amity.Stream}
+ * @returns The newly created {@link Amity.Stream}
  *
  * @category Stream API
  * @async
  */
 export const createStream = async (
-  bundle: Pick<Amity.InternalStream, 'title' | 'thumbnailFileId' | 'description'> & {
-    isSecure?: boolean;
-  },
+  bundle: Pick<Amity.Stream, 'title' | 'thumbnailFileId' | 'description'> & { isSecure?: boolean },
 ): Promise<Amity.Cached<Amity.Stream>> => {
   const client = getActiveClient();
   client.log('stream/createStream', bundle);
@@ -36,7 +33,7 @@ export const createStream = async (
   const { videoStreamings } = data;
 
   return {
-    data: LinkedObject.stream(videoStreamings[0]),
+    data: videoStreamings[0],
     cachedAt,
   };
 };

package/src/streamRepository/api/deleteStream.ts

@@ -15,17 +15,15 @@ import { getStream } from './getStream';
  * const success = await deleteStream(streamId)
  * ```
  *
- * Deletes a {@link Amity.InternalStream}
+ * Deletes a {@link Amity.Stream}
  *
- * @param streamId The {@link Amity.InternalStream} ID to delete
- * @return A success boolean if the {@link Amity.InternalStream} was deleted
+ * @param streamId The {@link Amity.Stream} ID to delete
+ * @return A success boolean if the {@link Amity.Stream} was deleted
  *
  * @category Stream API
  * @async
  */
-export const deleteStream = async (
-  streamId: Amity.InternalStream['streamId'],
-): Promise<boolean> => {
+export const deleteStream = async (streamId: Amity.Stream['streamId']): Promise<boolean> => {
   const client = getActiveClient();
   client.log('stream/deleteStream', streamId);
 

package/src/streamRepository/api/disposeStream.ts

@@ -8,18 +8,18 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * const stream = await disposeStream(streamId)
  * ```
  *
- * Dispose a {@link Amity.InternalStream}.
+ * Dispose a {@link Amity.Stream}.
  * Streaming status will be updated to "ended" and streaming url will be invalidated
  *
- * @param streamId The {@link Amity.InternalStream} ID to dispose
- * @returns the associated {@link Amity.InternalStream} object
+ * @param streamId The {@link Amity.Stream} ID to dispose
+ * @returns the associated {@link Amity.Stream} object
  *
  * @category Stream API
  * @async
  */
 export const disposeStream = async (
-  streamId: Amity.InternalStream['streamId'],
-): Promise<Amity.Cached<Amity.InternalStream>> => {
+  streamId: Amity.Stream['streamId'],
+): Promise<Amity.Cached<Amity.Stream>> => {
   const client = getActiveClient();
   client.log('stream/disposeStream', streamId);
 

package/src/streamRepository/api/getStreams.ts

@@ -0,0 +1,81 @@
+import { getActiveClient } from '~/client/api';
+
+import { toPage, toToken } from '~/core/query';
+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 getStreams = async (query?: {
+  isLive?: boolean;
+  statuses?: Amity.StreamStatus[];
+  userPublicIds?: Amity.InternalUser['userId'][];
+  sortBy?: 'lastCreated' | 'firstCreated';
+  isDeleted?: Amity.Stream['isDeleted'];
+  page?: Amity.Page;
+}): Promise<Amity.Cached<Amity.Paged<Amity.Stream>>> => {
+  const client = getActiveClient();
+  client.log('stream/getStreams', query);
+
+  const { page, ...params } = query ?? {};
+
+  const { data } = await client.http.get<{ results: Amity.StreamPayload } & Amity.Pagination>(
+    `/api/v3/video-streaming`,
+    {
+      params: {
+        ...params,
+        options: {
+          token: toToken(page, 'skiplimit'),
+        },
+      },
+    },
+  );
+
+  // 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 });
+
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
+
+  return { data: videoStreamings, cachedAt, prevPage, nextPage };
+};
+/* end_public_function */
+
+/**
+ * ```js
+ * import { getStreams } from '@amityco/ts-sdk-react-native'
+ * const streams = getStreams.locally()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Stream} objects from cache
+ *
+ * @param query The query parameters
+ * @returns streams
+ *
+ * @category Stream API
+ */
+getStreams.locally = (query: Parameters<typeof getStreams>[0]) => {
+  const client = getActiveClient();
+  client.log('stream/getStreams.locally', query);
+
+  // TODO
+};

package/src/streamRepository/api/queryStreams.ts

@@ -14,10 +14,10 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * const streams = await getStreams()
  * ```
  *
- * Queries a paginable list of {@link Amity.InternalStream} objects
+ * Queries a paginable list of {@link Amity.Stream} objects
  *
  * @param query The query parameters
- * @returns A page of {@link Amity.InternalStream} objects
+ * @returns A page of {@link Amity.Stream} objects
  *
  * @category Stream API
  * @async
@@ -27,9 +27,9 @@ export const queryStreams = async (query?: {
   statuses?: Amity.StreamStatus[];
   userPublicIds?: Amity.InternalUser['userId'][];
   sortBy?: 'lastCreated' | 'firstCreated';
-  isDeleted?: Amity.InternalStream['isDeleted'];
+  isDeleted?: Amity.Stream['isDeleted'];
   page?: Amity.Page;
-}): Promise<Amity.Cached<Amity.Paged<Amity.InternalStream>>> => {
+}): Promise<Amity.Cached<Amity.Paged<Amity.Stream>>> => {
   const client = getActiveClient();
   client.log('stream/queryStreams', query);
 

package/src/streamRepository/api/updateStream.ts

@@ -1,7 +1,6 @@
 import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { LinkedObject } from '~/utils/linkedObject';
 
 /* begin_public_function
   id: stream.update
@@ -39,7 +38,7 @@ export const updateStream = async (
   const { videoStreamings } = data;
 
   return {
-    data: LinkedObject.stream(videoStreamings.find(stream => stream.streamId === streamId)!),
+    data: videoStreamings.find(stream => stream.streamId === streamId)!,
     cachedAt,
   };
 };

package/src/streamRepository/events/index.ts

@@ -1,5 +1,3 @@
 export { onStreamStarted } from './onStreamStarted';
 export { onStreamStopped } from './onStreamStopped';
 export { onStreamRecorded } from './onStreamRecorded';
-export { onStreamFlagged } from './onStreamFlagged';
-export { onStreamTerminated } from './onStreamTerminated';

package/src/streamRepository/events/onStreamRecorded.ts

@@ -11,16 +11,14 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * })
  * ```
  *
- * Fired when the recordings of a {@link Amity.InternalStream} are available
+ * Fired when the recordings of a {@link Amity.Stream} are available
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category Stream Events
  */
-export const onStreamRecorded = (
-  callback: Amity.Listener<Amity.InternalStream>,
-): Amity.Unsubscriber => {
+export const onStreamRecorded = (callback: Amity.Listener<Amity.Stream>): Amity.Unsubscriber => {
   const client = getActiveClient();
 
   const filter = (payload: Amity.StreamPayload) => {