applesauce-relay 0.12.0 → 1.0.1

package/dist/operators/index.js

@@ -1,2 +1,5 @@
-export * from "./only-events.js";
+export * from "./complete-on-eose.js";
 export * from "./mark-from-relay.js";
+export * from "./only-events.js";
+export * from "./store-events.js";
+export * from "./to-event-store.js";

package/dist/operators/mark-from-relay.d.ts

@@ -1,4 +1,4 @@
 import { MonoTypeOperatorFunction } from "rxjs";
-import { SubscriptionResponse } from "../relay.js";
+import { SubscriptionResponse } from "../types.js";
 /** Marks all events as from the relay */
 export declare function markFromRelay(relay: string): MonoTypeOperatorFunction<SubscriptionResponse>;

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

@@ -1,5 +1,5 @@
 import { OperatorFunction } from "rxjs";
 import { NostrEvent } from "nostr-tools";
-import { SubscriptionResponse } from "../relay.js";
+import { SubscriptionResponse } from "../types.js";
 /** Filter subscription responses and only return the events */
 export declare function onlyEvents(): OperatorFunction<SubscriptionResponse, NostrEvent>;

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

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

package/dist/operators/store-events.js

@@ -0,0 +1,7 @@
+import { tap } from "rxjs";
+/** Sends all events to the event store */
+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

@@ -0,0 +1,6 @@
+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 */
+export declare function toEventStore(eventStore: IEventStore): OperatorFunction<SubscriptionResponse, NostrEvent[]>;

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

@@ -0,0 +1,19 @@
+import { scan } from "rxjs";
+import { insertEventIntoDescendingList } from "nostr-tools/utils";
+import { completeOnEose } from "./complete-on-eose.js";
+/** Adds all events to event store and returns a deduplicated timeline when EOSE is received */
+export function toEventStore(eventStore) {
+    return (source) => source.pipe(
+    // Complete when there are not events
+    completeOnEose(), 
+    // 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);
+    }, []));
+}

package/dist/pool.d.ts

@@ -1,12 +1,25 @@
 import { NostrEvent, type Filter } from "nostr-tools";
 import { Observable } from "rxjs";
