@stream-io/feeds-client 0.1.1 → 0.1.3

package/dist/index.node.js

@@ -259,6 +259,14 @@ decoders.BookmarkDeletedEvent = (input) => {
     };
     return decode(typeMappings, input);
 };
+decoders.BookmarkFolderDeletedEvent = (input) => {
+    const typeMappings = {
+        created_at: { type: 'DatetimeType', isSingle: true },
+        bookmark_folder: { type: 'BookmarkFolderResponse', isSingle: true },
+        received_at: { type: 'DatetimeType', isSingle: true },
+    };
+    return decode(typeMappings, input);
+};
 decoders.BookmarkFolderResponse = (input) => {
     const typeMappings = {
         created_at: { type: 'DatetimeType', isSingle: true },
@@ -266,6 +274,14 @@ decoders.BookmarkFolderResponse = (input) => {
     };
     return decode(typeMappings, input);
 };
+decoders.BookmarkFolderUpdatedEvent = (input) => {
+    const typeMappings = {
+        created_at: { type: 'DatetimeType', isSingle: true },
+        bookmark_folder: { type: 'BookmarkFolderResponse', isSingle: true },
+        received_at: { type: 'DatetimeType', isSingle: true },
+    };
+    return decode(typeMappings, input);
+};
 decoders.BookmarkResponse = (input) => {
     const typeMappings = {
         created_at: { type: 'DatetimeType', isSingle: true },
@@ -1225,6 +1241,12 @@ decoders.UpdateBlockListResponse = (input) => {
     };
     return decode(typeMappings, input);
 };
+decoders.UpdateBookmarkFolderResponse = (input) => {
+    const typeMappings = {
+        bookmark_folder: { type: 'BookmarkFolderResponse', isSingle: true },
+    };
+    return decode(typeMappings, input);
+};
 decoders.UpdateBookmarkResponse = (input) => {
     const typeMappings = {
         bookmark: { type: 'BookmarkResponse', isSingle: true },
@@ -1645,6 +1667,26 @@ class FeedsApi {
         decoders.QueryBookmarkFoldersResponse?.(response.body);
         return { ...response.body, metadata: response.metadata };
     }
+    async deleteBookmarkFolder(request) {
+        const pathParams = {
+            folder_id: request?.folder_id,
+        };
+        const response = await this.apiClient.sendRequest('DELETE', '/api/v2/feeds/bookmark_folders/{folder_id}', pathParams, undefined);
+        decoders.DeleteBookmarkFolderResponse?.(response.body);
+        return { ...response.body, metadata: response.metadata };
+    }
+    async updateBookmarkFolder(request) {
+        const pathParams = {
+            folder_id: request?.folder_id,
+        };
+        const body = {
+            name: request?.name,
+            custom: request?.custom,
+        };
+        const response = await this.apiClient.sendRequest('PATCH', '/api/v2/feeds/bookmark_folders/{folder_id}', pathParams, undefined, body, 'application/json');
+        decoders.UpdateBookmarkFolderResponse?.(response.body);
+        return { ...response.body, metadata: response.metadata };
+    }
     async queryBookmarks(request) {
         const body = {
             limit: request?.limit,
@@ -2321,14 +2363,9 @@ class StateStore {
             let previouslySelectedValues;
             const wrappedHandler = (nextValue) => {
                 const newlySelectedValues = selector(nextValue);
-                let hasUpdatedValues = typeof previouslySelectedValues === 'undefined';
-                for (const key in previouslySelectedValues) {
-                    if (previouslySelectedValues[key] === newlySelectedValues[key])
-                        continue;
-                    hasUpdatedValues = true;
-                    break;
-                }
-                if (!hasUpdatedValues)
+                // shallow comparison of previouslySelectedValues and newlySelectedValues
+                const selectionsAreEqual = StateStore.doSelectionsEqual(previouslySelectedValues, newlySelectedValues);
+                if (selectionsAreEqual)
                     return;
                 // save a copy of previouslySelectedValues before running
                 // handler - if previouslySelectedValues are set to
@@ -2359,7 +2396,7 @@ class StateStore {
             ? newValueOrPatch(this.value)
             : newValueOrPatch;
         // do not notify subscribers if the value hasn't changed
-        if (newValue === this.value)
+        if (Object.is(newValue, this.value))
             return;
         this.preprocessors.forEach((preprocessor) => preprocessor(newValue, this.value));
         const oldValue = this.value;
@@ -2376,6 +2413,19 @@ class StateStore {
             this.handlers.delete(handler);
         };
     }
+    static doSelectionsEqual(previouslySelectedValues, newlySelectedValues) {
+        let selectionsAreEqual;
+        if ((selectionsAreEqual = typeof previouslySelectedValues !== 'undefined')) {
+            for (const key in newlySelectedValues) {
+                if (Object.is(previouslySelectedValues[key], newlySelectedValues[key])) {
+                    continue;
+                }
+                selectionsAreEqual = false;
+                break;
+            }
+        }
+        return selectionsAreEqual;
+    }
     /**
      * Registers a preprocessor function that will be called before the state is updated.
      *
@@ -2601,7 +2651,7 @@ function getRandomValuesWithMathRandom(bytes) {
     }
 }
 const getRandomValues = (() => {
-    if (typeof crypto?.getRandomValues !== 'undefined') {
+    if (typeof crypto !== 'undefined' && typeof crypto?.getRandomValues !== 'undefined') {
         return crypto.getRandomValues.bind(crypto);
     }
     else if (typeof msCrypto !== 'undefined') {
@@ -3493,7 +3543,10 @@ class ApiClient {
             const encodedBody = requestContentType === 'multipart/form-data' ? new FormData() : body;
             if (requestContentType === 'multipart/form-data') {
                 Object.keys(body).forEach((key) => {
-                    encodedBody.append(key, body[key]);
+                    const value = body[key];
+                    if (value != null) {
+                        encodedBody.append(key, value);
+                    }
                 });
             }
             try {
@@ -3502,8 +3555,11 @@ class ApiClient {
                     method,
                     headers,
                     params: queryParams,
-                    paramsSerializer: params => this.queryParamsStringify(params),
+                    paramsSerializer: (params) => this.queryParamsStringify(params),
                     data: encodedBody,
+                    timeout: 
+                    // multipart/form-data requests should not have a timeout allowing ample time for file uploads
+                    requestContentType === 'multipart/form-data' ? 0 : this.timeout,
                 });
                 const metadata = this.getRequestMetadata(client_request_id, response);
                 return { body: response.data, metadata };
@@ -3567,9 +3623,9 @@ class ApiClient {
             };
         };
         this.baseUrl = options?.base_url ?? 'https://video.stream-io-api.com';
+        this.timeout = options?.timeout ?? 3000;
         this.axiosInstance = axios.create({
             baseURL: this.baseUrl,
-            timeout: options?.timeout ?? 3000,
         });
     }
     get webSocketBaseUrl() {
@@ -3610,6 +3666,8 @@ const eventDecoderMapping = {
     'feeds.bookmark.added': (data) => decoders.BookmarkAddedEvent(data),
     'feeds.bookmark.deleted': (data) => decoders.BookmarkDeletedEvent(data),
     'feeds.bookmark.updated': (data) => decoders.BookmarkUpdatedEvent(data),
+    'feeds.bookmark_folder.deleted': (data) => decoders.BookmarkFolderDeletedEvent(data),
+    'feeds.bookmark_folder.updated': (data) => decoders.BookmarkFolderUpdatedEvent(data),
     'feeds.comment.added': (data) => decoders.CommentAddedEvent(data),
     'feeds.comment.deleted': (data) => decoders.CommentDeletedEvent(data),
     'feeds.comment.reaction.added': (data) => decoders.CommentReactionAddedEvent(data),
@@ -4012,6 +4070,8 @@ class Feed extends FeedApi {
             'feeds.bookmark.added': this.handleBookmarkAdded.bind(this),
             'feeds.bookmark.deleted': this.handleBookmarkDeleted.bind(this),
             'feeds.bookmark.updated': this.handleBookmarkUpdated.bind(this),
+            'feeds.bookmark_folder.deleted': Feed.noop,
+            'feeds.bookmark_folder.updated': Feed.noop,
             'feeds.comment.added': (event) => {
                 const { comment } = event;
                 const forId = comment.parent_id ?? comment.object_id;
@@ -4101,16 +4161,19 @@ class Feed extends FeedApi {
                     return;
                 // this feed followed someone
                 if (event.follow.source_feed.fid === this.fid) {
-                    if (this.currentState.following_pagination?.next === END_OF_LIST) {
-                        this.state.next((currentState) => ({
+                    this.state.next((currentState) => {
+                        const newState = {
                             ...currentState,
                             ...event.follow.source_feed,
+                        };
+                        if (currentState.following_pagination?.next === END_OF_LIST) {
                             // TODO: respect sort
-                            following: currentState.following
+                            newState.following = currentState.following
                                 ? currentState.following.concat(event.follow)
-                                : [event.follow],
-                        }));
-                    }
+                                : [event.follow];
+                        }
+                        return newState;
+                    });
                 }
                 else if (
                 // someone followed this feed
@@ -4120,14 +4183,14 @@ class Feed extends FeedApi {
                     this.state.next((currentState) => {
                         const newState = { ...currentState, ...event.follow.target_feed };
                         if (source.created_by.id === connectedUser?.id) {
-                            newState.own_follows = newState.own_follows
-                                ? newState.own_follows.concat(event.follow)
+                            newState.own_follows = currentState.own_follows
+                                ? currentState.own_follows.concat(event.follow)
                                 : [event.follow];
                         }
                         if (currentState.followers_pagination?.next === END_OF_LIST) {
                             // TODO: respect sort
-                            newState.followers = newState.followers
-                                ? newState.followers.concat(event.follow)
+                            newState.followers = currentState.followers
+                                ? currentState.followers.concat(event.follow)
                                 : [event.follow];
                         }
                         return newState;
@@ -4153,9 +4216,9 @@ class Feed extends FeedApi {
                     this.state.next((currentState) => {
                         const newState = { ...currentState, ...event.follow.target_feed };
                         if (source.created_by.id === connectedUser?.id) {
-                            newState.own_follows = newState.own_follows?.filter((follow) => follow.source_feed.fid !== event.follow.source_feed.fid);
+                            newState.own_follows = currentState.own_follows?.filter((follow) => follow.source_feed.fid !== event.follow.source_feed.fid);
                         }
-                        newState.followers = newState.followers?.filter((follow) => follow.source_feed.fid !== event.follow.source_feed.fid);
+                        newState.followers = currentState.followers?.filter((follow) => follow.source_feed.fid !== event.follow.source_feed.fid);
                         return newState;
                     });
                 }
@@ -4282,6 +4345,12 @@ class Feed extends FeedApi {
             };
         });
     }
+    async synchronize() {
+        const { last_get_or_create_request_config } = this.state.getLatestValue();
+        if (last_get_or_create_request_config?.watch) {
+            await this.getOrCreate(last_get_or_create_request_config);
+        }
+    }
     async getOrCreate(request) {
         if (this.currentState.is_loading_activities) {
             throw new Error('Only one getOrCreate call is allowed at a time');
@@ -4347,6 +4416,7 @@ class Feed extends FeedApi {
                     if (!request?.following_pagination?.limit) {
                         delete nextState.following;
                     }
+                    nextState.last_get_or_create_request_config = request;
                     return nextState;
                 });
             }
@@ -4633,7 +4703,7 @@ class Feed extends FeedApi {
     }
     async getNextPage() {
         const currentState = this.currentState;
-        const response = await this.getOrCreate({
+        return await this.getOrCreate({
             member_pagination: {
                 limit: 0,
             },
@@ -4644,8 +4714,8 @@ class Feed extends FeedApi {
                 limit: 0,
             },
             next: currentState.next,
+            limit: currentState.last_get_or_create_request_config?.limit ?? 20,
         });
-        return response;
     }
     addActivity(request) {
         return this.feedsApi.addActivity({
@@ -5048,6 +5118,7 @@ class FeedsClient extends FeedsApi {
         super(apiClient);
         this.eventDispatcher = new EventDispatcher();
         this.activeFeeds = {};
+        this.healthyConnectionChangedEventCount = 0;
         this.pollFromState = (id) => this.polls_by_id.get(id);
         this.connectUser = async (user, tokenProvider) => {
             if (this.state.getLatestValue().connectedUser !== undefined ||
@@ -5063,7 +5134,10 @@ class FeedsClient extends FeedsApi {
                 }, this.tokenManager, this.connectionIdManager, [decodeWSEvent]);
                 this.wsConnection.on('all', (event) => this.eventDispatcher.dispatch(event));
                 const connectedEvent = await this.wsConnection.connect();
-                this.state.partialNext({ connectedUser: connectedEvent?.me });
+                this.state.partialNext({
+                    connectedUser: connectedEvent?.me,
+                    isWsConnectionHealthy: this.wsConnection.isHealthy,
+                });
             }
             catch (err) {
                 await this.disconnectUser();
@@ -5118,13 +5192,20 @@ class FeedsClient extends FeedsApi {
             removeConnectionEventListeners(this.updateNetworkConnectionStatus);
             this.connectionIdManager.reset();
             this.tokenManager.reset();
-            this.state.partialNext({ connectedUser: undefined });
+            this.state.partialNext({ connectedUser: undefined, isWsConnectionHealthy: false });
         };
         this.on = this.eventDispatcher.on;
         this.off = this.eventDispatcher.off;
         this.feed = (groupId, id) => {
             return this.getOrCreateActiveFeed(groupId, id);
         };
+        this.updateNetworkConnectionStatus = (event) => {
+            const networkEvent = {
+                type: 'network.changed',
+                online: event.type === 'online',
+            };
+            this.eventDispatcher.dispatch(networkEvent);
+        };
         this.getOrCreateActiveFeed = (group, id, data) => {
             const fid = `${group}:${id}`;
             if (this.activeFeeds[fid]) {
@@ -5136,15 +5217,9 @@ class FeedsClient extends FeedsApi {
                 return feed;
             }
         };
-        this.updateNetworkConnectionStatus = (event) => {
-            const networkEvent = {
-                type: 'network.changed',
-                online: event.type === 'online',
-            };
-            this.eventDispatcher.dispatch(networkEvent);
-        };
         this.state = new StateStore({
             connectedUser: undefined,
+            isWsConnectionHealthy: false,
         });
         this.moderation = new ModerationClient(apiClient);
         this.tokenManager = tokenManager;
@@ -5154,6 +5229,20 @@ class FeedsClient extends FeedsApi {
             const fid = event.fid;
             const feed = typeof fid === 'string' ? this.activeFeeds[fid] : undefined;
             switch (event.type) {
+                case 'connection.changed': {
+                    const { online } = event;
+                    this.state.partialNext({ isWsConnectionHealthy: online });
+                    if (online) {
+                        this.healthyConnectionChangedEventCount++;
+                        // we skip the first event as we could potentially be querying twice
+                        if (this.healthyConnectionChangedEventCount > 1) {
+                            for (const activeFeed of Object.values(this.activeFeeds)) {
+                                activeFeed.synchronize();
+                            }
+                        }
+                    }
+                    break;
+                }
                 case 'feeds.feed.created': {
                     if (feed)
                         break;