applesauce-relay 0.12.0 → 1.0.1

package/dist/relay.js

@@ -1,115 +1,283 @@
-import { BehaviorSubject, combineLatest, EMPTY, filter, map, merge, NEVER, of, shareReplay, switchMap, take, takeWhile, tap, timeout, } from "rxjs";
-import { webSocket } from "rxjs/webSocket";
-import { nanoid } from "nanoid";
 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 { webSocket } from "rxjs/webSocket";
+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 */
+export class ReqCloseError extends Error {
+}
 export class Relay {
     url;
-    log = logger.extend("Bakery");
-    socket$;
+    log = logger.extend("Relay");
+    socket;
+    /** Whether the relay is ready for subscriptions or event publishing. setting this to false will cause all .req and .event observables to hang until the relay is ready */
+    ready$ = new BehaviorSubject(true);
+    /** A method that returns an Observable that emits when the relay should reconnect */
+    reconnectTimer;
+    /** How many times the relay has tried to reconnect */
+    attempts$ = new BehaviorSubject(0);
+    /** Whether the relay is connected */
     connected$ = new BehaviorSubject(false);
-    challenge$;
+    /** The authentication challenge string from the relay */
+    challenge$ = new BehaviorSubject(null);
+    /** Whether the client is authenticated with the relay */
     authenticated$ = new BehaviorSubject(false);
-    notices$;
-    authRequiredForReq = new BehaviorSubject(false);
-    authRequiredForPublish = new BehaviorSubject(false);
-    reset() {
-        this.authenticated$.next(false);
-        this.authRequiredForReq.next(false);
-        this.authRequiredForPublish.next(false);
+    /** The notices from the relay */
+    notices$ = new BehaviorSubject([]);
+    /** 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;
+    }
+    get challenge() {
+        return this.challenge$.value;
     }
+    get notices() {
+        return this.notices$.value;
+    }
+    get authenticated() {
+        return this.authenticated$.value;
+    }
+    get information() {
+        return this._nip11;
+    }
+    /** If an EOSE message is not seen in this time, emit one locally  */
+    eoseTimeout = 10_000;
+    /** How long to wait for an OK message from the relay */
+    eventTimeout = 10_000;
+    /** How long to keep the connection alive after nothing is subscribed */
+    keepAlive = 30_000;
+    // subjects that track if an "auth-required" message has been received for REQ or EVENT
+    receivedAuthRequiredForReq = new BehaviorSubject(false);
+    receivedAuthRequiredForEvent = new BehaviorSubject(false);
+    // Computed observables that track if auth is required for REQ or EVENT
+    authRequiredForReq;
+    authRequiredForEvent;
+    resetState() {
+        // NOTE: only update the values if they need to be changed, otherwise this will cause an infinite loop
+        if (this.challenge$.value !== null)
+            this.challenge$.next(null);
+        if (this.authenticated$.value)
+            this.authenticated$.next(false);
+        if (this.notices$.value.length > 0)
+            this.notices$.next([]);
+        if (this.receivedAuthRequiredForReq.value)
+            this.receivedAuthRequiredForReq.next(false);
+        if (this.receivedAuthRequiredForEvent.value)
+            this.receivedAuthRequiredForEvent.next(false);
+    }
+    /** An internal observable that is responsible for watching all messages and updating state */
+    watchTower;
     constructor(url, opts) {
         this.url = url;
         this.log = this.log.extend(url);
-        this.socket$ = webSocket({
+        /** Use the static method to create a new reconnect method for this relay */
+        this.reconnectTimer = Relay.createReconnectTimer(url);
+        this.socket = webSocket({
             url,
             openObserver: {
                 next: () => {
                     this.log("Connected");
                     this.connected$.next(true);
-                    this.reset();
+                    this.attempts$.next(0);
+                    this.resetState();
                 },
             },
             closeObserver: {
-                next: () => {
+                next: (event) => {
                     this.log("Disconnected");
                     this.connected$.next(false);
-                    this.reset();
+                    this.attempts$.next(this.attempts$.value + 1);
+                    this.resetState();
+                    // Start the reconnect timer if the connection was not closed cleanly
+                    if (!event.wasClean)
+                        this.startReconnectTimer(event);
                 },
             },
             WebSocketCtor: opts?.WebSocket,
         });
-        // create an observable for listening for AUTH
-        this.challenge$ = this.socket$.pipe(
-        // listen for AUTH messages
-        filter((message) => message[0] === "AUTH"), 
-        // pick the challenge string out
-        map((m) => m[1]), 
-        // cache and share the challenge
-        shareReplay(1));
-        this.notices$ = this.socket$.pipe(
+        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");
+            return Relay.fetchInformationDocument(this.url);
+        }).pipe(
+        // if the fetch fails, return null
+        catchError(() => of(null)), 
+        // cache the result
+        shareReplay(1), 
+        // update the internal state
+        tap((info) => (this._nip11 = info)));
+        this.limitations$ = this.information$.pipe(map((info) => info?.limitation));
+        // 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(
         // listen for NOTICE messages
         filter((m) => m[0] === "NOTICE"), 
         // pick the string out of the message
         map((m) => m[1]));
+        // Update the notices state
+        const notice = this.notice$.pipe(
+        // 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(
+        // listen for AUTH messages
+        filter((message) => message[0] === "AUTH"), 
+        // pick the challenge string out
+        map((m) => m[1]), 
+        // Update the challenge state
+        tap((challenge) => {
+            this.log("Received AUTH challenge", challenge);
+            this.challenge$.next(challenge);
+        }));
+        // 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(
+            // Never emit any values
+            ignoreElements(), 
+            // Start the reconnect timer if the connection has an error
+            catchError((error) => {
+                this.startReconnectTimer(error instanceof Error ? error : new Error("Connection error"));
+                return NEVER;
+            }), 
+            // Add keep alive timer to the connection
+            share({ resetOnRefCountZero: () => timer(this.keepAlive) }));
+        }), 
+        // There should only be a single watch tower
+        share());
     }