-import { Relay, PublishResponse, SubscriptionResponse } from "./relay.js";
-export declare class RelayPool {
+import { RelayGroup } from "./group.js";
+import { Relay, RelayOptions } from "./relay.js";
+import { IPool, PublishResponse, PublishOptions, RequestOptions, SubscriptionOptions, SubscriptionResponse } from "./types.js";
+export declare class RelayPool implements IPool {
+    options?: RelayOptions | undefined;
     relays: Map<string, Relay>;
+    groups: Map<string, RelayGroup>;
+    constructor(options?: RelayOptions | undefined);
     /** Get or create a new relay connection */
     relay(url: string): Relay;
-    /** Make a REQ to multiple relays but does not deduplicate events */
-    req(relays: string[], filters: Filter[], id?: string): Observable<SubscriptionResponse>;
+    /** 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>;
     /** Send an EVENT message to multiple relays */
-    event(relays: string[], event: NostrEvent): Observable<PublishResponse[]>;
+    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>;
+    /** Open a subscription to multiple relays */
+    subscription(relays: string[], filters: Filter | Filter[], opts?: SubscriptionOptions): Observable<SubscriptionResponse>;
 }

package/dist/pool.js

@@ -1,41 +1,51 @@
-import { combineLatest, endWith, ignoreElements, merge, takeWhile } from "rxjs";
-import { nanoid } from "nanoid";
+import { RelayGroup } from "./group.js";
 import { Relay } from "./relay.js";
-import { onlyEvents } from "./operators/only-events.js";
 export class RelayPool {
+    options;
     relays = new Map();
+    groups = new Map();
+    constructor(options) {
+        this.options = options;
+    }
     /** Get or create a new relay connection */
     relay(url) {
         let relay = this.relays.get(url);
         if (relay)
             return relay;
         else {
-            relay = new Relay(url);
+            relay = new Relay(url, this.options);
             this.relays.set(url, relay);
             return relay;
         }
     }
-    /** Make a REQ to multiple relays but does not deduplicate events */
-    req(relays, filters, id = nanoid()) {
-        // create a REQ observable for each relay
-        const requests = relays.map((url) => this.relay(url).req(filters, id));
-        // create an observable that completes when all relays send EOSE
-        const eose = merge(
-        // create an array of observables for each relay that completes when EOSE
-        ...requests.map((o) => o.pipe(
-        // complete on EOSE message
-        takeWhile((m) => m !== "EOSE")))).pipe(
-        // ignore all messages
-        ignoreElements(), 
-        // emit EOSE on complete
-        endWith("EOSE"));
-        // create a stream that only emits events
-        const events = merge(...requests).pipe(onlyEvents());
-        // merge events and single EOSE streams
-        return merge(events, eose);
+    /** Create a group of relays */
+    group(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);
+        return group;
+    }
+    /** Make a REQ to multiple relays that does not deduplicate events */
+    req(relays, filters, id) {
+        return this.group(relays).req(filters, id);
     }
     /** Send an EVENT message to multiple relays */
     event(relays, event) {
-        return combineLatest(relays.map((url) => this.relay(url).event(event)));
+        return this.group(relays).event(event);
+    }
+    /** Publish an event to multiple relays */
+    publish(relays, event, opts) {
+        return this.group(relays).publish(event, opts);
+    }
+    /** Request events from multiple relays */
+    request(relays, filters, opts) {
+        return this.group(relays).request(filters, opts);
+    }
+    /** Open a subscription to multiple relays */
+    subscription(relays, filters, opts) {
+        return this.group(relays).subscription(filters, opts);
     }
 }

package/dist/relay.d.ts

@@ -1,35 +1,86 @@
+import { logger } from "applesauce-core";
+import { type Filter, type NostrEvent } from "nostr-tools";
 import { BehaviorSubject, Observable } from "rxjs";
 import { WebSocketSubject, WebSocketSubjectConfig } from "rxjs/webSocket";
-import { type Filter, type NostrEvent } from "nostr-tools";
-import { logger } from "applesauce-core";
-export type SubscriptionResponse = "EOSE" | NostrEvent;
-export type PublishResponse = {
-    ok: boolean;
-    message?: string;
-    from: string;
-};
+import { RelayInformation } from "nostr-tools/nip11";
+import { AuthSigner, 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 {
+}
 export type RelayOptions = {
     WebSocket?: WebSocketSubjectConfig<any>["WebSocketCtor"];
 };
-export declare class Relay {
+export declare class Relay implements IRelay {
     url: string;
-    log: typeof logger;
-    socket$: WebSocketSubject<any>;
+    protected log: typeof logger;
+    protected socket: WebSocketSubject<any>;
+    /** 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 */
+    protected ready$: BehaviorSubject<boolean>;
+    /** A method that returns an Observable that emits when the relay should reconnect */
+    reconnectTimer: (error: CloseEvent | Error, attempts: number) => Observable<number>;
+    /** How many times the relay has tried to reconnect */
+    attempts$: BehaviorSubject<number>;
+    /** Whether the relay is connected */
     connected$: BehaviorSubject<boolean>;
-    challenge$: Observable<string>;
+    /** The authentication challenge string from the relay */
+    challenge$: BehaviorSubject<string | null>;
+    /** Whether the client is authenticated with the relay */
     authenticated$: BehaviorSubject<boolean>;
-    notices$: Observable<string>;
-    protected authRequiredForReq: BehaviorSubject<boolean>;
-    protected authRequiredForPublish: BehaviorSubject<boolean>;
-    protected reset(): void;
+    /** The notices from the relay */
+    notices$: BehaviorSubject<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[];
+    get authenticated(): boolean;
+    get information(): RelayInformation | null;
+    /** If an EOSE message is not seen in this time, emit one locally  */
+    eoseTimeout: number;
+    /** How long to wait for an OK message from the relay */
+    eventTimeout: number;
+    /** How long to keep the connection alive after nothing is subscribed */
+    keepAlive: number;
+    protected receivedAuthRequiredForReq: BehaviorSubject<boolean>;
+    protected receivedAuthRequiredForEvent: BehaviorSubject<boolean>;
+    protected authRequiredForReq: Observable<boolean>;
+    protected authRequiredForEvent: Observable<boolean>;
+    protected resetState(): void;
+    /** An internal observable that is responsible for watching all messages and updating state */
+    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 */
     protected waitForAuth<T extends unknown = unknown>(requireAuth: Observable<boolean>, observable: Observable<T>): Observable<T>;
-    req(filters: Filter[], id?: string): Observable<SubscriptionResponse>;
-    /** send an Event message */
+    /** Wait for the relay to be ready to accept connections */
+    protected waitForReady<T extends unknown = unknown>(observable: Observable<T>): Observable<T>;
+    multiplex<T>(open: () => any, close: () => any, filter: (message: any) => boolean): Observable<T>;
+    /** 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>;
+    /** 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 */
-    auth(event: NostrEvent): Observable<{
-        ok: boolean;
-        message?: string;
-    }>;
+    auth(event: NostrEvent): Observable<PublishResponse>;
+    /** Authenticate with the relay using a signer */
+    authenticate(signer: AuthSigner): Observable<PublishResponse>;
+    /** Creates a REQ that retries when relay errors ( default 3 retries ) */
+    subscription(filters: Filter | Filter[], opts?: SubscriptionOptions): Observable<SubscriptionResponse>;
+    /** Makes a single request that retires on errors and completes on EOSE */
+    request(filters: Filter | Filter[], opts?: RequestOptions): Observable<NostrEvent>;
+    /** Publishes an event to the relay and retries when relay errors or responds with auth-required ( default 3 retries ) */
+    publish(event: NostrEvent, opts?: PublishOptions): Observable<PublishResponse>;
+    /** Static method to fetch the NIP-11 information document for a relay */
+    static fetchInformationDocument(url: string): Observable<RelayInformation | null>;
+    /** Static method to create a reconnection method for each relay */
+    static createReconnectTimer(_relay: string): (_error?: Error | CloseEvent, tries?: number) => Observable<0>;
 }