applesauce-relay 1.0.0 → 1.0.1

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"));
@@ -99,6 +115,14 @@ describe("req", () => {
         // Verify the subscription completed
         expect(spy.receivedError()).toBe(true);
     });
+    it("should not send multiple REQ messages for multiple subscriptions", async () => {
+        const sub = relay.req([{ kinds: [1] }], "sub1");
+        sub.subscribe();
+        sub.subscribe();
+        // Wait for all messages to be sent
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(server.messages).toEqual([["REQ", "sub1", { kinds: [1] }]]);
+    });
     it("should wait for authentication if relay responds with auth-required", async () => {
         // First subscription to trigger auth-required
         const firstSub = subscribeSpyTo(relay.req([{ kinds: [1] }], "sub1"), { expectErrors: true });

package/dist/relay.js

@@ -187,13 +187,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));
+        // Don't wait if the relay is already ready
+        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);
@@ -234,7 +238,9 @@ export class Relay {
         timeout({
             first: this.eoseTimeout,
             with: () => merge(of("EOSE"), NEVER),
-        }));
+        }), 
+        // Only create one upstream subscription
+        share());
         // Wait for auth if required and make sure to start the watch tower
         return this.waitForReady(this.waitForAuth(this.authRequiredForReq, observable));
     }
@@ -264,7 +270,9 @@ export class Relay {
         timeout({
             first: this.eventTimeout,
             with: () => of({ ok: false, from: this.url, message: "Timeout" }),
-        }));
+        }), 
+        // Only create one upstream subscription
+        share());
         // skip wait for auth if verb is AUTH
         if (verb === "AUTH")
             return this.waitForReady(observable);

package/package.json

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