@stream-io/feeds-client 0.2.4 → 0.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/feeds-client",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "packageManager": "yarn@3.2.4",
   "main": "./dist/index.node.js",
   "exports": {

package/src/common/real-time/event-models.ts

@@ -36,3 +36,19 @@ export interface ConnectedEvent {
    */
   type: string;
 }
+
+export enum UnhandledErrorType {
+  ReconnectionReconciliation = 'reconnection-reconciliation',
+}
+
+export type SyncFailure = { feed: string, reason: unknown };
+
+export type UnhandledErrorEvent = {
+  type: 'errors.unhandled';
+  error_type: UnhandledErrorType;
+} & (
+  | {
+      error_type: UnhandledErrorType.ReconnectionReconciliation;
+      failures: SyncFailure[];
+    }
+);

package/src/feed/event-handlers/feed/handle-feed-updated.ts

@@ -1,9 +1,9 @@
 import { Feed } from '../../../feed';
-import { EventPayload } from '../../../types-internal';
+import { EventPayload, PartializeAllBut } from '../../../types-internal';
 
 export function handleFeedUpdated(
   this: Feed,
-  event: EventPayload<'feeds.feed.updated'>,
+  event: PartializeAllBut<EventPayload<'feeds.feed.updated'>, 'feed'>,
 ) {
   this.state.partialNext({ ...event.feed });
 }

package/src/feeds-client/feeds-client.ts

@@ -37,6 +37,7 @@ import { ModerationClient } from '../moderation-client';
 import { StreamPoll } from '../common/Poll';
 import {
   Feed,
+  handleFeedUpdated,
   handleFollowCreated,
   handleFollowDeleted,
   handleFollowUpdated,
@@ -44,6 +45,10 @@ import {
   handleWatchStopped,
 } from '../feed';
 import { handleUserUpdated } from './event-handlers';
+import {
+  SyncFailure,
+  UnhandledErrorType,
+} from '../common/real-time/event-models';
 
 export type FeedsClientState = {
   connected_user: OwnUser | undefined;
@@ -100,14 +105,7 @@ export class FeedsClient extends FeedsApi {
           this.state.partialNext({ is_ws_connection_healthy: 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();
-              }
-            }
+            this.recoverOnReconnect();
           } else {
             for (const activeFeed of Object.values(this.activeFeeds)) {
               handleWatchStopped.bind(activeFeed)();
@@ -208,6 +206,31 @@ export class FeedsClient extends FeedsApi {
     });
   }
 
+  private recoverOnReconnect = async () => {
+    this.healthyConnectionChangedEventCount++;
+
+    // we skip the first event as we could potentially be querying twice
+    if (this.healthyConnectionChangedEventCount > 1) {
+      const entries = Object.entries(this.activeFeeds);
+
+      const results = await Promise.allSettled(
+        entries.map(([, feed]) => feed.synchronize()),
+      );
+
+      const failures: SyncFailure[] = results.flatMap((result, index) =>
+        result.status === 'rejected'
+          ? [{ feed: entries[index][0], reason: result.reason }]
+          : [],
+      );
+
+      this.eventDispatcher.dispatch({
+        type: 'errors.unhandled',
+        error_type: UnhandledErrorType.ReconnectionReconciliation,
+        failures,
+      });
+    }
+  };
+
   public pollFromState = (id: string) => this.polls_by_id.get(id);
 
   public hydratePollCache(activities: ActivityResponse[]) {
@@ -353,8 +376,13 @@ export class FeedsClient extends FeedsApi {
   async queryFeeds(request?: QueryFeedsRequest) {
     const response = await this._queryFeeds(request);
 
-    const feeds = response.feeds.map((f) =>
-      this.getOrCreateActiveFeed(f.group_id, f.id, f, request?.watch),
+    const feeds = response.feeds.map((feedResponse) =>
+      this.getOrCreateActiveFeed(
+        feedResponse.group_id,
+        feedResponse.id,
+        feedResponse,
+        request?.watch,
+      ),
     );
 
     return {
@@ -458,17 +486,20 @@ export class FeedsClient extends FeedsApi {
     watch?: boolean,
   ) => {
     const fid = `${group}:${id}`;
-    if (this.activeFeeds[fid]) {
-      const feed = this.activeFeeds[fid];
-      if (watch && !feed.currentState.watch) {
-        handleWatchStarted.bind(feed)();
-      }
-      return feed;
-    } else {
-      const feed = new Feed(this, group, id, data, watch);
-      this.activeFeeds[fid] = feed;
-      return feed;
+
+    if (!this.activeFeeds[fid]) {
+      this.activeFeeds[fid] = new Feed(this, group, id, data, watch);
     }
+
+    const feed = this.activeFeeds[fid];
+
+    if (!feed.currentState.watch) {
+      // feed isn't watched and may be stale, update it
+      if (data) handleFeedUpdated.call(feed, { feed: data });
+      if (watch) handleWatchStarted.call(feed);
+    }
+
+    return feed;
   };
 
   private findActiveFeedByActivityId(activityId: string) {

package/src/gen/feeds/FeedsApi.ts

@@ -127,6 +127,8 @@ import {
   UpdateUsersResponse,
   UpsertActivitiesRequest,
   UpsertActivitiesResponse,
+  UpsertPushPreferencesRequest,
+  UpsertPushPreferencesResponse,
   WSAuthMessage,
 } from '../models';
 import { decoders } from '../model-decoders/decoders';
@@ -726,6 +728,7 @@ export class FeedsApi {
       text: request?.text,
       visibility: request?.visibility,
       attachments: request?.attachments,
+      feeds: request?.feeds,
       filter_tags: request?.filter_tags,
       interest_tags: request?.interest_tags,
       custom: request?.custom,
@@ -2073,6 +2076,29 @@ export class FeedsApi {
     return { ...response.body, metadata: response.metadata };
   }
 
+  async updatePushNotificationPreferences(
+    request: UpsertPushPreferencesRequest,
+  ): Promise<StreamResponse<UpsertPushPreferencesResponse>> {
+    const body = {
+      preferences: request?.preferences,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<UpsertPushPreferencesResponse>
+    >(
+      'POST',
+      '/api/v2/push_preferences',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.UpsertPushPreferencesResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
   async deleteFile(request?: {
     url?: string;
   }): Promise<StreamResponse<Response>> {

package/src/gen/model-decoders/decoders.ts

@@ -1849,6 +1849,13 @@ decoders.UpsertConfigResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.UpsertPushPreferencesResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    user_preferences: { type: 'PushPreferences', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.User = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     ban_expires: { type: 'DatetimeType', isSingle: true },

package/src/gen/models/index.ts

@@ -1221,6 +1221,8 @@ export interface CallEgress {
 
 export interface CallIngressResponse {
   rtmp: RTMPIngress;
+
+  srt: SRTIngress;
 }
 
 export interface CallMember {
@@ -1783,6 +1785,12 @@ export const ChannelOwnCapability = {
 export type ChannelOwnCapability =
   (typeof ChannelOwnCapability)[keyof typeof ChannelOwnCapability];
 
+export interface ChannelPushPreferences {
+  chat_level?: string;
+
+  disabled_until?: Date;
+}
+
 export interface ChannelResponse {
   cid: string;
 
@@ -2912,15 +2920,15 @@ export interface FeedUpdatedEvent {
 }
 
 export interface FeedsPreferences {
-  comment?: string;
+  comment?: 'all' | 'none';
 
-  comment_reaction?: string;
+  comment_reaction?: 'all' | 'none';
 
-  follow?: string;
+  follow?: 'all' | 'none';
 
-  mention?: string;
+  mention?: 'all' | 'none';
 
-  reaction?: string;
+  reaction?: 'all' | 'none';
 
   custom_activity_types?: Record<string, string>;
 }
@@ -4562,6 +4570,24 @@ export interface PushNotificationConfig {
   push_types?: string[];
 }
 
+export interface PushPreferenceInput {
+  call_level?: 'all' | 'none' | 'default';
+
+  channel_cid?: string;
+
+  chat_level?: 'all' | 'mentions' | 'none' | 'default';
+
+  disabled_until?: Date;
+
+  feeds_level?: 'all' | 'none' | 'default';
+
+  remove_disable?: boolean;
+
+  user_id?: string;
+
+  feeds_preferences?: FeedsPreferences;
+}
+
 export interface PushPreferences {
   call_level?: string;
 
@@ -5314,6 +5340,10 @@ export interface SFUIDLastSeen {
   process_start_time: number;
 }
 
+export interface SRTIngress {
+  address: string;
+}
+
 export interface STTEgressConfig {
   closed_captions_enabled?: boolean;
 
@@ -5777,6 +5807,8 @@ export interface UpdateActivityRequest {
 
   attachments?: Attachment[];
 
+  feeds?: string[];
+
   filter_tags?: string[];
 
   interest_tags?: string[];
@@ -6024,6 +6056,21 @@ export interface UpsertConfigResponse {
   config?: ConfigResponse;
 }
 
+export interface UpsertPushPreferencesRequest {
+  preferences: PushPreferenceInput[];
+}
+
+export interface UpsertPushPreferencesResponse {
+  duration: string;
+
+  user_channel_preferences: Record<
+    string,
+    Record<string, ChannelPushPreferences | null>
+  >;
+
+  user_preferences: Record<string, PushPreferences>;
+}
+
 export interface User {
   banned: boolean;
 

package/src/types.ts

@@ -1,4 +1,7 @@
-import { ConnectionChangedEvent } from './common/real-time/event-models';
+import {
+  ConnectionChangedEvent,
+  UnhandledErrorEvent,
+} from './common/real-time/event-models';
 import { NetworkChangedEvent } from './common/types';
 import {
   PagerResponse,
@@ -10,7 +13,7 @@ import type {
 } from './gen/models';
 import { FeedsClient } from './feeds-client';
 
-export type FeedsEvent = WSEvent | ConnectionChangedEvent | NetworkChangedEvent;
+export type FeedsEvent = WSEvent | ConnectionChangedEvent | NetworkChangedEvent | UnhandledErrorEvent;
 export type ActivityIdOrCommentId = string;
 
 export type GetCommentsRequest = Parameters<FeedsClient['getComments']>[0];