applesauce-relay 0.0.0-next-20250327153627 → 0.0.0-next-20250330150216

package/dist/group.d.ts

@@ -0,0 +1,10 @@
+import { NostrEvent } from "nostr-tools";
+import { Observable } from "rxjs";
+import { Filter } from "nostr-tools";
+import { IRelay, Nip01Actions, PublishResponse, SubscriptionResponse } from "./types.js";
+export declare class RelayGroup implements Nip01Actions {
+    relays: IRelay[];
+    constructor(relays: IRelay[]);
+    req(filters: Filter | Filter[], id?: string): Observable<SubscriptionResponse>;
+    event(event: NostrEvent): Observable<PublishResponse>;
+}

package/dist/group.js

@@ -0,0 +1,23 @@
+import { combineLatest, filter, map, merge } from "rxjs";
+import { onlyEvents } from "./operators/only-events.js";
+import { nanoid } from "nanoid";
+export class RelayGroup {
+    relays;
+    constructor(relays) {
+        this.relays = relays;
+    }
+    req(filters, id = nanoid()) {
+        const requests = this.relays.reduce((acc, r) => ({ ...acc, [r.url]: r.req(filters, id) }), {});
+        // Create stream of events only
+        const events = merge(...Object.values(requests)).pipe(onlyEvents());
+        // Create stream that emits EOSE when all relays have sent EOSE
+        const eose = combineLatest(
+        // Create a new map of requests that only emits EOSE
+        Object.fromEntries(Object.entries(requests).map(([url, observable]) => [url, observable.pipe(filter((m) => m === "EOSE"))]))).pipe(map(() => "EOSE"));
+        // Merge events and the single EOSE stream
+        return merge(events, eose);
+    }
+    event(event) {
+        return merge(...this.relays.map((r) => r.event(event)));
+    }
+}

package/dist/index.d.ts

@@ -1,2 +1,3 @@
+export * from "./group.js";
 export * from "./pool.js";
 export * from "./relay.js";

package/dist/index.js

@@ -1,2 +1,3 @@
+export * from "./group.js";
 export * from "./pool.js";
 export * from "./relay.js";

package/dist/operators/mark-from-relay.d.ts

@@ -1,4 +1,4 @@
 import { MonoTypeOperatorFunction } from "rxjs";
-import { SubscriptionResponse } from "../relay.js";
+import { SubscriptionResponse } from "../types.js";
 /** Marks all events as from the relay */
 export declare function markFromRelay(relay: string): MonoTypeOperatorFunction<SubscriptionResponse>;

package/dist/operators/only-events.d.ts

@@ -1,5 +1,5 @@
 import { OperatorFunction } from "rxjs";
 import { NostrEvent } from "nostr-tools";
-import { SubscriptionResponse } from "../relay.js";
+import { SubscriptionResponse } from "../types.js";
 /** Filter subscription responses and only return the events */
 export declare function onlyEvents(): OperatorFunction<SubscriptionResponse, NostrEvent>;

package/dist/pool.d.ts

@@ -1,12 +1,19 @@
 import { NostrEvent, type Filter } from "nostr-tools";
 import { Observable } from "rxjs";
-import { Relay, PublishResponse, SubscriptionResponse } from "./relay.js";
+import { Relay, RelayOptions } from "./relay.js";
+import { PublishResponse, SubscriptionResponse } from "./types.js";
+import { RelayGroup } from "./group.js";
 export declare class RelayPool {
+    options?: RelayOptions | undefined;
     relays: Map<string, Relay>;
+    groups: Map<string, RelayGroup>;
+    constructor(options?: RelayOptions | undefined);
     /** Get or create a new relay connection */
     relay(url: string): Relay;
-    /** Make a REQ to multiple relays but does not deduplicate events */
-    req(relays: string[], filters: Filter[], id?: string): Observable<SubscriptionResponse>;
+    /** Create a group of relays */
+    group(relays: string[]): RelayGroup;
+    /** Make a REQ to multiple relays that does not deduplicate events */
+    req(relays: string[], filters: Filter | Filter[], id?: string): Observable<SubscriptionResponse>;
     /** Send an EVENT message to multiple relays */
-    event(relays: string[], event: NostrEvent): Observable<PublishResponse[]>;
+    event(relays: string[], event: NostrEvent): Observable<PublishResponse>;
 }

package/dist/pool.js

@@ -1,41 +1,39 @@
-import { combineLatest, endWith, ignoreElements, merge, takeWhile } from "rxjs";
-import { nanoid } from "nanoid";
 import { Relay } from "./relay.js";
