applesauce-relay 0.12.0 → 1.0.0

package/dist/__tests__/relay.test.js

@@ -0,0 +1,537 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { subscribeSpyTo } from "@hirez_io/observer-spy";
+import { getSeenRelays } from "applesauce-core/helpers";
+import { WS } from "vitest-websocket-mock";
+import { Relay } from "../relay.js";
+import { filter } from "rxjs/operators";
+import { firstValueFrom, of, throwError, timer } from "rxjs";
+const defaultMockInfo = {
+    name: "Test Relay",
+    description: "Test Relay Description",
+    pubkey: "testpubkey",
+    contact: "test@example.com",
+    supported_nips: [1, 2, 3],
+    software: "test-software",
+    version: "1.0.0",
+};
+let server;
+let relay;
+beforeEach(async () => {
+    // Mock empty information document
+    vi.spyOn(Relay, "fetchInformationDocument").mockImplementation(() => of(null));
+    // Create mock relay
+    server = new WS("wss://test", { jsonProtocol: true });
+    // Create relay
+    relay = new Relay("wss://test");
+    relay.keepAlive = 0;
+});
+// Wait for server to close to prevent memory leaks
+afterEach(async () => {
+    await WS.clean();
+    vi.clearAllTimers();
+    vi.useRealTimers();
+});
+const mockEvent = {
+    kind: 1,
+    id: "00007641c9c3e65a71843933a44a18060c7c267a4f9169efa3735ece45c8f621",
+    pubkey: "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d",
+    created_at: 1743712795,
+    tags: [["nonce", "13835058055282167643", "16"]],
+    content: "This is just stupid: https://codestr.fiatjaf.com/",
+    sig: "5a57b5a12bba4b7cf0121077b1421cf4df402c5c221376c076204fc4f7519e28ce6508f26ddc132c406ccfe6e62cc6db857b96c788565cdca9674fe9a0710ac2",
+};
+describe("req", () => {
+    it("should trigger connection to relay", async () => {
+        subscribeSpyTo(relay.req([{ kinds: [1] }], "sub1"));
+        // Wait for connection
+        await firstValueFrom(relay.connected$.pipe(filter(Boolean)));
+        expect(relay.connected).toBe(true);
+    });
+    it("should send REQ and CLOSE messages", async () => {
+        // Create subscription that completes after first EOSE
+        const sub = relay.req([{ kinds: [1] }], "sub1").subscribe();
+        // Verify REQ was sent
+        expect(await server.nextMessage).toEqual(["REQ", "sub1", { kinds: [1] }]);
+        // Send EOSE to complete subscription
+        server.send(["EOSE", "sub1"]);
+        // Complete the subscription
+        sub.unsubscribe();
+        // Verify CLOSE was sent
+        expect(await server.nextMessage).toEqual(["CLOSE", "sub1"]);
+    });
+    it("should emit nostr event and EOSE", async () => {
+        const spy = subscribeSpyTo(relay.req([{ kinds: [1] }], "sub1"));
+        await server.connected;
+        // Send EVENT message
+        server.send(["EVENT", "sub1", mockEvent]);
+        // Send EOSE message
+        server.send(["EOSE", "sub1"]);
+        expect(spy.getValues()).toEqual([expect.objectContaining(mockEvent), "EOSE"]);
+    });
+    it("should ignore EVENT and EOSE messages that do not match subscription id", async () => {
+        const spy = subscribeSpyTo(relay.req([{ kinds: [1] }], "sub1"));
+        await server.connected;
+        // Send EVENT message with wrong subscription id
+        server.send(["EVENT", "wrong_sub", mockEvent]);
+        // Send EOSE message with wrong subscription id
+        server.send(["EOSE", "wrong_sub"]);
+        // Send EVENT message with correct subscription id
+        server.send(["EVENT", "sub1", mockEvent]);
+        // Send EOSE message with correct subscription id
+        server.send(["EOSE", "sub1"]);
+        expect(spy.getValues()).toEqual([expect.objectContaining(mockEvent), "EOSE"]);
+    });
+    it("should mark events with their source relay", async () => {
+        const spy = subscribeSpyTo(relay.req([{ kinds: [1] }], "sub1"));
+        await server.connected;
+        // Send EVENT message
+        server.send(["EVENT", "sub1", mockEvent]);
+        // Get the received event
+        const receivedEvent = spy.getValues()[0];
+        // Verify the event was marked as seen from this relay
+        expect(getSeenRelays(receivedEvent)).toContain("wss://test");
+    });
+    it("should error subscription when CLOSED message is received", async () => {
+        const spy = subscribeSpyTo(relay.req([{ kinds: [1] }], "sub1"), { expectErrors: true });
+        await server.connected;
+        // Send CLOSED message for the subscription
+        server.send(["CLOSED", "sub1", "reason"]);
+        // Verify the subscription completed
+        expect(spy.receivedError()).toBe(true);
+    });
+    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 });
+        await server.nextMessage;
+        // Send CLOSED message with auth-required reason
+        server.send(["CLOSED", "sub1", "auth-required: need to authenticate"]);
+        // wait for complete
+        await firstSub.onError();
+        await server.nextMessage;
+        // Create a second subscription that should wait for auth
+        const secondSub = subscribeSpyTo(relay.req([{ kinds: [1] }], "sub2"), { expectErrors: true });
+        // Verify no REQ message was sent yet (waiting for auth)
+        expect(server).not.toHaveReceivedMessages(["REQ", "sub2", { kinds: [1] }]);
+        // Simulate successful authentication
+        relay.authenticated$.next(true);
+        // Now the REQ should be sent
+        await expect(server).toReceiveMessage(["REQ", "sub2", { kinds: [1] }]);
+        // Send EVENT and EOSE to complete the subscription
+        server.send(["EVENT", "sub2", mockEvent]);
+        server.send(["EOSE", "sub2"]);
+        // Verify the second subscription received the event and EOSE
+        expect(secondSub.getValues()).toEqual([expect.objectContaining(mockEvent), "EOSE"]);
+    });
+    it("should wait for authentication if relay info document has limitations.auth_required = true", async () => {
+        // Mock the fetchInformationDocument method to return a document with auth_required = true
+        vi.spyOn(Relay, "fetchInformationDocument").mockImplementation(() => of({
+            name: "Auth Required Relay",
+            description: "A relay that requires authentication",
+            pubkey: "",
+            contact: "",
+            supported_nips: [1, 2, 4],
+            software: "",
+            version: "",
+            limitation: {
+                auth_required: true,
+            },
+        }));
+        // Create a subscription that should wait for auth
+        const sub = subscribeSpyTo(relay.req([{ kinds: [1] }], "sub1"));
+        // Wait 10ms to ensure the information document is fetched
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        // Verify no REQ message was sent yet (waiting for auth)
+        expect(server).not.toHaveReceivedMessages(["REQ", "sub1", { kinds: [1] }]);
+        // Simulate successful authentication
+        relay.authenticated$.next(true);
+        // Now the REQ should be sent
+        await expect(server).toReceiveMessage(["REQ", "sub1", { kinds: [1] }]);
+        // Send EVENT and EOSE to complete the subscription
+        server.send(["EVENT", "sub1", mockEvent]);
+        server.send(["EOSE", "sub1"]);
+        // Verify the subscription received the event and EOSE
+        expect(sub.getValues()).toEqual([expect.objectContaining(mockEvent), "EOSE"]);
+    });
+    it("should throw error if relay closes connection with error", async () => {
+        const spy = subscribeSpyTo(relay.req([{ kinds: [1] }], "sub1"), { expectErrors: true });
+        await server.connected;
+        // Send CLOSE message with error
+        server.error({
+            reason: "error message",
+            code: 1000,
+            wasClean: false,
+        });
+        // Verify the subscription completed with an error
+        expect(spy.receivedError()).toBe(true);
+    });
+    it("should not return EOSE while waiting for the relay to be ready", async () => {
+        vi.useFakeTimers();
+        // @ts-expect-error
+        relay.ready$.next(false);
+        const spy = subscribeSpyTo(relay.req([{ kinds: [1] }], "sub1"), { expectErrors: true });
+        // Fast-forward time by 20 seconds
+        await vi.advanceTimersByTimeAsync(20000);
+        expect(spy.receivedComplete()).toBe(false);
+        expect(spy.receivedError()).toBe(false);
+        expect(spy.receivedNext()).toBe(false);
+    });
+    it("should wait when relay isn't ready", async () => {
+        // @ts-expect-error
+        relay.ready$.next(false);
+        subscribeSpyTo(relay.req([{ kinds: [1] }], "sub1"));
+        // Wait 10ms to ensure the relay didn't receive anything
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(server.messages.length).toBe(0);
+        // @ts-expect-error
+        relay.ready$.next(true);
+        await expect(server).toReceiveMessage(["REQ", "sub1", { kinds: [1] }]);
+    });
+});
+describe("event", () => {
+    it("should wait for authentication if relay responds with auth-required", async () => {
+        // First event to trigger auth-required
+        const firstSpy = subscribeSpyTo(relay.event(mockEvent));
+        await expect(server).toReceiveMessage(["EVENT", mockEvent]);
+        // Send OK with auth-required message
+        server.send(["OK", mockEvent.id, false, "auth-required: need to authenticate"]);
+        await firstSpy.onComplete();
+        // Create a second event that should wait for auth
+        const secondSpy = subscribeSpyTo(relay.event(mockEvent));
+        // Verify no EVENT message was sent yet (waiting for auth)
+        expect(server).not.toHaveReceivedMessages(["EVENT", mockEvent]);
+        // Simulate successful authentication
+        relay.authenticated$.next(true);
+        // Now the EVENT should be sent
+        await expect(server).toReceiveMessage(["EVENT", mockEvent]);
+        // Send OK response to complete the event
+        server.send(["OK", mockEvent.id, true, ""]);
+        // Verify the second event completed successfully
+        await secondSpy.onComplete();
+        expect(secondSpy.receivedComplete()).toBe(true);
+    });
+    it("should wait for authentication if relay info document has limitations.auth_required = true", async () => {
+        // Mock the fetchInformationDocument method to return a document with auth_required = true
+        vi.spyOn(Relay, "fetchInformationDocument").mockImplementation(() => of({
+            name: "Auth Required Relay",
+            description: "A relay that requires authentication",
+            pubkey: "",
+            contact: "",
+            supported_nips: [1, 2, 4],
+            software: "",
+            version: "",
+            limitation: {
+                auth_required: true,
+            },
+        }));
+        // Create a subscription that should wait for auth
+        const sub = subscribeSpyTo(relay.event(mockEvent));
+        // Wait 10ms to ensure the information document is fetched
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        // Verify no REQ message was sent yet (waiting for auth)
+        expect(server).not.toHaveReceivedMessages(["EVENT", mockEvent]);
+        // Simulate successful authentication
+        relay.authenticated$.next(true);
+        // Now the REQ should be sent
+        await expect(server).toReceiveMessage(["EVENT", mockEvent]);
+        // Send EVENT and EOSE to complete the subscription
+        server.send(["OK", mockEvent.id, true, ""]);
+        // Verify the subscription completed
+        await sub.onComplete();
+        expect(sub.receivedComplete()).toBe(true);
+    });
+    it("should trigger connection to relay", async () => {
+        subscribeSpyTo(relay.event(mockEvent));
+        // Wait for connection
+        await firstValueFrom(relay.connected$.pipe(filter(Boolean)));
+        expect(relay.connected).toBe(true);
+    });
+    it("observable should complete when matching OK response received", async () => {
+        const spy = subscribeSpyTo(relay.event(mockEvent));
+        // Verify EVENT message was sent
+        expect(await server.nextMessage).toEqual(["EVENT", mockEvent]);
+        // Send matching OK response
+        server.send(["OK", mockEvent.id, true, ""]);
+        await spy.onComplete();
+        expect(spy.receivedComplete()).toBe(true);
+    });
+    it("should ignore OK responses for different events", async () => {
+        const spy = subscribeSpyTo(relay.event(mockEvent));
+        await server.connected;
+        // Send non-matching OK response
+        server.send(["OK", "different_id", true, ""]);
+        expect(spy.receivedComplete()).toBe(false);
+        // Send matching OK response
+        server.send(["OK", mockEvent.id, true, ""]);
+        expect(spy.receivedComplete()).toBe(true);
+    });
+    it("should send EVENT message to relay", async () => {
+        relay.event(mockEvent).subscribe();
+        expect(await server.nextMessage).toEqual(["EVENT", mockEvent]);
+    });
+    it("should complete with error if no OK received within 10s", async () => {
+        vi.useFakeTimers();
+        const spy = subscribeSpyTo(relay.event(mockEvent));
+        // Fast-forward time by 10 seconds
+        await vi.advanceTimersByTimeAsync(10000);
+        expect(spy.receivedComplete()).toBe(true);
+        expect(spy.getLastValue()).toEqual({ ok: false, from: "wss://test", message: "Timeout" });
+    });
+    it("should throw error if relay closes connection with error", async () => {
+        const spy = subscribeSpyTo(relay.event(mockEvent), { expectErrors: true });
+        await server.connected;
+        // Send CLOSE message with error
+        server.error({
+            reason: "error message",
+            code: 1000,
+            wasClean: false,
+        });
+        // Verify the subscription completed with an error
+        expect(spy.receivedError()).toBe(true);
+    });
+    it("should not throw a timeout error while waiting for the relay to be ready", async () => {
+        vi.useFakeTimers();
+        // @ts-expect-error
+        relay.ready$.next(false);
+        const spy = subscribeSpyTo(relay.event(mockEvent), { expectErrors: true });
+        // Fast-forward time by 20 seconds
+        await vi.advanceTimersByTimeAsync(20000);
+        expect(spy.receivedComplete()).toBe(false);
+        expect(spy.receivedError()).toBe(false);
+    });
+    it("should wait when relay isn't ready", async () => {
+        // @ts-expect-error
+        relay.ready$.next(false);
+        subscribeSpyTo(relay.event(mockEvent));
+        // Wait 10ms to ensure the relay didn't receive anything
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(server.messages.length).toBe(0);
+        // @ts-expect-error
+        relay.ready$.next(true);
+        await expect(server).toReceiveMessage(["EVENT", mockEvent]);
+    });
+});
+describe("notices$", () => {
+    it("should not trigger connection to relay", async () => {
+        subscribeSpyTo(relay.notices$);
+        expect(relay.connected).toBe(false);
+    });
+    it("should accumulate notices in notices$ state", async () => {
+        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(relay.notices$.value).toEqual(["Notice 1", "Notice 2", "Notice 3"]);
+    });
+    it("should ignore non-NOTICE messages", async () => {
+        subscribeSpyTo(relay.req({ kinds: [1] }));
+        server.send(["NOTICE", "Important notice"]);
+        server.send(["OTHER", "other message"]);
+        // Verify only NOTICE messages are in the state
+        expect(relay.notices$.value).toEqual(["Important notice"]);
+    });
+});
+describe("challenge$", () => {
+    it("should not trigger connection to relay", async () => {
+        subscribeSpyTo(relay.challenge$);
+        expect(relay.connected).toBe(false);
+    });
+    it("should set challenge$ when AUTH message received", async () => {
+        subscribeSpyTo(relay.req({ kinds: [1] }));
+        // Send AUTH message with challenge string
+        server.send(["AUTH", "challenge-string-123"]);
+        // Verify challenge$ was set
+        expect(relay.challenge$.value).toBe("challenge-string-123");
+    });
+    it("should ignore non-AUTH messages", async () => {
+        subscribeSpyTo(relay.req({ kinds: [1] }));
+        server.send(["NOTICE", "Not a challenge"]);
+        server.send(["OTHER", "other message"]);
+        // Verify challenge$ remains null
+        expect(relay.challenge$.value).toBe(null);
+    });
+});
+describe("information$", () => {
+    it("should fetch information document when information$ is subscribed to", async () => {
+        // Mock the fetchInformationDocument method
+        const mockInfo = { ...defaultMockInfo, limitation: { auth_required: false } };
+        vi.spyOn(Relay, "fetchInformationDocument").mockReturnValue(of(mockInfo));
+        // Subscribe to information$
+        const sub = subscribeSpyTo(relay.information$);
+        // Verify fetchInformationDocument was called with the relay URL
+        expect(Relay.fetchInformationDocument).toHaveBeenCalledWith(relay.url);
+        // Verify the information was emitted
+        expect(sub.getLastValue()).toEqual(mockInfo);
+    });
+    it("should return null when fetchInformationDocument fails", async () => {
+        // Mock the fetchInformationDocument method to throw an error
+        vi.spyOn(Relay, "fetchInformationDocument").mockReturnValue(throwError(() => new Error("Failed to fetch")));
+        // Subscribe to information$
+        const sub = subscribeSpyTo(relay.information$);
+        // Verify fetchInformationDocument was called
+        expect(Relay.fetchInformationDocument).toHaveBeenCalled();
+        // Verify null was emitted
+        expect(sub.getLastValue()).toBeNull();
+    });
+    it("should cache the information document", async () => {
+        // Mock the fetchInformationDocument method
+        const mockInfo = { ...defaultMockInfo, limitation: { auth_required: true } };
+        vi.spyOn(Relay, "fetchInformationDocument").mockReturnValue(of(mockInfo));
+        // Subscribe to information$ multiple times
+        const sub1 = subscribeSpyTo(relay.information$);
+        const sub2 = subscribeSpyTo(relay.information$);
+        // Verify fetchInformationDocument was called only once
+        expect(Relay.fetchInformationDocument).toHaveBeenCalledTimes(1);
+        // Verify both subscriptions received the same information
+        expect(sub1.getLastValue()).toEqual(mockInfo);
+        expect(sub2.getLastValue()).toEqual(mockInfo);
+        // Verify the internal state was updated
+        expect(relay.information).toEqual(mockInfo);
+    });
+});
+describe("createReconnectTimer", () => {
+    it("should create a reconnect timer when relay closes with error", async () => {
+        const reconnectTimer = vi.fn().mockReturnValue(timer(1000));
+        vi.spyOn(Relay, "createReconnectTimer").mockReturnValue(reconnectTimer);
+        relay = new Relay("wss://test");
+        const spy = subscribeSpyTo(relay.req([{ kinds: [1] }]), { expectErrors: true });
+        // Send CLOSE message with error
+        server.error({
+            reason: "error message",
+            code: 1000,
+            wasClean: false,
+        });
+        // Verify the subscription errored
+        expect(spy.receivedError()).toBe(true);
+        expect(reconnectTimer).toHaveBeenCalledWith(expect.any(Error), 0);
+    });
+    it("should set ready$ to false until the reconnect timer completes", async () => {
+        vi.useFakeTimers();
+        const reconnectTimer = vi.fn().mockReturnValue(timer(1000));
+        vi.spyOn(Relay, "createReconnectTimer").mockReturnValue(reconnectTimer);
+        relay = new Relay("wss://test");
+        subscribeSpyTo(relay.req([{ kinds: [1] }]), { expectErrors: true });
+        // Send CLOSE message with error
+        server.error({
+            reason: "error message",
+            code: 1000,
+            wasClean: false,
+        });
+        // @ts-expect-error
+        expect(relay.ready$.value).toBe(false);
+        // Fast-forward time by 10ms
+        await vi.advanceTimersByTimeAsync(5000);
+        // @ts-expect-error
+        expect(relay.ready$.value).toBe(true);
+    });
+});
+describe("publish", () => {
+    it("should retry when auth-required is received and authentication is completed", async () => {
+        // First attempt to publish
+        const spy = subscribeSpyTo(relay.publish(mockEvent));
+        // Verify EVENT was sent
+        await expect(server).toReceiveMessage(["EVENT", mockEvent]);
+        // Send auth-required response
+        server.send(["AUTH", "challenge-string"]);
+        server.send(["OK", mockEvent.id, false, "auth-required: need to authenticate"]);
+        // Send auth event
+        const authEvent = { ...mockEvent, id: "auth-id" };
+        subscribeSpyTo(relay.auth(authEvent));
+        // Verify AUTH was sent
+        await expect(server).toReceiveMessage(["AUTH", authEvent]);
+        // Send successful auth response
+        server.send(["OK", authEvent.id, true, ""]);
+        // Wait for the event to be sent again
+        await expect(server).toReceiveMessage(["EVENT", mockEvent]);
+        // Send successful response for the retried event
+        server.send(["OK", mockEvent.id, true, ""]);
+        // Verify the final result is successful
+        expect(spy.getLastValue()).toEqual({ ok: true, message: "", from: "wss://test" });
+    });
+    it("should error after max retries", async () => {
+        const spy = subscribeSpyTo(relay.publish(mockEvent, { retries: 0 }), { expectErrors: true });
+        // Close with error
+        server.error({ reason: "error message", code: 1000, wasClean: false });
+        // Verify the subscription errored
+        expect(spy.receivedError()).toBe(true);
+    });
+});
+describe("request", () => {
+    it("should retry when auth-required is received and authentication is completed", async () => {
+        // First attempt to request
+        const spy = subscribeSpyTo(relay.request({ kinds: [1] }, { id: "sub1" }));
+        // Verify REQ was sent
+        await expect(server).toReceiveMessage(["REQ", "sub1", { kinds: [1] }]);
+        // Send auth-required response
+        server.send(["AUTH", "challenge-string"]);
+        server.send(["CLOSED", "sub1", "auth-required: need to authenticate"]);
+        // Wait for subscription to close
+        await expect(server).toReceiveMessage(["CLOSE", "sub1"]);
+        // Send auth event
+        const authEvent = { ...mockEvent, id: "auth-id" };
+        const authSpy = subscribeSpyTo(relay.auth(authEvent));
+        // Verify AUTH was sent
+        await expect(server).toReceiveMessage(["AUTH", authEvent]);
+        server.send(["OK", authEvent.id, true, ""]);
+        // Wait for auth to complete
+        await authSpy.onComplete();
+        // Wait for retry
+        await expect(server).toReceiveMessage(["REQ", "sub1", { kinds: [1] }]);
+        // Send response
+        server.send(["EVENT", "sub1", mockEvent]);
+        server.send(["EOSE", "sub1"]);
+        // Verify the final result is successful
+        expect(spy.getLastValue()).toEqual(expect.objectContaining(mockEvent));
+        expect(spy.receivedComplete()).toBe(true);
+    });
+});
+describe("subscription", () => {
+    it("should retry when auth-required is received and authentication is completed", async () => {
+        // First attempt to request
+        const spy = subscribeSpyTo(relay.subscription({ kinds: [1] }, { id: "sub1" }));
+        // Verify REQ was sent
+        await expect(server).toReceiveMessage(["REQ", "sub1", { kinds: [1] }]);
+        // Send auth-required response
+        server.send(["AUTH", "challenge-string"]);
+        server.send(["CLOSED", "sub1", "auth-required: need to authenticate"]);
+        // Wait for subscription to close
+        await expect(server).toReceiveMessage(["CLOSE", "sub1"]);
+        // Send auth event
+        const authEvent = { ...mockEvent, id: "auth-id" };
+        const authSpy = subscribeSpyTo(relay.auth(authEvent));
+        // Verify AUTH was sent
+        await expect(server).toReceiveMessage(["AUTH", authEvent]);
+        server.send(["OK", authEvent.id, true, ""]);
+        // Wait for auth to complete
+        await authSpy.onComplete();
+        // Wait for retry
+        await expect(server).toReceiveMessage(["REQ", "sub1", { kinds: [1] }]);
+        // Send response
+        server.send(["EVENT", "sub1", mockEvent]);
+        server.send(["EOSE", "sub1"]);
+        // Verify the final result is successful
+        expect(spy.getValues()).toEqual([expect.objectContaining(mockEvent), "EOSE"]);
+        expect(spy.receivedComplete()).toBe(false);
+    });
+});
+// describe("keepAlive", () => {
+//   it("should close the socket connection after keepAlive timeout", async () => {
+//     vi.useFakeTimers();
+//     // Set a short keepAlive timeout for testing
+//     relay.keepAlive = 100; // 100ms for quick testing
+//     // Subscribe to the relay to ensure it is active
+//     const sub = subscribeSpyTo(relay.req([{ kinds: [1] }]));
+//     // Wait for connection
+//     await server.connected;
+//     // Close the subscription
+//     sub.unsubscribe();
+//     // Fast-forward time by 10ms
+//     await vi.advanceTimersByTimeAsync(10);
+//     // should still be connected
+//     expect(relay.connected).toBe(true);
+//     // Wait for the keepAlive timeout to elapse
+//     await vi.advanceTimersByTimeAsync(150);
+//     expect(relay.connected).toBe(false);
+//   });
+// });