-    waitForAuth(requireAuth, observable) {
+    /** Set ready = false and start the reconnect timer */
+    startReconnectTimer(error) {
+        if (!this.ready$.value)
+            return;
+        this.ready$.next(false);
+        this.reconnectTimer(error, this.attempts$.value)
+            .pipe(take(1))
+            .subscribe(() => this.ready$.next(true));
+    }
+    /** Wait for ready and authenticated */
+    waitForAuth(
+    // NOTE: require BehaviorSubject so it always has a value
+    requireAuth, observable) {
         return combineLatest([requireAuth, this.authenticated$]).pipe(
-        // return EMPTY if auth is required and not authenticated
-        switchMap(([required, authenticated]) => {
-            if (required && !authenticated)
-                return EMPTY;
-            else
-                return observable;
-        }));
+        // wait for auth not required or authenticated
+        filter(([required, authenticated]) => !required || authenticated), 
+        // complete after the first value so this does not repeat
+        take(1), 
+        // switch to the observable
+        switchMap(() => observable));
+    }
+    /** Wait for the relay to be ready to accept connections */
+    waitForReady(observable) {
+        // Don't wait if the relay is already ready
+        if (this.ready$.value)
+            return observable;
+        else
+            return this.ready$.pipe(
+            // wait for ready to be true
+            filter((ready) => ready), 
+            // complete after the first value so this does not repeat
+            take(1), 
+            // switch to the observable
+            switchMap(() => observable));
+    }
+    multiplex(open, close, filter) {
+        return this.socket.multiplex(open, close, filter);
+    }
+    /** Send a message to the relay */
+    next(message) {
+        this.socket.next(message);
     }
