@amityco/ts-sdk 6.4.6-e12bdf9.0 → 6.5.0

package/src/reactionRepository/observers/getReactions.ts

@@ -10,7 +10,7 @@ import {
 } from '~/utils/constants';
 
 import { onReactorAdded, onReactorRemoved } from '../events';
-import { queryReactions } from '../api/queryReactions';
+import { queryReactor } from '../api/queryReactor';
 
 /* begin_public_function
   id: reaction.query
@@ -26,11 +26,11 @@ import { queryReactions } from '../api/queryReactions';
  * }, response => merge(reactions, response.data))
  * ```
  *
- * Observe all mutations on a list of {@link Amity.Reaction} for a given target object
+ * Observe all mutations on a list of {@link Amity.Reactor} for a given target object
  *
- * @param params.referenceType the type of the target
- * @param params.referenceId the ID of the target
+ * @param params for querying reactions
  * @param callback the function to call when new data are available
+ * @param config the live collection configuration
  * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the messages
  *
  * @category Reactions Live Collection
@@ -98,7 +98,7 @@ export const getReactions = (
 
     if (!initial && reactions.length > 0 && !collection?.params?.page) return;
 
-    const query = createQuery(queryReactions, {
+    const query = createQuery(queryReactor, {
       ...queryParams,
       page: (!initial ? collection?.params.page : undefined) ?? { limit },
     });
@@ -114,9 +114,7 @@ export const getReactions = (
         };
 
         if (result) {
-          data.data = [
-            ...new Set([...reactions, ...result[0].reactors.map(getResolver('reaction'))]),
-          ];
+          data.data = [...new Set([...reactions, ...result.map(getResolver('reactor'))])];
         }
 
         pushToCache(cacheKey, data);

package/src/streamRepository/observers/getStreamById.ts

@@ -3,6 +3,8 @@
 import { onStreamRecorded, onStreamStarted, onStreamStopped } from '../events';
 import { getStream as _getStream } from '../api/getStream';
 import { liveObject } from '~/utils/liveObject';
+import { getActiveClient } from '~/client';
+import { pullFromCache } from '~/cache/api';
 
 /* begin_public_function
   id: stream.get
@@ -10,7 +12,8 @@ import { liveObject } from '~/utils/liveObject';
 /**
  * ```js
  * import { StreamRepository } from '@amityco/ts-sdk'
- * const stream = await StreamRepository.getStreamById('foobar')
+ * const unsub = StreamRepository.getStreamById('foobar')
+ * unsub()
  * ```
  *
  * Fetches a {@link Amity.Stream} object
@@ -32,3 +35,34 @@ export const getStreamById = (
   ]);
 };
 /* end_public_function */
+
+/**
+ * ```js
+ * import { StreamRepository } from '@amityco/ts-sdk'
+ * const stream = StreamRepository.getStreamById.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Stream} live object
+ *
+ * @param streamId the ID of the {@link Amity.Stream} to fetch
+ * @returns the associated {@link Amity.Stream} live object
+ *
+ * @category Stream API
+ */
+getStreamById.locally = (
+  streamId: Amity.Stream['streamId'],
+): Amity.Cached<Amity.Stream> | undefined => {
+  const client = getActiveClient();
+  client.log('stream/getStreamById', streamId);
+
+  if (!client.cache) return;
+
+  const cached = pullFromCache<Amity.Stream>(['stream', 'get', streamId]);
+
+  if (!cached) return;
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  };
+};

package/src/streamRepository/observers/getStreams.ts

@@ -50,7 +50,7 @@ export const getStreams = (
   }
 
   const timestamp = Date.now();
-  log(`queryStreams(tmpid: ${timestamp}) > listen`);
+  log(`getStreams(tmpid: ${timestamp}) > listen`);
 
   const { limit: queryLimit, ...queryParams } = params;
 