package/dist/group.d.ts

@@ -0,0 +1,19 @@
+import { Filter, NostrEvent } from "nostr-tools";
+import { Observable } from "rxjs";
+import { IGroup, IRelay, PublishResponse, SubscriptionResponse, PublishOptions, RequestOptions, SubscriptionOptions } from "./types.js";
+export declare class RelayGroup implements IGroup {
+    relays: IRelay[];
+    constructor(relays: IRelay[]);
+    /** Takes an array of observables and only emits EOSE when all observables have emitted EOSE */
+    protected mergeEOSE(...requests: Observable<SubscriptionResponse>[]): Observable<import("nostr-tools").Event | "EOSE">;
+    /** Make a request to all relays */
+    req(filters: Filter | Filter[], id?: string): Observable<SubscriptionResponse>;
+    /** Send an event to all relays */
+    event(event: NostrEvent): Observable<PublishResponse>;
+    /** Publish an event to all relays with retries ( default 3 retries ) */
+    publish(event: NostrEvent, opts?: PublishOptions): Observable<PublishResponse[]>;
+    /** Request events from all relays with retries ( default 3 retries ) */
+    request(filters: Filter | Filter[], opts?: RequestOptions): Observable<NostrEvent>;
+    /** Open a subscription to all relays with retries ( default 3 retries ) */
+    subscription(filters: Filter | Filter[], opts?: SubscriptionOptions): Observable<SubscriptionResponse>;
+}

