@xmtp/browser-sdk 3.1.2 → 4.0.1

package/src/ClientWorkerClass.ts

@@ -11,6 +11,7 @@ import type {
   StreamAction,
   StreamActionErrorData,
 } from "@/types/actions/streams";
+import type { StreamOptions } from "@/utils/streams";
 
 const handleError = (event: ErrorEvent) => {
   console.error(event.message);
@@ -111,17 +112,24 @@ export class ClientWorkerClass {
    * @param callback - The callback to handle the stream message
    * @returns A function to remove the stream handler
    */
-  handleStreamMessage = <T extends StreamAction["result"]>(
+  handleStreamMessage = <T extends StreamAction["result"], V = T>(
     streamId: string,
-    callback: (error: Error | null, value: T | null) => void,
+    callback: (error: Error | null, value: T | undefined) => void,
+    options?: StreamOptions<T, V>,
   ) => {
     const streamHandler = (
       event: MessageEvent<StreamAction | StreamActionErrorData>,
     ) => {
       const eventData = event.data;
+      // only handle messages for the passed stream ID
       if (eventData.streamId === streamId) {
+        // if the stream failed, call the onFail callback
+        if (eventData.action === "stream.fail") {
+          options?.onFail?.();
+          return;
+        }
         if ("error" in eventData) {
-          callback(eventData.error, null);
+          callback(eventData.error, undefined);
         } else {
           callback(null, eventData.result as T);
         }
@@ -129,7 +137,10 @@ export class ClientWorkerClass {
     };
     this.#worker.addEventListener("message", streamHandler);
 
-    return () => {
+    return async () => {
+      await this.sendMessage("endStream", {
+        streamId,
+      });
       this.#worker.removeEventListener("message", streamHandler);
     };
   };

package/src/Conversation.ts

@@ -2,7 +2,6 @@ import type { ContentTypeId } from "@xmtp/content-type-primitives";
 import { ContentTypeText } from "@xmtp/content-type-text";
 import type { ConsentState } from "@xmtp/wasm-bindings";
 import { v4 } from "uuid";
-import { AsyncStream, type StreamCallback } from "@/AsyncStream";
 import type { Client } from "@/Client";
 import { DecodedMessage } from "@/DecodedMessage";
 import type {
@@ -12,6 +11,11 @@ import type {
 } from "@/utils/conversions";
 import { nsToDate } from "@/utils/date";
 import { MissingContentTypeError } from "@/utils/errors";
+import {
+  createStream,
+  type StreamCallback,
+  type StreamOptions,
+} from "@/utils/streams";
 
 /**
  * Represents a conversation
@@ -264,38 +268,35 @@ export class Conversation<ContentTypes = unknown> {
    * @param callback - Optional callback function for handling new stream values
    * @returns Stream instance for new messages
    */
-  async stream(callback?: StreamCallback<DecodedMessage<ContentTypes>>) {
-    const streamId = v4();
-    const asyncStream = new AsyncStream<DecodedMessage<ContentTypes>>();
-    const endStream = this.#client.handleStreamMessage<SafeMessage>(
-      streamId,
-      (error, value) => {
-        let err: Error | null = error;
-        let message: DecodedMessage<ContentTypes> | undefined;
-
-        if (value) {
-          try {
-            message = new DecodedMessage(this.#client, value);
-          } catch (error) {
-            err = error as Error;
-          }
-        }
-
-        void asyncStream.callback(err, message);
-        void callback?.(err, message);
-      },
-    );
-    await this.#client.sendMessage("conversation.stream", {
-      groupId: this.#id,
-      streamId,
-    });
-    asyncStream.onDone = () => {
-      void this.#client.sendMessage("endStream", {
+  async stream(
+    options?: StreamOptions<SafeMessage, DecodedMessage<ContentTypes>>,
+  ) {
+    const stream = async (
+      callback: StreamCallback<SafeMessage>,
+      onFail: () => void,
+    ) => {
+      const streamId = v4();
+      // sync the conversation
+      await this.sync();
+      // start the stream
+      await this.#client.sendMessage("conversation.stream", {
+        groupId: this.#id,
         streamId,
       });
-      endStream();
+      // handle stream messages
+      return this.#client.handleStreamMessage<
+        SafeMessage,
+        DecodedMessage<ContentTypes>
+      >(streamId, callback, {
+        ...options,
+        onFail,
+      });
     };
-    return asyncStream;
+    const convertMessage = (value: SafeMessage) => {
+      return new DecodedMessage(this.#client, value);
+    };
+
+    return createStream(stream, convertMessage, options);
   }
 
   async pausedForVersion() {

package/src/Conversations.ts

@@ -4,7 +4,6 @@ import {
   type Identifier,
 } from "@xmtp/wasm-bindings";
 import { v4 } from "uuid";
-import { AsyncStream, type StreamCallback } from "@/AsyncStream";
 import type { Client } from "@/Client";
 import { DecodedMessage } from "@/DecodedMessage";
 import { Dm } from "@/Dm";
@@ -16,6 +15,11 @@ import type {
   SafeListConversationsOptions,
   SafeMessage,
 } from "@/utils/conversions";
+import {
+  createStream,
+  type StreamCallback,
+  type StreamOptions,
+} from "@/utils/streams";
 
 /**
  * Manages conversations
@@ -285,144 +289,154 @@ export class Conversations<ContentTypes = unknown> {
   /**
    * Creates a stream for new conversations
    *
-   * @param callback - Optional callback function for handling new stream value
-   * @param conversationType - Optional type to filter conversations
+   * @param options - Optional stream options
+   * @param options.conversationType - Optional type to filter conversations
    * @returns Stream instance for new conversations
    */
   async stream<
     T extends Group<ContentTypes> | Dm<ContentTypes> =
       | Group<ContentTypes>
       | Dm<ContentTypes>,
-  >(callback?: StreamCallback<T>, conversationType?: ConversationType) {
-    const streamId = v4();
-    const asyncStream = new AsyncStream<T>();
-    const endStream = this.#client.handleStreamMessage<SafeConversation>(
-      streamId,
-      (error, value) => {
-        let err: Error | null = error;
-        let streamValue: T | undefined;
-
-        if (value) {
-          try {
-            streamValue =
-              value.metadata.conversationType === "group"
-                ? (new Group(this.#client, value.id, value) as T)
-                : (new Dm(this.#client, value.id, value) as T);
-          } catch (error) {
-            err = error as Error;
-          }
-        }
-
-        void asyncStream.callback(err, streamValue);
-        void callback?.(err, streamValue);
-      },
-    );
-    await this.#client.sendMessage("conversations.stream", {
-      streamId,
-      conversationType,
-    });
-    asyncStream.onDone = () => {
-      void this.#client.sendMessage("endStream", {
+  >(
+    options?: StreamOptions<SafeConversation, T> & {
+      conversationType?: ConversationType;
+    },
+  ) {
+    const stream = async (
+      callback: StreamCallback<SafeConversation>,
+      onFail: () => void,
+    ) => {
+      const streamId = v4();
+      // sync the conversation
+      await this.sync();
+      // start the stream
+      await this.#client.sendMessage("conversations.stream", {
         streamId,
+        conversationType: options?.conversationType,
       });
-      endStream();
+      // handle stream messages
+      return this.#client.handleStreamMessage<SafeConversation, T>(
+        streamId,
+        callback,
+        {
+          ...options,
+          onFail,
+        },
+      );
+    };
+    const convertConversation = (value: SafeConversation) => {
+      return value.metadata.conversationType === "group"
+        ? (new Group(this.#client, value.id, value) as T)
+        : (new Dm(this.#client, value.id, value) as T);
     };
-    return asyncStream;
+
+    return createStream(stream, convertConversation, options);
   }
 
   /**
    * Creates a stream for new group conversations
    *
-   * @param callback - Optional callback function for handling new stream value
+   * @param options - Optional stream options
    * @returns Stream instance for new group conversations
    */
-  async streamGroups(callback?: StreamCallback<Group<ContentTypes>>) {
-    return this.stream(callback, ConversationType.Group);
+  async streamGroups(
+    options?: StreamOptions<SafeConversation, Group<ContentTypes>>,
+  ) {
+    return this.stream({
+      ...options,
+      conversationType: ConversationType.Group,
+    });
   }
 
   /**
    * Creates a stream for new DM conversations
    *
-   * @param callback - Optional callback function for handling new stream value
+   * @param options - Optional stream options
    * @returns Stream instance for new DM conversations
    */
-  async streamDms(callback?: StreamCallback<Dm<ContentTypes>>) {
-    return this.stream(callback, ConversationType.Dm);
+  async streamDms(options?: StreamOptions<SafeConversation, Dm<ContentTypes>>) {
+    return this.stream({
+      ...options,
+      conversationType: ConversationType.Dm,
+    });
   }
 
   /**
    * Creates a stream for all new messages
    *
-   * @param callback - Optional callback function for handling new stream value
-   * @param conversationType - Optional conversation type to filter messages
+   * @param options - Optional stream options
+   * @param options.conversationType - Optional conversation type to filter messages
+   * @param options.consentStates - Optional consent states to filter messages
    * @returns Stream instance for new messages
    */
   async streamAllMessages(
-    callback?: StreamCallback<DecodedMessage<ContentTypes>>,
-    conversationType?: ConversationType,
-    consentStates?: ConsentState[],
+    options?: StreamOptions<SafeMessage, DecodedMessage<ContentTypes>> & {
+      conversationType?: ConversationType;
+      consentStates?: ConsentState[];
+    },
   ) {
-    const streamId = v4();
-    const asyncStream = new AsyncStream<DecodedMessage<ContentTypes>>();
-    const endStream = this.#client.handleStreamMessage<SafeMessage>(
-      streamId,
-      (error, value) => {
-        let err: Error | null = error;
-        let message: DecodedMessage<ContentTypes> | undefined;
-
-        if (value) {
-          try {
-            message = new DecodedMessage(this.#client, value);
-          } catch (error) {
-            err = error as Error;
-          }
-        }
-
-        void asyncStream.callback(err, message);
-        void callback?.(err, message);
-      },
-    );
-    await this.#client.sendMessage("conversations.streamAllMessages", {
-      streamId,
-      conversationType,
-      consentStates,
-    });
-    asyncStream.onDone = () => {
-      void this.#client.sendMessage("endStream", {
+    const stream = async (
+      callback: StreamCallback<SafeMessage>,
+      onFail: () => void,
+    ) => {
+      const streamId = v4();
+      // sync the conversation
+      await this.sync();
+      // start the stream
+      await this.#client.sendMessage("conversations.streamAllMessages", {
         streamId,
+        conversationType: options?.conversationType,
+        consentStates: options?.consentStates,
+      });
+      // handle stream messages
+      return this.#client.handleStreamMessage<
+        SafeMessage,
+        DecodedMessage<ContentTypes>
+      >(streamId, callback, {
+        ...options,
+        onFail,
       });
-      endStream();
     };
-    return asyncStream;
+    const convertMessage = (value: SafeMessage) => {
+      return new DecodedMessage(this.#client, value);
+    };
+
+    return createStream(stream, convertMessage, options);
   }
 
   /**
    * Creates a stream for all new group messages
    *
-   * @param callback - Optional callback function for handling new stream value
+   * @param options - Optional stream options
+   * @param options.consentStates - Optional consent states to filter messages
    * @returns Stream instance for new group messages
    */
   async streamAllGroupMessages(
-    callback?: StreamCallback<DecodedMessage<ContentTypes>>,
-    consentStates?: ConsentState[],
+    options?: StreamOptions<SafeMessage, DecodedMessage<ContentTypes>> & {
+      consentStates?: ConsentState[];
+    },
   ) {
-    return this.streamAllMessages(
-      callback,
-      ConversationType.Group,
-      consentStates,
-    );
+    return this.streamAllMessages({
+      ...options,
+      conversationType: ConversationType.Group,
+    });
   }
 
   /**
    * Creates a stream for all new DM messages
    *
-   * @param callback - Optional callback function for handling new stream value
+   * @param options - Optional stream options
+   * @param options.consentStates - Optional consent states to filter messages
    * @returns Stream instance for new DM messages
    */
   async streamAllDmMessages(
-    callback?: StreamCallback<DecodedMessage<ContentTypes>>,
-    consentStates?: ConsentState[],
+    options?: StreamOptions<SafeMessage, DecodedMessage<ContentTypes>> & {
+      consentStates?: ConsentState[];
+    },
   ) {
-    return this.streamAllMessages(callback, ConversationType.Dm, consentStates);
+    return this.streamAllMessages({
+      ...options,
+      conversationType: ConversationType.Dm,
+    });
   }
 }

package/src/Preferences.ts

@@ -1,7 +1,11 @@
 import type { ConsentEntityType, UserPreference } from "@xmtp/wasm-bindings";
 import { v4 } from "uuid";
-import { AsyncStream, type StreamCallback } from "@/AsyncStream";
 import type { SafeConsent } from "@/utils/conversions";
+import {
+  createStream,
+  type StreamCallback,
+  type StreamOptions,
+} from "@/utils/streams";
 import type { Client } from "./Client";
 
 /**
@@ -95,56 +99,64 @@ export class Preferences<ContentTypes = unknown> {
   /**
    * Creates a stream of consent state updates
    *
-   * @param callback - Optional callback function for handling stream updates
+   * @param options - Optional stream options
    * @returns Stream instance for consent updates
    */
-  async streamConsent(callback?: StreamCallback<SafeConsent[]>) {
-    const streamId = v4();
-    const asyncStream = new AsyncStream<SafeConsent[]>();
-    const endStream = this.#client.handleStreamMessage<SafeConsent[]>(
-      streamId,
-      (error, value) => {
-        void asyncStream.callback(error, value ?? undefined);
-        void callback?.(error, value ?? undefined);
-      },
-    );
-    await this.#client.sendMessage("preferences.streamConsent", {
-      streamId,
-    });
-    asyncStream.onDone = () => {
-      void this.#client.sendMessage("endStream", {
+  async streamConsent(options?: StreamOptions<SafeConsent[]>) {
+    const stream = async (
+      callback: StreamCallback<SafeConsent[]>,
+      onFail: () => void,
+    ) => {
+      const streamId = v4();
+      // sync the conversation
+      await this.sync();
+      // start the stream
+      await this.#client.sendMessage("preferences.streamConsent", {
         streamId,
       });
-      endStream();
+      // handle stream messages
+      return this.#client.handleStreamMessage<SafeConsent[]>(
+        streamId,
+        callback,
+        {
+          ...options,
+          onFail,
+        },
+      );
     };
-    return asyncStream;
+
+    return createStream(stream, undefined, options);
   }
 
   /**
    * Creates a stream of user preference updates
    *
-   * @param callback - Optional callback function for handling stream updates
+   * @param options - Optional stream options
    * @returns Stream instance for preference updates
    */
-  async streamPreferences(callback?: StreamCallback<UserPreference[]>) {
-    const streamId = v4();
-    const asyncStream = new AsyncStream<UserPreference[]>();
-    const endStream = this.#client.handleStreamMessage<UserPreference[]>(
-      streamId,
-      (error, value) => {
-        void asyncStream.callback(error, value ?? undefined);
-        void callback?.(error, value ?? undefined);
-      },
-    );
-    await this.#client.sendMessage("preferences.streamPreferences", {
-      streamId,
-    });
-    asyncStream.onDone = () => {
-      void this.#client.sendMessage("endStream", {
+  async streamPreferences(options?: StreamOptions<UserPreference[]>) {
+    const stream = async (
+      callback: StreamCallback<UserPreference[]>,
+      onFail: () => void,
+    ) => {
+      const streamId = v4();
+      // sync the conversation
+      await this.sync();
+      // start the stream
+      await this.#client.sendMessage("preferences.streamPreferences", {
         streamId,
       });
-      endStream();
+      // handle stream messages
+      return this.#client.handleStreamMessage<UserPreference[]>(
+        streamId,
+        callback,
+        {
+          ...options,
+          onFail,
+        },
+      );
     };
-    return asyncStream;
+
+    return createStream(stream, undefined, options);
   }
 }

package/src/WorkerConversation.ts

@@ -12,12 +12,12 @@ import {
   type PermissionPolicy,
   type PermissionUpdateType,
 } from "@xmtp/wasm-bindings";
-import { type StreamCallback } from "@/AsyncStream";
 import {
   fromSafeListMessagesOptions,
   toSafeGroupMember,
   type SafeListMessagesOptions,
 } from "@/utils/conversions";
+import type { StreamCallback } from "@/utils/streams";
 import type { WorkerClient } from "@/WorkerClient";
 
 export class WorkerConversation {
@@ -202,14 +202,17 @@ export class WorkerConversation {
     return this.#group.isMessageDisappearingEnabled();
   }
 
-  stream(callback?: StreamCallback<Message>) {
+  stream(callback: StreamCallback<Message>, onFail: () => void) {
     const on_message = (message: Message) => {
-      void callback?.(null, message);
+      callback(null, message);
     };
     const on_error = (error: Error | null) => {
-      void callback?.(error, undefined);
+      callback(error, undefined);
     };
-    return this.#group.stream({ on_message, on_error });
+    const on_close = () => {
+      onFail();
+    };
+    return this.#group.stream({ on_message, on_error, on_close });
   }
 
   pausedForVersion() {

package/src/WorkerConversations.ts

@@ -7,7 +7,6 @@ import {
   type Identifier,
   type Message,
 } from "@xmtp/wasm-bindings";
-import type { StreamCallback } from "@/AsyncStream";
 import {
   fromSafeCreateDmOptions,
   fromSafeCreateGroupOptions,
@@ -17,6 +16,7 @@ import {
   type SafeCreateGroupOptions,
   type SafeListConversationsOptions,
 } from "@/utils/conversions";
+import type { StreamCallback } from "@/utils/streams";
 import type { WorkerClient } from "@/WorkerClient";
 import { WorkerConversation } from "@/WorkerConversation";
 
@@ -151,42 +151,50 @@ export class WorkerConversations {
   }
 
   stream(
-    callback?: StreamCallback<Conversation>,
+    callback: StreamCallback<Conversation>,
+    onFail: () => void,
     conversationType?: ConversationType,
   ) {
     const on_conversation = (conversation: Conversation) => {
-      void callback?.(null, conversation);
+      callback(null, conversation);
     };
     const on_error = (error: Error | null) => {
-      void callback?.(error, undefined);
+      callback(error, undefined);
+    };
+    const on_close = () => {
+      onFail();
     };
     return this.#conversations.stream(
-      { on_conversation, on_error },
+      { on_conversation, on_error, on_close },
       conversationType,
     );
   }
 
-  streamGroups(callback?: StreamCallback<Conversation>) {
-    return this.#conversations.stream(callback, ConversationType.Group);
+  streamGroups(callback: StreamCallback<Conversation>, onFail: () => void) {
+    return this.stream(callback, onFail, ConversationType.Group);
   }
 
-  streamDms(callback?: StreamCallback<Conversation>) {
-    return this.#conversations.stream(callback, ConversationType.Dm);
+  streamDms(callback: StreamCallback<Conversation>, onFail: () => void) {
+    return this.stream(callback, onFail, ConversationType.Dm);
   }
 
   streamAllMessages(
-    callback?: StreamCallback<Message>,
+    callback: StreamCallback<Message>,
+    onFail: () => void,
     conversationType?: ConversationType,
     consentStates?: ConsentState[],
   ) {
     const on_message = (message: Message) => {
-      void callback?.(null, message);
+      callback(null, message);
     };
     const on_error = (error: Error | null) => {
-      void callback?.(error, undefined);
+      callback(error, undefined);
+    };
+    const on_close = () => {
+      onFail();
     };
     return this.#conversations.streamAllMessages(
-      { on_message, on_error },
+      { on_message, on_error, on_close },
       conversationType,
       consentStates,
     );