+    /** Create a REQ observable that emits events or "EOSE" or errors */
     req(filters, id = nanoid()) {
-        return this.waitForAuth(this.authRequiredForReq, this.socket$
-            .multiplex(() => ["REQ", id, ...filters], () => ["CLOSE", id], (message) => (message[0] === "EVENT" || message[0] === "CLOSE" || message[0] === "EOSE") && message[1] === id)
-            .pipe(
-        // listen for CLOSE auth-required
-        tap((m) => {
-            if (m[0] === "CLOSE" && m[1].startsWith("auth-required") && !this.authRequiredForReq.value) {
-                this.authRequiredForReq.next(true);
-            }
-        }), 
-        // complete when CLOSE is sent
-        takeWhile((m) => m[0] !== "CLOSE"), 
-        // pick event out of EVENT messages
+        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(
+        // Map the messages to events, EOSE, or throw an error
         map((message) => {
             if (message[0] === "EOSE")
                 return "EOSE";
+            else if (message[0] === "CLOSED")
+                throw new ReqCloseError(message[2]);
             else
                 return message[2];
+        }), catchError((error) => {
+            // Set REQ auth required if the REQ is closed with auth-required
+            if (error instanceof ReqCloseError &&
+                error.message.startsWith("auth-required") &&
+                !this.receivedAuthRequiredForReq.value) {
+                this.log("Auth required for REQ");
+                this.receivedAuthRequiredForReq.next(true);
+            }
+            // Pass the error through
+            return throwError(() => error);
         }), 
         // mark events as from relays
         markFromRelay(this.url), 
         // if no events are seen in 10s, emit EOSE
+        // TODO: this should emit EOSE event if events are seen, the timeout should be for only the EOSE message
         timeout({
-            first: 10_000,
+            first: this.eoseTimeout,
             with: () => merge(of("EOSE"), NEVER),
-        })));
+        }), 
+        // Only create one upstream subscription
+        share());
+        // Wait for auth if required and make sure to start the watch tower
+        return this.waitForReady(this.waitForAuth(this.authRequiredForReq, observable));
     }
