applesauce-relay 0.0.0-next-20251020143053 → 0.0.0-next-20251030142514

package/dist/negentropy.js

@@ -1,5 +1,5 @@
 import { logger } from "applesauce-core";
-import { map, share, firstValueFrom } from "rxjs";
+import { map, share, firstValueFrom, race, Observable } from "rxjs";
 import { nanoid } from "nanoid";
 import { Negentropy, NegentropyStorageVector } from "./lib/negentropy.js";
 const log = logger.extend("negentropy");
@@ -52,16 +52,49 @@ export async function negentropySync(storage, socket, filter, reconcile, opts) {
             throw new Error(msg[2]);
         return msg[2];
     }), share());
+    // Check if already aborted before starting sync
+    if (opts?.signal?.aborted)
+        return false;
+    // Create an observable that emits when abort signal is triggered
+    const abortSignal$ = new Observable((observer) => {
+        if (opts?.signal?.aborted) {
+            observer.next("abort");
+            observer.complete();
+            return;
+        }
+        const onAbort = () => {
+            observer.next("abort");
+            observer.complete();
+        };
+        opts?.signal?.addEventListener("abort", onAbort);
+        return () => opts?.signal?.removeEventListener("abort", onAbort);
+    });
     // keep an additional subscription open while waiting for async operations
-    const sub = incoming.subscribe((m) => log(m));
+    const sub = incoming.subscribe({
+        next: (m) => log(m),
+        error: () => { }, // Ignore errors here, they'll be caught by firstValueFrom
+    });
     try {
         while (msg && opts?.signal?.aborted !== true) {
-            const received = await firstValueFrom(incoming);
-            if (opts?.signal?.aborted)
-                return false;
-            const [newMsg, have, need] = await ne.reconcile(received);
-            await reconcile(have, need);
-            msg = newMsg;
+            // Race between incoming message and abort signal
+            try {
+                const received = await firstValueFrom(race(incoming.pipe(map((m) => ({ type: "message", data: m }))), abortSignal$.pipe(map(() => ({ type: "abort" })))));
+                if (received.type === "abort" || opts?.signal?.aborted) {
+                    sub.unsubscribe();
+                    return false;
+                }
+                const [newMsg, have, need] = await ne.reconcile(received.data);
+                await reconcile(have, need);
+                msg = newMsg;
+            }
+            catch (err) {
+                // Check if aborted during reconcile or message processing
+                if (opts?.signal?.aborted) {
+                    sub.unsubscribe();
+                    return false;
+                }
+                throw err;
+            }
         }
     }
     catch (err) {

package/dist/pool.d.ts

@@ -1,4 +1,5 @@
 import type { IAsyncEventStoreRead, IEventStoreRead } from "applesauce-core";
+import { FilterMap, OutboxMap } from "applesauce-core/helpers";
 import { Filter, type NostrEvent } from "nostr-tools";
 import { BehaviorSubject, Observable, Subject } from "rxjs";
 import { RelayGroup } from "./group.js";
@@ -33,7 +34,9 @@ export declare class RelayPool implements IPool {
     /** Open a subscription to multiple relays */
     subscription(relays: IPoolRelayInput, filters: FilterInput, options?: Parameters<RelayGroup["subscription"]>[1]): Observable<SubscriptionResponse>;
     /** Open a subscription for a map of relays and filters */
-    subscriptionMap(relays: Record<string, Filter | Filter[]> | Observable<Record<string, Filter | Filter[]>>, options?: Parameters<RelayGroup["subscription"]>[1]): Observable<SubscriptionResponse>;
+    subscriptionMap(relays: FilterMap | Observable<FilterMap>, options?: Parameters<RelayGroup["subscription"]>[1]): Observable<SubscriptionResponse>;
+    /** Open a subscription for an {@link OutboxMap} and filter */
+    outboxSubscription(outboxes: OutboxMap | Observable<OutboxMap>, filter: Omit<Filter, "authors">, options?: Parameters<RelayGroup["subscription"]>[1]): Observable<SubscriptionResponse>;
     /** Count events on multiple relays */
     count(relays: IPoolRelayInput, filters: Filter | Filter[], id?: string): Observable<Record<string, CountResponse>>;
     /** Negentropy sync events with the relays and an event store */

package/dist/pool.js

@@ -1,4 +1,4 @@
-import { isFilterEqual, normalizeURL } from "applesauce-core/helpers";
+import { createFilterMap, isFilterEqual, normalizeURL } from "applesauce-core/helpers";
 import { BehaviorSubject, distinctUntilChanged, isObservable, map, of, Subject } from "rxjs";
 import { RelayGroup } from "./group.js";
 import { Relay } from "./relay.js";
@@ -94,6 +94,15 @@ export class RelayPool {
             distinctUntilChanged(isFilterEqual));
         }, options);
     }
+    /** Open a subscription for an {@link OutboxMap} and filter */
+    outboxSubscription(outboxes, filter, options) {
+        const filterMap = isObservable(outboxes)
+            ? outboxes.pipe(
+            // Project outbox map to filter map
+            map((outboxes) => createFilterMap(outboxes, filter)))
+            : createFilterMap(outboxes, filter);
+        return this.subscriptionMap(filterMap, options);
+    }
     /** Count events on multiple relays */
     count(relays, filters, id) {
         return this.group(relays).count(filters, id);

package/dist/relay.js

@@ -506,6 +506,14 @@ export class Relay {
         };
         return new Observable((observer) => {
             const controller = new AbortController();
+            let cleanupCalled = false;
+            // Store reference to cleanup the negentropy properly
+            const cleanup = () => {
+                if (!cleanupCalled) {
+                    cleanupCalled = true;
+                    controller.abort();
+                }
+            };
             this.negentropy(store, filter, async (have, need) => {
                 // NOTE: it may be more efficient to sync all the events later in a single batch
                 // Send missing events to the relay
@@ -520,11 +528,17 @@ export class Relay {
                 }
             }, { signal: controller.signal })
                 // Complete the observable when the sync is complete
-                .then(() => observer.complete())
+                .then(() => {
+                if (!cleanupCalled)
+                    observer.complete();
+            })
                 // Error the observable when the sync fails
-                .catch((err) => observer.error(err));
+                .catch((err) => {
+                if (!cleanupCalled)
+                    observer.error(err);
+            });
             // Cancel the sync when the observable is unsubscribed
-            return () => controller.abort();
+            return cleanup;
         }).pipe(
         // Only create one upstream subscription
         share());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-relay",
-  "version": "0.0.0-next-20251020143053",
+  "version": "0.0.0-next-20251030142514",
   "description": "nostr relay communication framework built on rxjs",
   "type": "module",
   "main": "dist/index.js",
@@ -52,14 +52,14 @@
   },
   "dependencies": {
     "@noble/hashes": "^1.7.1",
-    "applesauce-core": "0.0.0-next-20251020143053",
+    "applesauce-core": "0.0.0-next-20251030142514",
     "nanoid": "^5.0.9",
     "nostr-tools": "~2.17",
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
     "@hirez_io/observer-spy": "^2.2.0",
-    "applesauce-signers": "^4.1.0",
+    "applesauce-signers": "0.0.0-next-20251030142514",
     "rimraf": "^6.0.1",
     "typescript": "^5.7.3",
     "vitest": "^3.2.4",