@stream-io/feeds-client 0.2.6 → 0.2.8

package/src/gen/models/index.ts

@@ -473,7 +473,7 @@ export interface ActivityResponse {
 
   moderation?: ModerationV2Response;
 
-  notification_context?: Record<string, any>;
+  notification_context?: NotificationContext;
 
   parent?: ActivityResponse;
 
@@ -587,6 +587,8 @@ export interface AddCommentReactionRequest {
 
   create_notification_activity?: boolean;
 
+  enforce_unique?: boolean;
+
   skip_push?: boolean;
 
   custom?: Record<string, any>;
@@ -647,6 +649,8 @@ export interface AddReactionRequest {
 
   create_notification_activity?: boolean;
 
+  enforce_unique?: boolean;
+
   skip_push?: boolean;
 
   custom?: Record<string, any>;
@@ -1223,6 +1227,8 @@ export interface CallIngressResponse {
   rtmp: RTMPIngress;
 
   srt: SRTIngress;
+
+  whip: WHIPIngress;
 }
 
 export interface CallMember {
@@ -1312,6 +1318,8 @@ export interface CallResponse {
 
   transcribing: boolean;
 
+  translating: boolean;
+
   type: string;
 
   updated_at: Date;
@@ -1544,6 +1552,8 @@ export interface Channel {
 
   created_by?: User;
 
+  members_lookup?: Record<string, ChannelMemberLookup>;
+
   truncated_by?: User;
 }
 
@@ -1727,6 +1737,22 @@ export interface ChannelMember {
   user?: UserResponse;
 }
 
+export interface ChannelMemberLookup {
+  archived: boolean;
+
+  banned: boolean;
+
+  hidden: boolean;
+
+  pinned: boolean;
+
+  archived_at?: Date;
+
+  ban_expires?: Date;
+
+  pinned_at?: Date;
+}
+
 export interface ChannelMemberResponse {
   channel_role: string;
 }
@@ -2269,6 +2295,10 @@ export interface DeleteCommentReactionResponse {
 
 export interface DeleteCommentResponse {
   duration: string;
+
+  activity: ActivityResponse;
+
+  comment: CommentResponse;
 }
 
 export interface DeleteFeedResponse {
@@ -4050,6 +4080,12 @@ export interface NotificationConfig {
   track_seen?: boolean;
 }
 
+export interface NotificationContext {
+  target?: NotificationTarget;
+
+  trigger?: NotificationTrigger;
+}
+
 export interface NotificationFeedUpdatedEvent {
   created_at: Date;
 
@@ -4098,6 +4134,26 @@ export interface NotificationStatusResponse {
   seen_activities?: string[];
 }
 
+export interface NotificationTarget {
+  id: string;
+
+  name?: string;
+
+  text?: string;
+
+  type?: string;
+
+  user_id?: string;
+
+  attachments?: Attachment[];
+}
+
+export interface NotificationTrigger {
+  text: string;
+
+  type: string;
+}
+
 export interface NullTime {}
 
 export interface OCRRule {
@@ -5699,6 +5755,8 @@ export interface TranscriptionSettings {
   mode: 'available' | 'disabled' | 'auto-on';
 
   speech_segment_config?: SpeechSegmentConfig;
+
+  translation?: TranslationSettings;
 }
 
 export interface TranscriptionSettingsResponse {
@@ -5746,6 +5804,14 @@ export interface TranscriptionSettingsResponse {
   mode: 'available' | 'disabled' | 'auto-on';
 
   speech_segment_config?: SpeechSegmentConfig;
+
+  translation?: TranslationSettings;
+}
+
+export interface TranslationSettings {
+  enabled: boolean;
+
+  languages: string[];
 }
 
 export interface TypingIndicators {
@@ -6449,6 +6515,10 @@ export interface VoteData {
   option_id?: string;
 }
 
+export interface WHIPIngress {
+  address: string;
+}
+
 export interface WSAuthMessage {
   token: string;
 

package/src/index.ts

@@ -0,0 +1,9 @@
+export * from '@stream-io/state-store';
+export * from './feeds-client/feeds-client';
+export * from './feed/feed';
+export * from './gen/models';
+export * from './types';
+export * from './common/types';
+export * from './common/search';
+export * from './common/Poll';
+export * from './utils';

package/src/test-utils/response-generators.ts

@@ -414,10 +414,14 @@ export function generateBookmarkUpdatedEvent(
 export function generateCommentAddedEvent(
   overrides: Omit<
     Partial<EventPayload<'feeds.comment.added'>>,
-    'comment' | 'type'
-  > & { comment?: Parameters<typeof generateCommentResponse>[0] } = {},
+    'comment' | 'activity' | 'type'
+  > & {
+    comment?: Parameters<typeof generateCommentResponse>[0];
+    activity?: Parameters<typeof generateActivityResponse>[0];
+  } = {},
 ): EventPayload<'feeds.comment.added'> {
   const comment = generateCommentResponse(overrides.comment);
+  const activity = generateActivityResponse(overrides.activity);
   return {
     type: 'feeds.comment.added',
     created_at: new Date(),
@@ -425,6 +429,7 @@ export function generateCommentAddedEvent(
     custom: {},
     ...overrides,
     comment,
+    activity,
   };
 }
 
@@ -465,14 +470,17 @@ export function generateCommentUpdatedEvent(
 export function generateCommentReactionAddedEvent(
   overrides: Omit<
     Partial<EventPayload<'feeds.comment.reaction.added'>>,
-    'comment' | 'reaction' | 'type'
+    'comment' | 'reaction' | 'activity' | 'type'
   > & {
     comment?: Parameters<typeof generateCommentResponse>[0];
     reaction?: Parameters<typeof generateFeedReactionResponse>[0];
+    activity?: Parameters<typeof generateActivityResponse>[0];
   } = {},
 ): EventPayload<'feeds.comment.reaction.added'> {
   const comment = generateCommentResponse(overrides.comment);
   const reaction = generateFeedReactionResponse(overrides.reaction);
+  const activity = generateActivityResponse(overrides.activity);
+
   return {
     type: 'feeds.comment.reaction.added',
     created_at: new Date(),
@@ -481,6 +489,7 @@ export function generateCommentReactionAddedEvent(
     ...overrides,
     comment,
     reaction,
+    activity,
   };
 }
 

package/src/types-internal.ts

@@ -14,3 +14,7 @@ export type EventPayload<T extends WSEvent['type']> = Extract<
 export type PartializeAllBut<T, K extends keyof T> = Pick<T, K> & {
   [key in K]?: T[key];
 };
+
+export type CommonProps<A, B> = {
+  [K in keyof A & keyof B]: A[K] & B[K]
+};

package/src/utils/index.ts

@@ -4,3 +4,4 @@ export * from './constants';
 export * from './type-assertions';
 export * from './state-update-queue';
 export * from './update-entity-in-array';
+export * from './logger';

package/src/utils/is-react-native.ts

@@ -0,0 +1,7 @@
+/**
+ * Checks whether we are using React Native
+ */
+export const isReactNative = () => {
+  if (typeof navigator === 'undefined') return false;
+  return navigator.product?.toLowerCase() === 'reactnative';
+};

package/src/utils/logger.ts

@@ -0,0 +1,18 @@
+import * as loggerInternal from '@stream-io/logger';
+
+type AvailableScopes =
+  | 'api-client'
+  | 'event-dispatcher'
+  | 'token-manager'
+  | 'stable-ws-connection';
+
+export type ConfigureLoggersOptions =
+  loggerInternal.ConfigureLoggersOptions<AvailableScopes>;
+export type Logger = loggerInternal.Logger<AvailableScopes>;
+
+export const configureLoggers =
+  loggerInternal.configureLoggers<AvailableScopes>;
+export const getLogger = loggerInternal.getLogger<AvailableScopes>;
+
+export type { LogLevel, Sink } from '@stream-io/logger';
+export { LogLevelEnum, restoreDefaults } from '@stream-io/logger';

package/src/utils/state-update-queue.test.ts

@@ -4,50 +4,126 @@ import { shouldUpdateState } from './state-update-queue';
 
 describe('state-update-queue', () => {
   describe('shouldUpdateState', () => {
-    it('should return true when watch is false', () => {
+    it('should return true when only watch is false', () => {
       const result = shouldUpdateState({
         stateUpdateQueueId: 'test-id',
-        stateUpdateQueue: new Set(['other-id']),
+        stateUpdateQueue: new Set(['ws-other-id']),
         watch: false,
+        isTriggeredByConnectedUser: true,
       });
 
       expect(result).toBe(true);
     });
 
-    it('should return true when watch is true but queueId is not in queue', () => {
-      const stateUpdateQueue = new Set(['other-id-1', 'other-id-2']);
+    it('should return true when only isTriggeredByConnectedUser is false', () => {
+      const result = shouldUpdateState({
+        stateUpdateQueueId: 'test-id',
+        stateUpdateQueue: new Set(['ws-other-id']),
+        watch: true,
+        isTriggeredByConnectedUser: false,
+      });
+
+      expect(result).toBe(true);
+    });
+
+    it('should return true when watch is true and it is triggered by the connected_user, but queueId is not in queue', () => {
+      const stateUpdateQueue = new Set(['ws-other-id-1', 'ws-other-id-2']);
 
       const result = shouldUpdateState({
         stateUpdateQueueId: 'test-id',
         stateUpdateQueue: stateUpdateQueue,
         watch: true,
+        isTriggeredByConnectedUser: true,
       });
 
-      expect(stateUpdateQueue).toContain('test-id');
+      expect(stateUpdateQueue).toContain('ws-test-id');
       expect(result).toBe(true);
     });
 
-    it('should return false and remove queueId from queue when watch is true and queueId is in queue', () => {
-      const stateUpdateQueue = new Set(['test-id', 'other-id']);
+    it('should return false and remove queueId from queue when watch is true and WS initiated queueId is in queue', () => {
+      const stateUpdateQueue = new Set(['ws-test-id', 'ws-other-id']);
 
       const result = shouldUpdateState({
         stateUpdateQueueId: 'test-id',
         stateUpdateQueue,
         watch: true,
+        fromWs: false,
+        isTriggeredByConnectedUser: true,
       });
 
       expect(result).toBe(false);
-      expect(stateUpdateQueue).toEqual(new Set(['other-id']));
+      expect(stateUpdateQueue).toEqual(new Set(['ws-other-id']));
     });
 
-    it('should handle empty queue when watch is true', () => {
+    it('should return false and remove queueId from queue when watch is true and HTTP initiated queueId is in queue', () => {
+      const stateUpdateQueue = new Set(['http-test-id', 'http-other-id']);
+
+      const result = shouldUpdateState({
+        stateUpdateQueueId: 'test-id',
+        stateUpdateQueue,
+        watch: true,
+        isTriggeredByConnectedUser: true,
+      });
+
+      expect(result).toBe(false);
+      expect(stateUpdateQueue).toEqual(new Set(['http-other-id']));
+    });
+
+    it('should handle empty queue when conditions are met', () => {
       const result = shouldUpdateState({
         stateUpdateQueueId: 'test-id',
         stateUpdateQueue: new Set(),
         watch: true,
+        isTriggeredByConnectedUser: true,
       });
 
       expect(result).toBe(true);
     });
+
+    it('should not clear the queue state if 2 equal HTTP response updates arrive', () => {
+      const stateUpdateQueue = new Set<string>();
+
+      const result1 = shouldUpdateState({
+        stateUpdateQueueId: 'test-id',
+        stateUpdateQueue,
+        watch: true,
+        fromWs: false,
+        isTriggeredByConnectedUser: true,
+      });
+
+      const result2 = shouldUpdateState({
+        stateUpdateQueueId: 'test-id',
+        stateUpdateQueue,
+        watch: true,
+        fromWs: false,
+        isTriggeredByConnectedUser: true,
+      });
+
+      expect(result1).toBe(true);
+      expect(result2).toBe(true);
+      expect(stateUpdateQueue).toEqual(new Set(['http-test-id']))
+    })
+
+    it('should not clear the queue state if 2 equal WS event updates arrive', () => {
+      const stateUpdateQueue = new Set<string>();
+
+      const result1 = shouldUpdateState({
+        stateUpdateQueueId: 'test-id',
+        stateUpdateQueue,
+        watch: true,
+        isTriggeredByConnectedUser: true,
+      });
+
+      const result2 = shouldUpdateState({
+        stateUpdateQueueId: 'test-id',
+        stateUpdateQueue,
+        watch: true,
+        isTriggeredByConnectedUser: true,
+      });
+
+      expect(result1).toBe(true);
+      expect(result2).toBe(true);
+      expect(stateUpdateQueue).toEqual(new Set(['ws-test-id']))
+    })
   });
 });

package/src/utils/state-update-queue.ts

@@ -1,24 +1,110 @@
-import { isFollowResponse } from './type-assertions';
+import { isFollowResponse, isReactionResponse } from './type-assertions';
+import { AddCommentReactionResponse, AddReactionResponse } from '../gen/models';
 
+/**
+ * Decide whether to apply a state update that may arrive twice (HTTP + WS)
+ * for the same logical change initiated by the connected user.
+ *
+ * ###### Why
+ * When `watch` is enabled and the connected user triggers a change, you often get:
+ * - an immediate local/HTTP-driven update (e.g., optimistic UI, REST response)
+ * - a subsequent server broadcast over WebSocket for the same change
+ *
+ * This helper suppresses the duplicate so you apply the update exactly once.
+ *
+ * ###### How it works
+ * - Builds a prefixed key from `stateUpdateQueueId` and the transport:
+ *   - HTTP → `http-${id}`
+ *   - WS   → `ws-${id}`
+ * - If the *paired* key already exists (e.g., WS sees `http-${id}` or HTTP sees `ws-${id}`),
+ *   it removes that key and returns `false` (skip as duplicate).
+ * - Otherwise it enqueues the current prefixed key and returns `true` (apply update).
+ *
+ * ###### When it returns `true`
+ * - `watch` is `false` -> no deduping needed
+ * - `isTriggeredByConnectedUser` is `false` -> dedupe only targets that echo the initiator's
+ * - First arrival for a given `id` and transport pair
+ *
+ * ###### When it returns `false`
+ * The *second* arrival for the same logical `{id}` from the *other* transport is detected
+ * (e.g., you already saw `http-${id}`, now a `ws-${id}` arrives).
+ *
+ * ###### Example
+ * ```ts
+ * const queue = new Set<string>();
+ *
+ * 1) User follows someone → HTTP path resolves first
+ * if (shouldUpdateState({
+ *   stateUpdateQueueId: 'follow:targetUserId',
+ *   stateUpdateQueue: queue,
+ *   watch: true,
+ *   fromWs: false,
+ *   isTriggeredByConnectedUser: true,
+ * })) {
+ *   applyFollowLocally();
+ * }
+ *
+ * 2) A moment later WS echoes the same follow
+ * if (shouldUpdateState({
+ *   stateUpdateQueueId: 'follow:targetUserId',
+ *   stateUpdateQueue: queue,
+ *   watch: true,
+ *   fromWs: true,
+ *   isTriggeredByConnectedUser: true,
+ * })) {
+ *   // This will return false → skip duplicate
+ *   applyFollowLocally();
+ * }
+ * ```
+ *
+ * ###### Reverse order also works
+ * If WS lands first and HTTP lands second, the second one will be skipped.
+ *
+ * ###### Choosing good IDs
+ * Use a stable, collision-free `stateUpdateQueueId` for the same logical change.
+ * Examples:
+ * - `follow-created-${sourceFeed.id}-${targetFeed.id}`
+ * - `activity-reaction-added-${activity.id}-${reaction.type}`
+ *
+ * @param config
+ * @param config.stateUpdateQueueId - Stable identifier for the logical change
+ * @param config.stateUpdateQueue - A shared Set used as a small dedupe cache
+ * @param config.watch - Whether watch/broadcast mode is enabled
+ * @param config.fromWs - `true` if this event came from WebSocket; `false` for HTTP (default: true)
+ * @param config.isTriggeredByConnectedUser - Only dedupe echoes of our own actions
+ *
+ * @returns {boolean} Whether or not the state update should be applied.
+ */
 export const shouldUpdateState = ({
   stateUpdateQueueId,
   stateUpdateQueue,
   watch,
+  fromWs = true,
+  isTriggeredByConnectedUser = false,
 }: {
   stateUpdateQueueId: string;
   stateUpdateQueue: Set<string>;
   watch: boolean;
-}) => {
-  if (!watch) {
+  fromWs?: boolean;
+  isTriggeredByConnectedUser: boolean;
+}): boolean => {
+  if (!watch || !isTriggeredByConnectedUser) {
     return true;
   }
 
-  if (watch && stateUpdateQueue.has(stateUpdateQueueId)) {
-    stateUpdateQueue.delete(stateUpdateQueueId);
+  const prefixedStateUpdateQueueId = fromWs
+    ? `ws-${stateUpdateQueueId}`
+    : `http-${stateUpdateQueueId}`;
+  const pairedStateUpdateQueueId = fromWs
+    ? `http-${stateUpdateQueueId}`
+    : `ws-${stateUpdateQueueId}`;
+
+  if (watch && stateUpdateQueue.has(pairedStateUpdateQueueId)) {
+    stateUpdateQueue.delete(pairedStateUpdateQueueId);
     return false;
   }
 
-  stateUpdateQueue.add(stateUpdateQueueId);
+  stateUpdateQueue.add(prefixedStateUpdateQueueId);
   return true;
 };
 
@@ -26,12 +112,19 @@ export function getStateUpdateQueueId(
   data: object,
   prefix?: 'deleted' | 'updated' | 'created' | (string & {}),
 ) {
+  const toJoin = prefix ? [prefix] : [];
   if (isFollowResponse(data)) {
-    const toJoin = [data.source_feed.feed, data.target_feed.feed];
-    if (prefix) {
-      toJoin.unshift(prefix);
-    }
-    return toJoin.join('-');
+    return toJoin
+      .concat([data.source_feed.feed, data.target_feed.feed])
+      .join('-');
+  } else if (isReactionResponse(data)) {
+    return toJoin
+      .concat([
+        (data as AddReactionResponse).activity.id ??
+          (data as AddCommentReactionResponse).comment.id,
+        data.reaction.type,
+      ])
+      .join('-');
   }
   // else if (isMemberResponse(data)) {
   // }

package/src/utils/type-assertions.ts

@@ -1,11 +1,32 @@
-import { CommentResponse, FollowResponse } from '../gen/models';
+import {
+  AddCommentReactionResponse,
+  AddReactionResponse,
+  CommentResponse,
+  DeleteCommentReactionResponse,
+  FollowResponse,
+} from '../gen/models';
 import { StreamFile } from '../types';
 import { CommentParent } from '../types';
+import { DeleteReactionResponse } from '@stream-io/node-sdk';
 
 export const isFollowResponse = (data: object): data is FollowResponse => {
   return 'source_feed' in data && 'target_feed' in data;
 };
 
+export const isReactionResponse = (
+  data: object,
+): data is (
+  | AddReactionResponse
+  | AddCommentReactionResponse
+  | DeleteReactionResponse
+  | DeleteCommentReactionResponse
+) & { fid: string } => {
+  return (
+    'reaction' in data &&
+    ('activity' in data || 'comment' in data)
+  );
+};
+
 export const isCommentResponse = (
   entity: CommentParent,
 ): entity is CommentResponse => {

package/dist/@react-bindings/hooks/client-state-hooks/useClientConnectedUser.d.ts

@@ -1,4 +0,0 @@
-/**
- * A React hook that returns the currently connected user on a `FeedsClient` instance and null otherwise.
- */
-export declare const useClientConnectedUser: () => import("../../..").OwnUser | undefined;

package/dist/@react-bindings/hooks/search-state-hooks/useSearchSources.d.ts

@@ -1,4 +0,0 @@
-import type { SearchController } from '../../../src/common/search';
-export declare const useSearchSources: (controllerFromProps?: SearchController) => {
-    sources: import("../../../src/common/search").SearchSource<any>[];
-} | undefined;

package/dist/@react-bindings/hooks/useStateStore.d.ts

@@ -1,3 +0,0 @@
-import { StateStore } from '../../src/common/StateStore';
-export declare function useStateStore<T extends Record<string, unknown>, O extends Readonly<Record<string, unknown> | readonly unknown[]>>(store: StateStore<T>, selector: (v: T) => O): O;
-export declare function useStateStore<T extends Record<string, unknown>, O extends Readonly<Record<string, unknown> | readonly unknown[]>>(store: StateStore<T> | undefined, selector: (v: T) => O): O | undefined;