applesauce-relay 5.2.0 → 6.0.2

package/dist/types.d.ts

@@ -1,21 +1,11 @@
-import type { IAsyncEventStoreActions, IAsyncEventStoreRead, IEventStoreRead } from "applesauce-core/event-store";
-import type { Filter } from "applesauce-core/helpers/filter";
+import type { IAsyncEventStoreActions, IAsyncEventStoreRead, IEventStoreActions, IEventStoreRead } from "applesauce-core/event-store";
 import type { EventTemplate, NostrEvent } from "applesauce-core/helpers/event";
+import type { Filter } from "applesauce-core/helpers/filter";
 import type { RelayInformation as CoreRelayInformation } from "nostr-tools/nip11";
-import type { Observable, repeat, retry } from "rxjs";
+import type { Observable, OperatorFunction, repeat, retry } from "rxjs";
 import type { WebSocketSubject } from "rxjs/webSocket";
-import type { GroupNegentropySyncOptions, GroupRequestOptions, GroupSubscriptionOptions } from "./group.js";
-import type { NegentropySyncOptions, ReconcileFunction } from "./negentropy.js";
-import type { SyncDirection } from "./relay.js";
-export type SubscriptionResponse = NostrEvent | "EOSE";
-export type PublishResponse = {
-    ok: boolean;
-    message?: string;
-    from: string;
-};
-export type CountResponse = {
-    count: number;
-};
+import type { NegentropySyncOptions } from "./negentropy.js";
+import type { Relay } from "./relay.js";
 /** Status information for a single relay */
 export interface RelayStatus {
     /** Relay URL */
@@ -48,28 +38,87 @@ export type PublishOptions = {
     /** Timeout for publish in milliseconds (default 30 seconds) */
     timeout?: number | boolean;
 };
-/** Options for the request method on the pool and relay */
-export type RequestOptions = SubscriptionOptions;
-/** Options for the subscription method on the pool and relay */
-export type SubscriptionOptions = {
+/** The response type when publishing an event to a relay */
+export type PublishResponse = {
+    ok: boolean;
+    message?: string;
+    from: string;
+};
+/** Base options for REQ subscriptions to a relay */
+export type RelayReqOptions = {
     /** Custom REQ id for the subscription */
     id?: string;
     /**
-     * Whether to resubscribe if the subscription is closed by the relay. default is false
+     * Whether to wait for authentication and retry if auth-required is received. default is true
+     */
+    waitForAuth?: boolean;
+    /**
+     * 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];
 };
+/** Internal type emitted when REQ is sent to the relay */
+export type RelayReqOpenMessage = {
+    type: "OPEN";
+    from: string;
+    id: string;
+    filters: Filter[];
+};
+/** Internal type emitted when an event is received from the relay */
+export type RelayReqEventMessage = {
+    type: "EVENT";
+    from: string;
+    id: string;
+    event: NostrEvent;
+};
+/** Internal type emitted when the relay sends an EOSE message */
+export type RelayReqEoseMessage = {
+    type: "EOSE";
+    from: string;
+    id: string;
+};
+/** Internal type emitted when the relay sends a CLOSED message */
+export type RelayReqClosedMessage = {
+    type: "CLOSED";
+    from: string;
+    id: string;
+    reason: string;
+};
+/** Internal type emitted from a REQ subscription to a relay */
+export type RelayReqMessage = RelayReqOpenMessage | RelayReqEventMessage | RelayReqEoseMessage | RelayReqClosedMessage;
+/** Options for the request method on the pool and relay */
+export type RelayRequestOptions = RelayReqOptions & {
+    /**
+     * Total timeout for the request before request emits a TimeoutError in milliseconds (default 30 seconds)
+     * Passed to rjxs timeout() operator */
+    timeout?: number;
+    /** An operator that determines when the request should complete. */
+    complete?: RelayRequestCompleteOperator;
+};
+/** The response type when making a request to a relay */
+export type RelayRequestResponse = NostrEvent;
+/** An operator that determines when a relay request should complete. truthy values are considered complete */
+export type RelayRequestCompleteOperator = OperatorFunction<RelayReqMessage, any>;
+/** Options for the subscription method on the pool and relay */
+export type RelaySubscriptionOptions = RelayReqOptions;
+/** The response type when subscribing to a relay */
+export type RelaySubscriptionResponse = NostrEvent | "EOSE";
+/** The response type when counting events on a relay */
+export type RelayCountResponse = {
+    count: number;
+};
+/** A minimal signer interface for authenticating with a relay */
 export type AuthSigner = {
     signEvent: (event: EventTemplate) => NostrEvent | Promise<NostrEvent>;
 };
 /** Filters that can be passed to request methods on the pool or relay */
-export type FilterInput = Filter | Filter[] | Observable<Filter | Filter[]> | ((relay: IRelay) => Filter | Filter[] | Observable<Filter | Filter[]>);
+export type FilterInput = Filter | Filter[] | Observable<Filter | Filter[]> | ((relay: Relay) => Filter | Filter[] | Observable<Filter | Filter[]>);
 export type RelayInformation = CoreRelayInformation & {
     /** An array of attributes that describe the relay type/characteristics */
     attributes?: string[];
@@ -80,112 +129,36 @@ export type NegentropyReadStore = IEventStoreRead | IAsyncEventStoreRead | Nostr
 export type NegentropyWriteStore = (IAsyncEventStoreRead & IAsyncEventStoreActions) | (IEventStoreRead & IAsyncEventStoreActions);
 /** An event store that can be used for negentropy sync */
 export type NegentropySyncStore = NegentropyReadStore | NegentropyWriteStore;
-export interface IRelay extends MultiplexWebSocket {
-    url: string;
-    message$: Observable<any>;
-    notice$: Observable<string>;
-    connected$: Observable<boolean>;
-    ready$: Observable<boolean>;
-    challenge$: Observable<string | null>;
-    authenticated$: Observable<boolean>;
-    notices$: Observable<string[]>;
-    open$: Observable<Event>;
-    close$: Observable<CloseEvent>;
-    closing$: Observable<void>;
-    error$: Observable<Error | null>;
-    lastMessageAt$: Observable<number>;
-    status$: Observable<RelayStatus>;
-    readonly connected: boolean;
-    readonly ready: boolean;
-    readonly authenticated: boolean;
-    readonly challenge: string | null;
-    readonly notices: string[];
-    readonly lastMessageAt: number;
-    /** Force close the connection */
-    close(): void;
-    /** Send a REQ message */
-    req(filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
-    /** Send a COUNT message */
-    count(filters: Filter | Filter[], id?: string): Observable<CountResponse>;
-    /** Send an EVENT message */
-    event(event: NostrEvent): Observable<PublishResponse>;
-    /** Send an AUTH message */
-    auth(event: NostrEvent): Promise<PublishResponse>;
-    /** Negentropy sync event ids with the relay and an event store */
-    negentropy(store: NegentropyReadStore, filter: Filter, reconcile: ReconcileFunction, opts?: NegentropySyncOptions): Promise<boolean>;
-    /** Authenticate with the relay using a signer */
-    authenticate(signer: AuthSigner): Promise<PublishResponse>;
-    /** Send an EVENT message with retries */
-    publish(event: NostrEvent, opts?: PublishOptions): Promise<PublishResponse>;
-    /** Send a REQ message with retries */
-    request(filters: FilterInput, opts?: RequestOptions): Observable<NostrEvent>;
-    /** Open a subscription with retries */
-    subscription(filters: FilterInput, opts?: SubscriptionOptions): Observable<SubscriptionResponse>;
-    /** Negentropy sync events with the relay and an event store */
-    sync(store: NegentropySyncStore, filter: Filter, direction?: SyncDirection): Observable<NostrEvent>;
-    /** Get the NIP-11 information document for the relay */
-    getInformation(): Promise<RelayInformation | null>;
-    /** Get the limitations for the relay */
-    getLimitations(): Promise<RelayInformation["limitation"] | null>;
-    /** Get the supported NIPs for the relay */
-    getSupported(): Promise<number[] | null>;
-}
-export type IGroupRelayInput = IRelay[] | Observable<IRelay[]>;
-export interface IGroup {
-    /** Observable of relay status for all relays in the group */
-    status$: Observable<Record<string, RelayStatus>>;
-    /** Send a REQ message */
-    req(filters: Parameters<IRelay["req"]>[0], id?: string): Observable<SubscriptionResponse>;
-    /** Send an EVENT message */
-    event(event: Parameters<IRelay["event"]>[0]): Observable<PublishResponse>;
-    /** Negentropy sync event ids with the relays and an event store */
-    negentropy(store: NegentropyReadStore, filter: Filter, reconcile: ReconcileFunction, opts?: NegentropySyncOptions): Promise<boolean>;
-    /** Add a relay to the group */
-    add(relay: IRelay): void;
-    /** Remove a relay from the group */
-    remove(relay: IRelay): void;
-    /** Check if a relay is in the group */
-    has(relay: IRelay | string): boolean;
-    /** Send an EVENT message with retries */
-    publish(event: Parameters<IRelay["event"]>[0], opts?: PublishOptions): Promise<PublishResponse[]>;
-    /** Send a REQ message with retries */
-    request(filters: Parameters<IRelay["request"]>[0], opts?: GroupRequestOptions): Observable<NostrEvent>;
-    /** Open a subscription with retries */
-    subscription(filters: Parameters<IRelay["subscription"]>[0], opts?: GroupSubscriptionOptions): Observable<SubscriptionResponse>;
-    /** Count events on the relays and an event store */
-    count(filters: Filter | Filter[], id?: string): Observable<Record<string, CountResponse>>;
-    /** Negentropy sync events with the relay and an event store */
-    sync(store: NegentropySyncStore, filter: Filter, direction?: SyncDirection): Observable<NostrEvent>;
-}
-/** Signals emitted by the pool */
-export interface IPoolSignals {
-    add$: Observable<IRelay>;
-    remove$: Observable<IRelay>;
-}
-export type IPoolRelayInput = string[] | Observable<string[]>;
-export interface IPool extends IPoolSignals {
-    /** Observable of relay status for all relays in the pool */
-    status$: Observable<Record<string, RelayStatus>>;
-    /** Get or create a relay */
-    relay(url: string): IRelay;
-    /** Create a relay group */
-    group(relays: IPoolRelayInput): IGroup;
-    /** Removes a relay from the pool and defaults to closing the connection */
-    remove(relay: string | IRelay, close?: boolean): void;
-    /** Send a REQ message */
-    req(relays: IPoolRelayInput, filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
-    /** Send an EVENT message */
-    event(relays: IPoolRelayInput, event: NostrEvent): Observable<PublishResponse>;
-    /** Negentropy sync event ids with the relays and an event store */
-    negentropy(relays: IPoolRelayInput, store: NegentropyReadStore, filter: Filter, reconcile: ReconcileFunction, opts?: GroupNegentropySyncOptions): Promise<boolean>;
-    /** Send an EVENT message to relays with retries */
-    publish(relays: IPoolRelayInput, event: Parameters<IGroup["publish"]>[0], opts?: Parameters<IGroup["publish"]>[1]): Promise<PublishResponse[]>;
-    /** Send a REQ message to relays with retries */
-    request(relays: IPoolRelayInput, filters: Parameters<IGroup["request"]>[0], opts?: Parameters<IGroup["request"]>[1]): Observable<NostrEvent>;
-    /** Open a subscription to relays with retries */
-    subscription(relays: IPoolRelayInput, filters: Parameters<IGroup["subscription"]>[0], opts?: Parameters<IGroup["subscription"]>[1]): Observable<SubscriptionResponse>;
-    /** Count events on the relays and an event store */
-    count(relays: IPoolRelayInput, filters: Filter | Filter[], id?: string): Observable<Record<string, CountResponse>>;
-    /** Negentropy sync events with the relay and an event store */
-    sync(relays: IPoolRelayInput, store: NegentropySyncStore, filter: Filter, direction?: SyncDirection): Observable<NostrEvent>;
-}
+/** The input arguments for a relay group */
+export type GroupRelayInput = Relay[] | Observable<Relay[]>;
+/** Options for negentropy sync on a group of relays */
+export type GroupNegentropySyncOptions = NegentropySyncOptions & {
+    /** Whether to sync in parallel (default true) */
+    parallel?: boolean;
+};
+/** Options for a subscription on a group of relays */
+export type GroupSubscriptionOptions = RelaySubscriptionOptions & {
+    /** Deduplicate events with an event store (default is a temporary instance of EventMemory), null will disable deduplication */
+    eventStore?: IEventStoreActions | IAsyncEventStoreActions | null;
+};
+/** Options for relay group REQ method */
+export type GroupReqOptions = RelayReqOptions;
+/** Options for a request on a group of relays */
+export type GroupRequestOptions = RelayRequestOptions & {
+    /** Deduplicate events with an event store (default is a temporary instance of EventMemory), null will disable deduplication */
+    eventStore?: IEventStoreActions | IAsyncEventStoreActions | null;
+    /** A custom operator that determines when the request should complete.*/
+    complete?: GroupRequestCompleteOperator;
+};
+/** The message that is emitted when the group receives an error message from the relay observable */
+export type GroupReqErrorMessage = {
+    type: "ERROR";
+    from: string;
+    error: unknown;
+};
+/** The response messages from a relay group subscription */
+export type GroupReqMessage = RelayReqMessage | GroupReqErrorMessage;
+/** A operator that determines when a group request should complete. truthy values are considered complete */
+export type GroupRequestCompleteOperator = OperatorFunction<GroupReqMessage, any>;
+/** The input type of relays for pool methods */
+export type PoolRelayInput = string[] | Observable<string[]>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-relay",
-  "version": "5.2.0",
+  "version": "6.0.2",
   "description": "nostr relay communication framework built on rxjs",
   "type": "module",
   "main": "dist/index.js",
@@ -57,14 +57,14 @@
   },
   "dependencies": {
     "@noble/hashes": "^1.7.1",
-    "applesauce-core": "^5.2.0",
+    "applesauce-core": "^6.0.0",
     "nanoid": "^5.0.9",
     "nostr-tools": "~2.19",
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
     "@hirez_io/observer-spy": "^2.2.0",
-    "applesauce-signers": "^5.2.0",
+    "applesauce-signers": "^6.0.0",
     "rimraf": "^6.0.1",
     "typescript": "^5.7.3",
     "vitest": "^4.0.15",

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

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

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

@@ -1,9 +0,0 @@
-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/to-event-store.d.ts

@@ -1,9 +0,0 @@
-import { OperatorFunction } from "rxjs";
-import { IEventStore } from "applesauce-core";
-import { NostrEvent } from "applesauce-core/helpers/event";
-import { SubscriptionResponse } from "../types.js";
-/**
- * Adds all events to event store and returns a deduplicated timeline when EOSE is received
- * @deprecated use `mapEventsToStore` and `mapEventsToTimeline` instead
- */
-export declare function toEventStore(eventStore: IEventStore): OperatorFunction<SubscriptionResponse, NostrEvent[]>;

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

@@ -1,15 +0,0 @@
-import { mapEventsToStore, mapEventsToTimeline } from "applesauce-core/observable";
-import { completeOnEose } from "./complete-on-eose.js";
-/**
- * Adds all events to event store and returns a deduplicated timeline when EOSE is received
- * @deprecated use `mapEventsToStore` and `mapEventsToTimeline` instead
- */
-export function toEventStore(eventStore) {
-    return (source) => source.pipe(
-    // Complete when there are not events
-    completeOnEose(), 
-    // Save events to store and remove duplicates
-    mapEventsToStore(eventStore, true), 
-    // Add the events to an array
-    mapEventsToTimeline());
-}