-    /** send an Event message */
+    /** Send an EVENT or AUTH message and return an observable of PublishResponse that completes or errors */
     event(event, verb = "EVENT") {
-        const observable = this.socket$
-            .multiplex(() => [verb, event], () => void 0, (m) => m[0] === "OK" && m[1] === event.id)
-            .pipe(
-        // format OK message
-        map((m) => ({ ok: m[2], message: m[3], from: this.url })), 
+        const base = defer(() => {
+            // Send event when subscription starts
+            this.socket.next([verb, event]);
+            return this.socket.pipe(filter((m) => m[0] === "OK" && m[1] === event.id), 
+            // 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(
         // complete on first value
         take(1), 
         // listen for OK auth-required
         tap(({ ok, message }) => {
-            if (ok === false && message.startsWith("auth-required") && !this.authRequiredForPublish.value) {
-                this.authRequiredForPublish.next(true);
+            if (ok === false && message?.startsWith("auth-required") && !this.receivedAuthRequiredForEvent.value) {
+                this.log("Auth required for publish");
+                this.receivedAuthRequiredForEvent.next(true);
             }
-        }));
+        }), 
+        // if no message is seen in 10s, emit EOSE
+        timeout({
+            first: this.eventTimeout,
+            with: () => of({ ok: false, from: this.url, message: "Timeout" }),
+        }), 
+        // Only create one upstream subscription
+        share());
         // skip wait for auth if verb is AUTH
         if (verb === "AUTH")
-            return observable;
+            return this.waitForReady(observable);
         else
-            return this.waitForAuth(this.authRequiredForPublish, observable);
+            return this.waitForReady(this.waitForAuth(this.authRequiredForEvent, observable));
     }
     /** send and AUTH message */
     auth(event) {
@@ -117,4 +285,55 @@ export class Relay {
         // update authenticated
         tap((result) => this.authenticated$.next(result.ok)));
     }
+    /** Authenticate with the relay using a signer */
+    authenticate(signer) {
+        if (!this.challenge)
+            throw new Error("Have not received authentication challenge");
+        const p = signer.signEvent(nip42.makeAuthEvent(this.url, this.challenge));
+        const start = p instanceof Promise ? from(p) : of(p);
+        return start.pipe(switchMap((event) => this.auth(event)));
+    }
+    /** Creates a REQ that retries when relay errors ( default 3 retries ) */
+    subscription(filters, opts) {
+        return this.req(filters, opts?.id).pipe(
+        // Retry on connection errors
+        retry({ count: opts?.retries ?? 3, resetOnSuccess: true }));
+    }
+    /** Makes a single request that retires on errors and completes on EOSE */
+    request(filters, opts) {
+        return this.req(filters, opts?.id).pipe(
+        // Retry on connection errors
+        retry(opts?.retries ?? 3), 
+        // Complete when EOSE is received
+        completeOnEose());
+    }
+    /** Publishes an event to the relay and retries when relay errors or responds with auth-required ( default 3 retries ) */
+    publish(event, opts) {
+        return this.event(event).pipe(mergeMap((result) => {
+            // If the relay responds with auth-required, throw an error for the retry operator to handle
+            if (result.ok === false && result.message?.startsWith("auth-required:"))
+                return throwError(() => new Error(result.message));
+            return of(result);
+        }), 
+        // Retry the publish until it succeeds or the number of retries is reached
+        retry(opts?.retries ?? 3));
+    }
+    /** 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(
+        // if the fetch fails, return null
+        catchError(() => of(null)), 
+        // timeout after 10s
+        simpleTimeout(10_000));
+    }
+    /** Static method to create a reconnection method for each relay */
+    static createReconnectTimer(_relay) {
+        return (_error, tries = 0) => {
+            // Calculate delay with exponential backoff: 2^attempts * 1000ms
+            // with a maximum delay of 5 minutes (300000ms)
+            const delay = Math.min(Math.pow(1.5, tries) * 1000, 300000);
+            // Return a timer that will emit after the calculated delay
+            return timer(delay);
+        };
+    }
 }

package/dist/types.d.ts

