@stream-io/feeds-client 0.3.41 → 0.3.43

package/dist/types/utils/retry.d.ts

@@ -0,0 +1,25 @@
+export type RetryOptions = {
+    maxRetries?: number;
+    shouldRetry?: (error: unknown, attempt: number) => boolean;
+};
+/**
+ * Checks if an error is a client error (4xx HTTP status code) that should not be retried.
+ * Client errors indicate issues with the request itself (bad input, unauthorized, not found, etc.)
+ * and retrying won't help.
+ *
+ * @param error - The error to check
+ * @returns true if the error should be retried, false if it's a client error
+ */
+export declare function isRetryableError(error: unknown): boolean;
+/**
+ * Wraps an async function with automatic retry logic using exponential backoff.
+ *
+ * By default, retries are performed for server errors (5xx) and network errors,
+ * but not for client errors (4xx) which indicate issues with the request itself.
+ *
+ * @param fn - The async function to retry
+ * @param options - Retry options
+ * @returns The result of the function
+ */
+export declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+//# sourceMappingURL=retry.d.ts.map

package/dist/types/utils/retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../../src/utils/retry.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,YAAY,GAAG;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;CAC5D,CAAC;AAIF;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CASxD;AAED;;;;;;;;;GASG;AACH,wBAAsB,SAAS,CAAC,CAAC,EAC/B,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,OAAO,GAAE,YAAiB,GACzB,OAAO,CAAC,CAAC,CAAC,CAiCZ"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/feeds-client",
-  "version": "0.3.41",
+  "version": "0.3.43",
   "packageManager": "yarn@3.2.4",
   "main": "./dist/cjs/index.js",
   "module": "./dist/es/index.mjs",

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

@@ -40,7 +40,7 @@ export interface ConnectedEvent {
 
 export enum UnhandledErrorType {
   ReconnectionReconciliation = 'reconnection-reconciliation',
-  FetchingOwnCapabilitiesOnNewActivity = 'fetching-own-capabilities-on-new-activity',
+  FetchingOwnFieldsOnNewActivity = 'fetching-own-fields-on-new-activity',
 }
 
 export type SyncFailure = {
@@ -58,7 +58,7 @@ export type UnhandledErrorEvent = {
       failures: SyncFailure[];
     }
   | {
-      error_type: UnhandledErrorType.FetchingOwnCapabilitiesOnNewActivity;
+      error_type: UnhandledErrorType.FetchingOwnFieldsOnNewActivity;
       error: StreamApiError;
     }
 );

package/src/feed/feed.ts

@@ -66,6 +66,7 @@ import {
   feedsLoggerSystem,
   uniqueArrayMerge,
 } from '../utils';
+import { withRetry } from '../utils/retry';
 import { handleActivityFeedback } from './event-handlers/activity/handle-activity-feedback';
 import { deepEqual } from '../utils/deep-equal';
 import { getOrCreateActiveFeed } from '../feeds-client/get-or-create-active-feed';
@@ -294,7 +295,7 @@ export class Feed extends FeedApi {
     const { last_get_or_create_request_config } = this.state.getLatestValue();
     if (last_get_or_create_request_config?.watch) {
       this.inProgressGetOrCreate = undefined;
-      await this.getOrCreate(last_get_or_create_request_config);
+      await withRetry(() => this.getOrCreate(last_get_or_create_request_config));
     }
   }
 

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

@@ -92,6 +92,7 @@ import {
   type GetBatchedOwnFieldsThrottledCallback,
   DEFAULT_BATCH_OWN_FIELDS_THROTTLING_INTERVAL,
 } from '../utils/throttling';
+import { withRetry } from '../utils/retry';
 import { ActivityWithStateUpdates } from '../activity-with-state-updates/activity-with-state-updates';
 import { getFeed } from '../activity-with-state-updates/get-feed';
 import {
@@ -291,8 +292,7 @@ export class FeedsClient extends FeedsApi {
           }).catch((error) => {
             this.eventDispatcher.dispatch({
               type: 'errors.unhandled',
-              error_type:
-                UnhandledErrorType.FetchingOwnCapabilitiesOnNewActivity,
+              error_type: UnhandledErrorType.FetchingOwnFieldsOnNewActivity,
               error,
             });
           });
@@ -328,11 +328,13 @@ export class FeedsClient extends FeedsApi {
         return [{ feed, reason: result.reason, activity_id: activity?.id }];
       });
 
