applesauce-relay 0.0.0-next-20250327153627 → 0.0.0-next-20250330153313

package/README.md

@@ -1,3 +1,97 @@
 # Applesauce Relay
 
 `applesauce-relay` is a nostr relay communication framework built on top of [RxJS](https://rxjs.dev/)
+
+## Examples
+
+### Single Relay
+
+```typescript
+import { Relay } from "./relay";
+
+// Connect to a single relay
+const relay = new Relay("wss://relay.example.com");
+
+// Subscribe to events
+relay
+  .req({
+    kinds: [1],
+    limit: 10,
+  })
+  .subscribe((response) => {
+    if (response === "EOSE") {
+      console.log("End of stored events");
+    } else {
+      console.log("Received event:", response);
+    }
+  });
+
+// Publish an event
+const event = {
+  kind: 1,
+  content: "Hello Nostr!",
+  created_at: Math.floor(Date.now() / 1000),
+  tags: [],
+  // ... other required fields
+};
+
+relay.event(event).subscribe((response) => {
+  console.log(`Published:`, response.ok);
+});
+```
+
+### Relay Pool
+
+```typescript
+import { RelayPool } from "./pool";
+
+// Create a pool and connect to multiple relays
+const pool = new RelayPool();
+const relays = ["wss://relay1.example.com", "wss://relay2.example.com"];
+
+// Subscribe to events from multiple relays
+pool
+  .req(relays, {
+    kinds: [1],
+    limit: 10,
+  })
+  .subscribe((response) => {
+    if (response === "EOSE") {
+      console.log("End of stored events");
+    } else {
+      console.log("Received event:", response);
+    }
+  });
+
+// Publish to multiple relays
+pool.event(relays, event).subscribe((response) => {
+  console.log(`Published to ${response.from}:`, response.ok);
+});
+```
+
+### Relay Group
+
+```typescript
+import { RelayPool } from "./pool";
+
+const pool = new RelayPool();
+const relays = ["wss://relay1.example.com", "wss://relay2.example.com"];
+
+// Create a group (automatically deduplicates events)
+const group = pool.group(relays);
+
+// Subscribe to events
+group
+  .req({
+    kinds: [1],
+    limit: 10,
+  })
+  .subscribe((response) => {
+    console.log("Received:", response);
+  });
+
+// Publish to all relays in group
+group.event(event).subscribe((response) => {
+  console.log(`Published to ${response.from}:`, response.ok);
+});
+```

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,4 @@
+export * from "./group.js";
 export * from "./pool.js";
 export * from "./relay.js";
+export * from "./types.js";

package/dist/index.js

@@ -1,2 +1,4 @@
+export * from "./group.js";
 export * from "./pool.js";
 export * from "./relay.js";
+export * from "./types.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,35 @@ 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;
-    socket$: WebSocketSubject<any>;
+    protected log: typeof logger;
+    protected socket: WebSocketSubject<any>;
     connected$: BehaviorSubject<boolean>;
-    challenge$: Observable<string>;
+    challenge$: BehaviorSubject<string | null>;
     authenticated$: BehaviorSubject<boolean>;
-    notices$: Observable<string>;
+    notices$: BehaviorSubject<string[]>;
+    /** An observable of all messages from the relay */
+    message$: Observable<any>;
+    /** An observable of NOTICE messages from the relay */
+    notice$: Observable<string>;
+    get connected(): boolean;
+    get challenge(): string | null;
+    get notices(): string[];
+    get authenticated(): boolean;
     protected authRequiredForReq: BehaviorSubject<boolean>;
     protected authRequiredForPublish: BehaviorSubject<boolean>;
-    protected reset(): void;
+    protected resetState(): void;
+    /** An internal observable that is responsible for watching all messages and updating state */
+    protected watchTower: Observable<never>;
     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,75 +1,122 @@
-import { BehaviorSubject, combineLatest, EMPTY, filter, map, merge, NEVER, of, shareReplay, switchMap, take, takeWhile, tap, timeout, } from "rxjs";
+import { BehaviorSubject, combineLatest, filter, ignoreElements, map, merge, NEVER, of, scan, share, 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");
-    socket$;
+    log = logger.extend("Relay");
+    socket;
     connected$ = new BehaviorSubject(false);
-    challenge$;
+    challenge$ = new BehaviorSubject(null);
     authenticated$ = new BehaviorSubject(false);
-    notices$;
+    notices$ = new BehaviorSubject([]);
+    /** An observable of all messages from the relay */
+    message$;
+    /** An observable of NOTICE messages from the relay */
+    notice$;
+    // sync state
+    get connected() {
+        return this.connected$.value;
+    }
+    get challenge() {
+        return this.challenge$.value;
+    }
+    get notices() {
+        return this.notices$.value;
+    }
+    get authenticated() {
+        return this.authenticated$.value;
+    }
     authRequiredForReq = new BehaviorSubject(false);
     authRequiredForPublish = new BehaviorSubject(false);
-    reset() {
-        this.authenticated$.next(false);
-        this.authRequiredForReq.next(false);
-        this.authRequiredForPublish.next(false);
+    resetState() {
+        // NOTE: only update the values if they need to be changed, otherwise this will cause an infinite loop
+        if (this.challenge$.value !== null)
+            this.challenge$.next(null);
+        if (this.authenticated$.value)
+            this.authenticated$.next(false);
+        if (this.notices$.value.length > 0)
+            this.notices$.next([]);
+        if (this.authRequiredForReq.value)
+            this.authRequiredForReq.next(false);
+        if (this.authRequiredForPublish.value)
+            this.authRequiredForPublish.next(false);
     }
+    /** An internal observable that is responsible for watching all messages and updating state */
+    watchTower;
     constructor(url, opts) {
         this.url = url;
         this.log = this.log.extend(url);
-        this.socket$ = webSocket({
+        this.socket = webSocket({
             url,
             openObserver: {
                 next: () => {
                     this.log("Connected");
                     this.connected$.next(true);
-                    this.reset();
+                    this.resetState();
                 },
             },
             closeObserver: {
                 next: () => {
                     this.log("Disconnected");
                     this.connected$.next(false);
-                    this.reset();
+                    this.resetState();
                 },
             },
             WebSocketCtor: opts?.WebSocket,
         });
-        // create an observable for listening for AUTH
-        this.challenge$ = this.socket$.pipe(
-        // listen for AUTH messages
-        filter((message) => message[0] === "AUTH"), 
-        // pick the challenge string out
-        map((m) => m[1]), 
-        // cache and share the challenge
-        shareReplay(1));
-        this.notices$ = this.socket$.pipe(
+        this.message$ = this.socket.asObservable();
+        this.notice$ = this.message$.pipe(
         // listen for NOTICE messages
         filter((m) => m[0] === "NOTICE"), 
         // pick the string out of the message
         map((m) => m[1]));
+        // Update the notices state
+        const notice = this.notice$.pipe(
+        // Track all notices
+        scan((acc, notice) => [...acc, notice], []), 
+        // Update the notices state
+        tap((notices) => this.notices$.next(notices)));
+        // Update the challenge state
+        const challenge = this.message$.pipe(
+        // listen for AUTH messages
+        filter((message) => message[0] === "AUTH"), 
+        // pick the challenge string out
+        map((m) => m[1]), 
+        // Update the challenge state
+        tap((challenge) => {
+            this.log("Received AUTH challenge", challenge);
+            this.challenge$.next(challenge);
+        }));
+        // Merge all watchers
+        this.watchTower = merge(notice, challenge).pipe(
+        // Never emit any values
+        ignoreElements(), 
+        // There should only be a single watch tower
+        share());
     }
     waitForAuth(requireAuth, observable) {
         return combineLatest([requireAuth, this.authenticated$]).pipe(
         // 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)
+        const request = this.socket
+            .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) => {
             if (m[0] === "CLOSE" && m[1].startsWith("auth-required") && !this.authRequiredForReq.value) {
+                this.log("Auth required for REQ");
                 this.authRequiredForReq.next(true);
             }
         }), 
@@ -85,14 +132,17 @@ 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),
-        })));
+        }));
+        // Wait for auth if required and make sure to start the watch tower
+        return this.waitForAuth(this.authRequiredForReq, merge(this.watchTower, request));
     }
     /** send an Event message */
     event(event, verb = "EVENT") {
-        const observable = this.socket$
+        const observable = this.socket
             .multiplex(() => [verb, event], () => void 0, (m) => m[0] === "OK" && m[1] === event.id)
             .pipe(
         // format OK message
@@ -102,14 +152,16 @@ export class Relay {
         // listen for OK auth-required
         tap(({ ok, message }) => {
             if (ok === false && message.startsWith("auth-required") && !this.authRequiredForPublish.value) {
+                this.log("Auth required for publish");
                 this.authRequiredForPublish.next(true);
             }
         }));
+        const withWatchTower = merge(this.watchTower, observable);
         // skip wait for auth if verb is AUTH
         if (verb === "AUTH")
-            return observable;
+            return withWatchTower;
         else
-            return this.waitForAuth(this.authRequiredForPublish, observable);
+            return this.waitForAuth(this.authRequiredForPublish, withWatchTower);
     }
     /** send and AUTH message */
     auth(event) {

package/dist/types.d.ts

@@ -0,0 +1,42 @@
+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 | null>;
+    authenticated$: Observable<boolean>;
+    notices$: 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;
+    message$: Observable<any>;
+    notice$: Observable<string>;
+    readonly connected: boolean;
+    readonly authenticated: boolean;
+    readonly challenge: string | null;
+    readonly notices: 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-20250330153313",
   "description": "A collection of observable based loaders built on rx-nostr",
   "type": "module",
   "main": "dist/index.js",
@@ -21,6 +21,21 @@
       "require": "./dist/index.js",
       "types": "./dist/index.d.ts"
     },
+    "./pool": {
+      "import": "./dist/pool.js",
+      "require": "./dist/pool.js",
+      "types": "./dist/pool.d.ts"
+    },
+    "./relay": {
+      "import": "./dist/relay.js",
+      "require": "./dist/relay.js",
+      "types": "./dist/relay.d.ts"
+    },
+    "./types": {
+      "import": "./dist/types.js",
+      "require": "./dist/types.js",
+      "types": "./dist/types.d.ts"
+    },
     "./operators": {
       "import": "./dist/operators/index.js",
       "require": "./dist/operators/index.js",
@@ -33,7 +48,7 @@
     }
   },
   "dependencies": {
-    "applesauce-core": "0.0.0-next-20250327153627",
+    "applesauce-core": "0.0.0-next-20250330153313",
     "nanoid": "^5.0.9",
     "nostr-tools": "^2.10.4",
     "rxjs": "^7.8.1"