applesauce-relay 1.2.0 → 2.1.1

package/dist/negentropy.d.ts

@@ -1,8 +1,8 @@
-import { ISyncEventStore } from "applesauce-core";
+import { IEventStoreRead } from "applesauce-core";
 import { Filter } from "nostr-tools";
 import { MultiplexWebSocket } from "./types.js";
 import { NegentropyStorageVector } from "./lib/negentropy.js";
-export declare function buildStorageFromFilter(store: ISyncEventStore, filter: Filter): NegentropyStorageVector;
+export declare function buildStorageFromFilter(store: IEventStoreRead, filter: Filter): NegentropyStorageVector;
 export declare function buildStorageVector(items: {
     id: string;
     created_at: number;

package/dist/negentropy.js

@@ -5,7 +5,7 @@ import { Negentropy, NegentropyStorageVector } from "./lib/negentropy.js";
 const log = logger.extend("negentropy");
 export function buildStorageFromFilter(store, filter) {
     const storage = new NegentropyStorageVector();
-    for (const event of store.getAll(filter))
+    for (const event of store.getByFilters(filter))
         storage.insert(event.created_at, event.id);
     storage.seal();
     return storage;

package/dist/operators/complete-on-eose.js

@@ -1,7 +1,4 @@
 import { takeWhile } from "rxjs";
-export function completeOnEose(includeEose) {
-    if (includeEose)
-        return takeWhile((m) => m !== "EOSE", true);
-    else
-        return takeWhile((m) => m !== "EOSE", false);
+export function completeOnEose(inclusive) {
+    return takeWhile((m) => m !== "EOSE", inclusive);
 }

package/dist/operators/store-events.d.ts

@@ -1,5 +1,5 @@
 import { IEventStore } from "applesauce-core";
 import { MonoTypeOperatorFunction } from "rxjs";
 import { SubscriptionResponse } from "../types.js";
-/** Sends all events to the event store */
+/** Sends all events to the event store but does not remove duplicates */
 export declare function storeEvents(eventStore: IEventStore): MonoTypeOperatorFunction<SubscriptionResponse>;

package/dist/operators/store-events.js

@@ -1,5 +1,5 @@
 import { tap } from "rxjs";
-/** Sends all events to the event store */
+/** Sends all events to the event store but does not remove duplicates */
 export function storeEvents(eventStore) {
     return (source) => {
         return source.pipe(tap((event) => typeof event !== "string" && eventStore.add(event)));

package/dist/operators/to-event-store.d.ts

@@ -2,5 +2,8 @@ import { OperatorFunction } from "rxjs";
 import { IEventStore } from "applesauce-core";
 import { NostrEvent } from "nostr-tools";
 import { SubscriptionResponse } from "../types.js";
-/** Adds all events to event store and returns a deduplicated timeline when EOSE is received */
+/**
+ * Adds all events to event store and returns a deduplicated timeline when EOSE is received
+ * @deprecated use `mapEventsToStore` and `mapEventsToTimeline` instead
+ */
 export declare function toEventStore(eventStore: IEventStore): OperatorFunction<SubscriptionResponse, NostrEvent[]>;

package/dist/operators/to-event-store.js

@@ -1,19 +1,15 @@
-import { scan } from "rxjs";
-import { insertEventIntoDescendingList } from "nostr-tools/utils";
+import { mapEventsToStore, mapEventsToTimeline } from "applesauce-core/observable";
 import { completeOnEose } from "./complete-on-eose.js";
-/** Adds all events to event store and returns a deduplicated timeline when EOSE is received */
+/**
+ * Adds all events to event store and returns a deduplicated timeline when EOSE is received
+ * @deprecated use `mapEventsToStore` and `mapEventsToTimeline` instead
+ */
 export function toEventStore(eventStore) {
     return (source) => source.pipe(
     // Complete when there are not events
     completeOnEose(), 
+    // Save events to store and remove duplicates
+    mapEventsToStore(eventStore, true), 
     // Add the events to an array
-    scan((events, event) => {
-        // Get the current instance of this event
-        let e = eventStore.add(event);
-        // If its not in the timeline, add it
-        if (events.includes(e))
-            return events;
-        else
-            return insertEventIntoDescendingList(events, e);
-    }, []));
+    mapEventsToTimeline());
 }

package/dist/relay.d.ts

@@ -61,12 +61,12 @@ export declare class Relay implements IRelay {
     protected authRequiredForReq: Observable<boolean>;
     protected authRequiredForEvent: Observable<boolean>;
     protected resetState(): void;
-    /** An internal observable that is responsible for watching all messages and updating state */
+    /** An internal observable that is responsible for watching all messages and updating state, subscribing to it will trigger a connection to the relay */
     protected watchTower: Observable<never>;
     constructor(url: string, opts?: RelayOptions);
     /** Set ready = false and start the reconnect timer */
     protected startReconnectTimer(error: Error | CloseEvent): void;
-    /** Wait for ready and authenticated */
+    /** Wait for authentication state, make connection and then wait for authentication if required */
     protected waitForAuth<T extends unknown = unknown>(requireAuth: Observable<boolean>, observable: Observable<T>): Observable<T>;
     /** Wait for the relay to be ready to accept connections */
     protected waitForReady<T extends unknown = unknown>(observable: Observable<T>): Observable<T>;

package/dist/relay.js

@@ -2,8 +2,9 @@ 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, endWith, filter, finalize, from, ignoreElements, isObservable, map, merge, mergeMap, NEVER, of, retry, scan, share, shareReplay, Subject, switchMap, take, takeUntil, tap, throwError, timeout, timer, } from "rxjs";
+import { BehaviorSubject, catchError, combineLatest, defer, endWith, filter, finalize, from, ignoreElements, isObservable, map, merge, mergeMap, mergeWith, NEVER, of, retry, scan, share, shareReplay, Subject, switchMap, take, takeUntil, tap, throwError, timeout, timer, } from "rxjs";
 import { webSocket } from "rxjs/webSocket";
+import { ensureHttpURL } from "applesauce-core/helpers";
 import { completeOnEose } from "./operators/complete-on-eose.js";
 import { markFromRelay } from "./operators/mark-from-relay.js";
 /** An error that is thrown when a REQ is closed from the relay side */
@@ -85,7 +86,7 @@ export class Relay {
         if (this.receivedAuthRequiredForEvent.value)
             this.receivedAuthRequiredForEvent.next(false);
     }
-    /** An internal observable that is responsible for watching all messages and updating state */
+    /** An internal observable that is responsible for watching all messages and updating state, subscribing to it will trigger a connection to the relay */
     watchTower;
     constructor(url, opts) {
         this.url = url;
@@ -190,11 +191,13 @@ export class Relay {
             .pipe(take(1))
             .subscribe(() => this.ready$.next(true));
     }
-    /** Wait for ready and authenticated */
+    /** Wait for authentication state, make connection and then wait for authentication if required */
     waitForAuth(
     // NOTE: require BehaviorSubject so it always has a value
     requireAuth, observable) {
         return combineLatest([requireAuth, this.authenticated$]).pipe(
+        // Once the auth state is known, make a connection and watch for auth challenges
+        mergeWith(this.watchTower), 
         // wait for auth not required or authenticated
         filter(([required, authenticated]) => !required || authenticated), 
         // complete after the first value so this does not repeat
@@ -284,10 +287,8 @@ export class Relay {
             // format OK message
             map((m) => ({ ok: m[2], message: m[3], from: this.url })));
         });
-        // Start the watch tower with the observable
-        const withWatchTower = merge(this.watchTower, base);
-        // Add complete operators
-        const observable = withWatchTower.pipe(
+        // Start the watch tower and add complete operators
+        const observable = merge(this.watchTower, base).pipe(
         // complete on first value
         take(1), 
         // listen for OK auth-required
@@ -351,7 +352,7 @@ export class Relay {
     }
     /** Static method to fetch the NIP-11 information document for a relay */
     static fetchInformationDocument(url) {
-        return from(fetch(url, { headers: { Accept: "application/nostr+json" } }).then((res) => res.json())).pipe(
+        return from(fetch(ensureHttpURL(url), { headers: { Accept: "application/nostr+json" } }).then((res) => res.json())).pipe(
         // if the fetch fails, return null
         catchError(() => of(null)), 
         // timeout after 10s

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-relay",
-  "version": "1.2.0",
+  "version": "2.1.1",
   "description": "nostr relay communication framework built on rxjs",
   "type": "module",
   "main": "dist/index.js",
@@ -54,16 +54,17 @@
   },
   "dependencies": {
     "@noble/hashes": "^1.7.1",
-    "applesauce-core": "^1.2.0",
+    "applesauce-core": "^2.0.0",
     "nanoid": "^5.0.9",
-    "nostr-tools": "^2.10.4",
+    "nostr-tools": "^2.13",
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
     "@hirez_io/observer-spy": "^2.2.0",
+    "applesauce-signers": "^2.0.0",
     "@vitest/expect": "^3.1.1",
     "typescript": "^5.7.3",
-    "vitest": "^3.1.1",
+    "vitest": "^3.2.3",
     "vitest-websocket-mock": "^0.5.0"
   },
   "funding": {

package/dist/__tests__/auth.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/auth.test.js

@@ -1,111 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { subscribeSpyTo } from "@hirez_io/observer-spy";
-import { WS } from "vitest-websocket-mock";
-import { Relay } from "../relay.js";
-let server;
-let relay;
-beforeEach(async () => {
-    server = new WS("wss://test", { jsonProtocol: true });
-    relay = new Relay("wss://test");
-    // Create a persistent subscription to keep the connection open
-    // @ts-expect-error
-    subscribeSpyTo(relay.socket);
-});
-afterEach(async () => {
-    server.close();
-    // Wait for server to close to prevent memory leaks
-    await WS.clean();
-});
-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("event", () => {
-    it("should wait for auth before sending EVENT if auth-required received", async () => {
-        // Create first event subscription
-        const spy1 = subscribeSpyTo(relay.event(mockEvent));
-        // Verify EVENT was sent
-        const firstEventMessage = await server.nextMessage;
-        expect(firstEventMessage).toEqual(["EVENT", mockEvent]);
-        // Send auth-required response
-        server.send(["OK", mockEvent.id, false, "auth-required: need to authenticate"]);
-        // Create second event subscription - this should not send EVENT yet
-        const spy2 = subscribeSpyTo(relay.event(mockEvent));
-        // Should not have received any messages
-        expect(server.messages.length).toBe(1);
-        // Send AUTH challenge
-        server.send(["AUTH", "challenge-string"]);
-        // Send auth event
-        const authEvent = { ...mockEvent, id: "auth-id" };
-        subscribeSpyTo(relay.auth(authEvent));
-        // Verify AUTH was sent
-        const authMessage = await server.nextMessage;
-        expect(authMessage).toEqual(["AUTH", authEvent]);
-        // Send successful auth response
-        server.send(["OK", authEvent.id, true, ""]);
-        // Now the second EVENT should be sent
-        const secondEventMessage = await server.nextMessage;
-        expect(secondEventMessage).toEqual(["EVENT", mockEvent]);
-        // Send OK response for second event
-        server.send(["OK", mockEvent.id, true, ""]);
-        expect(spy1.getLastValue()).toEqual({
-            ok: false,
-            message: "auth-required: need to authenticate",
-            from: "wss://test",
-        });
-        expect(spy2.getLastValue()).toEqual({ ok: true, message: "", from: "wss://test" });
-    });
-});
-describe("req", () => {
-    it("should wait for auth before sending REQ if auth-required received", async () => {
-        // Create first REQ subscription
-        const filters = [{ kinds: [1], limit: 10 }];
-        subscribeSpyTo(relay.req(filters, "sub1"), { expectErrors: true });
-        // Verify REQ was sent
-        const firstReqMessage = await server.nextMessage;
-        expect(firstReqMessage).toEqual(["REQ", "sub1", ...filters]);
-        // Send auth-required response
-        server.send(["CLOSED", "sub1", "auth-required: need to authenticate"]);
-        // Consume the client CLOSE message for sub1
-        await server.nextMessage;
-        // Create second REQ subscription - this should not send REQ yet
-        subscribeSpyTo(relay.req(filters, "sub2"), { expectErrors: true });
-        // Should not have received any messages
-        expect(server.messages).not.toContain(["REQ", "sub2", ...filters]);
-        // Send AUTH challenge
-        server.send(["AUTH", "challenge-string"]);
-        // Send auth event
-        const authEvent = { ...mockEvent, id: "auth-id" };
-        subscribeSpyTo(relay.auth(authEvent));
-        // Verify AUTH was sent
-        const authMessage = await server.nextMessage;
-        expect(authMessage).toEqual(["AUTH", authEvent]);
-        // Send successful auth response
-        server.send(["OK", authEvent.id, true, ""]);
-        // Now the second REQ should be sent
-        const secondReqMessage = await server.nextMessage;
-        expect(secondReqMessage).toEqual(["REQ", "sub2", ...filters]);
-        // Send some events for the second subscription
-        server.send(["EVENT", "sub2", mockEvent]);
-        server.send(["EOSE", "sub2"]);
-    });
-});
-describe("auth", () => {
-    it("should set authenticated state after successful AUTH challenge response", async () => {
-        // Send AUTH challenge
-        server.send(["AUTH", "challenge-string"]);
-        // Send auth event response
-        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, ""]);
-        expect(relay.authenticated).toBe(true);
-    });
-});

package/dist/__tests__/exports.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/exports.test.js

@@ -1,19 +0,0 @@
-import { describe, expect, it } from "vitest";
-import * as exports from "../index.js";
-describe("exports", () => {
-    it("should export the expected functions", () => {
-        expect(Object.keys(exports).sort()).toMatchInlineSnapshot(`
-      [
-        "Relay",
-        "RelayGroup",
-        "RelayPool",
-        "ReqCloseError",
-        "completeOnEose",
-        "markFromRelay",
-        "onlyEvents",
-        "storeEvents",
-        "toEventStore",
-      ]
-    `);
-    });
-});

package/dist/__tests__/group.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/group.test.js

@@ -1,106 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { subscribeSpyTo } from "@hirez_io/observer-spy";
-import { WS } from "vitest-websocket-mock";
-import { Relay } from "../relay.js";
-import { RelayGroup } from "../group.js";
-import { of } from "rxjs";
-let mockRelay1;
-let mockRelay2;
-let relay1;
-let relay2;
-let group;
-let mockEvent;
-beforeEach(async () => {
-    // Create mock relays
-    mockRelay1 = new WS("wss://relay1.test", { jsonProtocol: true });
-    mockRelay2 = new WS("wss://relay2.test", { jsonProtocol: true });
-    // Mock empty information document
-    vi.spyOn(Relay, "fetchInformationDocument").mockImplementation(() => of(null));
-    // Create relays
-    relay1 = new Relay("wss://relay1.test");
-    relay2 = new Relay("wss://relay2.test");
-    // Create group
-    group = new RelayGroup([relay1, relay2]);
-    mockEvent = {
-        kind: 1,
-        id: "test-id",
-        pubkey: "test-pubkey",
-        created_at: 1234567890,
-        tags: [],
-        content: "test content",
-        sig: "test-sig",
-    };
-});
-afterEach(async () => {
-    mockRelay1.close();
-    mockRelay2.close();
-    await WS.clean();
-});
-describe("req", () => {
-    it("should make requests to multiple relays", async () => {
-        group.req([{ kinds: [1] }], "test-sub").subscribe();
-        await expect(mockRelay1).toReceiveMessage(["REQ", "test-sub", { kinds: [1] }]);
-        await expect(mockRelay2).toReceiveMessage(["REQ", "test-sub", { kinds: [1] }]);
-    });
-    it("should emit events from all relays", async () => {
-        const spy = subscribeSpyTo(group.req([{ kinds: [1] }], "test-sub"));
-        await expect(mockRelay1).toReceiveMessage(["REQ", "test-sub", { kinds: [1] }]);
-        await expect(mockRelay2).toReceiveMessage(["REQ", "test-sub", { kinds: [1] }]);
-        mockRelay1.send(["EVENT", "test-sub", { ...mockEvent, id: "1" }]);
-        mockRelay2.send(["EVENT", "test-sub", { ...mockEvent, id: "2" }]);
-        expect(spy.getValues()).toEqual([expect.objectContaining({ id: "1" }), expect.objectContaining({ id: "2" })]);
-    });
-    it("should only emit EOSE once all relays have emitted EOSE", async () => {
-        const spy = subscribeSpyTo(group.req([{ kinds: [1] }], "test-sub"));
-        mockRelay1.send(["EOSE", "test-sub"]);
-        expect(spy.getValues()).not.toContain("EOSE");
-        mockRelay2.send(["EOSE", "test-sub"]);
-        expect(spy.getValues()).toContain("EOSE");
-    });
-    it("should ignore relays that have an error", async () => {
-        const spy = subscribeSpyTo(group.req([{ kinds: [1] }], "test-sub"));
-        mockRelay1.error();
-        mockRelay2.send(["EVENT", "test-sub", mockEvent]);
-        mockRelay2.send(["EOSE", "test-sub"]);
-        expect(spy.getValues()).toEqual([expect.objectContaining(mockEvent), "EOSE"]);
-    });
-    it("should emit EOSE if all relays error", async () => {
-        const spy = subscribeSpyTo(group.req([{ kinds: [1] }], "test-sub"));
-        mockRelay1.error();
-        mockRelay2.error();
-        expect(spy.getValues()).toEqual(["EOSE"]);
-    });
-});
-describe("event", () => {
-    it("should send EVENT to all relays in the group", async () => {
-        group.event(mockEvent).subscribe();
-        await expect(mockRelay1).toReceiveMessage(["EVENT", mockEvent]);
-        await expect(mockRelay2).toReceiveMessage(["EVENT", mockEvent]);
-    });
-    it("should emit OK messages from all relays", async () => {
-        const spy = subscribeSpyTo(group.event(mockEvent));
-        mockRelay1.send(["OK", mockEvent.id, true, ""]);
-        mockRelay2.send(["OK", mockEvent.id, true, ""]);
-        expect(spy.getValues()).toEqual([
-            expect.objectContaining({ ok: true, from: "wss://relay1.test", message: "" }),
-            expect.objectContaining({ ok: true, from: "wss://relay2.test", message: "" }),
-        ]);
-    });
-    it("should complete when all relays have sent OK messages", async () => {
-        const spy = subscribeSpyTo(group.event(mockEvent));
-        mockRelay1.send(["OK", mockEvent.id, true, ""]);
-        expect(spy.receivedComplete()).toBe(false);
-        mockRelay2.send(["OK", mockEvent.id, true, ""]);
-        expect(spy.receivedComplete()).toBe(true);
-    });
-    it("should handle relay errors and still complete", async () => {
-        const spy = subscribeSpyTo(group.event(mockEvent));
-        mockRelay1.error();
-        mockRelay2.send(["OK", mockEvent.id, true, ""]);
-        expect(spy.getValues()).toEqual([
-            expect.objectContaining({ ok: false, from: "wss://relay1.test", message: "Unknown error" }),
-            expect.objectContaining({ ok: true, from: "wss://relay2.test", message: "" }),
-        ]);
-        expect(spy.receivedComplete()).toBe(true);
-    });
-});

package/dist/__tests__/pool.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/pool.test.js

@@ -1,96 +0,0 @@
-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";
-let pool;
-let mockServer1;
-let mockServer2;
-let mockEvent;
-beforeEach(async () => {
-    // Create mock WebSocket servers
-    mockServer1 = new WS("wss://relay1.example.com");
-    mockServer2 = new WS("wss://relay2.example.com");
-    pool = new RelayPool();
-    mockEvent = {
-        kind: 1,
-        id: "test-id",
-        pubkey: "test-pubkey",
-        created_at: 1743712795,
-        tags: [],
-        content: "test content",
-        sig: "test-sig",
-    };
-});
-afterEach(async () => {
-    mockServer1.close();
-    mockServer2.close();
-    // Clean up WebSocket mocks
-    await WS.clean();
-});
-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/"));
-    });
-});
-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);
-    });
-});
-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));
-    });
-});
-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.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/relay.test.js