-import { onlyEvents } from "./operators/only-events.js";
+import { RelayGroup } from "./group.js";
 export class RelayPool {
+    options;
     relays = new Map();
+    groups = new Map();
+    constructor(options) {
+        this.options = options;
+    }
     /** Get or create a new relay connection */
     relay(url) {
         let relay = this.relays.get(url);
         if (relay)
             return relay;
         else {
-            relay = new Relay(url);
+            relay = new Relay(url, this.options);
             this.relays.set(url, relay);
             return relay;
         }
     }
-    /** Make a REQ to multiple relays but does not deduplicate events */
-    req(relays, filters, id = nanoid()) {
-        // create a REQ observable for each relay
-        const requests = relays.map((url) => this.relay(url).req(filters, id));
-        // create an observable that completes when all relays send EOSE
-        const eose = merge(
-        // create an array of observables for each relay that completes when EOSE
-        ...requests.map((o) => o.pipe(
-        // complete on EOSE message
-        takeWhile((m) => m !== "EOSE")))).pipe(
-        // ignore all messages
-        ignoreElements(), 
-        // emit EOSE on complete
-        endWith("EOSE"));
-        // create a stream that only emits events
-        const events = merge(...requests).pipe(onlyEvents());
-        // merge events and single EOSE streams
-        return merge(events, eose);
+    /** Create a group of relays */
+    group(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.set(key, group);
+        return group;
+    }
+    /** Make a REQ to multiple relays that does not deduplicate events */
+    req(relays, filters, id) {
+        return this.group(relays).req(filters, id);
     }
     /** Send an EVENT message to multiple relays */
     event(relays, event) {
-        return combineLatest(relays.map((url) => this.relay(url).event(event)));
+        return this.group(relays).event(event);
     }
 }

package/dist/relay.d.ts

@@ -2,29 +2,25 @@ import { BehaviorSubject, Observable } from "rxjs";
 import { WebSocketSubject, WebSocketSubjectConfig } from "rxjs/webSocket";
 import { type Filter, type NostrEvent } from "nostr-tools";
 import { logger } from "applesauce-core";
-export type SubscriptionResponse = "EOSE" | NostrEvent;
-export type PublishResponse = {
-    ok: boolean;
-    message?: string;
-    from: string;
-};
+import { IRelay, PublishResponse, SubscriptionResponse } from "./types.js";
 export type RelayOptions = {
     WebSocket?: WebSocketSubjectConfig<any>["WebSocketCtor"];
 };
-export declare class Relay {
+export declare class Relay implements IRelay {
     url: string;
-    log: typeof logger;
+    protected log: typeof logger;
     socket$: WebSocketSubject<any>;
     connected$: BehaviorSubject<boolean>;
     challenge$: Observable<string>;
     authenticated$: BehaviorSubject<boolean>;
-    notices$: Observable<string>;
+    notice$: Observable<string>;
     protected authRequiredForReq: BehaviorSubject<boolean>;
     protected authRequiredForPublish: BehaviorSubject<boolean>;
     protected reset(): void;
     constructor(url: string, opts?: RelayOptions);
     protected waitForAuth<T extends unknown = unknown>(requireAuth: Observable<boolean>, observable: Observable<T>): Observable<T>;
-    req(filters: Filter[], id?: string): Observable<SubscriptionResponse>;
+    multiplex<T>(open: () => any, close: () => any, filter: (message: any) => boolean): Observable<T>;
+    req(filters: Filter | Filter[], id?: string): Observable<SubscriptionResponse>;
     /** send an Event message */
     event(event: NostrEvent, verb?: "EVENT" | "AUTH"): Observable<PublishResponse>;
     /** send and AUTH message */

package/dist/relay.js

@@ -1,22 +1,26 @@
-import { BehaviorSubject, combineLatest, EMPTY, filter, map, merge, NEVER, of, shareReplay, switchMap, take, takeWhile, tap, timeout, } from "rxjs";
+import { BehaviorSubject, combineLatest, filter, map, merge, NEVER, of, shareReplay, switchMap, take, takeWhile, tap, timeout, } from "rxjs";
 import { webSocket } from "rxjs/webSocket";
 import { nanoid } from "nanoid";
 import { logger } from "applesauce-core";
 import { markFromRelay } from "./operators/mark-from-relay.js";
 export class Relay {
     url;
-    log = logger.extend("Bakery");
+    log = logger.extend("Relay");
     socket$;
     connected$ = new BehaviorSubject(false);
     challenge$;
     authenticated$ = new BehaviorSubject(false);
-    notices$;
+    notice$;
     authRequiredForReq = new BehaviorSubject(false);
     authRequiredForPublish = new BehaviorSubject(false);
     reset() {
-        this.authenticated$.next(false);
-        this.authRequiredForReq.next(false);
-        this.authRequiredForPublish.next(false);
+        // NOTE: only update the values if they need to be changed, otherwise this will cause an infinite loop
+        if (this.authenticated$.value)
+            this.authenticated$.next(false);
+        if (this.authRequiredForReq.value)
+            this.authRequiredForReq.next(false);
+        if (this.authRequiredForPublish.value)
+            this.authRequiredForPublish.next(false);
     }
     constructor(url, opts) {
         this.url = url;
@@ -47,7 +51,7 @@ export class Relay {
         map((m) => m[1]), 
         // cache and share the challenge
         shareReplay(1));
-        this.notices$ = this.socket$.pipe(
+        this.notice$ = this.socket$.pipe(
         // listen for NOTICE messages
         filter((m) => m[0] === "NOTICE"), 
         // pick the string out of the message
@@ -58,14 +62,17 @@ export class Relay {
         // return EMPTY if auth is required and not authenticated
         switchMap(([required, authenticated]) => {
             if (required && !authenticated)
-                return EMPTY;
+                return NEVER;
             else
                 return observable;
         }));
     }
+    multiplex(open, close, filter) {
+        return this.socket$.multiplex(open, close, filter);
+    }
     req(filters, id = nanoid()) {
         return this.waitForAuth(this.authRequiredForReq, this.socket$
-            .multiplex(() => ["REQ", id, ...filters], () => ["CLOSE", id], (message) => (message[0] === "EVENT" || message[0] === "CLOSE" || message[0] === "EOSE") && message[1] === id)
+            .multiplex(() => (Array.isArray(filters) ? ["REQ", id, ...filters] : ["REQ", id, filters]), () => ["CLOSE", id], (message) => (message[0] === "EVENT" || message[0] === "CLOSE" || message[0] === "EOSE") && message[1] === id)
             .pipe(
         // listen for CLOSE auth-required
         tap((m) => {
@@ -85,6 +92,7 @@ export class Relay {
         // 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
         timeout({
             first: 10_000,
             with: () => merge(of("EOSE"), NEVER),

package/dist/types.d.ts

@@ -0,0 +1,36 @@
+import { Filter, NostrEvent } from "nostr-tools";
+import { Observable } from "rxjs";
+import { WebSocketSubject } from "rxjs/webSocket";
+export type SubscriptionResponse = "EOSE" | NostrEvent;
+export type PublishResponse = {
+    ok: boolean;
+    message?: string;
+    from: string;
+};
+export type MultiplexWebSocket<T = any> = Pick<WebSocketSubject<T>, "multiplex">;
+export interface IRelayState {
+    connected$: Observable<boolean>;
+    challenge$: Observable<string>;
+    authenticated$: Observable<boolean>;
+    notice$: Observable<string>;
+}
+export interface Nip01Actions {
+    /** Send an EVENT message */
+    event(event: NostrEvent): Observable<PublishResponse>;
+    /** Send a REQ message */
+    req(filters: Filter | Filter[], id?: string): Observable<SubscriptionResponse>;
+}
+export interface IRelay extends MultiplexWebSocket, Nip01Actions, IRelayState {
+    url: string;
+    /** Send an AUTH message */
+    auth(event: NostrEvent): Observable<{
+        ok: boolean;
+        message?: string;
+    }>;
+}
+export interface IPoolActions {
+    /** Send an EVENT message */
+    event(relays: string[], event: NostrEvent): Observable<PublishResponse[]>;
+    /** Send a REQ message */
+    req(relays: string[], filters: Filter | Filter[]): Observable<SubscriptionResponse[]>;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-relay",
-  "version": "0.0.0-next-20250327153627",
+  "version": "0.0.0-next-20250330150216",
   "description": "A collection of observable based loaders built on rx-nostr",
   "type": "module",
   "main": "dist/index.js",
@@ -33,7 +33,7 @@
     }
   },
   "dependencies": {
-    "applesauce-core": "0.0.0-next-20250327153627",
+    "applesauce-core": "0.0.0-next-20250330150216",
     "nanoid": "^5.0.9",
     "nostr-tools": "^2.10.4",
     "rxjs": "^7.8.1"