applesauce-relay 1.1.0 → 2.0.0

package/dist/group.d.ts

@@ -1,19 +1,19 @@
-import { Filter, NostrEvent } from "nostr-tools";
+import { type NostrEvent } from "nostr-tools";
 import { Observable } from "rxjs";
-import { IGroup, IRelay, PublishResponse, SubscriptionResponse, PublishOptions, RequestOptions, SubscriptionOptions } from "./types.js";
+import { IGroup, IRelay, PublishResponse, SubscriptionResponse, PublishOptions, RequestOptions, SubscriptionOptions, FilterInput } 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>;
+    req(filters: FilterInput, 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>;
+    request(filters: FilterInput, opts?: RequestOptions): Observable<NostrEvent>;
     /** Open a subscription to all relays with retries ( default 3 retries ) */
-    subscription(filters: Filter | Filter[], opts?: SubscriptionOptions): Observable<SubscriptionResponse>;
+    subscription(filters: FilterInput, opts?: SubscriptionOptions): Observable<SubscriptionResponse>;
 }

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/pool.d.ts

@@ -1,8 +1,8 @@
-import { NostrEvent, type Filter } from "nostr-tools";
+import { type NostrEvent } from "nostr-tools";
 import { BehaviorSubject, Observable } from "rxjs";
 import { RelayGroup } from "./group.js";
 import { Relay, RelayOptions } from "./relay.js";
