applesauce-relay 0.0.0-next-20251015123951 → 0.0.0-next-20251027164028

package/README.md

@@ -10,16 +10,15 @@ npm install applesauce-relay
 
 ## Features
 
-- [x] NIP-01
+- [x] NIP-01 `REQ` and `EVENT` messages
 - [x] Relay pool and groups
-- [x] Fetch NIP-11 information before connecting
 - [x] NIP-11 `auth_required` limitation
 - [ ] NIP-11 `max_subscriptions` limitation
 - [x] Client negentropy sync
 - [x] Reconnection backoff logic
 - [x] republish event on reconnect and auth-required
 - [x] Resubscribe on reconnect and auth-required
-- [ ] NIP-45 COUNT
+- [x] NIP-45 COUNT
 
 ## Examples
 

package/dist/group.d.ts

@@ -1,9 +1,9 @@
 import { Filter, type NostrEvent } from "nostr-tools";
-import { Observable } from "rxjs";
+import { BehaviorSubject, MonoTypeOperatorFunction, Observable } from "rxjs";
 import { IAsyncEventStoreActions, IAsyncEventStoreRead, IEventStoreActions, IEventStoreRead } from "applesauce-core";
 import { NegentropySyncOptions, type ReconcileFunction } from "./negentropy.js";
-import { FilterInput, IGroup, IRelay, PublishOptions, PublishResponse, RequestOptions, SubscriptionOptions, SubscriptionResponse } from "./types.js";
 import { SyncDirection } from "./relay.js";