@@ -1,644 +0,0 @@
-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, Subject, 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 expected messages to relay", async () => {
-        subscribeSpyTo(relay.req([{ kinds: [1] }], "sub1"));
-        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
-        const sub = subscribeSpyTo(relay.req([{ kinds: [1] }], "sub1"));
-        // Verify REQ was sent
-        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
-        await expect(server).toReceiveMessage(["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 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 });
-        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] }]);
-    });
-    it("should wait for filters if filters are provided as an observable", async () => {
-        const filters = new Subject();
-        subscribeSpyTo(relay.req(filters, "sub1"));
-        // Wait 10sm and ensure no messages were sent yet
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(server.messagesToConsume.pendingItems.length).toBe(0);
-        // Send REQ message with filters
-        filters.next([{ kinds: [1] }]);
-        // Wait for the REQ message to be sent
-        await expect(server).toReceiveMessage(["REQ", "sub1", { kinds: [1] }]);
-    });
-    it("should update filters if filters are provided as an observable", async () => {
-        const filters = new Subject();
-        subscribeSpyTo(relay.req(filters, "sub1"));
-        // Send REQ message with filters
-        filters.next([{ kinds: [1] }]);
-        // Should send REQ message with new filters
-        await expect(server).toReceiveMessage(["REQ", "sub1", { kinds: [1] }]);
-        // Send REQ message with filters
-        filters.next([{ kinds: [2] }]);
-        // Should send new REQ message with new filters
-        await expect(server).toReceiveMessage(["REQ", "sub1", { kinds: [2] }]);
-        // It should not send CLOSE message
-        await expect(server.messages).not.toContain(["CLOSE", "sub1"]);
-    });
-    it("should complete if filters are provided as an observable that completes", async () => {
-        const filters = new Subject();
-        const sub = subscribeSpyTo(relay.req(filters, "sub1"));
-        // Send REQ message with filters
-        filters.next([{ kinds: [1] }]);
-        // Complete the observable
-        filters.complete();
-        await sub.onComplete();
-        expect(sub.receivedComplete()).toBe(true);
-    });
-});
-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("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 () => {
-        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/operators/__tests__/exports.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/operators/__tests__/exports.test.js

@@ -1,15 +0,0 @@
-import { describe, expect, it } from "vitest";
-import * as exports from "../index.js";
-describe("exports", () => {
-    it("should export the expected functions", () => {
-        expect(Object.keys(exports).sort()).toMatchInlineSnapshot(`
-      [
-        "completeOnEose",
-        "markFromRelay",
-        "onlyEvents",
-        "storeEvents",
-        "toEventStore",
-      ]
-    `);
-    });
-});