-import { IPool, PublishResponse, PublishOptions, RequestOptions, SubscriptionOptions, SubscriptionResponse } from "./types.js";
+import { IPool, PublishResponse, PublishOptions, RequestOptions, SubscriptionOptions, SubscriptionResponse, FilterInput } from "./types.js";
 export declare class RelayPool implements IPool {
     options?: RelayOptions | undefined;
     groups$: BehaviorSubject<Map<string, RelayGroup>>;
@@ -18,13 +18,13 @@ export declare class RelayPool implements IPool {
     /** Create a group of relays */
     group(relays: string[]): RelayGroup;
     /** Make a REQ to multiple relays that does not deduplicate events */
-    req(relays: string[], filters: Filter | Filter[], id?: string): Observable<SubscriptionResponse>;
+    req(relays: string[], filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
     /** Send an EVENT message to multiple relays */
     event(relays: string[], event: NostrEvent): Observable<PublishResponse>;
     /** Publish an event to multiple relays */
     publish(relays: string[], event: NostrEvent, opts?: PublishOptions): Observable<PublishResponse>;
     /** Request events from multiple relays */
-    request(relays: string[], filters: Filter | Filter[], opts?: RequestOptions): Observable<NostrEvent>;
+    request(relays: string[], filters: FilterInput, opts?: RequestOptions): Observable<NostrEvent>;
     /** Open a subscription to multiple relays */
-    subscription(relays: string[], filters: Filter | Filter[], opts?: SubscriptionOptions): Observable<SubscriptionResponse>;
+    subscription(relays: string[], filters: FilterInput, opts?: SubscriptionOptions): Observable<SubscriptionResponse>;
 }

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/dist/relay.d.ts

@@ -3,7 +3,7 @@ import { type Filter, type NostrEvent } from "nostr-tools";
 import { BehaviorSubject, Observable } from "rxjs";
 import { WebSocketSubject, WebSocketSubjectConfig } from "rxjs/webSocket";
 import { RelayInformation } from "nostr-tools/nip11";
-import { AuthSigner, IRelay, PublishOptions, PublishResponse, RequestOptions, SubscriptionOptions, SubscriptionResponse } from "./types.js";
+import { AuthSigner, FilterInput, IRelay, PublishOptions, PublishResponse, RequestOptions, SubscriptionOptions, SubscriptionResponse } from "./types.js";
 /** An error that is thrown when a REQ is closed from the relay side */
 export declare class ReqCloseError extends Error {
 }
@@ -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>;
@@ -74,7 +74,7 @@ export declare class Relay implements IRelay {
     /** Send a message to the relay */
     next(message: any): void;
     /** Create a REQ observable that emits events or "EOSE" or errors */
-    req(filters: Filter | Filter[], id?: string): Observable<SubscriptionResponse>;
+    req(filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
     /** Send an EVENT or AUTH message and return an observable of PublishResponse that completes or errors */
     event(event: NostrEvent, verb?: "EVENT" | "AUTH"): Observable<PublishResponse>;
     /** send and AUTH message */

package/dist/relay.js

@@ -2,7 +2,7 @@ import { logger } from "applesauce-core";
 import { simpleTimeout } from "applesauce-core/observable";
 import { nanoid } from "nanoid";
 import { nip42 } from "nostr-tools";
-import { BehaviorSubject, catchError, combineLatest, defer, filter, from, ignoreElements, map, merge, mergeMap, NEVER, of, retry, scan, share, shareReplay, Subject, switchMap, take, 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 { completeOnEose } from "./operators/complete-on-eose.js";
 import { markFromRelay } from "./operators/mark-from-relay.js";
@@ -85,7 +85,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 +190,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
@@ -225,10 +227,24 @@ export class Relay {
     }
     /** Create a REQ observable that emits events or "EOSE" or errors */
     req(filters, id = nanoid()) {
-        const request = this.socket.multiplex(() => (Array.isArray(filters) ? ["REQ", id, ...filters] : ["REQ", id, filters]), () => ["CLOSE", id], (message) => (message[0] === "EVENT" || message[0] === "CLOSED" || message[0] === "EOSE") && message[1] === id);
-        // Start the watch tower with the observable
-        const withWatchTower = merge(this.watchTower, request);
-        const observable = withWatchTower.pipe(
+        // Convert filters input into an observable, if its a normal value merge it with NEVER so it never completes
+        const input = isObservable(filters) ? filters : merge(of(filters), NEVER);
+        // Create an observable that completes when the upstream observable completes
+        const complete = input.pipe(ignoreElements(), endWith(null));
+        // Create an observable that filters responses from the relay to just the ones for this REQ
+        const messages = this.socket.pipe(filter((m) => Array.isArray(m) && (m[0] === "EVENT" || m[0] === "CLOSED" || m[0] === "EOSE") && m[1] === id));
+        // Create an observable that controls sending the filters and closing the REQ
+        const control = input.pipe(
+        // Send the filters when they change
+        tap((filters) => this.socket.next(Array.isArray(filters) ? ["REQ", id, ...filters] : ["REQ", id, filters])), 
+        // Close the req when unsubscribed
+        finalize(() => this.socket.next(["CLOSE", id])), 
+        // Once filters have been sent, switch to listening for messages
+        switchMap(() => messages));
+        // Start the watch tower with the observables
+        const observable = merge(this.watchTower, control).pipe(
+        // Complete the subscription when the input is completed
+        takeUntil(complete), 
         // Map the messages to events, EOSE, or throw an error
         map((message) => {
             if (message[0] === "EOSE")
@@ -270,10 +286,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

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import { EventTemplate, Filter, NostrEvent } from "nostr-tools";
+import { type EventTemplate, type Filter, type NostrEvent } from "nostr-tools";
 import { Observable } from "rxjs";
 import { WebSocketSubject } from "rxjs/webSocket";
 export type SubscriptionResponse = NostrEvent | "EOSE";
@@ -28,11 +28,13 @@ export type SubscriptionOptions = {
 export type AuthSigner = {
     signEvent: (event: EventTemplate) => NostrEvent | Promise<NostrEvent>;
 };
+/** The type of input the REQ method accepts */
+export type FilterInput = Filter | Filter[] | Observable<Filter | Filter[]>;
 export interface Nip01Actions {
     /** Send an EVENT message */
     event(event: NostrEvent): Observable<PublishResponse>;
     /** Send a REQ message */
-    req(filters: Filter | Filter[], id?: string): Observable<SubscriptionResponse>;
+    req(filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
 }
 export interface IRelay extends MultiplexWebSocket, Nip01Actions, IRelayState {
     url: string;
@@ -52,12 +54,12 @@ export interface IRelay extends MultiplexWebSocket, Nip01Actions, IRelayState {
         retries?: number;
     }): Observable<PublishResponse>;
     /** Send a REQ message with retries */
-    request(filters: Filter | Filter[], opts?: {
+    request(filters: FilterInput, opts?: {
         id?: string;
         retries?: number;
     }): Observable<NostrEvent>;
     /** Open a subscription with retries */
-    subscription(filters: Filter | Filter[], opts?: {
+    subscription(filters: FilterInput, opts?: {
         id?: string;
         retries?: number;
     }): Observable<SubscriptionResponse>;
@@ -68,12 +70,12 @@ export interface IGroup extends Nip01Actions {
         retries?: number;
     }): Observable<PublishResponse>;
     /** Send a REQ message with retries */
-    request(filters: Filter | Filter[], opts?: {
+    request(filters: FilterInput, opts?: {
         id?: string;
         retries?: number;
     }): Observable<NostrEvent>;
     /** Open a subscription with retries */
-    subscription(filters: Filter | Filter[], opts?: {
+    subscription(filters: FilterInput, opts?: {
         id?: string;
         retries?: number;
     }): Observable<SubscriptionResponse>;
@@ -82,7 +84,7 @@ export interface IPool {
     /** Send an EVENT message */
     event(relays: string[], event: NostrEvent): Observable<PublishResponse>;
     /** Send a REQ message */
-    req(relays: string[], filters: Filter | Filter[], id?: string): Observable<SubscriptionResponse>;
+    req(relays: string[], filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
     /** Get or create a relay */
     relay(url: string): IRelay;
     /** Create a relay group */
@@ -92,12 +94,12 @@ export interface IPool {
         retries?: number;
     }): Observable<PublishResponse>;
     /** Send a REQ message to relays with retries */
-    request(relays: string[], filters: Filter | Filter[], opts?: {
+    request(relays: string[], filters: FilterInput, opts?: {
         id?: string;
         retries?: number;
     }): Observable<NostrEvent>;
     /** Open a subscription to relays with retries */
-    subscription(relays: string[], filters: Filter | Filter[], opts?: {
+    subscription(relays: string[], filters: FilterInput, opts?: {
         id?: string;
         retries?: number;
     }): Observable<SubscriptionResponse>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-relay",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "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.0.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__/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 {};