applesauce-relay 0.0.0-next-20250430200159 → 0.0.0-next-20250505205231

package/dist/__tests__/pool.test.js

@@ -1,4 +1,4 @@
-import { test, expect, beforeEach, afterEach } from "vitest";
+import { expect, beforeEach, afterEach, describe, it } from "vitest";
 import { subscribeSpyTo } from "@hirez_io/observer-spy";
 import { WS } from "vitest-websocket-mock";
 import { RelayPool } from "../pool.js";
@@ -27,55 +27,70 @@ afterEach(async () => {
     // Clean up WebSocket mocks
     await WS.clean();
 });
-test("creates new relay connections", () => {
-    const url = "wss://relay1.example.com";
-    const relay = pool.relay(url);
-    expect(relay).toBeDefined();
-    expect(pool.relays.get(url)).toBe(relay);
+describe("relay", () => {
+    it("should create a new relay", () => {
+        const url = "wss://relay1.example.com/";
+        const relay = pool.relay(url);
+        expect(relay).toBeDefined();
+        expect(pool.relays.get(url)).toBe(relay);
+    });
+    it("should return existing relay connection if already exists", () => {
+        const url = "wss://relay1.example.com";
+        const relay1 = pool.relay(url);
+        const relay2 = pool.relay(url);
+        expect(relay1).toBe(relay2);
+        expect(pool.relays.size).toBe(1);
+    });
+    it("should normalize relay urls", () => {
+        expect(pool.relay("wss://relay.example.com")).toBe(pool.relay("wss://relay.example.com/"));
+        expect(pool.relay("wss://relay.example.com:443")).toBe(pool.relay("wss://relay.example.com/"));
+        expect(pool.relay("ws://relay.example.com:80")).toBe(pool.relay("ws://relay.example.com/"));
+    });
 });
-test("returns existing relay connection if already exists", () => {
-    const url = "wss://relay1.example.com";
-    const relay1 = pool.relay(url);
-    const relay2 = pool.relay(url);
-    expect(relay1).toBe(relay2);
-    expect(pool.relays.size).toBe(1);
+describe("group", () => {
+    it("should create a relay group", () => {
+        const urls = ["wss://relay1.example.com/", "wss://relay2.example.com/"];
+        const group = pool.group(urls);
+        expect(group).toBeDefined();
+        expect(pool.groups.get(urls.sort().join(","))).toBe(group);
+    });
 });
-test("creates relay group with multiple relays", () => {
-    const urls = ["wss://relay1.example.com", "wss://relay2.example.com"];
-    const group = pool.group(urls);
-    expect(group).toBeDefined();
-    expect(pool.groups.get(urls.sort().join(","))).toBe(group);
+describe("req", () => {
+    it("should send subscription to multiple relays", async () => {
+        const urls = ["wss://relay1.example.com", "wss://relay2.example.com"];
+        const filters = { kinds: [1] };
+        const spy = subscribeSpyTo(pool.req(urls, filters));
+        // Verify REQ was sent to both relays
+        const req1 = await mockServer1.nextMessage;
+        const req2 = await mockServer2.nextMessage;
+        // Both messages should be REQ messages with the same filter
+        expect(JSON.parse(req1)[0]).toBe("REQ");
+        expect(JSON.parse(req2)[0]).toBe("REQ");
+        expect(JSON.parse(req1)[2]).toEqual(filters);
+        expect(JSON.parse(req2)[2]).toEqual(filters);
+        // Send EVENT from first relay
+        mockServer1.send(JSON.stringify(["EVENT", JSON.parse(req1)[1], mockEvent]));
+        // Send EOSE from both relays
+        mockServer1.send(JSON.stringify(["EOSE", JSON.parse(req1)[1]]));
+        mockServer2.send(JSON.stringify(["EOSE", JSON.parse(req2)[1]]));
+        expect(spy.getValues()).toContainEqual(expect.objectContaining(mockEvent));
+    });
 });
-test("req method sends subscription to multiple relays", async () => {
-    const urls = ["wss://relay1.example.com", "wss://relay2.example.com"];
-    const filters = { kinds: [1] };
-    const spy = subscribeSpyTo(pool.req(urls, filters));
-    // Verify REQ was sent to both relays
-    const req1 = await mockServer1.nextMessage;
-    const req2 = await mockServer2.nextMessage;
-    // Both messages should be REQ messages with the same filter
-    expect(JSON.parse(req1)[0]).toBe("REQ");
-    expect(JSON.parse(req2)[0]).toBe("REQ");
-    expect(JSON.parse(req1)[2]).toEqual(filters);
-    expect(JSON.parse(req2)[2]).toEqual(filters);
-    // Send EVENT from first relay
-    mockServer1.send(JSON.stringify(["EVENT", JSON.parse(req1)[1], mockEvent]));
-    // Send EOSE from both relays
-    mockServer1.send(JSON.stringify(["EOSE", JSON.parse(req1)[1]]));
-    mockServer2.send(JSON.stringify(["EOSE", JSON.parse(req2)[1]]));
-    expect(spy.getValues()).toContainEqual(expect.objectContaining(mockEvent));
-});
-test("event method publishes to multiple relays", async () => {
-    const urls = ["wss://relay1.example.com", "wss://relay2.example.com"];
-    const spy = subscribeSpyTo(pool.event(urls, mockEvent));
-    // Verify EVENT was sent to both relays
-    const event1 = await mockServer1.nextMessage;
-    const event2 = await mockServer2.nextMessage;
-    expect(JSON.parse(event1)).toEqual(["EVENT", mockEvent]);
-    expect(JSON.parse(event2)).toEqual(["EVENT", mockEvent]);
-    // Send OK responses from both relays
-    mockServer1.send(JSON.stringify(["OK", mockEvent.id, true, ""]));
-    mockServer2.send(JSON.stringify(["OK", mockEvent.id, true, ""]));
-    expect(spy.getValues()).toContainEqual({ ok: true, from: "wss://relay1.example.com", message: "" });
-    expect(spy.getValues()).toContainEqual({ ok: true, from: "wss://relay2.example.com", message: "" });
+describe("event", () => {
+    it("should publish to multiple relays", async () => {
+        const urls = ["wss://relay1.example.com/", "wss://relay2.example.com/"];
+        const spy = subscribeSpyTo(pool.event(urls, mockEvent));
+        // Verify EVENT was sent to both relays
+        const event1 = await mockServer1.nextMessage;
+        const event2 = await mockServer2.nextMessage;
+        expect(JSON.parse(event1)).toEqual(["EVENT", mockEvent]);
+        expect(JSON.parse(event2)).toEqual(["EVENT", mockEvent]);
+        // Send OK responses from both relays
+        mockServer1.send(JSON.stringify(["OK", mockEvent.id, true, ""]));
+        mockServer2.send(JSON.stringify(["OK", mockEvent.id, true, ""]));
+        expect(spy.getValues()).toEqual([
+            { ok: true, from: "wss://relay1.example.com/", message: "" },
+            { ok: true, from: "wss://relay2.example.com/", message: "" },
+        ]);
+    });
 });

package/dist/__tests__/relay.test.js

@@ -49,9 +49,7 @@ describe("req", () => {
     });
     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] }]]);
+        await expect(server).toReceiveMessage(["REQ", "sub1", { kinds: [1] }]);
     });
     it("should not close the REQ when EOSE is received", async () => {
         // Create subscription that completes after first EOSE

package/dist/pool.js

@@ -1,6 +1,7 @@
 import { BehaviorSubject } from "rxjs";
 import { RelayGroup } from "./group.js";
 import { Relay } from "./relay.js";
+import { normalizeURL } from "applesauce-core/helpers";
 export class RelayPool {
     options;
     groups$ = new BehaviorSubject(new Map());
@@ -21,19 +22,25 @@ export class RelayPool {
     }
     /** Get or create a new relay connection */
     relay(url) {
+        // Normalize the url
+        url = normalizeURL(url);
+        // Check if the url is blacklisted
         if (this.blacklist.has(url))
             throw new Error("Relay is on blacklist");
+        // Check if the relay already exists
         let relay = this.relays.get(url);
         if (relay)
             return relay;
-        else {
-            relay = new Relay(url, this.options);
-            this.relays$.next(this.relays.set(url, relay));
-            return relay;
-        }
+        // Create a new relay
+        relay = new Relay(url, this.options);
+        this.relays$.next(this.relays.set(url, relay));
+        return relay;
     }
     /** Create a group of relays */
     group(relays) {
+        // Normalize all urls
+        relays = relays.map((url) => normalizeURL(url));
+        // Filter out any blacklisted relays
         relays = this.filterBlacklist(relays);
         const key = relays.sort().join(",");
         let group = this.groups.get(key);

package/package.json

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