applesauce-relay 1.0.1 → 1.2.0

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

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

package/dist/__tests__/exports.test.js

@@ -0,0 +1,19 @@
+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__/pool.test.js

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

package/dist/__tests__/relay.test.js

@@ -4,7 +4,7 @@ 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";
+import { firstValueFrom, of, Subject, throwError, timer } from "rxjs";
 const defaultMockInfo = {
     name: "Test Relay",
     description: "Test Relay Description",
@@ -49,9 +49,7 @@ describe("req", () => {
     });
     it("should send expected messages to relay", async () => {
         subscribeSpyTo(relay.req([{ kinds: [1] }], "sub1"));
-        // Wait for all message to be sent
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(server.messages).toEqual([["REQ", "sub1", { kinds: [1] }]]);
+        await expect(server).toReceiveMessage(["REQ", "sub1", { kinds: [1] }]);
     });
     it("should not close the REQ when EOSE is received", async () => {
         // Create subscription that completes after first EOSE
@@ -210,6 +208,41 @@ describe("req", () => {
         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 () => {
@@ -356,9 +389,59 @@ describe("notices$", () => {
         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 () => {

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[]>;
+    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/group.js

@@ -1,5 +1,5 @@
 import { nanoid } from "nanoid";
-import { catchError, EMPTY, endWith, ignoreElements, merge, of, toArray } from "rxjs";
+import { catchError, EMPTY, endWith, ignoreElements, merge, of } from "rxjs";
 import { completeOnEose } from "./operators/complete-on-eose.js";
 import { onlyEvents } from "./operators/only-events.js";
 export class RelayGroup {
@@ -37,7 +37,7 @@ export class RelayGroup {
     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());
+        catchError((err) => of({ ok: false, from: relay.url, message: err?.message || "Unknown error" })))));
     }
     /** Request events from all relays with retries ( default 3 retries ) */
     request(filters, opts) {

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

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

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

@@ -0,0 +1,15 @@
+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",
+      ]
+    `);
+    });
+});

package/dist/pool.d.ts

@@ -1,25 +1,30 @@
-import { NostrEvent, type Filter } from "nostr-tools";
-import { Observable } from "rxjs";
+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;
-    relays: Map<string, Relay>;
-    groups: Map<string, RelayGroup>;
+    groups$: BehaviorSubject<Map<string, RelayGroup>>;
+    get groups(): Map<string, RelayGroup>;
+    relays$: BehaviorSubject<Map<string, Relay>>;
+    get relays(): Map<string, Relay>;
+    /** An array of relays to never connect to */
+    blacklist: Set<string>;
     constructor(options?: RelayOptions | undefined);
+    protected filterBlacklist(urls: string[]): string[];
     /** Get or create a new relay connection */
     relay(url: string): Relay;
     /** 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[]>;
+    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,31 +1,53 @@
+import { BehaviorSubject } from "rxjs";
 import { RelayGroup } from "./group.js";
 import { Relay } from "./relay.js";
+import { normalizeURL } from "applesauce-core/helpers";
 export class RelayPool {
     options;
-    relays = new Map();
-    groups = new Map();
+    groups$ = new BehaviorSubject(new Map());
+    get groups() {
+        return this.groups$.value;
+    }
+    relays$ = new BehaviorSubject(new Map());
+    get relays() {
+        return this.relays$.value;
+    }
+    /** An array of relays to never connect to */
+    blacklist = new Set();
     constructor(options) {
         this.options = options;
     }
+    filterBlacklist(urls) {
+        return urls.filter((url) => !this.blacklist.has(url));
+    }
     /** 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.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);
         if (group)
             return group;
         group = new RelayGroup(relays.map((url) => this.relay(url)));
-        this.groups.set(key, group);
+        this.groups$.next(this.groups.set(key, group));
         return group;
     }
     /** Make a REQ to multiple relays that does not deduplicate events */

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 {
 }
@@ -28,15 +28,23 @@ export declare class Relay implements IRelay {
     authenticated$: BehaviorSubject<boolean>;
     /** The notices from the relay */
     notices$: BehaviorSubject<string[]>;
+    /** The last connection error */
+    error$: BehaviorSubject<Error | null>;
+    /**
+     * A passive observable of all messages from the relay
+     * @note Subscribing to this will not connect to the relay
+     */
+    message$: Observable<any>;
+    /**
+     * A passive observable of NOTICE messages from the relay
+     * @note Subscribing to this will not connect to the relay
+     */
+    notice$: Observable<string>;
     /** An observable that emits the NIP-11 information document for the relay */
     information$: Observable<RelayInformation | null>;
     protected _nip11: RelayInformation | null;
     /** An observable that emits the limitations for the relay */
     limitations$: Observable<RelayInformation["limitation"] | null>;
-    /** An observable of all messages from the relay */
-    message$: Observable<any>;
-    /** An observable of NOTICE messages from the relay */
-    notice$: Observable<string>;
     get connected(): boolean;
     get challenge(): string | null;
     get notices(): string[];
@@ -66,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, switchMap, take, tap, throwError, timeout, timer, } from "rxjs";
+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 { webSocket } from "rxjs/webSocket";
 import { completeOnEose } from "./operators/complete-on-eose.js";
 import { markFromRelay } from "./operators/mark-from-relay.js";
@@ -27,15 +27,23 @@ export class Relay {
     authenticated$ = new BehaviorSubject(false);
     /** The notices from the relay */
     notices$ = new BehaviorSubject([]);
+    /** The last connection error */
+    error$ = new BehaviorSubject(null);
+    /**
+     * A passive observable of all messages from the relay
+     * @note Subscribing to this will not connect to the relay
+     */
+    message$;
+    /**
+     * A passive observable of NOTICE messages from the relay
+     * @note Subscribing to this will not connect to the relay
+     */
+    notice$;
     /** An observable that emits the NIP-11 information document for the relay */
     information$;
     _nip11 = null;
     /** An observable that emits the limitations for the relay */
     limitations$;
-    /** An observable of all messages from the relay */
-    message$;
-    /** An observable of NOTICE messages from the relay */
-    notice$;
     // sync state
     get connected() {
         return this.connected$.value;
@@ -91,6 +99,7 @@ export class Relay {
                     this.log("Connected");
                     this.connected$.next(true);
                     this.attempts$.next(0);
+                    this.error$.next(null);
                     this.resetState();
                 },
             },
@@ -107,7 +116,6 @@ export class Relay {
             },
             WebSocketCtor: opts?.WebSocket,
         });
-        this.message$ = this.socket.asObservable();
         // Create an observable to fetch the NIP-11 information document
         this.information$ = defer(() => {
             this.log("Fetching NIP-11 information document");
@@ -123,19 +131,18 @@ export class Relay {
         // Create observables that track if auth is required for REQ or EVENT
         this.authRequiredForReq = combineLatest([this.receivedAuthRequiredForReq, this.limitations$]).pipe(map(([received, limitations]) => received || limitations?.auth_required === true), tap((required) => required && this.log("Auth required for REQ")), shareReplay(1));
         this.authRequiredForEvent = combineLatest([this.receivedAuthRequiredForEvent, this.limitations$]).pipe(map(([received, limitations]) => received || limitations?.auth_required === true), tap((required) => required && this.log("Auth required for EVENT")), shareReplay(1));
-        this.notice$ = this.message$.pipe(
+        // Update the notices state
+        const listenForNotice = this.socket.pipe(
         // listen for NOTICE messages
-        filter((m) => m[0] === "NOTICE"), 
+        filter((m) => Array.isArray(m) && m[0] === "NOTICE"), 
         // pick the string out of the message
-        map((m) => m[1]));
-        // Update the notices state
-        const notice = this.notice$.pipe(
+        map((m) => m[1]), 
         // Track all notices
         scan((acc, notice) => [...acc, notice], []), 
         // Update the notices state
         tap((notices) => this.notices$.next(notices)));
         // Update the challenge state
-        const challenge = this.message$.pipe(
+        const ListenForChallenge = this.socket.pipe(
         // listen for AUTH messages
         filter((message) => message[0] === "AUTH"), 
         // pick the challenge string out
@@ -145,12 +152,21 @@ export class Relay {
             this.log("Received AUTH challenge", challenge);
             this.challenge$.next(challenge);
         }));
+        const allMessagesSubject = new Subject();
+        const listenForAllMessages = this.socket.pipe(tap((message) => allMessagesSubject.next(message)));
+        // Create passive observables for messages and notices
+        this.message$ = allMessagesSubject.asObservable();
+        this.notice$ = this.message$.pipe(
+        // listen for NOTICE messages
+        filter((m) => Array.isArray(m) && m[0] === "NOTICE"), 
+        // pick the string out of the message
+        map((m) => m[1]));
         // Merge all watchers
         this.watchTower = this.ready$.pipe(switchMap((ready) => {
             if (!ready)
                 return NEVER;
             // Only start the watch tower if the relay is ready
-            return merge(notice, challenge, this.information$).pipe(
+            return merge(listenForAllMessages, listenForNotice, ListenForChallenge, this.information$).pipe(
             // Never emit any values
             ignoreElements(), 
             // Start the reconnect timer if the connection has an error
@@ -168,6 +184,7 @@ export class Relay {
     startReconnectTimer(error) {
         if (!this.ready$.value)
             return;
+        this.error$.next(error instanceof Error ? error : new Error("Connection error"));
         this.ready$.next(false);
         this.reconnectTimer(error, this.attempts$.value)
             .pipe(take(1))
@@ -208,10 +225,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")

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>;
@@ -66,14 +68,14 @@ export interface IGroup extends Nip01Actions {
     /** Send an EVENT message with retries */
     publish(event: NostrEvent, opts?: {
         retries?: number;
-    }): Observable<PublishResponse[]>;
+    }): 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 */
@@ -90,14 +92,14 @@ export interface IPool {
     /** Send an EVENT message to relays with retries */
     publish(relays: string[], event: NostrEvent, opts?: {
         retries?: number;
-    }): Observable<PublishResponse[]>;
+    }): 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.0.1",
+  "version": "1.2.0",
   "description": "nostr relay communication framework built on rxjs",
   "type": "module",
   "main": "dist/index.js",
@@ -54,7 +54,7 @@
   },
   "dependencies": {
     "@noble/hashes": "^1.7.1",
-    "applesauce-core": "^1.0.0",
+    "applesauce-core": "^1.2.0",
     "nanoid": "^5.0.9",
     "nostr-tools": "^2.10.4",
     "rxjs": "^7.8.1"