Re-work publish/thunk status

packages/net/src/publish.ts

@@ -1,3 +1,4 @@
+import {fromPairs} from "@welshman/lib"
 import {SignedEvent} from "@welshman/util"
 import {RelayMessage, ClientMessageType, isRelayOk} from "./message.js"
 import {AdapterEvent, AdapterContext, getAdapter} from "./adapter.js"
@@ -14,6 +15,7 @@ export enum PublishStatus {
 export type PublishResult = {
   status: PublishStatus
   detail: string
+  relay: string
 }
 
 export type PublishOneOptions = {
@@ -22,26 +24,30 @@ export type PublishOneOptions = {
   signal?: AbortSignal
   timeout?: number
   context?: AdapterContext
-  onSuccess?: (detail: string) => void
-  onFailure?: (detail: string) => void
-  onPending?: () => void
-  onTimeout?: () => void
-  onAborted?: () => void
-  onComplete?: () => void
+  onSuccess?: (result: PublishResult) => void
+  onFailure?: (result: PublishResult) => void
+  onPending?: (result: PublishResult) => void
+  onTimeout?: (result: PublishResult) => void
+  onAborted?: (result: PublishResult) => void
+  onComplete?: (result: PublishResult) => void
 }
 
 export const publishOne = (options: PublishOneOptions) =>
-  new Promise(resolve => {
+  new Promise<PublishResult>(resolve => {
     const adapter = getAdapter(options.relay, options.context)
 
-    let status = PublishStatus.Pending
+    const result = {
+      relay: options.relay,
+      status: PublishStatus.Pending,
+      detail: "",
+    }
 
-    options.onPending?.()
+    options.onPending?.(result)
 
     const cleanup = () => {
-      options.onComplete?.()
+      options.onComplete?.(result)
       adapter.cleanup()
-      resolve(status)
+      resolve(result)
     }
 
     adapter.on(AdapterEvent.Receive, (message: RelayMessage, url: string) => {
@@ -51,11 +57,15 @@ export const publishOne = (options: PublishOneOptions) =>
         if (id !== options.event.id) return
 
         if (ok) {
-          status = PublishStatus.Success
-          options.onSuccess?.(detail)
+          result.status = PublishStatus.Success
+          result.detail = detail
+
+          options.onSuccess?.(result)
         } else {
-          status = PublishStatus.Failure
-          options.onFailure?.(detail)
+          result.status = PublishStatus.Failure
+          result.detail = detail
+
+          options.onFailure?.(result)
         }
 
         cleanup()
@@ -63,18 +73,22 @@ export const publishOne = (options: PublishOneOptions) =>
     })
 
     options.signal?.addEventListener("abort", () => {
-      if (status === PublishStatus.Pending) {
-        status = PublishStatus.Aborted
-        options.onAborted?.()
+      if (result.status === PublishStatus.Pending) {
+        result.status = PublishStatus.Aborted
+        result.detail = "aborted"
+
+        options.onAborted?.(result)
       }
 
       cleanup()
     })
 
     setTimeout(() => {
-      if (status === PublishStatus.Pending) {
-        status = PublishStatus.Timeout
-        options.onTimeout?.()
+      if (result.status === PublishStatus.Pending) {
+        result.status = PublishStatus.Timeout
+        result.detail = "timed out"
+
+        options.onTimeout?.(result)
       }
 
       cleanup()
@@ -83,7 +97,7 @@ export const publishOne = (options: PublishOneOptions) =>
     adapter.send([ClientMessageType.Event, options.event])
   })
 
-export type PublishStatusByRelay = Record<string, PublishStatus>
+export type PublishResultsByRelay = Record<string, PublishResult>
 
 export type PublishOptions = {
   event: SignedEvent
@@ -91,17 +105,16 @@ export type PublishOptions = {
   signal?: AbortSignal
   timeout?: number
   context?: AdapterContext
-  onSuccess?: (detail: string, relay: string) => void
-  onFailure?: (detail: string, relay: string) => void
-  onPending?: (relay: string) => void
-  onTimeout?: (relay: string) => void
-  onAborted?: (relay: string) => void
-  onComplete?: () => void
+  onSuccess?: (result: PublishResult) => void
+  onFailure?: (result: PublishResult) => void
+  onPending?: (result: PublishResult) => void
+  onTimeout?: (result: PublishResult) => void
+  onAborted?: (result: PublishResult) => void
+  onComplete?: (result: PublishResult) => void
 }
 
-export const publish = async (options: PublishOptions) => {
+export const publish = async (options: PublishOptions): Promise<PublishResultsByRelay> => {
   const {event, timeout, signal, context} = options
-  const status: PublishStatusByRelay = {}
   const completed = new Set<string>()
   const relays = new Set(options.relays)
 
@@ -109,44 +122,31 @@ export const publish = async (options: PublishOptions) => {
     console.warn("Non-unique relays passed to publish")
   }
 
-  await Promise.all(
-    options.relays.map(relay =>
-      publishOne({
-        event,
-        relay,
-        signal,
-        timeout,
-        context,
-        onSuccess: (detail: string) => {
-          status[relay] = PublishStatus.Success
-          options.onSuccess?.(detail, relay)
-        },
-        onFailure: (detail: string) => {
-          status[relay] = PublishStatus.Failure
-          options.onFailure?.(detail, relay)
-        },
-        onPending: () => {
-          status[relay] = PublishStatus.Pending
-          options.onPending?.(relay)
-        },
-        onTimeout: () => {
-          status[relay] = PublishStatus.Timeout
-          options.onTimeout?.(relay)
-        },
-        onAborted: () => {
-          status[relay] = PublishStatus.Aborted
-          options.onAborted?.(relay)
-        },
-        onComplete: () => {
-          completed.add(relay)
+  return fromPairs(
+    await Promise.all(
+      options.relays.map(async relay => {
+        const result = await publishOne({
+          event,
+          relay,
+          signal,
+          timeout,
+          context,
+          onSuccess: options.onSuccess,
+          onFailure: options.onFailure,
+          onPending: options.onPending,
+          onTimeout: options.onTimeout,
+          onAborted: options.onAborted,
+          onComplete: (result: PublishResult) => {
+            completed.add(relay)
 
-          if (completed.size === relays.size) {
-            options.onComplete?.()
-          }
-        },
+            if (completed.size === relays.size) {
+              options.onComplete?.(result)
+            }
+          },
+        })
+
+        return [relay, result]
       }),
     ),
   )
-
-  return status
 }