applesauce-relay 6.0.0 → 6.0.2

package/dist/pool.js

@@ -46,6 +46,7 @@ export class RelayPool {
         relay = new Relay(url, this.options);
         this.relays.set(url, relay);
         this.relays$.next(this.relays);
+        this.add$.next(relay);
         return relay;
     }
     /** Create a group of relays */

package/dist/relay.d.ts

@@ -42,10 +42,10 @@ export type RelayOptions = {
         now: number;
         attempts: number;
     }) => "reconnect" | "close" | "ignore";
-    /** Default reconnect config for subscription() method */
-    subscriptionReconnect?: RetryConfig;
-    /** Default reconnect config for request() method */
-    requestReconnect?: RetryConfig;
+    /** Default retry count or config for subscription() connection errors (default: 3) */
+    subscriptionReconnect?: number | RetryConfig;
+    /** Default retry count or config for request() connection errors (default: 3) */
+    requestReconnect?: number | RetryConfig;
     /** Default retry config for publish() method */
     publishRetry?: RetryConfig;
 };
@@ -134,9 +134,9 @@ export declare class Relay {
     pingFrequency: number;
     /** How long to wait for EOSE response in milliseconds (default 20000) */
     pingTimeout: number;
-    /** Default reconnect config for subscription() method */
+    /** Default retry config for subscription() connection errors */
     subscriptionReconnect: RetryConfig;
-    /** Default reconnect config for request() method */
+    /** Default retry config for request() connection errors */
     requestReconnect: RetryConfig;
     /** Default retry config for publish() method */
     publishRetry: RetryConfig;
@@ -159,7 +159,12 @@ export declare class Relay {
     multiplex<T>(open: () => any, close: () => any, filter: (message: any) => boolean): Observable<T>;
     /** Send a message to the relay */
     send(message: any): void;
-    /** Create a REQ observable that emits events or "EOSE" or errors */
+    /**
+     * Create a REQ observable that emits OPEN, EVENT, EOSE, and CLOSED messages.
+     *
+     * `resubscribe` only repeats after the relay sends a clean CLOSED message for this REQ.
+     * `reconnect` only retries connection errors and does not retry relay CLOSED errors.
+     */
     req(filters: FilterInput, opts?: RelayReqOptions): Observable<RelayReqMessage>;
     /** Create a COUNT observable that emits a single count response */
     count(filters: Filter | Filter[], id?: string): Observable<RelayCountResponse>;
@@ -171,15 +176,17 @@ export declare class Relay {
     negentropy(store: NegentropyReadStore, filter: Filter, reconcile: ReconcileFunction, opts?: NegentropySyncOptions): Promise<boolean>;
     /** Authenticate with the relay using a signer */
     authenticate(signer: AuthSigner): Promise<PublishResponse>;
-    /** Internal operator for creating the retry() operator for reconnecting to the websocket */
+    /** Internal operator for creating a retry() operator */
     protected customRetryOperator<T extends unknown = unknown>(times: undefined | boolean | number | RetryConfig, base?: RetryConfig): MonoTypeOperatorFunction<T>;
-    /** Internal operator for creating the repeat() operator for resubscribing */
-    protected customRepeatOperator<T extends unknown = unknown>(times: undefined | boolean | number | RepeatConfig | undefined): MonoTypeOperatorFunction<T>;
+    /** Internal operator for retrying connection failures without retrying relay CLOSED errors */
+    protected customConnectionRetryOperator<T extends unknown = unknown>(times: undefined | boolean | number | RetryConfig, base?: RetryConfig): MonoTypeOperatorFunction<T>;
+    /** Internal operator for creating the repeat() operator, optionally gated by a condition */
+    protected customRepeatOperator<T extends unknown = unknown>(times: undefined | boolean | number | RepeatConfig | undefined, condition?: () => boolean): MonoTypeOperatorFunction<T>;
     /** Internal operator for creating the timeout() operator */
     protected customTimeoutOperator<T extends unknown = unknown>(timeout: undefined | boolean | number, defaultTimeout: number): MonoTypeOperatorFunction<T>;
-    /** Creates a REQ that retries when relay errors ( default 3 retries ) */
+    /** Creates a persistent REQ that retries connection errors (default 3 retries) */
     subscription(filters: FilterInput, opts?: RelaySubscriptionOptions): Observable<RelaySubscriptionResponse>;
-    /** Makes a single request that retires on errors and completes on EOSE */
+    /** Makes a single request that retries connection errors and completes on EOSE */
     request(filters: FilterInput, opts?: RelayRequestOptions): Observable<RelayRequestResponse>;
     /** Publishes an event to the relay and retries when relay errors or responds with auth-required ( default 3 retries ) */
     publish(event: NostrEvent, opts?: PublishOptions): Promise<PublishResponse>;

package/dist/relay.js

@@ -4,16 +4,21 @@ import { ensureHttpURL } from "applesauce-core/helpers/url";
 import { mapEventsToStore, simpleTimeout } from "applesauce-core/observable";
 import { nanoid } from "nanoid";
 import { makeAuthEvent } from "nostr-tools/nip42";
-import { BehaviorSubject, catchError, combineLatest, defer, endWith, filter, finalize, firstValueFrom, from, identity, ignoreElements, isObservable, lastValueFrom, map, merge, mergeMap, mergeWith, NEVER, Observable, of, repeat, retry, scan, share, shareReplay, startWith, Subject, switchMap, take, takeUntil, takeWhile, tap, throwError, timeout, timer, } from "rxjs";
+import { BehaviorSubject, catchError, combineLatest, defer, EMPTY, endWith, filter, finalize, firstValueFrom, from, identity, ignoreElements, isObservable, lastValueFrom, map, merge, mergeMap, mergeWith, NEVER, Observable, of, repeat, retry, scan, share, shareReplay, startWith, Subject, switchMap, take, takeUntil, takeWhile, tap, throwError, timeout, timer, } from "rxjs";
 import { webSocket } from "rxjs/webSocket";
 import { completeWhen } from "./operators/complete-when.js";
 const AUTH_REQUIRED_PREFIX = "auth-required:";
-/** Default retry subscription, request, and publish. linear backoff */
+/** Default reconnect/retry config for request, subscription, and publish. linear backoff */
 const DEFAULT_RETRY_CONFIG = {
     count: 3,
     delay: (_err, count) => timer(count * 1000),
     resetOnSuccess: true,
 };
+function normalizeRetryConfig(config) {
+    if (typeof config === "number")
+        return { ...DEFAULT_RETRY_CONFIG, count: config };
+    return { ...DEFAULT_RETRY_CONFIG, ...(config ?? {}) };
+}
 /** Flags for the negentropy sync type */
 export var SyncDirection;
 (function (SyncDirection) {
@@ -174,9 +179,9 @@ export class Relay {
     pingFrequency = 29_000;
     /** How long to wait for EOSE response in milliseconds (default 20000) */
     pingTimeout = 20_000;
-    /** Default reconnect config for subscription() method */
+    /** Default retry config for subscription() connection errors */
     subscriptionReconnect;
-    /** Default reconnect config for request() method */
+    /** Default retry config for request() connection errors */
     requestReconnect;
     /** Default retry config for publish() method */
     publishRetry;
@@ -224,8 +229,8 @@ export class Relay {
         if (opts?.onUnresponsive !== undefined)
             this.onUnresponsive = opts.onUnresponsive;
         // Set retry configs
-        this.subscriptionReconnect = { ...DEFAULT_RETRY_CONFIG, ...(opts?.subscriptionReconnect ?? {}) };
-        this.requestReconnect = { ...DEFAULT_RETRY_CONFIG, ...(opts?.requestReconnect ?? {}) };
+        this.subscriptionReconnect = normalizeRetryConfig(opts?.subscriptionReconnect);
+        this.requestReconnect = normalizeRetryConfig(opts?.requestReconnect);
         this.publishRetry = { ...DEFAULT_RETRY_CONFIG, ...(opts?.publishRetry ?? {}) };
         // Create an observable that tracks boolean authentication state
         this.authenticated$ = this.authenticationResponse$.pipe(map((response) => response?.ok === true));
@@ -461,7 +466,12 @@ export class Relay {
     send(message) {
         this.socket.next(message);
     }
-    /** Create a REQ observable that emits events or "EOSE" or errors */
+    /**
+     * Create a REQ observable that emits OPEN, EVENT, EOSE, and CLOSED messages.
+     *
+     * `resubscribe` only repeats after the relay sends a clean CLOSED message for this REQ.
+     * `reconnect` only retries connection errors and does not retry relay CLOSED errors.
+     */
     req(filters, opts) {
         const id = opts?.id ?? nanoid();
         const waitForAuth = opts?.waitForAuth ?? true;
@@ -479,6 +489,7 @@ export class Relay {
         const filtersComplete = input.pipe(ignoreElements(), endWith(true));
         // Track whether the relay already sent CLOSED so we skip the redundant client CLOSE
         let relayClosedSub = false;
+        let shouldResubscribe = false;
         // 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), 
         // Map NIP-01 messages to RelayReqMessage
@@ -497,6 +508,7 @@ export class Relay {
                 const error = parseClosedError(m.reason);
                 if (error)
                     throw error;
+                shouldResubscribe = true;
             }
         }), 
         // Complete the stream on unprefixed CLOSED, emitting the CLOSED message last (inclusive)
@@ -509,6 +521,7 @@ export class Relay {
         map((filters) => {
             // Reset closed flag on each new REQ (resubscribe cycles)
             relayClosedSub = false;
+            shouldResubscribe = false;
             this.socket.next(["REQ", id, ...filters]);
             // Add to tracking when REQ is sent
             this.reqs$.next({ ...this.reqs$.value, [id]: filters });
@@ -541,7 +554,7 @@ export class Relay {
         share());
         // Wait for auth only when enabled and make sure to start the watch tower
         const reqWithAuthStrategy = waitForAuth ? this.waitForAuth(this.authRequiredForRead$, observable) : observable;
-        return this.waitForReady(reqWithAuthStrategy).pipe(
+        return defer(() => this.waitForReady(reqWithAuthStrategy)).pipe(
         // Retry only auth-required errors, optionally waiting for authentication first
         retry({
             delay: (error) => {
@@ -558,8 +571,10 @@ export class Relay {
                 return this.authenticated$.pipe(filter((authenticated) => authenticated), take(1));
             },
         }), 
-        // Create resubscribe logic (repeat operator)
-        this.customRepeatOperator(opts?.resubscribe), 
+        // Retry connection errors independently from relay CLOSED errors
+        this.customConnectionRetryOperator(opts?.reconnect), 
+        // Resubscribe only after the relay cleanly CLOSED this REQ
+        this.customRepeatOperator(opts?.resubscribe, () => shouldResubscribe), 
         // Only create one upstream subscription
         share());
     }
@@ -679,7 +694,7 @@ export class Relay {
         const start = p instanceof Promise ? from(p) : of(p);
         return lastValueFrom(start.pipe(switchMap((event) => this.auth(event))));
     }
-    /** Internal operator for creating the retry() operator for reconnecting to the websocket */
+    /** Internal operator for creating a retry() operator */
     customRetryOperator(times, base) {
         if (times === false || times === undefined)
             return identity;
@@ -690,16 +705,45 @@ export class Relay {
         else
             return retry({ ...base, ...times });
     }
-    /** Internal operator for creating the repeat() operator for resubscribing */
-    customRepeatOperator(times) {
+    /** Internal operator for retrying connection failures without retrying relay CLOSED errors */
+    customConnectionRetryOperator(times, base) {
         if (times === false || times === undefined)
             return identity;
-        else if (times === true)
-            return repeat();
+        const config = typeof times === "number" ? { ...base, count: times } : times === true ? (base ?? {}) : { ...base, ...times };
+        return retry({
+            ...config,
+            delay: (error, count) => {
+                if (error instanceof RelayClosedError)
+                    return throwError(() => error);
+                if (typeof config.delay === "number")
+                    return timer(config.delay);
+                if (typeof config.delay === "function")
+                    return config.delay(error, count);
+                return of(null);
+            },
+        });
+    }
+    /** Internal operator for creating the repeat() operator, optionally gated by a condition */
+    customRepeatOperator(times, condition) {
+        if (times === false || times === undefined)
+            return identity;
+        const delay = (repeatCount) => {
+            if (condition && !condition())
+                return EMPTY;
+            if (typeof times === "object") {
+                if (typeof times.delay === "number")
+                    return timer(times.delay);
+                if (typeof times.delay === "function")
+                    return times.delay(repeatCount);
+            }
+            return of(null);
+        };
+        if (times === true)
+            return repeat({ delay });
         else if (typeof times === "number")
-            return repeat(times);
+            return repeat({ count: times, delay });
         else
-            return repeat(times);
+            return repeat({ ...times, delay });
     }
     /** Internal operator for creating the timeout() operator */
     customTimeoutOperator(timeout, defaultTimeout) {
@@ -713,7 +757,7 @@ export class Relay {
         else
             return simpleTimeout(timeout ?? defaultTimeout);
     }
-    /** Creates a REQ that retries when relay errors ( default 3 retries ) */
+    /** Creates a persistent REQ that retries connection errors (default 3 retries) */
     subscription(filters, opts) {
         return this.req(filters, {
             ...opts,
@@ -726,7 +770,7 @@ export class Relay {
         // Single subscription
         share());
     }
-    /** Makes a single request that retires on errors and completes on EOSE */
+    /** Makes a single request that retries connection errors and completes on EOSE */
     request(filters, opts) {
         const req = this.req(filters, {
             ...opts,

package/dist/types.d.ts

@@ -53,12 +53,12 @@ export type RelayReqOptions = {
      */
     waitForAuth?: boolean;
     /**
-     * Whether to resubscribe if the subscription is closed by the relay. default is false
+     * Whether to resubscribe after a clean CLOSED message from the relay. default is false
      * @see https://rxjs.dev/api/index/function/repeat
      */
     resubscribe?: boolean | number | Parameters<typeof repeat>[0];
     /**
-     * Whether to reconnect when socket is closed. default is true (3 retries with 1 second delay)
+     * Whether to retry connection errors. default is true (3 retries with linear backoff)
      * @see https://rxjs.dev/api/index/function/retry
      */
     reconnect?: boolean | number | Parameters<typeof retry>[0];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-relay",
-  "version": "6.0.0",
+  "version": "6.0.2",
   "description": "nostr relay communication framework built on rxjs",
   "type": "module",
   "main": "dist/index.js",