package/dist/group.js

@@ -0,0 +1,54 @@
+import { nanoid } from "nanoid";
+import { catchError, EMPTY, endWith, ignoreElements, merge, of, toArray } from "rxjs";
+import { completeOnEose } from "./operators/complete-on-eose.js";
+import { onlyEvents } from "./operators/only-events.js";
+export class RelayGroup {
+    relays;
+    constructor(relays) {
+        this.relays = relays;
+    }
+    /** Takes an array of observables and only emits EOSE when all observables have emitted EOSE */
+    mergeEOSE(...requests) {
+        // Create stream of events only
+        const events = merge(...requests).pipe(onlyEvents());
+        // Create stream that emits EOSE when all relays have sent EOSE
+        const eose = merge(
+        // Create a new map of requests that only emits EOSE
+        ...requests.map((observable) => observable.pipe(completeOnEose(), ignoreElements()))).pipe(
+        // When all relays have sent EOSE, emit EOSE
+        endWith("EOSE"));
+        return merge(events, eose);
+    }
+    /** Make a request to all relays */
+    req(filters, id = nanoid(8)) {
+        const requests = this.relays.map((relay) => relay.req(filters, id).pipe(
+        // Ignore connection errors
+        catchError(() => of("EOSE"))));
+        // Merge events and the single EOSE stream
+        return this.mergeEOSE(...requests);
+    }
+    /** Send an event to all relays */
+    event(event) {
+        return merge(...this.relays.map((relay) => relay.event(event).pipe(
+        // Catch error and return as PublishResponse
+        catchError((err) => of({ ok: false, from: relay.url, message: err?.message || "Unknown error" })))));
+    }
+    /** Publish an event to all relays with retries ( default 3 retries ) */
+    publish(event, opts) {
+        return merge(...this.relays.map((relay) => relay.publish(event, opts).pipe(
+        // Catch error and return as PublishResponse
+        catchError((err) => of({ ok: false, from: relay.url, message: err?.message || "Unknown error" }))))).pipe(toArray());
+    }
+    /** Request events from all relays with retries ( default 3 retries ) */
+    request(filters, opts) {
+        return merge(...this.relays.map((relay) => relay.request(filters, opts).pipe(
+        // Ignore individual connection errors
+        catchError(() => EMPTY))));
+    }
+    /** Open a subscription to all relays with retries ( default 3 retries ) */
+    subscription(filters, opts) {
+        return this.mergeEOSE(...this.relays.map((relay) => relay.subscription(filters, opts).pipe(
+        // Ignore individual connection errors
+        catchError(() => EMPTY))));
+    }
+}

package/dist/index.d.ts

@@ -1,2 +1,5 @@
+export * from "./group.js";
 export * from "./pool.js";
 export * from "./relay.js";
+export * from "./types.js";
+export * from "./operators/index.js";

package/dist/index.js

@@ -1,2 +1,5 @@
+export * from "./group.js";
 export * from "./pool.js";
 export * from "./relay.js";
+export * from "./types.js";
+export * from "./operators/index.js";