applesauce-relay 0.0.0-next-20250330150216 → 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/index.d.ts

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

package/dist/index.js

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

package/dist/relay.d.ts

@@ -9,14 +9,24 @@ export type RelayOptions = {
 export declare class Relay implements IRelay {
     url: string;
     protected log: typeof logger;
-    socket$: WebSocketSubject<any>;
+    protected socket: WebSocketSubject<any>;
     connected$: BehaviorSubject<boolean>;
-    challenge$: Observable<string>;
+    challenge$: BehaviorSubject<string | null>;
     authenticated$: BehaviorSubject<boolean>;
+    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>;
     multiplex<T>(open: () => any, close: () => any, filter: (message: any) => boolean): Observable<T>;

package/dist/relay.js

@@ -1,4 +1,4 @@
-import { BehaviorSubject, combineLatest, 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";
@@ -6,56 +6,95 @@ import { markFromRelay } from "./operators/mark-from-relay.js";
 export class Relay {
     url;
     log = logger.extend("Relay");
-    socket$;
+    socket;
     connected$ = new BehaviorSubject(false);
-    challenge$;
+    challenge$ = new BehaviorSubject(null);
     authenticated$ = new BehaviorSubject(false);
+    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() {
+    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.notice$ = 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(
@@ -68,15 +107,16 @@ export class Relay {
         }));
     }
     multiplex(open, close, filter) {
-        return this.socket$.multiplex(open, close, filter);
+        return this.socket.multiplex(open, close, filter);
     }
     req(filters, id = nanoid()) {
-        return this.waitForAuth(this.authRequiredForReq, this.socket$
+        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);
             }
         }), 
@@ -96,11 +136,13 @@ export class Relay {
         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
@@ -110,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

@@ -10,9 +10,9 @@ export type PublishResponse = {
 export type MultiplexWebSocket<T = any> = Pick<WebSocketSubject<T>, "multiplex">;
 export interface IRelayState {
     connected$: Observable<boolean>;
-    challenge$: Observable<string>;
+    challenge$: Observable<string | null>;
     authenticated$: Observable<boolean>;
-    notice$: Observable<string>;
+    notices$: Observable<string[]>;
 }
 export interface Nip01Actions {
     /** Send an EVENT message */
@@ -22,6 +22,12 @@ export interface Nip01Actions {
 }
 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-relay",
-  "version": "0.0.0-next-20250330150216",
+  "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-20250330150216",
+    "applesauce-core": "0.0.0-next-20250330153313",
     "nanoid": "^5.0.9",
     "nostr-tools": "^2.10.4",
     "rxjs": "^7.8.1"