-      this.eventDispatcher.dispatch({
-        type: 'errors.unhandled',
-        error_type: UnhandledErrorType.ReconnectionReconciliation,
-        failures,
-      });
+      if (failures.length > 0) {
+        this.eventDispatcher.dispatch({
+          type: 'errors.unhandled',
+          error_type: UnhandledErrorType.ReconnectionReconciliation,
+          failures,
+        });
+      }
     }
   };
 
@@ -620,6 +622,7 @@ export class FeedsClient extends FeedsApi {
 
     this.activeActivities = [];
     this.activeFeeds = {};
+    this.healthyConnectionChangedEventCount = 0;
 
     this.state.partialNext(this.initialState);
 
@@ -704,7 +707,7 @@ export class FeedsClient extends FeedsApi {
   }
 
   async ownBatch(request: OwnBatchRequest) {
-    const response = await super.ownBatch(request);
+    const response = await withRetry(() => super.ownBatch(request));
     Object.entries(response.data).forEach(([fid, ownFields]) => {
       const feed = this.activeFeeds[fid];
       if (feed) {

package/src/gen/models/index.ts

@@ -4078,6 +4078,18 @@ export interface NotificationFeedUpdatedEvent {
   user?: UserResponseCommonFields;
 }
 
+export interface NotificationParentActivity {
+  id: string;
+
+  text?: string;
+
+  type?: string;
+
+  user_id?: string;
+
+  attachments?: Attachment[];
+}
+
 export interface NotificationStatusResponse {
   unread: number;
 
@@ -4106,6 +4118,8 @@ export interface NotificationTarget {
   attachments?: Attachment[];
 
   comment?: NotificationComment;
+
+  parent_activity?: NotificationParentActivity;
 }
 
 export interface NotificationTrigger {

package/src/utils/retry.ts

@@ -0,0 +1,76 @@
+import { retryInterval, sleep } from '../common/utils';
+import { StreamApiError } from '../common/types';
+
+export type RetryOptions = {
+  maxRetries?: number;
+  shouldRetry?: (error: unknown, attempt: number) => boolean;
+};
+
+const DEFAULT_MAX_RETRIES = 3;
+
+/**
+ * Checks if an error is a client error (4xx HTTP status code) that should not be retried.
+ * Client errors indicate issues with the request itself (bad input, unauthorized, not found, etc.)
+ * and retrying won't help.
+ *
+ * @param error - The error to check
+ * @returns true if the error should be retried, false if it's a client error
+ */
+export function isRetryableError(error: unknown): boolean {
+  if (error instanceof StreamApiError) {
+    const statusCode = error.metadata?.response_code;
+    // Don't retry on 4xx client errors
+    if (statusCode && statusCode >= 400 && statusCode < 500) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * Wraps an async function with automatic retry logic using exponential backoff.
+ *
+ * By default, retries are performed for server errors (5xx) and network errors,
+ * but not for client errors (4xx) which indicate issues with the request itself.
+ *
+ * @param fn - The async function to retry
+ * @param options - Retry options
+ * @returns The result of the function
+ */
+export async function withRetry<T>(
+  fn: () => Promise<T>,
+  options: RetryOptions = {},
+): Promise<T> {
+  const { maxRetries = DEFAULT_MAX_RETRIES, shouldRetry } = options;
+
+  let lastError: unknown;
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+
+      const isLastAttempt = attempt === maxRetries;
+
+      if (isLastAttempt) {
+        throw error;
+      }
+
+      // Use custom shouldRetry if provided, otherwise use default behavior
+      const shouldRetryResult = shouldRetry
+        ? shouldRetry(error, attempt)
+        : isRetryableError(error);
+
+      if (!shouldRetryResult) {
+        throw error;
+      }
+
+      const delay = retryInterval(attempt + 1);
+      await sleep(delay);
+    }
+  }
+
+  // This should never be reached, but TypeScript needs it
+  throw lastError;
+}