+import { CountResponse, FilterInput, IGroup, IGroupRelayInput, IRelay, PublishOptions, PublishResponse, RequestOptions, SubscriptionOptions, SubscriptionResponse } from "./types.js";
 /** Options for negentropy sync on a group of relays */
 export type GroupNegentropySyncOptions = NegentropySyncOptions & {
     /** Whether to sync in parallel (default true) */
@@ -20,10 +20,21 @@ export type GroupRequestOptions = RequestOptions & {
     eventStore?: IEventStoreActions | IAsyncEventStoreActions | null;
 };
 export declare class RelayGroup implements IGroup {
-    relays: IRelay[];
-    constructor(relays: IRelay[]);
-    /** Takes an array of observables and only emits EOSE when all observables have emitted EOSE */
-    protected mergeEOSE(requests: Observable<SubscriptionResponse>[], eventStore?: IEventStoreActions | IAsyncEventStoreActions | null): Observable<import("nostr-tools").Event | "EOSE">;
+    protected relays$: BehaviorSubject<IRelay[]> | Observable<IRelay[]>;
+    get relays(): IRelay[];
+    constructor(relays: IGroupRelayInput);
+    /** Whether this group is controlled by an upstream observable */
+    private get controlled();
+    /** Check if a relay is in the group */
+    has(relay: IRelay | string): boolean;
+    /** Add a relay to the group */
+    add(relay: IRelay): void;
+    /** Remove a relay from the group */
+    remove(relay: IRelay): void;
+    /** Internal logic for handling requests to multiple relays */
+    protected internalSubscription(project: (relay: IRelay) => Observable<SubscriptionResponse>, eventOperator?: MonoTypeOperatorFunction<NostrEvent>): Observable<SubscriptionResponse>;
+    /** Internal logic for handling publishes to multiple relays */
+    protected internalPublish(project: (relay: IRelay) => Observable<PublishResponse>): Observable<PublishResponse>;
     /**
      * Make a request to all relays
      * @note This does not deduplicate events
@@ -38,10 +49,12 @@ export declare class RelayGroup implements IGroup {
     negentropy(store: IEventStoreRead | IAsyncEventStoreRead | NostrEvent[], filter: Filter, reconcile: ReconcileFunction, opts?: GroupNegentropySyncOptions): Promise<boolean>;
     /** Publish an event to all relays with retries ( default 3 retries ) */
     publish(event: NostrEvent, opts?: PublishOptions): Promise<PublishResponse[]>;
-    /** Request events from all relays with retries ( default 3 retries ) */
+    /** Request events from all relays and complete on EOSE */
     request(filters: FilterInput, opts?: GroupRequestOptions): Observable<NostrEvent>;
     /** Open a subscription to all relays with retries ( default 3 retries ) */
     subscription(filters: FilterInput, opts?: GroupSubscriptionOptions): Observable<SubscriptionResponse>;
+    /** Count events on all relays in the group */
+    count(filters: Filter | Filter[], id?: string): Observable<Record<string, CountResponse>>;
     /** Negentropy sync events with the relays and an event store */
     sync(store: IEventStoreRead | IAsyncEventStoreRead | NostrEvent[], filter: Filter, direction?: SyncDirection): Observable<NostrEvent>;
 }

package/dist/group.js

@@ -1,45 +1,143 @@
 import { nanoid } from "nanoid";
-import { catchError, defer, EMPTY, endWith, identity, ignoreElements, merge, of, share, switchMap, } from "rxjs";
+import { BehaviorSubject, catchError, combineLatest, defaultIfEmpty, defer, endWith, filter, from, identity, ignoreElements, lastValueFrom, map, merge, of, scan, share, switchMap, take, takeWhile, toArray, } from "rxjs";
 import { EventMemory, filterDuplicateEvents, } from "applesauce-core";
 import { completeOnEose } from "./operators/complete-on-eose.js";
 import { onlyEvents } from "./operators/only-events.js";
+import { reverseSwitchMap } from "./operators/reverse-switch-map.js";
+/** Convert an error to a PublishResponse */
+function errorToPublishResponse(relay) {
+    return catchError((err) => of({ ok: false, from: relay.url, message: err?.message || "Unknown error" }));
+}
 export class RelayGroup {
-    relays;
+    relays$ = new BehaviorSubject([]);
+    get relays() {
+        if (this.relays$ instanceof BehaviorSubject)
+            return this.relays$.value;
+        throw new Error("This group was created with an observable, relays are not available");
+    }
     constructor(relays) {
-        this.relays = relays;
+        this.relays$ = Array.isArray(relays) ? new BehaviorSubject(relays) : relays;
+    }
+    /** Whether this group is controlled by an upstream observable */
+    get controlled() {
+        return this.relays$ instanceof BehaviorSubject === false;
+    }
+    /** Check if a relay is in the group */
+    has(relay) {
+        if (this.controlled)
+            throw new Error("This group was created with an observable, relays are not available");
+        if (typeof relay === "string")
+            return this.relays.some((r) => r.url === relay);
+        return this.relays.includes(relay);
+    }
+    /** Add a relay to the group */
+    add(relay) {
+        if (this.has(relay))
+            return;
+        this.relays$.next([...this.relays, relay]);
     }
-    /** Takes an array of observables and only emits EOSE when all observables have emitted EOSE */
-    mergeEOSE(requests, eventStore = new EventMemory()) {
-        // Create stream of events only
-        const events = merge(...requests).pipe(
-        // Ignore non event responses
+    /** Remove a relay from the group */
+    remove(relay) {
+        if (!this.has(relay))
+            return;
+        this.relays$.next(this.relays.filter((r) => r !== relay));
+    }
+    /** Internal logic for handling requests to multiple relays */
+    internalSubscription(project, eventOperator = identity) {
+        // Keep a cache of upstream observables for each relay
+        const upstream = new WeakMap();
+        // Subscribe to the group relays
+        const main = this.relays$.pipe(
+        // Every time they change switch to a new observable
+        // Using reverseSwitchMap to subscribe to the new relays before unsubscribing from the old ones
+        // This avoids sending duplicate REQ messages to the relays
+        reverseSwitchMap((relays) => {
+            const observables = [];
+            for (const relay of relays) {
+                // If an upstream observable exists for this relay, use it
+                if (upstream.has(relay)) {
+                    observables.push(upstream.get(relay));
+                    continue;
+                }
+                const observable = project(relay).pipe(
+                // Catch connection errors and return EOSE
+                catchError(() => of("EOSE")), 
+                // Map values into tuple of relay and value
+                map((value) => [relay, value]));
+                observables.push(observable);
+                upstream.set(relay, observable);
+            }
+            return merge(...observables);
+        }), 
+        // Only create one upstream subscription
+        share());
+        // Create an observable that only emits the events from the relays
+        const events = main.pipe(
+        // Pick the value from the tuple
+        map(([_, value]) => value), 
+        // Only return events
         onlyEvents(), 
-        // If an event store is provided, filter duplicate events
-        eventStore ? filterDuplicateEvents(eventStore) : identity);
-        // Create stream that emits EOSE when all relays have sent EOSE
-        const eose = merge(
-        // Create a new map of requests that only emits EOSE
-        ...requests.map((observable) => observable.pipe(completeOnEose(), ignoreElements()))).pipe(
+        // Add event operations
+        eventOperator);
+        // Create an observable that emits EOSE when all relays have sent EOSE
+        const eose = this.relays$.pipe(
+        // When the relays change, switch to a new observable
+        switchMap((relays) => 
+        // Subscribe to the events, and wait for EOSE from all relays
+        main.pipe(
+        // Only select EOSE messages
+        filter(([_, value]) => value === "EOSE"), 
+        // Track the relays that have sent EOSE
+        scan((received, [relay]) => [...received, relay], []), 
+        // Keep the observable open while there are relays that have not sent EOSE
+        takeWhile((received) => relays.some((r) => !received.includes(r))), 
+        // Ignore all values
+        ignoreElements(), 
         // When all relays have sent EOSE, emit EOSE
-        endWith("EOSE"));
-        return merge(events, eose);
+        endWith("EOSE"))));
+        return merge(events, eose).pipe(
+        // Ensure a single upstream
+        share());
+    }
+    /** Internal logic for handling publishes to multiple relays */
+    internalPublish(project) {
+        // Keep a cache of upstream observables for each relay
+        const upstream = new WeakMap();
+        // Subscribe to the group relays
+        return this.relays$.pipe(
+        // Take a snapshot of relays (no updates yet...)
+        take(1), 
+        // Every time they change switch to a new observable
+        switchMap((relays) => {
+            const observables = [];
+            for (const relay of relays) {
+                // If an upstream observable exists for this relay, use it
+                if (upstream.has(relay)) {
+                    observables.push(upstream.get(relay));
+                    continue;
+                }
+                // Create a new upstream observable for this relay
+                const observable = project(relay).pipe(
+                // Catch error and return as PublishResponse
+                errorToPublishResponse(relay));
+                observables.push(observable);
+                upstream.set(relay, observable);
+            }
+            return merge(...observables);
+        }), 
+        // Ensure a single upstream
+        share());
     }
     /**
      * Make a request to all relays
      * @note This does not deduplicate events
      */
-    req(filters, id = nanoid(8), opts) {
-        const requests = this.relays.map((relay) => relay.req(filters, id).pipe(
-        // Ignore connection errors
-        catchError(() => of("EOSE"))));
-        // Merge events and the single EOSE stream
-        return this.mergeEOSE(requests, opts?.eventStore);
+    req(filters, id = nanoid(), opts) {
+        return this.internalSubscription((relay) => relay.req(filters, id), opts?.eventStore ? filterDuplicateEvents(opts?.eventStore) : identity);
     }
     /** Send an event to all relays */
     event(event) {
-        return merge(...this.relays.map((relay) => relay.event(event).pipe(
-        // Catch error and return as PublishResponse
-        catchError((err) => of({ ok: false, from: relay.url, message: err?.message || "Unknown error" })))));
+        return this.internalPublish((relay) => relay.event(event));
     }
     /** Negentropy sync events with the relays and an event store */
     async negentropy(store, filter, reconcile, opts) {
@@ -57,25 +155,29 @@ export class RelayGroup {
     }
     /** Publish an event to all relays with retries ( default 3 retries ) */
     publish(event, opts) {
-        return Promise.all(this.relays.map((relay) => relay.publish(event, opts).catch(
-        // Catch error and return as PublishResponse
-        (err) => ({ ok: false, from: relay.url, message: err?.message || "Unknown error" }))));
+        return lastValueFrom(this.internalPublish((relay) => from(relay.publish(event, opts))).pipe(toArray(), defaultIfEmpty([])));
     }
-    /** Request events from all relays with retries ( default 3 retries ) */
+    /** Request events from all relays and complete on EOSE */
     request(filters, opts) {
-        return merge(...this.relays.map((relay) => relay.request(filters, opts).pipe(
-        // Ignore individual connection errors
-        catchError(() => EMPTY)))).pipe(
+        return this.internalSubscription((relay) => relay.request(filters, opts).pipe(
+        // Simulate EOSE on completion
+        endWith("EOSE")), 
         // If an event store is provided, filter duplicate events
-        opts?.eventStore == null ? identity : filterDuplicateEvents(opts?.eventStore ?? new EventMemory()));
+        opts?.eventStore == null ? identity : filterDuplicateEvents(opts?.eventStore ?? new EventMemory())).pipe(
+        // Complete when all relays have sent EOSE
+        completeOnEose());
     }
     /** Open a subscription to all relays with retries ( default 3 retries ) */
     subscription(filters, opts) {
-        return this.mergeEOSE(this.relays.map((relay) => relay.subscription(filters, opts).pipe(
-        // Ignore individual connection errors
-        catchError(() => EMPTY))), 
-        // Pass event store so that duplicate events are removed
-        opts?.eventStore);
+        return this.internalSubscription((relay) => relay.subscription(filters, opts), 
+        // If an event store is provided, filter duplicate events
+        opts?.eventStore == null ? identity : filterDuplicateEvents(opts?.eventStore ?? new EventMemory()));
+    }
+    /** Count events on all relays in the group */
+    count(filters, id = nanoid()) {
+        return this.relays$.pipe(switchMap((relays) => combineLatest(Object.fromEntries(relays.map((relay) => [relay.url, relay.count(filters, id)])))), 
+        // Ensure a single upstream
+        share());
     }
     /** Negentropy sync events with the relays and an event store */
     sync(store, filter, direction) {

package/dist/liveness.d.ts

@@ -2,9 +2,7 @@ import { Observable } from "rxjs";
 import { IPool } from "./types.js";
 /** Relay health states for liveness tracking */
 export type RelayHealthState = "online" | "offline" | "dead";
-/**
- * State information for a relay's health tracking
- */
+/** State information for a relay's health tracking */
 export interface RelayState {
     /** Current relay health state */
     state: RelayHealthState;

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/operators/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./complete-on-eose.js";
+export * from "./liveness.js";
 export * from "./mark-from-relay.js";
 export * from "./only-events.js";
+export * from "./reverse-switch-map.js";
 export * from "./store-events.js";
 export * from "./to-event-store.js";
-export * from "./liveness.js";

package/dist/operators/index.js

@@ -1,6 +1,7 @@
 export * from "./complete-on-eose.js";
+export * from "./liveness.js";
 export * from "./mark-from-relay.js";
 export * from "./only-events.js";
+export * from "./reverse-switch-map.js";
 export * from "./store-events.js";
 export * from "./to-event-store.js";
-export * from "./liveness.js";

package/dist/operators/reverse-switch-map.d.ts

@@ -0,0 +1,9 @@
+import { OperatorFunction, ObservableInput, ObservedValueOf } from "rxjs";
+/**
+ * Like switchMap, but subscribes to the new observable before unsubscribing from the old one.
+ * This prevents gaps in subscription coverage.
+ *
+ * @param project A function that, when applied to an item emitted by the source Observable,
+ * returns an Observable.
+ */
+export declare function reverseSwitchMap<T, O extends ObservableInput<any>>(project: (value: T, index: number) => O): OperatorFunction<T, ObservedValueOf<O>>;

package/dist/operators/reverse-switch-map.js

@@ -0,0 +1,46 @@
+import { from } from "rxjs";
+import { createOperatorSubscriber } from "rxjs/internal/operators/OperatorSubscriber";
+import { operate } from "rxjs/internal/util/lift";
+/**
+ * Like switchMap, but subscribes to the new observable before unsubscribing from the old one.
+ * This prevents gaps in subscription coverage.
+ *
+ * @param project A function that, when applied to an item emitted by the source Observable,
+ * returns an Observable.
+ */
+export function reverseSwitchMap(project) {
+    return operate((source, subscriber) => {
+        let innerSubscriber = null;
+        let index = 0;
+        // Whether or not the source subscription has completed
+        let isComplete = false;
+        // We only complete the result if the source is complete AND we don't have an active inner subscription.
+        // This is called both when the source completes and when the inners complete.
+        const checkComplete = () => {
+            if (isComplete && !innerSubscriber)
+                subscriber.complete();
+        };
+        source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+            const outerIndex = index++;
+            const oldSubscriber = innerSubscriber;
+            // Create the new inner subscription FIRST
+            // Immediately assign the new subscriber because observables can emit and complete synchronously
+            const self = (innerSubscriber = createOperatorSubscriber(subscriber, (innerValue) => subscriber.next(innerValue), () => {
+                // The inner has completed. Null out the inner subscriber to
+                // free up memory and to signal that we have no inner subscription
+                // currently. Only do this if this is still the active inner subscriber.
+                if (innerSubscriber === self || innerSubscriber === null) {
+                    innerSubscriber = null;
+                    checkComplete();
+                }
+            }));
+            // Subscribe to the new observable FIRST
+            from(project(value, outerIndex)).subscribe(innerSubscriber);
+            // THEN unsubscribe from the previous inner subscription
+            oldSubscriber?.unsubscribe();
+        }, () => {
+            isComplete = true;
+            checkComplete();
+        }));
+    });
+}

package/dist/pool.d.ts

@@ -1,42 +1,44 @@
 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";
 import type { NegentropySyncOptions, ReconcileFunction } from "./negentropy.js";
 import { Relay, SyncDirection, type RelayOptions } from "./relay.js";
-import type { FilterInput, IPool, IRelay, PublishResponse, SubscriptionResponse } from "./types.js";
+import type { CountResponse, FilterInput, IPool, IPoolRelayInput, IRelay, PublishResponse, SubscriptionResponse } from "./types.js";
 export declare class RelayPool implements IPool {
     options?: RelayOptions | undefined;
-    groups$: BehaviorSubject<Map<string, RelayGroup>>;
-    get groups(): Map<string, RelayGroup>;
     relays$: BehaviorSubject<Map<string, Relay>>;
     get relays(): Map<string, Relay>;
     /** A signal when a relay is added */
     add$: Subject<IRelay>;
     /** A signal when a relay is removed */
     remove$: Subject<IRelay>;
-    /** An array of relays to never connect to */
-    blacklist: Set<string>;
     constructor(options?: RelayOptions | undefined);
-    protected filterBlacklist(urls: string[]): string[];
     /** Get or create a new relay connection */
     relay(url: string): Relay;
     /** Create a group of relays */
-    group(relays: string[]): RelayGroup;
+    group(relays: IPoolRelayInput): RelayGroup;
     /** Removes a relay from the pool and defaults to closing the connection */
     remove(relay: string | IRelay, close?: boolean): void;
     /** Make a REQ to multiple relays that does not deduplicate events */
-    req(relays: string[], filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
+    req(relays: IPoolRelayInput, filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
     /** Send an EVENT message to multiple relays */
-    event(relays: string[], event: NostrEvent): Observable<PublishResponse>;
+    event(relays: IPoolRelayInput, event: NostrEvent): Observable<PublishResponse>;
     /** Negentropy sync event ids with the relays and an event store */
-    negentropy(relays: string[], store: IEventStoreRead | IAsyncEventStoreRead | NostrEvent[], filter: Filter, reconcile: ReconcileFunction, opts?: NegentropySyncOptions): Promise<boolean>;
+    negentropy(relays: IPoolRelayInput, store: IEventStoreRead | IAsyncEventStoreRead | NostrEvent[], filter: Filter, reconcile: ReconcileFunction, opts?: NegentropySyncOptions): Promise<boolean>;
     /** Publish an event to multiple relays */
-    publish(relays: string[], event: Parameters<RelayGroup["publish"]>[0], opts?: Parameters<RelayGroup["publish"]>[1]): Promise<PublishResponse[]>;
+    publish(relays: IPoolRelayInput, event: Parameters<RelayGroup["publish"]>[0], opts?: Parameters<RelayGroup["publish"]>[1]): Promise<PublishResponse[]>;
     /** Request events from multiple relays */
-    request(relays: string[], filters: Parameters<RelayGroup["request"]>[0], opts?: Parameters<RelayGroup["request"]>[1]): Observable<NostrEvent>;
+    request(relays: IPoolRelayInput, filters: FilterInput, opts?: Parameters<RelayGroup["request"]>[1]): Observable<NostrEvent>;
     /** Open a subscription to multiple relays */
-    subscription(relays: string[], filters: Parameters<RelayGroup["subscription"]>[0], options?: Parameters<RelayGroup["subscription"]>[1]): Observable<SubscriptionResponse>;
+    subscription(relays: IPoolRelayInput, filters: FilterInput, options?: Parameters<RelayGroup["subscription"]>[1]): Observable<SubscriptionResponse>;
+    /** Open a subscription for a map of relays and filters */
+    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 */
-    sync(relays: string[], store: IEventStoreRead | IAsyncEventStoreRead | NostrEvent[], filter: Filter, direction?: SyncDirection): Observable<NostrEvent>;
+    sync(relays: IPoolRelayInput, store: IEventStoreRead | IAsyncEventStoreRead | NostrEvent[], filter: Filter, direction?: SyncDirection): Observable<NostrEvent>;
 }

package/dist/pool.js

@@ -1,13 +1,9 @@
-import { normalizeURL } from "applesauce-core/helpers";
-import { BehaviorSubject, Subject } from "rxjs";
+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";
 export class RelayPool {
     options;
-    groups$ = new BehaviorSubject(new Map());
-    get groups() {
-        return this.groups$.value;
-    }
     relays$ = new BehaviorSubject(new Map());
     get relays() {
         return this.relays$.value;
@@ -16,34 +12,13 @@ export class RelayPool {
     add$ = new Subject();
     /** A signal when a relay is removed */
     remove$ = new Subject();
-    /** An array of relays to never connect to */
-    blacklist = new Set();
     constructor(options) {
         this.options = options;
-        // Listen for relays being added and removed to emit connect / disconnect signals
-        // const listeners = new Map<IRelay, Subscription>();
-        // this.add$.subscribe((relay) =>
-        //   listeners.set(
-        //     relay,
-        //     relay.connected$.subscribe((conn) => (conn ? this.connect$.next(relay) : this.disconnect$.next(relay))),
-        //   ),
-        // );
-        // this.remove$.subscribe((relay) => {
-        //   const listener = listeners.get(relay);
-        //   if (listener) listener.unsubscribe();
-        //   listeners.delete(relay);
-        // });
-    }
-    filterBlacklist(urls) {
-        return urls.filter((url) => !this.blacklist.has(url));
     }
     /** Get or create a new relay connection */
     relay(url) {
         // Normalize the url
         url = normalizeURL(url);
-        // Check if the url is blacklisted
-        if (this.blacklist.has(url))
-            throw new Error("Relay is on blacklist");
         // Check if the relay already exists
         let relay = this.relays.get(url);
         if (relay)
@@ -57,17 +32,9 @@ export class RelayPool {
     }
     /** Create a group of relays */
     group(relays) {
-        // Normalize all urls
-        relays = relays.map((url) => normalizeURL(url));
-        // Filter out any blacklisted relays
-        relays = this.filterBlacklist(relays);
-        const key = relays.sort().join(",");
-        let group = this.groups.get(key);
-        if (group)
-            return group;
-        group = new RelayGroup(relays.map((url) => this.relay(url)));
-        this.groups$.next(this.groups.set(key, group));
-        return group;
+        return new RelayGroup(Array.isArray(relays)
+            ? relays.map((url) => this.relay(url))
+            : relays.pipe(map((urls) => urls.map((url) => this.relay(url)))));
     }
     /** Removes a relay from the pool and defaults to closing the connection */
     remove(relay, close = true) {
@@ -112,6 +79,34 @@ export class RelayPool {
     subscription(relays, filters, options) {
         return this.group(relays).subscription(filters, options);
     }
+    /** Open a subscription for a map of relays and filters */
+    subscriptionMap(relays, options) {
+        // Convert input to observable
+        const relays$ = isObservable(relays) ? relays : of(relays);
+        return this.group(
+        // Create a group with an observable of dynamic relay urls
+        relays$.pipe(map((dir) => Object.keys(dir)))).subscription((relay) => {
+            // Return observable to subscribe to the relays unique filters
+            return relays$.pipe(
+            // Select the relays filters
+            map((dir) => dir[relay.url]), 
+            // Don't send duplicate filters
+            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);
+    }
     /** Negentropy sync events with the relays and an event store */
     sync(relays, store, filter, direction) {
         return this.group(relays).sync(store, filter, direction);

package/dist/relay.d.ts

@@ -4,7 +4,7 @@ import { RelayInformation } from "nostr-tools/nip11";
 import { BehaviorSubject, MonoTypeOperatorFunction, Observable, RepeatConfig, RetryConfig, Subject } from "rxjs";
 import { WebSocketSubject, WebSocketSubjectConfig } from "rxjs/webSocket";
 import { type NegentropySyncOptions, type ReconcileFunction } from "./negentropy.js";
-import { AuthSigner, FilterInput, IRelay, PublishOptions, PublishResponse, RequestOptions, SubscriptionOptions, SubscriptionResponse } from "./types.js";
+import { AuthSigner, CountResponse, FilterInput, IRelay, PublishOptions, PublishResponse, RequestOptions, SubscriptionOptions, SubscriptionResponse } from "./types.js";
 /** Flags for the negentropy sync type */
 export declare enum SyncDirection {
     RECEIVE = 1,
@@ -104,6 +104,8 @@ export declare class Relay implements IRelay {
     send(message: any): void;
     /** Create a REQ observable that emits events or "EOSE" or errors */
     req(filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
+    /** Create a COUNT observable that emits a single count response */
+    count(filters: Filter | Filter[], id?: string): Observable<CountResponse>;
     /** Send an EVENT or AUTH message and return an observable of PublishResponse that completes or errors */
     event(event: NostrEvent, verb?: "EVENT" | "AUTH"): Observable<PublishResponse>;
     /** send and AUTH message */
@@ -118,10 +120,12 @@ export declare class Relay implements IRelay {
     protected customRepeatOperator<T extends unknown = unknown>(times: undefined | boolean | number | RepeatConfig | undefined): MonoTypeOperatorFunction<T>;
     /** Internal operator for creating the timeout() operator */
     protected customTimeoutOperator<T extends unknown = unknown>(timeout: undefined | boolean | number, defaultTimeout: number): MonoTypeOperatorFunction<T>;
+    /** Internal operator for handling auth-required errors from REQ/COUNT operations */
+    protected handleAuthRequiredForReq(operation: "REQ" | "COUNT"): MonoTypeOperatorFunction<any>;
     /** Creates a REQ that retries when relay errors ( default 3 retries ) */
-    subscription(filters: Filter | Filter[], opts?: SubscriptionOptions): Observable<SubscriptionResponse>;
+    subscription(filters: FilterInput, opts?: SubscriptionOptions): Observable<SubscriptionResponse>;
     /** Makes a single request that retires on errors and completes on EOSE */
-    request(filters: Filter | Filter[], opts?: RequestOptions): Observable<NostrEvent>;
+    request(filters: FilterInput, opts?: RequestOptions): Observable<NostrEvent>;
     /** Publishes an event to the relay and retries when relay errors or responds with auth-required ( default 3 retries ) */
     publish(event: NostrEvent, opts?: PublishOptions): Promise<PublishResponse>;
     /** Negentropy sync events with the relay and an event store */

package/dist/relay.js

@@ -7,6 +7,7 @@ import { BehaviorSubject, catchError, combineLatest, defer, endWith, filter, fin
 import { webSocket } from "rxjs/webSocket";
 import { completeOnEose } from "./operators/complete-on-eose.js";
 import { markFromRelay } from "./operators/mark-from-relay.js";
+const AUTH_REQUIRED_PREFIX = "auth-required:";
 const DEFAULT_RETRY_CONFIG = { count: 10, delay: 1000, resetOnSuccess: true };
 /** Flags for the negentropy sync type */
 export var SyncDirection;
@@ -264,7 +265,15 @@ export class Relay {
     /** Create a REQ observable that emits events or "EOSE" or errors */
     req(filters, id = nanoid()) {
         // Convert filters input into an observable, if its a normal value merge it with NEVER so it never completes
-        const input = isObservable(filters) ? filters : merge(of(filters), NEVER);
+        let input;
+        // Create input from filters input
+        if (typeof filters === "function") {
+            const result = filters(this);
+            input = (isObservable(result) ? result : merge(of(result), NEVER)).pipe(map((f) => (Array.isArray(f) ? f : [f])));
+        }
+        else {
+            input = (isObservable(filters) ? filters : merge(of(filters), NEVER)).pipe(map((f) => (Array.isArray(f) ? f : [f])));
+        }
         // Create an observable that completes when the upstream observable completes
         const filtersComplete = input.pipe(ignoreElements(), endWith(null));
         // Create an observable that filters responses from the relay to just the ones for this REQ
@@ -274,7 +283,7 @@ export class Relay {
         // Create an observable that controls sending the filters and closing the REQ
         const control = input.pipe(
         // Send the filters when they change
-        tap((filters) => this.socket.next(Array.isArray(filters) ? ["REQ", id, ...filters] : ["REQ", id, filters])), 
+        tap((filters) => this.socket.next(["REQ", id, ...filters])), 
         // Send the CLOSE message when unsubscribed or input completes
         finalize(() => this.socket.next(["CLOSE", id])), 
         // Once filters have been sent, switch to listening for messages
@@ -294,21 +303,11 @@ export class Relay {
                 throw new ReqCloseError(message[2]);
             else
                 return message[2];
-        }), catchError((error) => {
-            // Set REQ auth required if the REQ is closed with auth-required
-            if (error instanceof ReqCloseError &&
-                error.message.startsWith("auth-required") &&
-                !this.receivedAuthRequiredForReq.value) {
-                this.log("Auth required for REQ");
-                this.receivedAuthRequiredForReq.next(true);
-            }
-            // Pass the error through
-            return throwError(() => error);
-        }), 
+        }), this.handleAuthRequiredForReq("REQ"), 
         // mark events as from relays
         markFromRelay(this.url), 
         // if no events are seen in 10s, emit EOSE
-        // TODO: this should emit EOSE event if events are seen, the timeout should be for only the EOSE message
+        // TODO: this timeout should only emit EOSE after the last event is seen and no EOSE has been sent in (timeout ms)
         timeout({
             first: this.eoseTimeout,
             with: () => merge(of("EOSE"), NEVER),
@@ -318,6 +317,38 @@ export class Relay {
         // Wait for auth if required and make sure to start the watch tower
         return this.waitForReady(this.waitForAuth(this.authRequiredForRead$, observable));
     }
+    /** Create a COUNT observable that emits a single count response */
+    count(filters, id = nanoid()) {
+        // Create an observable that filters responses from the relay to just the ones for this COUNT
+        const messages = this.socket.pipe(filter((m) => Array.isArray(m) && (m[0] === "COUNT" || m[0] === "CLOSED") && m[1] === id), 
+        // Singleton (prevents duplicate subscriptions)
+        share());
+        // Send the COUNT message and listen for response
+        const observable = defer(() => {
+            // Send the COUNT message when subscription starts
+            this.socket.next(Array.isArray(filters) ? ["COUNT", id, ...filters] : ["COUNT", id, filters]);
+            // Merge with watch tower to keep connection alive
+            return merge(this.watchTower, messages);
+        }).pipe(
+        // Map the messages to count responses or throw an error
+        map((message) => {
+            if (message[0] === "COUNT")
+                return message[2];
+            else
+                throw new ReqCloseError(message[2]);
+        }), this.handleAuthRequiredForReq("COUNT"), 
+        // Complete on first value (COUNT responses are single-shot)
+        take(1), 
+        // Add timeout
+        timeout({
+            first: this.eoseTimeout,
+            with: () => throwError(() => new Error("COUNT timeout")),
+        }), 
+        // Only create one upstream subscription
+        share());
+        // Start the watch tower and wait for auth if required
+        return this.waitForReady(this.waitForAuth(this.authRequiredForRead$, observable));
+    }
     /** Send an EVENT or AUTH message and return an observable of PublishResponse that completes or errors */
     event(event, verb = "EVENT") {
         const messages = defer(() => {
@@ -338,7 +369,7 @@ export class Relay {
         take(1), 
         // listen for OK auth-required
         tap(({ ok, message }) => {
-            if (ok === false && message?.startsWith("auth-required") && !this.receivedAuthRequiredForEvent.value) {
+            if (ok === false && message?.startsWith(AUTH_REQUIRED_PREFIX) && !this.receivedAuthRequiredForEvent.value) {
                 this.log("Auth required for publish");
                 this.receivedAuthRequiredForEvent.next(true);
             }
@@ -414,6 +445,20 @@ export class Relay {
         else
             return simpleTimeout(timeout ?? defaultTimeout);
     }
+    /** Internal operator for handling auth-required errors from REQ/COUNT operations */
+    handleAuthRequiredForReq(operation) {
+        return catchError((error) => {
+            // Set auth required if the operation is closed with auth-required
+            if (error instanceof ReqCloseError &&
+                error.message.startsWith(AUTH_REQUIRED_PREFIX) &&
+                !this.receivedAuthRequiredForReq.value) {
+                this.log(`Auth required for ${operation}`);
+                this.receivedAuthRequiredForReq.next(true);
+            }
+            // Pass the error through
+            return throwError(() => error);
+        });
+    }
     /** Creates a REQ that retries when relay errors ( default 3 retries ) */
     subscription(filters, opts) {
         return this.req(filters, opts?.id).pipe(
@@ -440,7 +485,7 @@ export class Relay {
     publish(event, opts) {
         return lastValueFrom(this.event(event).pipe(mergeMap((result) => {
             // If the relay responds with auth-required, throw an error for the retry operator to handle
-            if (result.ok === false && result.message?.startsWith("auth-required:"))
+            if (result.ok === false && result.message?.startsWith(AUTH_REQUIRED_PREFIX))
                 return throwError(() => new Error(result.message));
             return of(result);
         }), 
@@ -461,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
@@ -475,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/dist/types.d.ts

@@ -12,6 +12,9 @@ export type PublishResponse = {
     message?: string;
     from: string;
 };
+export type CountResponse = {
+    count: number;
+};
 export type MultiplexWebSocket<T = any> = Pick<WebSocketSubject<T>, "multiplex">;
 /** Options for the publish method on the pool and relay */
 export type PublishOptions = {
@@ -55,8 +58,8 @@ export type SubscriptionOptions = {
 export type AuthSigner = {
     signEvent: (event: EventTemplate) => NostrEvent | Promise<NostrEvent>;
 };
-/** The type of input the REQ method accepts */
-export type FilterInput = Filter | Filter[] | Observable<Filter | Filter[]>;
+/** Filters that can be passed to request methods on the pool or relay */
+export type FilterInput = Filter | Filter[] | Observable<Filter | Filter[]> | ((relay: IRelay) => Filter | Filter[] | Observable<Filter | Filter[]>);
 export interface IRelay extends MultiplexWebSocket {
     url: string;
     message$: Observable<any>;
@@ -77,6 +80,8 @@ export interface IRelay extends MultiplexWebSocket {
     close(): void;
     /** Send a REQ message */
     req(filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
+    /** Send a COUNT message */
+    count(filters: Filter | Filter[], id?: string): Observable<CountResponse>;
     /** Send an EVENT message */
     event(event: NostrEvent): Observable<PublishResponse>;
     /** Send an AUTH message */
@@ -100,19 +105,28 @@ export interface IRelay extends MultiplexWebSocket {
     /** Get the supported NIPs for the relay */
     getSupported(): Promise<number[] | null>;
 }
+export type IGroupRelayInput = IRelay[] | Observable<IRelay[]>;
 export interface IGroup {
     /** Send a REQ message */
-    req(filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
+    req(filters: Parameters<IRelay["req"]>[0], id?: string): Observable<SubscriptionResponse>;
     /** Send an EVENT message */
-    event(event: NostrEvent): Observable<PublishResponse>;
+    event(event: Parameters<IRelay["event"]>[0]): Observable<PublishResponse>;
     /** Negentropy sync event ids with the relays and an event store */
     negentropy(store: IEventStoreRead | IAsyncEventStoreRead | NostrEvent[], filter: Filter, reconcile: ReconcileFunction, opts?: NegentropySyncOptions): Promise<boolean>;
+    /** Add a relay to the group */
+    add(relay: IRelay): void;
+    /** Remove a relay from the group */
+    remove(relay: IRelay): void;
+    /** Check if a relay is in the group */
+    has(relay: IRelay | string): boolean;
     /** Send an EVENT message with retries */
-    publish(event: NostrEvent, opts?: PublishOptions): Promise<PublishResponse[]>;
+    publish(event: Parameters<IRelay["event"]>[0], opts?: PublishOptions): Promise<PublishResponse[]>;
     /** Send a REQ message with retries */
-    request(filters: FilterInput, opts?: GroupRequestOptions): Observable<NostrEvent>;
+    request(filters: Parameters<IRelay["request"]>[0], opts?: GroupRequestOptions): Observable<NostrEvent>;
     /** Open a subscription with retries */
-    subscription(filters: FilterInput, opts?: GroupSubscriptionOptions): Observable<SubscriptionResponse>;
+    subscription(filters: Parameters<IRelay["subscription"]>[0], opts?: GroupSubscriptionOptions): Observable<SubscriptionResponse>;
+    /** Count events on the relays and an event store */
+    count(filters: Filter | Filter[], id?: string): Observable<Record<string, CountResponse>>;
     /** Negentropy sync events with the relay and an event store */
     sync(store: IEventStoreRead | IAsyncEventStoreRead | NostrEvent[], filter: Filter, direction?: SyncDirection): Observable<NostrEvent>;
 }
@@ -121,25 +135,28 @@ export interface IPoolSignals {
     add$: Observable<IRelay>;
     remove$: Observable<IRelay>;
 }
+export type IPoolRelayInput = string[] | Observable<string[]>;
 export interface IPool extends IPoolSignals {
     /** Get or create a relay */
     relay(url: string): IRelay;
     /** Create a relay group */
-    group(relays: string[]): IGroup;
+    group(relays: IPoolRelayInput): IGroup;
     /** Removes a relay from the pool and defaults to closing the connection */
     remove(relay: string | IRelay, close?: boolean): void;
     /** Send a REQ message */
-    req(relays: string[], filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
+    req(relays: IPoolRelayInput, filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
     /** Send an EVENT message */
-    event(relays: string[], event: NostrEvent): Observable<PublishResponse>;
+    event(relays: IPoolRelayInput, event: NostrEvent): Observable<PublishResponse>;
     /** Negentropy sync event ids with the relays and an event store */
-    negentropy(relays: string[], store: IEventStoreRead | IAsyncEventStoreRead | NostrEvent[], filter: Filter, reconcile: ReconcileFunction, opts?: GroupNegentropySyncOptions): Promise<boolean>;
+    negentropy(relays: IPoolRelayInput, store: IEventStoreRead | IAsyncEventStoreRead | NostrEvent[], filter: Filter, reconcile: ReconcileFunction, opts?: GroupNegentropySyncOptions): Promise<boolean>;
     /** Send an EVENT message to relays with retries */
-    publish(relays: string[], event: Parameters<IGroup["publish"]>[0], opts?: Parameters<IGroup["publish"]>[1]): Promise<PublishResponse[]>;
+    publish(relays: IPoolRelayInput, event: Parameters<IGroup["publish"]>[0], opts?: Parameters<IGroup["publish"]>[1]): Promise<PublishResponse[]>;
     /** Send a REQ message to relays with retries */
-    request(relays: string[], filters: Parameters<IGroup["request"]>[0], opts?: Parameters<IGroup["request"]>[1]): Observable<NostrEvent>;
+    request(relays: IPoolRelayInput, filters: Parameters<IGroup["request"]>[0], opts?: Parameters<IGroup["request"]>[1]): Observable<NostrEvent>;
     /** Open a subscription to relays with retries */
-    subscription(relays: string[], filters: Parameters<IGroup["subscription"]>[0], opts?: Parameters<IGroup["subscription"]>[1]): Observable<SubscriptionResponse>;
+    subscription(relays: IPoolRelayInput, filters: Parameters<IGroup["subscription"]>[0], opts?: Parameters<IGroup["subscription"]>[1]): Observable<SubscriptionResponse>;
+    /** Count events on the relays and an event store */
+    count(relays: IPoolRelayInput, filters: Filter | Filter[], id?: string): Observable<Record<string, CountResponse>>;
     /** Negentropy sync events with the relay and an event store */
-    sync(relays: string[], store: IEventStoreRead | IAsyncEventStoreRead | NostrEvent[], filter: Filter, direction?: SyncDirection): Observable<NostrEvent>;
+    sync(relays: IPoolRelayInput, store: IEventStoreRead | IAsyncEventStoreRead | NostrEvent[], filter: Filter, direction?: SyncDirection): Observable<NostrEvent>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-relay",
-  "version": "0.0.0-next-20251015123951",
+  "version": "0.0.0-next-20251027164028",
   "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-20251015123951",
+    "applesauce-core": "0.0.0-next-20251027164028",
     "nanoid": "^5.0.9",
     "nostr-tools": "~2.17",
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
     "@hirez_io/observer-spy": "^2.2.0",
-    "applesauce-signers": "0.0.0-next-20251015123951",
+    "applesauce-signers": "0.0.0-next-20251027164028",
     "rimraf": "^6.0.1",
     "typescript": "^5.7.3",
     "vitest": "^3.2.4",