feat: note publishing progress

packages/system/src/nostr-system.ts

@@ -1,8 +1,8 @@
 import debug from "debug";
 
-import { unwrap, sanitizeRelayUrl, ExternalStore, FeedCache } from "@snort/shared";
+import { unwrap, sanitizeRelayUrl, ExternalStore, FeedCache, removeUndefined } from "@snort/shared";
 import { NostrEvent, TaggedNostrEvent } from "./nostr";
-import { AuthHandler, Connection, RelaySettings, ConnectionStateSnapshot } from "./connection";
+import { AuthHandler, Connection, RelaySettings, ConnectionStateSnapshot, OkResponse } from "./connection";
 import { Query } from "./query";
 import { NoteCollection, NoteStore, NoteStoreSnapshotData } from "./note-collection";
 import { BuiltRawReqFilter, RequestBuilder, RequestStrategy } from "./request-builder";
@@ -354,35 +354,45 @@ export class NostrSystem extends ExternalStore<SystemSnapshot> implements System
   /**
    * Send events to writable relays
    */
-  BroadcastEvent(ev: NostrEvent) {
-    for (const [, s] of this.#sockets) {
-      if (!s.Ephemeral) {
-        s.SendEvent(ev);
-      }
-    }
+  async BroadcastEvent(ev: NostrEvent, cb?: (rsp: OkResponse) => void) {
+    const socks = [...this.#sockets.values()].filter(a => !a.Ephemeral && a.Settings.write);
+    const oks = await Promise.all(
+      socks.map(async s => {
+        try {
+          const rsp = await s.SendAsync(ev);
+          cb?.(rsp);
+          return rsp;
+        } catch (e) {
+          console.error(e);
+        }
+        return;
+      }),
+    );
+    return removeUndefined(oks);
   }
 
   /**
    * Write an event to a relay then disconnect
    */
-  async WriteOnceToRelay(address: string, ev: NostrEvent) {
+  async WriteOnceToRelay(address: string, ev: NostrEvent): Promise<OkResponse> {
     const addrClean = sanitizeRelayUrl(address);
     if (!addrClean) {
       throw new Error("Invalid relay address");
     }
 
-    if (this.#sockets.has(addrClean)) {
-      await this.#sockets.get(addrClean)?.SendAsync(ev);
+    const existing = this.#sockets.get(addrClean);
+    if (existing) {
+      return await existing.SendAsync(ev);
     } else {
-      return await new Promise<void>((resolve, reject) => {
+      return await new Promise<OkResponse>((resolve, reject) => {
         const c = new Connection(address, { write: true, read: true }, this.#handleAuth?.bind(this), true);
 
-        const t = setTimeout(reject, 5_000);
+        const t = setTimeout(reject, 10_000);
         c.OnConnected = async () => {
           clearTimeout(t);
-          await c.SendAsync(ev);
+          const rsp = await c.SendAsync(ev);
           c.Close();
-          resolve();
+          resolve(rsp);
         };
         c.Connect();
       });