applesauce-relay 0.11.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 hzrd149
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./pool.js";
+export * from "./relay.js";

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from "./pool.js";
+export * from "./relay.js";

package/dist/operators/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./only-events.js";
+export * from "./mark-from-relay.js";

package/dist/operators/index.js

@@ -0,0 +1,2 @@
+export * from "./only-events.js";
+export * from "./mark-from-relay.js";

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

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

package/dist/operators/mark-from-relay.js

@@ -0,0 +1,9 @@
+import { tap } from "rxjs";
+import { addSeenRelay } from "applesauce-core/helpers";
+/** Marks all events as from the relay */
+export function markFromRelay(relay) {
+    return (source) => source.pipe(tap((message) => {
+        if (typeof message !== "string")
+            addSeenRelay(message, relay);
+    }));
+}

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

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

package/dist/operators/only-events.js

@@ -0,0 +1,5 @@
+import { filter } from "rxjs";
+/** Filter subscription responses and only return the events */
+export function onlyEvents() {
+    return (source) => source.pipe(filter((r) => r !== "EOSE"));
+}

package/dist/pool.d.ts

@@ -0,0 +1,12 @@
+import { NostrEvent, type Filter } from "nostr-tools";
+import { Observable } from "rxjs";
+import { Relay, PublishResponse, SubscriptionResponse } from "./relay.js";
+export declare class RelayPool {
+    relays: Map<string, Relay>;
+    /** 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>;
+    /** Send an EVENT message to multiple relays */
+    event(relays: string[], event: NostrEvent): Observable<PublishResponse[]>;
+}

package/dist/pool.js

@@ -0,0 +1,41 @@
+import { combineLatest, endWith, ignoreElements, merge, takeWhile } from "rxjs";
+import { nanoid } from "nanoid";
+import { Relay } from "./relay.js";
+import { onlyEvents } from "./operators/only-events.js";
+export class RelayPool {
+    relays = new Map();
+    /** Get or create a new relay connection */
+    relay(url) {
+        let relay = this.relays.get(url);
+        if (relay)
+            return relay;
+        else {
+            relay = new Relay(url);
+            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);
+    }
+    /** Send an EVENT message to multiple relays */
+    event(relays, event) {
+        return combineLatest(relays.map((url) => this.relay(url).event(event)));
+    }
+}

package/dist/relay.d.ts

@@ -0,0 +1,35 @@
+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;
+};
+export type RelayOptions = {
+    WebSocket?: WebSocketSubjectConfig<any>["WebSocketCtor"];
+};
+export declare class Relay {
+    url: string;
+    log: typeof logger;
+    socket$: WebSocketSubject<any>;
+    connected$: BehaviorSubject<boolean>;
+    challenge$: Observable<string>;
+    authenticated$: BehaviorSubject<boolean>;
+    notices$: Observable<string>;
+    protected authRequiredForReq: BehaviorSubject<boolean>;
+    protected authRequiredForPublish: BehaviorSubject<boolean>;
+    protected reset(): void;
+    constructor(url: string, opts?: RelayOptions);
+    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 */
+    event(event: NostrEvent, verb?: "EVENT" | "AUTH"): Observable<PublishResponse>;
+    /** send and AUTH message */
+    auth(event: NostrEvent): Observable<{
+        ok: boolean;
+        message?: string;
+    }>;
+}

package/dist/relay.js

@@ -0,0 +1,120 @@
+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 { markFromRelay } from "./operators/mark-from-relay.js";
+export class Relay {
+    url;
+    log = logger.extend("Bakery");
+    socket$;
+    connected$ = new BehaviorSubject(false);
+    challenge$;
+    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);
+    }
+    constructor(url, opts) {
+        this.url = url;
+        this.log = this.log.extend(url);
+        this.socket$ = webSocket({
+            url,
+            openObserver: {
+                next: () => {
+                    this.log("Connected");
+                    this.connected$.next(true);
+                    this.reset();
+                },
+            },
+            closeObserver: {
+                next: () => {
+                    this.log("Disconnected");
+                    this.connected$.next(false);
+                    this.reset();
+                },
+            },
+            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(
+        // listen for NOTICE messages
+        filter((m) => m[0] === "NOTICE"), 
+        // pick the string out of the message
+        map((m) => m[1]));
+    }
+    waitForAuth(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;
+        }));
+    }
+    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
+        map((message) => {
+            if (message[0] === "EOSE")
+                return "EOSE";
+            else
+                return message[2];
+        }), 
+        // mark events as from relays
+        markFromRelay(this.url), 
+        // if no events are seen in 10s, emit EOSE
+        timeout({
+            first: 10_000,
+            with: () => merge(of("EOSE"), NEVER),
+        })));
+    }
+    /** send an Event message */
+    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 })), 
+        // 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);
+            }
+        }));
+        // skip wait for auth if verb is AUTH
+        if (verb === "AUTH")
+            return observable;
+        else
+            return this.waitForAuth(this.authRequiredForPublish, observable);
+    }
+    /** send and AUTH message */
+    auth(event) {
+        return this.event(event, "AUTH").pipe(
+        // update authenticated
+        tap((result) => this.authenticated$.next(result.ok)));
+    }
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "applesauce-relay",
+  "version": "0.11.0",
+  "description": "A collection of observable based loaders built on rx-nostr",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "keywords": [
+    "nostr",
+    "applesauce"
+  ],
+  "author": "hzrd149",
+  "license": "MIT",
+  "files": [
+    "dist",
+    "applesauce"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./operators": {
+      "import": "./dist/operators/index.js",
+      "require": "./dist/operators/index.js",
+      "types": "./dist/operators/index.d.ts"
+    },
+    "./operators/*": {
+      "import": "./dist/operators/*.js",
+      "require": "./dist/operators/*.js",
+      "types": "./dist/operators/*.d.ts"
+    }
+  },
+  "dependencies": {
+    "nanoid": "^5.0.9",
+    "nostr-tools": "^2.10.4",
+    "rxjs": "^7.8.1",
+    "applesauce-core": "^0.11.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.3",
+    "vitest": "^3.0.5",
+    "vitest-nostr": "^0.4.1",
+    "vitest-websocket-mock": "^0.4.0"
+  },
+  "funding": {
+    "type": "lightning",
+    "url": "lightning:nostrudel@geyser.fund"
+  },
+  "scripts": {
+    "build": "tsc",
+    "watch:build": "tsc --watch > /dev/null",
+    "test": "vitest run --passWithNoTests",
+    "watch:test": "vitest"
+  }
+}