@@ -58,7 +58,7 @@ export const getStreams = (
   const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
 
   const disposers: Amity.Unsubscriber[] = [];
-  const cacheKey = ['streams', 'collection', {}];
+  const cacheKey = ['streams', 'collection', params];
 
   const applyFilter = (data: Amity.Stream[]): Amity.Stream[] => {
     let streams = filterByPropEquality(data, 'isDeleted', params.isDeleted);
@@ -73,7 +73,9 @@ export const getStreams = (
   const responder = (data: Amity.UserLiveCollectionCache, isEventModel = false) => {
     const streams: Amity.Stream[] =
       data.data
-        .map(streamId => pullFromCache<Amity.Stream>(['streams', 'get', streamId])!)
+        .map(streamId => {
+          return pullFromCache<Amity.Stream>(['stream', 'get', streamId])!;
+        })
         .filter(Boolean)
         .map(({ data }) => data) ?? [];
 
@@ -124,7 +126,6 @@ export const getStreams = (
         if (result) {
           data.data = [...new Set([...streams, ...result.map(getResolver('stream'))])];
         }
-
         pushToCache(cacheKey, data);
 
         responder(data);
@@ -142,7 +143,7 @@ export const getStreams = (
   onFetch(true);
 
   return () => {
-    log(`queryStreams(tmpid: ${timestamp}) > dispose`);
+    log(`getStreams(tmpid: ${timestamp}) > dispose`);
     disposers.forEach(fn => fn());
   };
 };

package/src/streamRepository/observers/tests/getStreamById.test.ts

@@ -0,0 +1,44 @@
+import { enableCache } from '~/cache/api';
+import { client, connectClient, disconnectClient, pause, streamResponse } from '~/utils/tests';
+import { getStreamById } from '../getStreamById';
+
+const STREAM_ID = streamResponse.data.videoStreamings[0].streamId;
+
+const getSnapshot = (params?: Record<string, any>) => {
+  return {
+    data: undefined as undefined | Amity.Stream,
+    loading: true,
+    error: undefined as any,
+    ...params,
+  };
+};
+
+describe('getStreamById', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  test('Should return the stream from backend', async () => {
+    enableCache();
+    const snapshot = getSnapshot();
+    const update = getSnapshot({ data: streamResponse.data.videoStreamings[0], loading: false });
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(streamResponse);
+
+    getStreamById(STREAM_ID, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(1, expect.objectContaining(snapshot));
+    expect(callback).toHaveBeenNthCalledWith(2, expect.objectContaining(update));
+  });
+
+  test('Should return stream from locally', async () => {
+    const stream: ReturnType<typeof getStreamById.locally> = getStreamById.locally(STREAM_ID);
+    expect(stream?.data).toEqual(streamResponse.data.videoStreamings[0]);
+  });
+});

package/src/userRepository/observers/getUsers.ts

@@ -28,6 +28,36 @@ import {
   onUserDeleted,
 } from '../events';
 
+/*
+ * Exported for testing
+ * @hidden
+ */
+export const applyFilter = <T extends Amity.User>(
+  data: T[],
+  params: Amity.UserLiveCollection,
+): T[] => {
+  let users = filterByPropEquality(data, 'displayName', params.displayName);
+
+  switch (params.sortBy) {
+    case 'firstCreated':
+      users = users.sort(sortByFirstCreated);
+      break;
+
+    case 'lastCreated':
+      users = users.sort(sortByLastCreated);
+      break;
+
+    default:
+      users = users
+        // this needs to be aligned with the backend data type
+        .map(u => (u.displayName ? u : { ...u, displayName: '' }))
+        // @ts-ignore
+        .sort(sortByDisplayName);
+  }
+
+  return users;
+};
+
 /* begin_public_function
   id: user.query
 */
@@ -55,6 +85,7 @@ export const getUsers = (
   const { log, cache } = getActiveClient();
 
   if (!cache) {
+    // eslint-disable-next-line no-console
     console.log(ENABLE_CACHE_MESSAGE);
   }
 
@@ -69,29 +100,6 @@ export const getUsers = (
   const disposers: Amity.Unsubscriber[] = [];
   const cacheKey = ['user', 'collection', {}];
 
-  const applyFilter = (data: Amity.User[]): Amity.User[] => {
-    let users = filterByPropEquality(data, 'displayName', params.displayName);
-
-    switch (params.sortBy) {
-      case 'firstCreated':
-        users = users.sort(sortByFirstCreated);
-        break;
-
-      case 'lastCreated':
-        users = users.sort(sortByLastCreated);
-        break;
-
-      default:
-        users = users
-          // this needs to be aligned with the backend data type
-          .map(u => (u.displayName ? u : { ...u, displayName: '' }))
-          // @ts-ignore
-          .sort(sortByDisplayName);
-    }
-
-    return users;
-  };
-
   const responder = (data: Amity.UserLiveCollectionCache, isEventModel = false) => {
     const users: Amity.User[] =
       data.data
@@ -104,7 +112,7 @@ export const getUsers = (
       /*
        * Only apply filter to RTE Model
        */
-      data: isEventModel ? applyFilter(users) : users,
+      data: isEventModel ? applyFilter(users, params) : users,
       hasNextPage: !!data.params?.page,
       loading: data.loading,
       error: data.error,

package/src/userRepository/observers/tests/getUsers.test.ts

@@ -1,3 +1,4 @@
+import { getPastDate } from '~/core/model';
 import { disableCache, enableCache } from '~/cache/api';
 import {
   client,
@@ -10,7 +11,10 @@ import {
   userQueryResponsePage2,
 } from '~/utils/tests';
 
-import { getUsers } from '../getUsers';
+// makes it easier to spy on applyFilter
+import * as getUsersModule from '../getUsers';
+
+const { getUsers, applyFilter } = getUsersModule;
 
 const getSnapshot = (params?: Record<string, any>) => {
   return {
@@ -166,5 +170,46 @@ describe('getUsers', () => {
         ),
       );
     });
+
+    test('it should apply filters on RTE only', async () => {
+      const callback = jest.fn();
+      const applyFilterSpy = jest.spyOn(getUsersModule, 'applyFilter');
+      client.http.get = jest.fn().mockResolvedValue(userQueryResponse);
+
+      getUsers(params, callback);
+      await pause();
+
+      expect(applyFilterSpy).not.toHaveBeenCalled();
+
+      client.emitter.emit('user.updated', { users: [updatedUser], files: [] });
+      await pause();
+
+      expect(applyFilterSpy).toHaveBeenCalled();
+    });
+  });
+});
+
+describe('getUsers > applyFilter', () => {
+  const u1 = {
+    userId: 'test',
+    displayName: 'a',
+    createdAt: new Date().toISOString(),
+  } as Amity.User;
+
+  const u2 = {
+    userId: 'searchable',
+    displayName: 'b',
+    createdAt: getPastDate(),
+  } as Amity.User;
+
+  const filters: [string, Amity.UserLiveCollection, Amity.User[], Amity.User[]][] = [
+    ['it should filter by display name', { displayName: 'a' }, [u1, u2], [u1]],
+    ['it should sort by dispaly name', {}, [u1, u2], [u1, u2]],
+    ['it should sort by last created', { sortBy: 'lastCreated' }, [u1, u2], [u1, u2]],
+    ['it should sort by first created', { sortBy: 'firstCreated' }, [u1, u2], [u2, u1]],
+  ];
+
+  test.each(filters)('%s', (test, param, input, expected) => {
+    expect(applyFilter(input, param)).toStrictEqual(expected);
   });
 });

package/src/utils/tests/dummy/reaction.ts

@@ -1,22 +1,18 @@
 import { post11, user11 } from '.';
 
-export const reaction11: Amity.Reaction = {
-  reactionName: 'reaction11',
-  reactionId: 'reaction11',
-  referenceId: post11.postId,
-  referenceType: 'post',
-  userId: user11.userId,
-  createdAt: '',
-};
-
 export const reactor11: Amity.Reactor = {
   reactionName: 'reaction11',
   reactionId: 'reaction11',
   userId: user11.userId,
   createdAt: '',
 };
+export const reaction11: Amity.Reaction = {
+  referenceId: post11.postId,
+  referenceType: 'post',
+  reactors: [reactor11],
+};
 
 export const reactionPayload: Amity.ReactionPayload = {
-  reactions: [{ ...reaction11, reactors: [reactor11] }],
+  reactions: [reaction11],
   users: [user11],
 };

package/src/utils/tests/dummy/stream.ts

@@ -84,3 +84,50 @@ export const streamResponse = {
     ],
   },
 };
+
+export const streamsResponse = [
+  {
+    title: 'Deleted',
+    description: 'Deleted',
+    metadata: {},
+    streamerUrl: {},
+    watcherUrl: {},
+    status: 'ended',
+    isLive: false,
+    isDeleted: true,
+    startedAt: '2023-06-06T05:43:31.540Z',
+    endedAt: '2023-06-06T07:21:54.298Z',
+    resolution: 'HD',
+    updatedAt: '2023-06-06T07:21:54.299Z',
+    createdAt: '2023-06-06T05:43:21.633Z',
+    streamId: '53d239a2d1b05f340ab0010d71e8b1a0',
+    userId: 'DFonV53',
+    thumbnailFileId: null,
+    platform: {
+      name: 'apsara',
+      version: '2016-11-01',
+    },
+  },
+  {
+    title: 'Deleted',
+    description: 'Deleted',
+    metadata: {},
+    streamerUrl: {},
+    watcherUrl: {},
+    status: 'ended',
+    isLive: false,
+    isDeleted: true,
+    startedAt: '2023-06-06T04:14:34.066Z',
+    endedAt: '2023-06-06T07:21:54.298Z',
+    resolution: 'HD',
+    updatedAt: '2023-06-06T07:21:54.299Z',
+    createdAt: '2023-06-06T04:14:26.166Z',
+    streamId: '9370a1f526389435946199e49428522d',
+    userId: 'DFonV53',
+    thumbnailFileId: null,
+    platform: {
+      name: 'apsara',
+      version: '2016-11-01',
+    },
+  },
+];