@@ -0,0 +1,104 @@
+import { EventTemplate, Filter, NostrEvent } from "nostr-tools";
+import { Observable } from "rxjs";
+import { WebSocketSubject } from "rxjs/webSocket";
+export type SubscriptionResponse = NostrEvent | "EOSE";
+export type PublishResponse = {
+    ok: boolean;
+    message?: string;
+    from: string;
+};
+export type MultiplexWebSocket<T = any> = Pick<WebSocketSubject<T>, "multiplex">;
+export interface IRelayState {
+    connected$: Observable<boolean>;
+    challenge$: Observable<string | null>;
+    authenticated$: Observable<boolean>;
+    notices$: Observable<string[]>;
+}
+export type PublishOptions = {
+    retries?: number;
+};
+export type RequestOptions = {
+    id?: string;
+    retries?: number;
+};
+export type SubscriptionOptions = {
+    id?: string;
+    retries?: number;
+};
+export type AuthSigner = {
+    signEvent: (event: EventTemplate) => NostrEvent | Promise<NostrEvent>;
+};
+export interface Nip01Actions {
+    /** Send an EVENT message */
+    event(event: NostrEvent): Observable<PublishResponse>;
+    /** Send a REQ message */
+    req(filters: Filter | Filter[], id?: string): Observable<SubscriptionResponse>;
+}
+export interface IRelay extends MultiplexWebSocket, Nip01Actions, IRelayState {
+    url: string;
+    message$: Observable<any>;
+    notice$: Observable<string>;
+    readonly connected: boolean;
+    readonly authenticated: boolean;
+    readonly challenge: string | null;
+    readonly notices: string[];
+    /** Send an AUTH message */
+    auth(event: NostrEvent): Observable<{
+        ok: boolean;
+        message?: string;
+    }>;
+    /** Send an EVENT message with retries */
+    publish(event: NostrEvent, opts?: {
+        retries?: number;
+    }): Observable<PublishResponse>;
+    /** Send a REQ message with retries */
+    request(filters: Filter | Filter[], opts?: {
+        id?: string;
+        retries?: number;
+    }): Observable<NostrEvent>;
+    /** Open a subscription with retries */
+    subscription(filters: Filter | Filter[], opts?: {
+        id?: string;
+        retries?: number;
+    }): Observable<SubscriptionResponse>;
+}
+export interface IGroup extends Nip01Actions {
+    /** Send an EVENT message with retries */
+    publish(event: NostrEvent, opts?: {
+        retries?: number;
+    }): Observable<PublishResponse[]>;
+    /** Send a REQ message with retries */
+    request(filters: Filter | Filter[], opts?: {
+        id?: string;
+        retries?: number;
+    }): Observable<NostrEvent>;
+    /** Open a subscription with retries */
+    subscription(filters: Filter | Filter[], opts?: {
+        id?: string;
+        retries?: number;
+    }): Observable<SubscriptionResponse>;
+}
+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>;
+    /** Get or create a relay */
+    relay(url: string): IRelay;
+    /** Create a relay group */
+    group(relays: string[]): IGroup;
+    /** Send an EVENT message to relays with retries */
+    publish(relays: string[], event: NostrEvent, opts?: {
+        retries?: number;
+    }): Observable<PublishResponse[]>;
+    /** Send a REQ message to relays with retries */
+    request(relays: string[], filters: Filter | Filter[], opts?: {
+        id?: string;
+        retries?: number;
+    }): Observable<NostrEvent>;
+    /** Open a subscription to relays with retries */
+    subscription(relays: string[], filters: Filter | Filter[], opts?: {
+        id?: string;
+        retries?: number;
+    }): Observable<SubscriptionResponse>;
+}

package/dist/types.js

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "applesauce-relay",
-  "version": "0.12.0",
-  "description": "A collection of observable based loaders built on rx-nostr",
+  "version": "1.0.1",
+  "description": "nostr relay communication framework built on rxjs",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -21,6 +21,21 @@
       "require": "./dist/index.js",
       "types": "./dist/index.d.ts"
     },
+    "./pool": {
+      "import": "./dist/pool.js",
+      "require": "./dist/pool.js",
+      "types": "./dist/pool.d.ts"
+    },
+    "./relay": {
+      "import": "./dist/relay.js",
+      "require": "./dist/relay.js",
+      "types": "./dist/relay.d.ts"
+    },
+    "./types": {
+      "import": "./dist/types.js",
+      "require": "./dist/types.js",
+      "types": "./dist/types.d.ts"
+    },
     "./operators": {
       "import": "./dist/operators/index.js",
       "require": "./dist/operators/index.js",
@@ -30,19 +45,26 @@
       "import": "./dist/operators/*.js",
       "require": "./dist/operators/*.js",
       "types": "./dist/operators/*.d.ts"
+    },
+    "./negentropy": {
+      "import": "./dist/negentropy.js",
+      "require": "./dist/negentropy.js",
+      "types": "./dist/negentropy.d.ts"
     }
   },
   "dependencies": {
-    "applesauce-core": "^0.12.0",
+    "@noble/hashes": "^1.7.1",
+    "applesauce-core": "^1.0.0",
     "nanoid": "^5.0.9",
     "nostr-tools": "^2.10.4",
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
+    "@hirez_io/observer-spy": "^2.2.0",
+    "@vitest/expect": "^3.1.1",
     "typescript": "^5.7.3",
-    "vitest": "^3.0.5",
-    "vitest-nostr": "^0.4.1",
-    "vitest-websocket-mock": "^0.4.0"
+    "vitest": "^3.1.1",
+    "vitest-websocket-mock": "^0.5.0"
   },
   "funding": {
     "type": "lightning",