applesauce-relay 0.0.0-next-20250430170741 → 0.0.0-next-20250430195017

package/dist/__tests__/relay.test.js

@@ -47,17 +47,33 @@ describe("req", () => {
         await firstValueFrom(relay.connected$.pipe(filter(Boolean)));
         expect(relay.connected).toBe(true);
     });
-    it("should send REQ and CLOSE messages", async () => {
+    it("should send expected messages to relay", async () => {
+        subscribeSpyTo(relay.req([{ kinds: [1] }], "sub1"));
+        // Wait for all message to be sent
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(server.messages).toEqual([["REQ", "sub1", { kinds: [1] }]]);
+    });
+    it("should not close the REQ when EOSE is received", async () => {
         // Create subscription that completes after first EOSE
-        const sub = relay.req([{ kinds: [1] }], "sub1").subscribe();
+        const sub = subscribeSpyTo(relay.req([{ kinds: [1] }], "sub1"));
         // Verify REQ was sent
-        expect(await server.nextMessage).toEqual(["REQ", "sub1", { kinds: [1] }]);
+        await expect(server).toReceiveMessage(["REQ", "sub1", { kinds: [1] }]);
         // Send EOSE to complete subscription
+        server.send(["EVENT", "sub1", mockEvent]);
         server.send(["EOSE", "sub1"]);
+        // Verify the subscription did not complete
+        expect(sub.receivedComplete()).toBe(false);
+        expect(sub.getValues()).toEqual([expect.objectContaining(mockEvent), "EOSE"]);
+    });
+    it("should send CLOSE when unsubscribed", async () => {
+        // Create subscription that completes after first EOSE
+        const sub = subscribeSpyTo(relay.req([{ kinds: [1] }], "sub1"));
+        // Verify REQ was sent
+        await expect(server).toReceiveMessage(["REQ", "sub1", { kinds: [1] }]);
         // Complete the subscription
         sub.unsubscribe();
         // Verify CLOSE was sent
-        expect(await server.nextMessage).toEqual(["CLOSE", "sub1"]);
+        await expect(server).toReceiveMessage(["CLOSE", "sub1"]);
     });
     it("should emit nostr event and EOSE", async () => {
         const spy = subscribeSpyTo(relay.req([{ kinds: [1] }], "sub1"));
@@ -332,9 +348,59 @@ describe("notices$", () => {
         expect(relay.notices$.value).toEqual(["Important notice"]);
     });
 });
+describe("notice$", () => {
+    it("should not trigger connection to relay", async () => {
+        subscribeSpyTo(relay.notice$);
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(relay.connected).toBe(false);
+    });
+    it("should emit NOTICE messages when they are received", async () => {
+        const spy = subscribeSpyTo(relay.notice$);
+        // Start connection
+        subscribeSpyTo(relay.req({ kinds: [1] }));
+        // Send multiple NOTICE messages
+        server.send(["NOTICE", "Notice 1"]);
+        server.send(["NOTICE", "Notice 2"]);
+        server.send(["NOTICE", "Notice 3"]);
+        // Verify the notices state contains all messages
+        expect(spy.getValues()).toEqual(["Notice 1", "Notice 2", "Notice 3"]);
+    });
+    it("should ignore non-NOTICE messages", async () => {
+        const spy = subscribeSpyTo(relay.notice$);
+        // Start connection
+        subscribeSpyTo(relay.req({ kinds: [1] }));
+        server.send(["NOTICE", "Important notice"]);
+        server.send(["OTHER", "other message"]);
+        // Verify only NOTICE messages are in the state
+        expect(spy.getValues()).toEqual(["Important notice"]);
+    });
+});
+describe("message$", () => {
+    it("should not trigger connection to relay", async () => {
+        subscribeSpyTo(relay.message$);
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(relay.connected).toBe(false);
+    });
+    it("should emit all messages when they are received", async () => {
+        const spy = subscribeSpyTo(relay.message$);
+        // Start connection
+        subscribeSpyTo(relay.req({ kinds: [1] }));
+        // Send multiple NOTICE messages
+        server.send(["NOTICE", "Notice 1"]);
+        server.send(["EVENT", "sub1", mockEvent]);
+        server.send(["EOSE", "sub1"]);
+        // Verify the notices state contains all messages
+        expect(spy.getValues()).toEqual([
+            ["NOTICE", "Notice 1"],
+            ["EVENT", "sub1", mockEvent],
+            ["EOSE", "sub1"],
+        ]);
+    });
+});
 describe("challenge$", () => {
     it("should not trigger connection to relay", async () => {
         subscribeSpyTo(relay.challenge$);
+        await new Promise((resolve) => setTimeout(resolve, 10));
         expect(relay.connected).toBe(false);
     });
     it("should set challenge$ when AUTH message received", async () => {

package/dist/relay.d.ts

@@ -30,21 +30,21 @@ export declare class Relay implements IRelay {
     notices$: BehaviorSubject<string[]>;
     /** The last connection error */
     error$: BehaviorSubject<Error | null>;
-    /** An observable that emits the NIP-11 information document for the relay */
-    information$: Observable<RelayInformation | null>;
-    protected _nip11: RelayInformation | null;
-    /** An observable that emits the limitations for the relay */
-    limitations$: Observable<RelayInformation["limitation"] | null>;
     /**
-     * An observable of all messages from the relay
-     * @note Subscribing to this will cause the relay to connect
+     * A passive observable of all messages from the relay
+     * @note Subscribing to this will not connect to the relay
      */
     message$: Observable<any>;
     /**
-     * An observable of NOTICE messages from the relay
-     * @note Subscribing to this will cause the relay to connect
+     * A passive observable of NOTICE messages from the relay
+     * @note Subscribing to this will not connect to the relay
      */
     notice$: Observable<string>;
+    /** An observable that emits the NIP-11 information document for the relay */
+    information$: Observable<RelayInformation | null>;
+    protected _nip11: RelayInformation | null;
+    /** An observable that emits the limitations for the relay */
+    limitations$: Observable<RelayInformation["limitation"] | null>;
     get connected(): boolean;
     get challenge(): string | null;
     get notices(): string[];

package/dist/relay.js

@@ -2,7 +2,7 @@ import { logger } from "applesauce-core";
 import { simpleTimeout } from "applesauce-core/observable";
 import { nanoid } from "nanoid";
 import { nip42 } from "nostr-tools";
-import { BehaviorSubject, catchError, combineLatest, defer, filter, from, ignoreElements, map, merge, mergeMap, NEVER, of, retry, scan, share, shareReplay, switchMap, take, tap, throwError, timeout, timer, } from "rxjs";
+import { BehaviorSubject, catchError, combineLatest, defer, filter, from, ignoreElements, map, merge, mergeMap, NEVER, of, retry, scan, share, shareReplay, Subject, switchMap, take, tap, throwError, timeout, timer, } from "rxjs";
 import { webSocket } from "rxjs/webSocket";
 import { completeOnEose } from "./operators/complete-on-eose.js";
 import { markFromRelay } from "./operators/mark-from-relay.js";
@@ -29,21 +29,21 @@ export class Relay {
     notices$ = new BehaviorSubject([]);
     /** The last connection error */
     error$ = new BehaviorSubject(null);
-    /** An observable that emits the NIP-11 information document for the relay */
-    information$;
-    _nip11 = null;
-    /** An observable that emits the limitations for the relay */
-    limitations$;
     /**
-     * An observable of all messages from the relay
-     * @note Subscribing to this will cause the relay to connect
+     * A passive observable of all messages from the relay
+     * @note Subscribing to this will not connect to the relay
      */
     message$;
     /**
-     * An observable of NOTICE messages from the relay
-     * @note Subscribing to this will cause the relay to connect
+     * A passive observable of NOTICE messages from the relay
+     * @note Subscribing to this will not connect to the relay
      */
     notice$;
+    /** An observable that emits the NIP-11 information document for the relay */
+    information$;
+    _nip11 = null;
+    /** An observable that emits the limitations for the relay */
+    limitations$;
     // sync state
     get connected() {
         return this.connected$.value;
@@ -116,7 +116,6 @@ export class Relay {
             },
             WebSocketCtor: opts?.WebSocket,
         });
-        this.message$ = this.socket.asObservable();
         // Create an observable to fetch the NIP-11 information document
         this.information$ = defer(() => {
             this.log("Fetching NIP-11 information document");
@@ -132,19 +131,18 @@ export class Relay {
         // Create observables that track if auth is required for REQ or EVENT
         this.authRequiredForReq = combineLatest([this.receivedAuthRequiredForReq, this.limitations$]).pipe(map(([received, limitations]) => received || limitations?.auth_required === true), tap((required) => required && this.log("Auth required for REQ")), shareReplay(1));
         this.authRequiredForEvent = combineLatest([this.receivedAuthRequiredForEvent, this.limitations$]).pipe(map(([received, limitations]) => received || limitations?.auth_required === true), tap((required) => required && this.log("Auth required for EVENT")), shareReplay(1));
-        this.notice$ = this.message$.pipe(
+        // Update the notices state
+        const listenForNotice = this.socket.pipe(
         // listen for NOTICE messages
-        filter((m) => m[0] === "NOTICE"), 
+        filter((m) => Array.isArray(m) && m[0] === "NOTICE"), 
         // pick the string out of the message
-        map((m) => m[1]));
-        // Update the notices state
-        const notice = this.notice$.pipe(
+        map((m) => m[1]), 
         // 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(
+        const ListenForChallenge = this.socket.pipe(
         // listen for AUTH messages
         filter((message) => message[0] === "AUTH"), 
         // pick the challenge string out
@@ -154,12 +152,21 @@ export class Relay {
             this.log("Received AUTH challenge", challenge);
             this.challenge$.next(challenge);
         }));
+        const allMessagesSubject = new Subject();
+        const listenForAllMessages = this.socket.pipe(tap((message) => allMessagesSubject.next(message)));
+        // Create passive observables for messages and notices
+        this.message$ = allMessagesSubject.asObservable();
+        this.notice$ = this.message$.pipe(
+        // listen for NOTICE messages
+        filter((m) => Array.isArray(m) && m[0] === "NOTICE"), 
+        // pick the string out of the message
+        map((m) => m[1]));
         // Merge all watchers
         this.watchTower = this.ready$.pipe(switchMap((ready) => {
             if (!ready)
                 return NEVER;
             // Only start the watch tower if the relay is ready
-            return merge(notice, challenge, this.information$).pipe(
+            return merge(listenForAllMessages, listenForNotice, ListenForChallenge, this.information$).pipe(
             // Never emit any values
             ignoreElements(), 
             // Start the reconnect timer if the connection has an error
@@ -184,9 +191,7 @@ export class Relay {
             .subscribe(() => this.ready$.next(true));
     }
     /** Wait for ready and authenticated */
-    waitForAuth(
-    // NOTE: require BehaviorSubject so it always has a value
-    requireAuth, observable) {
+    waitForAuth(requireAuth, observable) {
         return combineLatest([requireAuth, this.authenticated$]).pipe(
         // wait for auth not required or authenticated
         filter(([required, authenticated]) => !required || authenticated), 
@@ -197,13 +202,17 @@ export class Relay {
     }
     /** Wait for the relay to be ready to accept connections */
     waitForReady(observable) {
-        return this.ready$.pipe(
-        // wait for ready to be true
-        filter((ready) => ready), 
-        // complete after the first value so this does not repeat
-        take(1), 
-        // switch to the observable
-        switchMap(() => observable));
+        // If the relay is ready, don't wait
+        if (this.ready$.value)
+            return observable;
+        else
+            return this.ready$.pipe(
+            // wait for ready to be true
+            filter((ready) => ready), 
+            // complete after the first value so this does not repeat
+            take(1), 
+            // switch to the observable
+            switchMap(() => observable));
     }
     multiplex(open, close, filter) {
         return this.socket.multiplex(open, close, filter);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-relay",
-  "version": "0.0.0-next-20250430170741",
+  "version": "0.0.0-next-20250430195017",
   "description": "nostr relay communication framework built on rxjs",
   "type": "module",
   "main": "dist/index.js",