applesauce-loaders 0.12.0 → 1.0.0

package/README.md

@@ -1,24 +1,32 @@
 # applesauce-loaders
 
-A collection of observable based loaders built on top of [rx-nostr](https://penpenpng.github.io/rx-nostr/)
+A collection of loader classes to make loading common events from multiple relays easier.
 
 ## Replaceable event loader
 
 The `ReplaceableLoader` class can be used to load profiles (kind 0), contact lists (kind 3), and any other replaceable (1xxxx) or parameterized replaceable event (3xxxx)
 
 ```ts
+import { Observable } from "rxjs";
 import { EventStore } from "applesauce-core";
 import { ReplaceableLoader } from "applesauce-loaders/loaders";
-import { createRxNostr, nip07Signer } from "rx-nostr";
-import { verifier } from "rx-nostr-crypto";
 
 export const eventStore = new EventStore();
 
-export const rxNostr = createRxNostr({
-  verifier,
-  signer: nip07Signer(),
-  connectionStrategy: "lazy-keep",
-});
+// Create a method to let the loaders use nostr-tools relay pool
+function nostrRequest(relays: string[], filters: Filter[]) {
+  return new Observable((observer) => {
+    const sub = pool.subscribe(filters, {
+      onevent: (event) => observer.next(event),
+      oneose: () => {
+        sub.close();
+        observer.complete();
+      },
+    });
+
+    return () => sub.close();
+  });
+}
 
 // create method to load events from the cache relay
 function cacheRequest(filters: Filter[]) {

package/dist/helpers/address-pointer.js

@@ -1,5 +1,5 @@
 import { getReplaceableUID, mergeRelaySets } from "applesauce-core/helpers";
-import { isParameterizedReplaceableKind, isReplaceableKind } from "nostr-tools/kinds";
+import { isAddressableKind, isReplaceableKind } from "nostr-tools/kinds";
 import { unique } from "./array.js";
 /** Converts an array of address pointers to a filter */
 export function createFilterFromAddressPointers(pointers) {
@@ -14,7 +14,7 @@ export function createFilterFromAddressPointers(pointers) {
 /** Takes a set of address pointers, groups them, then returns filters for the groups */
 export function createFiltersFromAddressPointers(pointers) {
     // split the points in to two groups so they they don't mix in the filters
-    const parameterizedReplaceable = pointers.filter((p) => isParameterizedReplaceableKind(p.kind));
+    const parameterizedReplaceable = pointers.filter((p) => isAddressableKind(p.kind));
     const replaceable = pointers.filter((p) => isReplaceableKind(p.kind));
     const filters = [];
     if (replaceable.length > 0) {
@@ -29,7 +29,7 @@ export function createFiltersFromAddressPointers(pointers) {
 }
 /** Checks if a relay will understand an address pointer */
 export function isLoadableAddressPointer(pointer) {
-    if (isParameterizedReplaceableKind(pointer.kind))
+    if (isAddressableKind(pointer.kind))
         return !!pointer.identifier;
     else
         return isReplaceableKind(pointer.kind);

package/dist/helpers/pointer.d.ts

@@ -1,6 +1,6 @@
 export declare function groupByRelay<T extends {
     relays?: string[];
-}>(pointers: T[], defaultKey?: string): Map<string, T[]>;
+}>(pointers: T[], extraRelays?: string[]): Map<string, T[]>;
 export interface MessageWithRelay {
     relays?: string[];
     /** Ignore timeout and force message through */

package/dist/helpers/pointer.js

@@ -1,7 +1,8 @@
-export function groupByRelay(pointers, defaultKey) {
+import { mergeRelaySets } from "applesauce-core/helpers";
+export function groupByRelay(pointers, extraRelays) {
     let byRelay = new Map();
     for (const pointer of pointers) {
-        let relays = pointer.relays?.length ? pointer.relays : defaultKey ? [defaultKey] : [];
+        let relays = mergeRelaySets(pointer.relays, extraRelays);
         for (const relay of relays) {
             if (!byRelay.has(relay))
                 byRelay.set(relay, [pointer]);

package/dist/loaders/cache-timeline-loader.d.ts

@@ -1,6 +1,6 @@
-import { EventPacket } from "rx-nostr";
-import { BehaviorSubject } from "rxjs";
 import { logger } from "applesauce-core";
+import { NostrEvent } from "nostr-tools";
+import { BehaviorSubject } from "rxjs";
 import { CacheRequest, Loader } from "./loader.js";
 import { TimelessFilter } from "./relay-timeline-loader.js";
 export type CacheTimelineLoaderOptions = {
@@ -8,7 +8,7 @@ export type CacheTimelineLoaderOptions = {
     limit?: number;
 };
 /** A loader that can be used to load a timeline in chunks */
-export declare class CacheTimelineLoader extends Loader<number | void, EventPacket> {
+export declare class CacheTimelineLoader extends Loader<number | void, NostrEvent> {
     filters: TimelessFilter[];
     id: string;
     loading$: BehaviorSubject<boolean>;

package/dist/loaders/cache-timeline-loader.js

@@ -1,7 +1,7 @@
-import { BehaviorSubject, filter, map, mergeMap, tap } from "rxjs";
-import { markFromCache, unixNow } from "applesauce-core/helpers";
 import { logger } from "applesauce-core";
+import { markFromCache, unixNow } from "applesauce-core/helpers";
 import { nanoid } from "nanoid";
+import { BehaviorSubject, filter, map, mergeMap, tap } from "rxjs";
 import { Loader } from "./loader.js";
 /** A loader that can be used to load a timeline in chunks */
 export class CacheTimelineLoader extends Loader {
@@ -52,7 +52,7 @@ export class CacheTimelineLoader extends Loader {
                         this.log(`Finished batch, got ${count} events`);
                     }
                 },
-            }), map((event) => ({ event, from: "", subId: "cache-timeline-loader", type: "EVENT" })));
+            }));
         })));
         this.filters = filters;
         // create a unique logger for this instance

package/dist/loaders/index.d.ts

@@ -6,5 +6,4 @@ export * from "./timeline-loader.js";
 export * from "./relay-timeline-loader.js";
 export * from "./cache-timeline-loader.js";
 export * from "./tag-value-loader.js";
-export * from "./request-loader.js";
 export * from "./dns-identity-loader.js";

package/dist/loaders/index.js

@@ -6,5 +6,4 @@ export * from "./timeline-loader.js";
 export * from "./relay-timeline-loader.js";
 export * from "./cache-timeline-loader.js";
 export * from "./tag-value-loader.js";
-export * from "./request-loader.js";
 export * from "./dns-identity-loader.js";

package/dist/loaders/loader.d.ts

@@ -4,6 +4,8 @@ export type RelayFilterMap<T = Filter> = {
     [relay: string]: T[];
 };
 export type CacheRequest = (filters: Filter[]) => Observable<NostrEvent>;
+export type NostrResponse = NostrEvent | "EOSE";
+export type NostrRequest = (relays: string[], filters: Filter[], id?: string) => Observable<NostrResponse>;
 export interface ILoader<T, R> extends Subscribable<R> {
     next: (value: T) => void;
     pipe: Observable<R>["pipe"];

package/dist/loaders/relay-timeline-loader.d.ts

@@ -1,15 +1,14 @@
-import { EventPacket, RxNostr } from "rx-nostr";
-import { BehaviorSubject } from "rxjs";
 import { logger } from "applesauce-core";
-import { Filter } from "nostr-tools";
-import { Loader } from "./loader.js";
+import { Filter, NostrEvent } from "nostr-tools";
+import { BehaviorSubject } from "rxjs";
+import { Loader, NostrRequest } from "./loader.js";
 export type TimelessFilter = Omit<Filter, "since" | "until">;
 export type RelayTimelineLoaderOptions = {
     /** default number of events to request in each batch */
     limit?: number;
 };
 /** A loader that can be used to load a timeline in chunks */
-export declare class RelayTimelineLoader extends Loader<number | void, EventPacket> {
+export declare class RelayTimelineLoader extends Loader<number | void, NostrEvent> {
     relay: string;
     filters: TimelessFilter[];
     id: string;
@@ -20,5 +19,5 @@ export declare class RelayTimelineLoader extends Loader<number | void, EventPack
     /** if the timeline is complete */
     complete: boolean;
     protected log: typeof logger;
-    constructor(rxNostr: RxNostr, relay: string, filters: TimelessFilter[], opts?: RelayTimelineLoaderOptions);
+    constructor(request: NostrRequest, relay: string, filters: TimelessFilter[], opts?: RelayTimelineLoaderOptions);
 }

package/dist/loaders/relay-timeline-loader.js

@@ -1,8 +1,8 @@
-import { createRxOneshotReq } from "rx-nostr";
-import { BehaviorSubject, filter, map, Observable } from "rxjs";
 import { logger } from "applesauce-core";
-import { nanoid } from "nanoid";
 import { unixNow } from "applesauce-core/helpers";
+import { nanoid } from "nanoid";
+import { BehaviorSubject, filter, map, Observable } from "rxjs";
+import { completeOnEOSE } from "../operators/complete-on-eose.js";
 import { Loader } from "./loader.js";
 /** A loader that can be used to load a timeline in chunks */
 export class RelayTimelineLoader extends Loader {
@@ -18,7 +18,7 @@ export class RelayTimelineLoader extends Loader {
     /** if the timeline is complete */
     complete = false;
     log = logger.extend("RelayTimelineLoader");
-    constructor(rxNostr, relay, filters, opts) {
+    constructor(request, relay, filters, opts) {
         super((source) => new Observable((observer) => {
             return source
                 .pipe(filter(() => !this.loading && !this.complete), map((limit) => {
@@ -35,16 +35,17 @@ export class RelayTimelineLoader extends Loader {
                 .subscribe((filters) => {
                 // make batch request
                 let count = 0;
-                const req = createRxOneshotReq({ filters, rxReqId: this.id });
                 this.loading$.next(true);
                 this.log(`Next batch starting at ${filters[0].until} limit ${filters[0].limit}`);
-                rxNostr.use(req, { on: { relays: [relay] } }).subscribe({
-                    next: (packet) => {
+                request([relay], filters)
+                    .pipe(completeOnEOSE())
+                    .subscribe({
+                    next: (event) => {
                         // update cursor when event is received
-                        this.cursor = Math.min(packet.event.created_at - 1, this.cursor);
+                        this.cursor = Math.min(event.created_at - 1, this.cursor);
                         count++;
                         // forward packet
-                        observer.next(packet);
+                        observer.next(event);
                     },
                     error: (err) => observer.error(err),
                     complete: () => {

package/dist/loaders/replaceable-loader.d.ts

@@ -1,7 +1,7 @@
-import { EventPacket, RxNostr } from "rx-nostr";
 import { logger } from "applesauce-core";
-import { CacheRequest, Loader } from "./loader.js";
+import { NostrEvent } from "nostr-tools";
 import { LoadableAddressPointer } from "../helpers/address-pointer.js";
+import { CacheRequest, Loader, NostrRequest } from "./loader.js";
 export type ReplaceableLoaderOptions = {
     /**
      * Time interval to buffer requests in ms
@@ -12,12 +12,16 @@ export type ReplaceableLoaderOptions = {
     cacheRequest?: CacheRequest;
     /** Fallback lookup relays to check when event cant be found */
     lookupRelays?: string[];
+    /** An array of relays to always fetch from */
+    extraRelays?: string[];
 };
-export declare class ReplaceableLoader extends Loader<LoadableAddressPointer, EventPacket> {
+export declare class ReplaceableLoader extends Loader<LoadableAddressPointer, NostrEvent> {
     log: typeof logger;
     /** A method used to load events from a local cache */
     cacheRequest?: CacheRequest;
     /** Fallback lookup relays to check when event cant be found */
     lookupRelays?: string[];
-    constructor(rxNostr: RxNostr, opts?: ReplaceableLoaderOptions);
+    /** An array of relays to always fetch from */
+    extraRelays?: string[];
+    constructor(request: NostrRequest, opts?: ReplaceableLoaderOptions);
 }

package/dist/loaders/replaceable-loader.js

@@ -1,22 +1,21 @@
-import { tap, filter, bufferTime, map } from "rxjs";
-import { createRxOneshotReq } from "rx-nostr";
-import { getEventUID, markFromCache, mergeRelaySets } from "applesauce-core/helpers";
 import { logger } from "applesauce-core";
+import { getEventUID, markFromCache, mergeRelaySets } from "applesauce-core/helpers";
 import { nanoid } from "nanoid";
-import { Loader } from "./loader.js";
-import { generatorSequence } from "../operators/generator-sequence.js";
+import { bufferTime, filter, map, tap } from "rxjs";
 import { consolidateAddressPointers, createFiltersFromAddressPointers, getAddressPointerId, getRelaysFromPointers, isLoadableAddressPointer, } from "../helpers/address-pointer.js";
-import { getDefaultReadRelays } from "../helpers/rx-nostr.js";
+import { completeOnEOSE } from "../operators/complete-on-eose.js";
 import { distinctRelaysBatch } from "../operators/distinct-relays.js";
+import { generatorSequence } from "../operators/generator-sequence.js";
+import { Loader } from "./loader.js";
 /** A generator that tries to load the address pointers from the cache first, then tries the relays */
-function* cacheFirstSequence(rxNostr, pointers, log, opts) {
+function* cacheFirstSequence(request, pointers, log, opts) {
     const id = nanoid(4);
     let remaining = Array.from(pointers);
     const pointerRelays = Array.from(getRelaysFromPointers(pointers));
     // handle previous step results and decide if to exit
     const handleResults = (results) => {
         if (results.length) {
-            const coordinates = new Set(results.map((p) => getEventUID(p.event)));
+            const coordinates = new Set(results.map((event) => getEventUID(event)));
             // if there where results, filter out any pointers that where found
             remaining = remaining.filter((pointer) => {
                 const found = coordinates.has(getAddressPointerId(pointer));
@@ -39,20 +38,16 @@ function* cacheFirstSequence(rxNostr, pointers, log, opts) {
         const filters = createFiltersFromAddressPointers(remaining);
         const results = yield opts.cacheRequest(filters).pipe(
         // mark the event as from the cache
-        tap((event) => markFromCache(event)), 
-        // convert to event packets
-        map((e) => ({ event: e, from: "", subId: "replaceable-loader", type: "EVENT" })));
+        tap((event) => markFromCache(event)));
         if (handleResults(results))
             return;
     }
-    // load from pointer relays and default relays
-    const defaultRelays = getDefaultReadRelays(rxNostr);
-    const remoteRelays = mergeRelaySets(pointerRelays, defaultRelays);
-    if (remoteRelays.length > 0) {
-        log(`[${id}] Requesting`, remoteRelays, remaining);
+    // load from pointer relays and extra relays
+    const mergedRelays = mergeRelaySets(pointerRelays, opts?.extraRelays);
+    if (mergedRelays.length > 0) {
+        log(`[${id}] Requesting`, mergedRelays, remaining);
         const filters = createFiltersFromAddressPointers(remaining);
-        const req = createRxOneshotReq({ filters, rxReqId: id });
-        const results = yield rxNostr.use(req, { on: { relays: remoteRelays } });
+        const results = yield request(mergedRelays, filters).pipe(completeOnEOSE());
         if (handleResults(results))
             return;
     }
@@ -63,8 +58,7 @@ function* cacheFirstSequence(rxNostr, pointers, log, opts) {
         if (relays.length > 0) {
             log(`[${id}] Request from lookup`, relays, remaining);
             const filters = createFiltersFromAddressPointers(remaining);
-            const req = createRxOneshotReq({ filters, rxReqId: id });
-            const results = yield rxNostr.use(req, { on: { relays } });
+            const results = yield request(relays, filters).pipe(completeOnEOSE());
             if (handleResults(results))
                 return;
         }
@@ -76,7 +70,9 @@ export class ReplaceableLoader extends Loader {
     cacheRequest;
     /** Fallback lookup relays to check when event cant be found */
     lookupRelays;
-    constructor(rxNostr, opts) {
+    /** An array of relays to always fetch from */
+    extraRelays;
+    constructor(request, opts) {
         super((source) => {
             return source.pipe(
             // filter out invalid pointers
@@ -92,9 +88,10 @@ export class ReplaceableLoader extends Loader {
             // ignore empty buffer
             filter((buffer) => buffer.length > 0), 
             // check cache, relays, lookup relays in that order
-            generatorSequence((pointers) => cacheFirstSequence(rxNostr, pointers, this.log, {
+            generatorSequence((pointers) => cacheFirstSequence(request, pointers, this.log, {
                 cacheRequest: this.cacheRequest,
                 lookupRelays: this.lookupRelays,
+                extraRelays: this.extraRelays,
             }), 
             // there will always be more events, never complete
             false));
@@ -102,5 +99,6 @@ export class ReplaceableLoader extends Loader {
         // set options
         this.cacheRequest = opts?.cacheRequest;
         this.lookupRelays = opts?.lookupRelays;
+        this.extraRelays = opts?.extraRelays;
     }
 }

package/dist/loaders/single-event-loader.d.ts

@@ -1,6 +1,6 @@
-import { EventPacket, RxNostr } from "rx-nostr";
 import { logger } from "applesauce-core";
-import { CacheRequest, Loader } from "./loader.js";
+import { NostrEvent } from "nostr-tools";
+import { CacheRequest, Loader, NostrRequest } from "./loader.js";
 export type LoadableEventPointer = {
     id: string;
     /** Relays to load from */
@@ -12,15 +12,21 @@ export type SingleEventLoaderOptions = {
      * @default 1000
      */
     bufferTime?: number;
-    /** A method used to load events from a local cache */
-    cacheRequest?: CacheRequest;
     /**
      * How long the loader should wait before it allows an event pointer to be refreshed from a relay
      * @default 60000
      */
     refreshTimeout?: number;
+    /** A method used to load events from a local cache */
+    cacheRequest?: CacheRequest;
+    /** An array of relays to always fetch from */
+    extraRelays?: string[];
 };
-export declare class SingleEventLoader extends Loader<LoadableEventPointer, EventPacket> {
+export declare class SingleEventLoader extends Loader<LoadableEventPointer, NostrEvent> {
     log: typeof logger;
-    constructor(rxNostr: RxNostr, opts?: SingleEventLoaderOptions);
+    /** A method used to load events from a local cache */
+    cacheRequest?: CacheRequest;
+    /** An array of relays to always fetch from */
+    extraRelays?: string[];
+    constructor(request: NostrRequest, opts?: SingleEventLoaderOptions);
 }

package/dist/loaders/single-event-loader.js

@@ -1,5 +1,4 @@
 import { bufferTime, filter, from, map, mergeAll, tap } from "rxjs";
-import { createRxOneshotReq } from "rx-nostr";
 import { markFromCache } from "applesauce-core/helpers";
 import { logger } from "applesauce-core";
 import { nanoid } from "nanoid";
@@ -8,21 +7,20 @@ import { generatorSequence } from "../operators/generator-sequence.js";
 import { distinctRelaysBatch } from "../operators/distinct-relays.js";
 import { groupByRelay } from "../helpers/pointer.js";
 import { consolidateEventPointers } from "../helpers/event-pointer.js";
-function* cacheFirstSequence(rxNostr, pointers, opts, log) {
+import { completeOnEOSE } from "../operators/complete-on-eose.js";
+function* cacheFirstSequence(request, pointers, opts, log) {
     let remaining = [...pointers];
     const id = nanoid(8);
     log = log.extend(id);
     const loaded = (packets) => {
-        const ids = new Set(packets.map((p) => p.event.id));
+        const ids = new Set(packets.map((p) => p.id));
         remaining = remaining.filter((p) => !ids.has(p.id));
     };
     if (opts?.cacheRequest) {
         let filter = { ids: remaining.map((e) => e.id) };
         const results = yield opts.cacheRequest([filter]).pipe(
         // mark the event as from the cache
-        tap((event) => markFromCache(event)), 
-        // convert to event packets
-        map((e) => ({ event: e, from: "", subId: "single-event-loader", type: "EVENT" })));
+        tap((event) => markFromCache(event)));
         if (results.length > 0) {
             log(`Loaded ${results.length} events from cache`);
             loaded(results);
@@ -31,20 +29,15 @@ function* cacheFirstSequence(rxNostr, pointers, opts, log) {
     // exit early if all pointers are loaded
     if (remaining.length === 0)
         return;
-    let byRelay = groupByRelay(remaining, "default");
+    let byRelay = groupByRelay(remaining, opts.extraRelays);
     // load remaining pointers from the relays
     let results = yield from(Array.from(byRelay.entries()).map(([relay, pointers]) => {
         let filter = { ids: pointers.map((e) => e.id) };
         let count = 0;
-        const req = createRxOneshotReq({ filters: [filter], rxReqId: id });
         log(`Requesting from ${relay}`, filter.ids);
-        let sub$;
-        // don't specify relay if this is the "default" relay
-        if (relay === "default")
-            sub$ = rxNostr.use(req);
-        else
-            sub$ = rxNostr.use(req, { on: { relays: [relay] } });
-        return sub$.pipe(tap({
+        return request([relay], [filter], id)
+            .pipe(completeOnEOSE())
+            .pipe(tap({
             next: () => count++,
             complete: () => log(`Completed ${relay}, loaded ${count} events`),
         }));
@@ -57,20 +50,25 @@ function* cacheFirstSequence(rxNostr, pointers, opts, log) {
 }
 export class SingleEventLoader extends Loader {
     log = logger.extend("SingleEventLoader");
-    constructor(rxNostr, opts) {
-        let options = opts || {};
+    /** A method used to load events from a local cache */
+    cacheRequest;
+    /** An array of relays to always fetch from */
+    extraRelays;
+    constructor(request, opts) {
         super((source) => source.pipe(
-        // load first from cache
+        // batch every second
         bufferTime(opts?.bufferTime ?? 1000), 
         // ignore empty buffers
         filter((buffer) => buffer.length > 0), 
         // only request events from relays once
-        distinctRelaysBatch((p) => p.id, options.refreshTimeout ?? 60_000), 
+        distinctRelaysBatch((p) => p.id, opts?.refreshTimeout ?? 60_000), 
         // ensure there is only one of each event pointer
         map(consolidateEventPointers), 
         // run the loader sequence
-        generatorSequence((pointers) => cacheFirstSequence(rxNostr, pointers, options, this.log), 
+        generatorSequence((pointers) => cacheFirstSequence(request, pointers, { cacheRequest: this.cacheRequest, extraRelays: this.extraRelays }, this.log), 
         // there will always be more events, never complete
         false)));
+        this.cacheRequest = opts?.cacheRequest;
+        this.extraRelays = opts?.extraRelays;
     }
 }

package/dist/loaders/tag-value-loader.d.ts

@@ -1,6 +1,6 @@
-import { EventPacket, RxNostr } from "rx-nostr";
 import { logger } from "applesauce-core";
-import { CacheRequest, Loader } from "./loader.js";
+import { NostrEvent } from "nostr-tools";
+import { CacheRequest, Loader, NostrRequest } from "./loader.js";
 export type TabValuePointer = {
     /** The value of the tag to load */
     value: string;
@@ -25,9 +25,15 @@ export type TagValueLoaderOptions = {
     since?: number;
     /** Method used to load from the cache */
     cacheRequest?: CacheRequest;
+    /** An array of relays to always fetch from */
+    extraRelays?: string[];
 };
-export declare class TagValueLoader extends Loader<TabValuePointer, EventPacket> {
+export declare class TagValueLoader extends Loader<TabValuePointer, NostrEvent> {
     name: string;
     protected log: typeof logger;
-    constructor(rxNostr: RxNostr, tagName: string, opts?: TagValueLoaderOptions);
+    /** A method to load events from a local cache */
+    cacheRequest?: CacheRequest;
+    /** An array of relays to always fetch from */
+    extraRelays?: string[];
+    constructor(request: NostrRequest, tagName: string, opts?: TagValueLoaderOptions);
 }

package/dist/loaders/tag-value-loader.js

@@ -1,15 +1,18 @@
-import { createRxOneshotReq } from "rx-nostr";
-import { bufferTime, filter, map, merge, mergeMap, tap } from "rxjs";
-import { markFromCache } from "applesauce-core/helpers";
 import { logger } from "applesauce-core";
-import { Loader } from "./loader.js";
-import { distinctRelaysBatch } from "../operators/distinct-relays.js";
-import { getDefaultReadRelays } from "../helpers/rx-nostr.js";
+import { markFromCache, mergeRelaySets } from "applesauce-core/helpers";
+import { bufferTime, filter, merge, mergeMap, tap } from "rxjs";
 import { unique } from "../helpers/array.js";
+import { completeOnEOSE } from "../operators/complete-on-eose.js";
+import { distinctRelaysBatch } from "../operators/distinct-relays.js";
+import { Loader } from "./loader.js";
 export class TagValueLoader extends Loader {
     name;
     log = logger.extend("TagValueLoader");
-    constructor(rxNostr, tagName, opts) {
+    /** A method to load events from a local cache */
+    cacheRequest;
+    /** An array of relays to always fetch from */
+    extraRelays;
+    constructor(request, tagName, opts) {
         const filterTag = `#${tagName}`;
         super((source) => source.pipe(
         // batch the pointers
@@ -29,7 +32,7 @@ export class TagValueLoader extends Loader {
                 baseFilter.authors = opts.authors;
             // build request map for relays
             const requestMap = pointers.reduce((map, pointer) => {
-                const relays = pointer.relays ?? getDefaultReadRelays(rxNostr);
+                const relays = mergeRelaySets(pointer.relays, this.extraRelays);
                 for (const relay of relays) {
                     if (!map[relay]) {
                         // create new filter for relay
@@ -45,9 +48,9 @@ export class TagValueLoader extends Loader {
                 return map;
             }, {});
             let fromCache = 0;
-            const cacheRequest = opts
-                ?.cacheRequest?.([{ ...baseFilter, [filterTag]: unique(pointers.map((p) => p.value)) }])
-                .pipe(
+            const cacheRequest = this?.cacheRequest?.([
+                { ...baseFilter, [filterTag]: unique(pointers.map((p) => p.value)) },
+            ]).pipe(
             // mark the event as from the cache
             tap({
                 next: (event) => {
@@ -58,16 +61,14 @@ export class TagValueLoader extends Loader {
                     if (fromCache > 0)
                         this.log(`Loaded ${fromCache} from cache`);
                 },
-            }), 
-            // convert to event packets
-            map((e) => ({ event: e, from: "", subId: "replaceable-loader", type: "EVENT" })));
-            const requests = Object.entries(requestMap).map(([relay, filters]) => {
-                const req = createRxOneshotReq({ filters });
-                return rxNostr.use(req, { on: { relays: [relay] } });
-            });
+            }));
+            const requests = Object.entries(requestMap).map(([relay, filters]) => request([relay], filters).pipe(completeOnEOSE()));
             this.log(`Requesting ${pointers.length} tag values from ${requests.length} relays`);
             return cacheRequest ? merge(cacheRequest, ...requests) : merge(...requests);
         })));
+        // Set options
+        this.cacheRequest = opts?.cacheRequest;
+        this.extraRelays = opts?.extraRelays;
         // create a unique logger for this instance
         this.name = opts?.name ?? "";
         this.log = this.log.extend(opts?.kinds ? `${this.name} ${filterTag} (${opts?.kinds?.join(",")})` : `${this.name} ${filterTag}`);

package/dist/loaders/timeline-loader.d.ts

@@ -1,15 +1,15 @@
-import { EventPacket, RxNostr } from "rx-nostr";
-import { BehaviorSubject } from "rxjs";
 import { logger } from "applesauce-core";
-import { RelayTimelineLoader, TimelessFilter } from "./relay-timeline-loader.js";
-import { CacheRequest, Loader, RelayFilterMap } from "./loader.js";
+import { NostrEvent } from "nostr-tools";
+import { BehaviorSubject } from "rxjs";
 import { CacheTimelineLoader } from "./cache-timeline-loader.js";
+import { CacheRequest, Loader, NostrRequest, RelayFilterMap } from "./loader.js";
+import { RelayTimelineLoader, TimelessFilter } from "./relay-timeline-loader.js";
 export type TimelineLoaderOptions = {
     limit?: number;
     cacheRequest?: CacheRequest;
 };
 /** A multi-relay timeline loader that can be used to load a timeline from multiple relays */
-export declare class TimelineLoader extends Loader<number | undefined, EventPacket> {
+export declare class TimelineLoader extends Loader<number | undefined, NostrEvent> {
     id: string;
     loading$: BehaviorSubject<boolean>;
     get loading(): boolean;
@@ -17,6 +17,6 @@ export declare class TimelineLoader extends Loader<number | undefined, EventPack
     protected log: typeof logger;
     protected cache?: CacheTimelineLoader;
     protected loaders: Map<string, RelayTimelineLoader>;
-    constructor(rxNostr: RxNostr, requests: RelayFilterMap<TimelessFilter>, opts?: TimelineLoaderOptions);
+    constructor(request: NostrRequest, requests: RelayFilterMap<TimelessFilter>, opts?: TimelineLoaderOptions);
     static simpleFilterMap(relays: string[], filters: TimelessFilter[]): RelayFilterMap<TimelessFilter>;
 }

package/dist/loaders/timeline-loader.js

@@ -1,10 +1,10 @@
-import { BehaviorSubject, combineLatest, connect, merge, tap } from "rxjs";
 import { logger } from "applesauce-core";
 import { mergeFilters } from "applesauce-core/helpers";
 import { nanoid } from "nanoid";
-import { RelayTimelineLoader } from "./relay-timeline-loader.js";
-import { Loader } from "./loader.js";
+import { BehaviorSubject, combineLatest, connect, merge, tap } from "rxjs";
 import { CacheTimelineLoader } from "./cache-timeline-loader.js";
+import { Loader } from "./loader.js";
+import { RelayTimelineLoader } from "./relay-timeline-loader.js";
 /** A multi-relay timeline loader that can be used to load a timeline from multiple relays */
 export class TimelineLoader extends Loader {
     id = nanoid(8);
@@ -16,7 +16,7 @@ export class TimelineLoader extends Loader {
     log = logger.extend("TimelineLoader");
     cache;
     loaders;
-    constructor(rxNostr, requests, opts) {
+    constructor(request, requests, opts) {
         const loaders = new Map();
         // create cache loader
         const cache = opts?.cacheRequest
@@ -24,7 +24,7 @@ export class TimelineLoader extends Loader {
             : undefined;
         // create loaders
         for (const [relay, filters] of Object.entries(requests)) {
-            loaders.set(relay, new RelayTimelineLoader(rxNostr, relay, filters, opts));
+            loaders.set(relay, new RelayTimelineLoader(request, relay, filters, opts));
         }
         const allLoaders = cache ? [cache, ...loaders.values()] : Array.from(loaders.values());
         super((source) => {

package/dist/loaders/user-sets-loader.d.ts

@@ -1,6 +1,6 @@
-import { EventPacket, RxNostr } from "rx-nostr";
 import { logger } from "applesauce-core";
-import { CacheRequest, Loader } from "./loader.js";
+import { NostrEvent } from "nostr-tools";
+import { CacheRequest, Loader, NostrRequest } from "./loader.js";
 export type LoadableSetPointer = {
     /** A replaceable kind >= 30000 & < 40000 */
     kind: number;
@@ -25,7 +25,9 @@ export type UserSetsLoaderOptions = {
     refreshTimeout?: number;
 };
 /** A loader that can be used to load users NIP-51 sets events ( kind >= 30000 < 40000) */
-export declare class UserSetsLoader extends Loader<LoadableSetPointer, EventPacket> {
+export declare class UserSetsLoader extends Loader<LoadableSetPointer, NostrEvent> {
     log: typeof logger;
-    constructor(rxNostr: RxNostr, opts?: UserSetsLoaderOptions);
+    /** An array of relays to always fetch from */
+    extraRelays?: string[];
+    constructor(request: NostrRequest, opts?: UserSetsLoaderOptions);
 }

package/dist/loaders/user-sets-loader.js

@@ -1,15 +1,15 @@
-import { tap, from, filter, map, mergeAll, bufferTime } from "rxjs";
-import { createRxOneshotReq } from "rx-nostr";
-import { markFromCache } from "applesauce-core/helpers";
 import { logger } from "applesauce-core";
+import { markFromCache } from "applesauce-core/helpers";
 import { nanoid } from "nanoid";
-import { Loader } from "./loader.js";
-import { generatorSequence } from "../operators/generator-sequence.js";
+import { bufferTime, filter, from, map, mergeAll, tap } from "rxjs";
 import { consolidateAddressPointers, createFiltersFromAddressPointers } from "../helpers/address-pointer.js";
 import { groupByRelay } from "../helpers/pointer.js";
+import { completeOnEOSE } from "../operators/complete-on-eose.js";
 import { distinctRelaysBatch } from "../operators/distinct-relays.js";
+import { generatorSequence } from "../operators/generator-sequence.js";
+import { Loader } from "./loader.js";
 /** A generator that tries to load the address pointers from the cache first, then tries the relays */
-function* cacheFirstSequence(rxNostr, pointers, log, opts) {
+function* cacheFirstSequence(request, pointers, log, opts) {
     const id = nanoid(8);
     log = log.extend(id);
     // first attempt, load from cache relays
@@ -18,27 +18,18 @@ function* cacheFirstSequence(rxNostr, pointers, log, opts) {
         const filters = createFiltersFromAddressPointers(pointers);
         const results = yield opts.cacheRequest(filters).pipe(
         // mark the event as from the cache
-        tap((event) => markFromCache(event)), 
-        // convert to event packets
-        map((e) => ({ event: e, from: "", subId: "user-sets-loader", type: "EVENT" })));
+        tap((event) => markFromCache(event)));
         if (results.length > 0) {
             log(`Loaded ${results.length} events from cache`);
         }
     }
-    let byRelay = groupByRelay(pointers, "default");
+    let byRelay = groupByRelay(pointers, opts?.extraRelays);
     // load sets from relays
     yield from(Array.from(byRelay.entries()).map(([relay, pointers]) => {
         let filters = createFiltersFromAddressPointers(pointers);
         let count = 0;
-        const req = createRxOneshotReq({ filters, rxReqId: id });
         log(`Requesting from ${relay}`, pointers);
-        let sub$;
-        // don't specify relay if this is the "default" relay
-        if (relay === "default")
-            sub$ = rxNostr.use(req);
-        else
-            sub$ = rxNostr.use(req, { on: { relays: [relay] } });
-        return sub$.pipe(tap({
+        return request([relay], filters, id).pipe(completeOnEOSE(), tap({
             next: () => count++,
             complete: () => log(`Completed ${relay}, loaded ${count} events`),
         }));
@@ -47,7 +38,9 @@ function* cacheFirstSequence(rxNostr, pointers, log, opts) {
 /** A loader that can be used to load users NIP-51 sets events ( kind >= 30000 < 40000) */
 export class UserSetsLoader extends Loader {
     log = logger.extend("UserSetsLoader");
-    constructor(rxNostr, opts) {
+    /** An array of relays to always fetch from */
+    extraRelays;
+    constructor(request, opts) {
         let options = opts || {};
         super((source) => source.pipe(
         // load first from cache
@@ -59,7 +52,7 @@ export class UserSetsLoader extends Loader {
         // deduplicate address pointers
         map(consolidateAddressPointers), 
         // check cache, relays, lookup relays in that order
-        generatorSequence((pointers) => cacheFirstSequence(rxNostr, pointers, this.log, options), 
+        generatorSequence((pointers) => cacheFirstSequence(request, pointers, this.log, options), 
         // there will always be more events, never complete
         false)));
     }

package/dist/operators/complete-on-eose.d.ts

@@ -0,0 +1,3 @@
+import { OperatorFunction } from "rxjs";
+/** Completes the observable when an EOSE message is received */
+export declare function completeOnEOSE<T extends unknown>(): OperatorFunction<T | "EOSE", T>;

package/dist/operators/complete-on-eose.js

@@ -0,0 +1,5 @@
+import { takeWhile } from "rxjs";
+/** Completes the observable when an EOSE message is received */
+export function completeOnEOSE() {
+    return (source) => source.pipe(takeWhile((m) => m !== "EOSE", false));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-loaders",
-  "version": "0.12.0",
+  "version": "1.0.0",
   "description": "A collection of observable based loaders built on rx-nostr",
   "type": "module",
   "main": "dist/index.js",
@@ -53,18 +53,16 @@
     }
   },
   "dependencies": {
-    "applesauce-core": "^0.12.0",
+    "applesauce-core": "^1.0.0",
     "nanoid": "^5.0.9",
     "nostr-tools": "^2.10.4",
-    "rx-nostr": "^3.5.0",
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
-    "rx-nostr-crypto": "^3.1.3",
-    "typescript": "^5.7.3",
-    "vitest": "^3.0.5",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.1",
     "vitest-nostr": "^0.4.1",
-    "vitest-websocket-mock": "^0.4.0"
+    "vitest-websocket-mock": "^0.5.0"
   },
   "funding": {
     "type": "lightning",

package/dist/helpers/rx-nostr.d.ts

@@ -1,2 +0,0 @@
-import { RxNostr } from "rx-nostr";
-export declare function getDefaultReadRelays(rxNostr: RxNostr): string[];

package/dist/helpers/rx-nostr.js

@@ -1,5 +0,0 @@
-export function getDefaultReadRelays(rxNostr) {
-    return Object.entries(rxNostr.getDefaultRelays())
-        .filter(([_, config]) => config.read)
-        .map(([relay]) => relay);
-}

package/dist/loaders/__tests__/request-loader.test.d.ts

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

package/dist/loaders/__tests__/request-loader.test.js

@@ -1,37 +0,0 @@
-import { Subject } from "rxjs";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { TimeoutError } from "applesauce-core/observable";
-import { EventStore, QueryStore } from "applesauce-core";
-import { RequestLoader } from "../request-loader.js";
-let eventStore;
-let queryStore;
-let loader;
-beforeEach(() => {
-    eventStore = new EventStore();
-    queryStore = new QueryStore(eventStore);
-    loader = new RequestLoader(queryStore);
-    // @ts-expect-error
-    loader.replaceableLoader = new Subject();
-    vi.spyOn(loader.replaceableLoader, "next").mockImplementation(() => { });
-});
-describe("profile", () => {
-    it("should return a promise that resolves", async () => {
-        const p = loader.profile({ pubkey: "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d" });
-        expect(loader.replaceableLoader.next).toHaveBeenCalledWith(expect.objectContaining({ pubkey: "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d" }));
-        eventStore.add({
-            content: '{"name":"fiatjaf","about":"~","picture":"https://fiatjaf.com/static/favicon.jpg","nip05":"_@fiatjaf.com","lud16":"fiatjaf@zbd.gg","website":"https://nostr.technology"}',
-            created_at: 1738588530,
-            id: "c43be8b4634298e97dde3020a5e6aeec37d7f5a4b0259705f496e81a550c8f8b",
-            kind: 0,
-            pubkey: "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d",
-            sig: "202a1bf6a58943d660c1891662dbdda142aa8e5bca9d4a3cb03cde816ad3bdda6f4ec3b880671506c2820285b32218a0afdec2d172de9694d83972190ab4f9da",
-            tags: [],
-        });
-        expect(await p).toEqual(expect.objectContaining({ name: "fiatjaf" }));
-    });
-    it("should reject with TimeoutError after 10 seconds", async () => {
-        // reduce timeout for tests
-        loader.requestTimeout = 10;
-        await expect(loader.profile({ pubkey: "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d" })).rejects.toThrow(TimeoutError);
-    });
-});

package/dist/loaders/request-loader.d.ts

@@ -1,30 +0,0 @@
-import { IEventStore, QueryStore } from "applesauce-core";
-import { ProfilePointer } from "nostr-tools/nip19";
-import { Observable } from "rxjs";
-import { ReplaceableLoader } from "./replaceable-loader.js";
-import { LoadableAddressPointer } from "../helpers/address-pointer.js";
-/** A special Promised based loader built on the {@link QueryStore} */
-export declare class RequestLoader {
-    store: QueryStore;
-    requestTimeout: number;
-    replaceableLoader?: ReplaceableLoader;
-    constructor(store: QueryStore);
-    protected runWithTimeout<T extends unknown, Args extends Array<any>>(queryConstructor: (...args: Args) => {
-        key: string;
-        run: (events: IEventStore, store: QueryStore) => Observable<T>;
-    }, ...args: Args): Promise<NonNullable<T>>;
-    protected checkReplaceable(): ReplaceableLoader;
-    /** Requests a single replaceable event */
-    replaceable(pointer: LoadableAddressPointer, force?: boolean): Promise<import("nostr-tools").Event>;
-    /** Loads a pubkeys profile */
-    profile(pointer: ProfilePointer, force?: boolean): Promise<import("applesauce-core/helpers").ProfileContent>;
-    /** Loads a pubkeys profile */
-    mailboxes(pointer: ProfilePointer, force?: boolean): Promise<{
-        inboxes: string[];
-        outboxes: string[];
-    }>;
-    /** Loads a pubkeys profile */
-    contacts(pointer: ProfilePointer, force?: boolean): Promise<ProfilePointer[]>;
-    /** Loads a pubkeys blossom servers */
-    blossomServers(pointer: ProfilePointer, force?: boolean): Promise<URL[]>;
-}

package/dist/loaders/request-loader.js

@@ -1,57 +0,0 @@
-import { kinds } from "nostr-tools";
-import { MailboxesQuery, ProfileQuery, ReplaceableQuery, UserBlossomServersQuery, UserContactsQuery, } from "applesauce-core/queries";
-import { getObservableValue, simpleTimeout } from "applesauce-core/observable";
-import { filter } from "rxjs";
-import { BLOSSOM_SERVER_LIST_KIND } from "applesauce-core/helpers";
-/** A special Promised based loader built on the {@link QueryStore} */
-export class RequestLoader {
-    store;
-    requestTimeout = 10_000;
-    replaceableLoader;
-    constructor(store) {
-        this.store = store;
-    }
-    // hacky method to run queries with timeouts
-    async runWithTimeout(queryConstructor, ...args) {
-        return getObservableValue(this.store.createQuery(queryConstructor, ...args).pipe(
-        // ignore undefined and null values
-        filter((v) => v !== undefined && v !== null), 
-        // timeout with an error is not values
-        simpleTimeout(this.requestTimeout)));
-    }
-    checkReplaceable() {
-        if (!this.replaceableLoader)
-            throw new Error("Missing ReplaceableLoader");
-        return this.replaceableLoader;
-    }
-    /** Requests a single replaceable event */
-    replaceable(pointer, force) {
-        this.checkReplaceable().next({ ...pointer, force });
-        return this.runWithTimeout(ReplaceableQuery, pointer.kind, pointer.pubkey, pointer.identifier);
-    }
-    /** Loads a pubkeys profile */
-    profile(pointer, force) {
-        this.checkReplaceable().next({ kind: kinds.Metadata, pubkey: pointer.pubkey, relays: pointer.relays, force });
-        return this.runWithTimeout(ProfileQuery, pointer.pubkey);
-    }
-    /** Loads a pubkeys profile */
-    mailboxes(pointer, force) {
-        this.checkReplaceable().next({ kind: kinds.RelayList, pubkey: pointer.pubkey, relays: pointer.relays, force });
-        return this.runWithTimeout(MailboxesQuery, pointer.pubkey);
-    }
-    /** Loads a pubkeys profile */
-    contacts(pointer, force) {
-        this.checkReplaceable().next({ kind: kinds.Contacts, pubkey: pointer.pubkey, relays: pointer.relays, force });
-        return this.runWithTimeout(UserContactsQuery, pointer.pubkey);
-    }
-    /** Loads a pubkeys blossom servers */
-    blossomServers(pointer, force) {
-        this.checkReplaceable().next({
-            kind: BLOSSOM_SERVER_LIST_KIND,
-            pubkey: pointer.pubkey,
-            relays: pointer.relays,
-            force,
-        });
-        return this.runWithTimeout(UserBlossomServersQuery, pointer.pubkey);
-    }
-}