applesauce-loaders 2.0.0 → 3.0.0

package/dist/helpers/address-pointer.d.ts

@@ -1,16 +1,6 @@
 import { AddressPointerWithoutD } from "applesauce-core/helpers";
 import { Filter } from "nostr-tools";
 import { AddressPointer } from "nostr-tools/nip19";
-export type LoadableAddressPointer = {
-    kind: number;
-    pubkey: string;
-    /** Optional "d" tag for paramaritized replaceable */
-    identifier?: string;
-    /** Relays to load from */
-    relays?: string[];
-    /** Ignore all forms of caching */
-    force?: boolean;
-};
 /** Converts an array of address pointers to a filter */
 export declare function createFilterFromAddressPointers(pointers: AddressPointerWithoutD[] | AddressPointer[]): Filter;
 /** Takes a set of address pointers, groups them, then returns filters for the groups */
@@ -23,7 +13,3 @@ export declare function groupAddressPointersByKind(pointers: AddressPointerWitho
 export declare function groupAddressPointersByPubkey(pointers: AddressPointerWithoutD[]): Map<string, AddressPointerWithoutD[]>;
 /** Groups address pointers by kind or pubkey depending on which is most optimal */
 export declare function groupAddressPointersByPubkeyOrKind(pointers: AddressPointerWithoutD[]): Map<string, AddressPointerWithoutD[]> | Map<number, AddressPointerWithoutD[]>;
-/** @deprecated use mergeRelaySets instead */
-export declare function getRelaysFromPointers(pointers: AddressPointerWithoutD[]): Set<string>;
-/** deduplicates an array of address pointers and merges their relays array */
-export declare function consolidateAddressPointers(pointers: LoadableAddressPointer[]): LoadableAddressPointer[];

package/dist/helpers/address-pointer.js

@@ -1,4 +1,3 @@
-import { createReplaceableAddress, mergeRelaySets } from "applesauce-core/helpers";
 import { isAddressableKind, isReplaceableKind } from "nostr-tools/kinds";
 import { unique } from "./array.js";
 /** Converts an array of address pointers to a filter */
@@ -14,15 +13,15 @@ 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) => isAddressableKind(p.kind));
     const replaceable = pointers.filter((p) => isReplaceableKind(p.kind));
+    const addressable = pointers.filter((p) => isAddressableKind(p.kind));
     const filters = [];
     if (replaceable.length > 0) {
         const groups = groupAddressPointersByPubkeyOrKind(replaceable);
         filters.push(...Array.from(groups.values()).map(createFilterFromAddressPointers));
     }
-    if (parameterizedReplaceable.length > 0) {
-        const groups = groupAddressPointersByPubkeyOrKind(parameterizedReplaceable);
+    if (addressable.length > 0) {
+        const groups = groupAddressPointersByPubkeyOrKind(addressable);
         filters.push(...Array.from(groups.values()).map(createFilterFromAddressPointers));
     }
     return filters;
@@ -62,48 +61,3 @@ export function groupAddressPointersByPubkeyOrKind(pointers) {
     const pubkeys = new Set(pointers.map((p) => p.pubkey));
     return pubkeys.size < kinds.size ? groupAddressPointersByPubkey(pointers) : groupAddressPointersByKind(pointers);
 }
-/** @deprecated use mergeRelaySets instead */
-export function getRelaysFromPointers(pointers) {
-    const relays = new Set();
-    for (const pointer of pointers) {
-        if (!pointer.relays)
-            continue;
-        for (const relay of pointer.relays) {
-            relays.add(relay);
-        }
-    }
-    return relays;
-}
-/** deep clone a loadable pointer to ensure its safe to modify */
-function cloneLoadablePointer(pointer) {
-    const clone = { ...pointer };
-    if (pointer.relays)
-        clone.relays = [...pointer.relays];
-    return clone;
-}
-/** deduplicates an array of address pointers and merges their relays array */
-export function consolidateAddressPointers(pointers) {
-    const byAddress = new Map();
-    for (const pointer of pointers) {
-        const addr = createReplaceableAddress(pointer.kind, pointer.pubkey, pointer.identifier);
-        if (byAddress.has(addr)) {
-            // duplicate, merge pointers
-            const current = byAddress.get(addr);
-            // merge relays
-            if (pointer.relays) {
-                if (current.relays)
-                    current.relays = mergeRelaySets(current.relays, pointer.relays);
-                else
-                    current.relays = pointer.relays;
-            }
-            // merge force flag
-            if (pointer.force !== undefined) {
-                current.force = current.force || pointer.force;
-            }
-        }
-        else
-            byAddress.set(addr, cloneLoadablePointer(pointer));
-    }
-    // return consolidated pointers
-    return Array.from(byAddress.values());
-}

package/dist/helpers/cache.d.ts

@@ -1,9 +1,7 @@
 import { Observable } from "rxjs";
 import { Filter, NostrEvent } from "nostr-tools";
-import { CacheRequest, FilterRequest } from "../types.js";
+import { CacheRequest } from "../types.js";
 /** Calls the cache request and converts the reponse into an observable */
 export declare function unwrapCacheRequest(request: CacheRequest, filters: Filter[]): Observable<NostrEvent>;
 /** Calls a cache request method with filters and marks all returned events as being from the cache */
 export declare function makeCacheRequest(request: CacheRequest, filters: Filter[]): Observable<NostrEvent>;
-/** Wraps a cache request method and returns a FilterRequest */
-export declare function wrapCacheRequest(request: CacheRequest): FilterRequest;

package/dist/helpers/cache.js

@@ -16,7 +16,3 @@ export function unwrapCacheRequest(request, filters) {
 export function makeCacheRequest(request, filters) {
     return unwrapCacheRequest(request, filters).pipe(tap((e) => markFromCache(e)));
 }
-/** Wraps a cache request method and returns a FilterRequest */
-export function wrapCacheRequest(request) {
-    return (filters) => makeCacheRequest(request, filters);
-}

package/dist/helpers/loaders.d.ts

@@ -1,3 +1,8 @@
 import { MonoTypeOperatorFunction, Observable, OperatorFunction } from "rxjs";
-/** Creates a loader that takes a single value and batches the requests to an upstream loader */
+/** Takes a value optionally wrapped in an observable and unwraps it */
+export declare function unwrap<T, R>(value: T | Observable<T>, next: (value: T) => Observable<R>): Observable<R>;
+/**
+ * Creates a loader that takes a single value and batches the requests to an upstream loader
+ * IMPORTANT: the buffer operator MUST NOT filter values. its important that every input creates a new upstream request
+ */
 export declare function batchLoader<Input extends unknown = unknown, Output extends unknown = unknown>(buffer: OperatorFunction<Input, Input[]>, upstream: (input: Input[]) => Observable<Output>, matcher: (input: Input, output: Output) => boolean, output?: MonoTypeOperatorFunction<Output>): (value: Input) => Observable<Output>;

package/dist/helpers/loaders.js

@@ -1,18 +1,33 @@
-import { filter, identity, map, mergeAll, Observable, share, Subject, take, } from "rxjs";
-/** Creates a loader that takes a single value and batches the requests to an upstream loader */
+import { filter, identity, isObservable, mergeAll, Observable, share, Subject, switchMap, take, } from "rxjs";
+/** Takes a value optionally wrapped in an observable and unwraps it */
+export function unwrap(value, next) {
+    return isObservable(value) ? value.pipe(take(1), switchMap(next)) : next(value);
+}
+/**
+ * Creates a loader that takes a single value and batches the requests to an upstream loader
+ * IMPORTANT: the buffer operator MUST NOT filter values. its important that every input creates a new upstream request
+ */
 export function batchLoader(buffer, upstream, matcher, output) {
     const queue = new Subject();
-    const requests = queue.pipe(buffer, 
-    // ignore empty buffers
-    filter((buffer) => buffer.length > 0), 
-    // create a new upstream request for each buffer and make sure only one is created
-    map((v) => upstream(v).pipe(share())), 
-    // Make sure that only a single upstream buffer is created
-    share());
+    const next = new Subject();
+    // Every "buffer" make a new upstream request
+    queue.pipe(buffer).subscribe((buffer) => {
+        // If there is nothing in the buffer, dont make a request
+        if (buffer.length === 0)
+            return;
+        return next.next(upstream(buffer).pipe(
+        // Never reset the upstream request
+        share({ resetOnRefCountZero: false, resetOnComplete: false, resetOnError: false })));
+    });
     return (input) => new Observable((observer) => {
         // Add the pointer to the queue when observable is subscribed
-        setTimeout(() => queue.next(input), 0);
-        return requests
+        // NOTE: do not use setTimeout here, FF has a strange bug where it will delay the queue.next until after the buffer
+        /*
+        Adding the value to the queue before the request subscribes to the next batch may cause it to miss the next batch
+        but it should work the majority of the time because buffers use setTimeout internally which always runs next tick
+        */
+        queue.next(input);
+        return next
             .pipe(
         // wait for the next batch to run
         take(1), 

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

@@ -1,8 +1,17 @@
 import { IEventStore } from "applesauce-core";
 import { NostrEvent } from "nostr-tools";
 import { Observable } from "rxjs";
-import { LoadableAddressPointer } from "../helpers/address-pointer.js";
 import { CacheRequest, NostrRequest, UpstreamPool } from "../types.js";
+export type LoadableAddressPointer = {
+    kind: number;
+    pubkey: string;
+    /** Optional "d" tag for paramaritized replaceable */
+    identifier?: string;
+    /** Relays to load from */
+    relays?: string[];
+    /** Whether to ignore the cache */
+    cache?: boolean;
+};
 /** A method that takes address pointers and returns an observable of events */
 export type AddressPointersLoader = (pointers: LoadableAddressPointer[]) => Observable<NostrEvent>;
 export type AddressPointerLoader = (pointer: LoadableAddressPointer) => Observable<NostrEvent>;
@@ -17,6 +26,8 @@ export declare function relayHintsAddressPointersLoader(request: NostrRequest):
 export declare function relaysAddressPointersLoader(request: NostrRequest, relays: Observable<string[]> | string[]): AddressPointersLoader;
 /** Creates a loader that loads all event pointers based on their relays */
 export declare function addressPointerLoadingSequence(...loaders: (AddressPointersLoader | undefined)[]): AddressPointersLoader;
+/** deduplicates an array of address pointers and merges their relays array */
+export declare function consolidateAddressPointers(pointers: LoadableAddressPointer[]): LoadableAddressPointer[];
 export type AddressLoaderOptions = Partial<{
     /** Time interval to buffer requests in ms ( default 1000 ) */
     bufferTime: number;
@@ -28,10 +39,10 @@ export type AddressLoaderOptions = Partial<{
     cacheRequest: CacheRequest;
     /** Whether to follow relay hints ( default true ) */
     followRelayHints: boolean;
-    /** Fallback lookup relays to check when event cant be found */
-    lookupRelays: string[] | Observable<string[]>;
     /** An array of relays to always fetch from */
     extraRelays: string[] | Observable<string[]>;
+    /** Fallback lookup relays to check when event cant be found */
+    lookupRelays: string[] | Observable<string[]>;
 }>;
 /** Create a pre-built address pointer loader that supports batching, caching, and lookup relays */
 export declare function createAddressLoader(pool: UpstreamPool, opts?: AddressLoaderOptions): AddressPointerLoader;

package/dist/loaders/address-loader.js

@@ -1,19 +1,23 @@
 import { mapEventsToStore } from "applesauce-core";
 import { createReplaceableAddress, getReplaceableAddress, getReplaceableIdentifier, isReplaceable, mergeRelaySets, } from "applesauce-core/helpers";
-import { bufferTime, catchError, EMPTY, filter, isObservable, map, of, pipe, switchMap, take } from "rxjs";
-import { consolidateAddressPointers, createFiltersFromAddressPointers, isLoadableAddressPointer, } from "../helpers/address-pointer.js";
-import { makeCacheRequest, wrapCacheRequest } from "../helpers/cache.js";
-import { batchLoader } from "../helpers/loaders.js";
-import { wrapGeneratorFunction } from "../operators/generator.js";
+import { bufferTime, catchError, EMPTY } from "rxjs";
+import { createFiltersFromAddressPointers, isLoadableAddressPointer } from "../helpers/address-pointer.js";
+import { makeCacheRequest } from "../helpers/cache.js";
+import { batchLoader, unwrap } from "../helpers/loaders.js";
 import { wrapUpstreamPool } from "../helpers/upstream.js";
+import { wrapGeneratorFunction } from "../operators/generator.js";
 /**
  * Loads address pointers from an async cache
  * @note ignores pointers with force=true
  */
 export function cacheAddressPointersLoader(request) {
-    return (pointers) => makeCacheRequest(request, createFiltersFromAddressPointers(pointers
-        // Ignore pointers that want to skip cache
-        .filter((p) => p.force !== true)));
+    return (pointers) => {
+        pointers = pointers.filter((p) => p.cache !== false);
+        // Skip if there are no pointers to load from cache
+        if (pointers.length === 0)
+            return EMPTY;
+        return makeCacheRequest(request, createFiltersFromAddressPointers(pointers));
+    };
 }
 /** Loads address pointers from the relay hints */
 export function relayHintsAddressPointersLoader(request) {
@@ -27,22 +31,22 @@ export function relayHintsAddressPointersLoader(request) {
 }
 /** Loads address pointers from an array of relays */
 export function relaysAddressPointersLoader(request, relays) {
-    return (pointers) => 
-    // Resolve the relays as an observable
-    (isObservable(relays) ? relays : of(relays)).pipe(
-    // Only take the first value
-    take(1), 
-    // Make the request
-    switchMap((relays) => {
+    return (pointers) => unwrap(relays, (relays) => {
         if (relays.length === 0)
             return EMPTY;
         const filters = createFiltersFromAddressPointers(pointers);
         return request(relays, filters);
-    }));
+    });
 }
 /** Creates a loader that loads all event pointers based on their relays */
 export function addressPointerLoadingSequence(...loaders) {
     return wrapGeneratorFunction(function* (pointers) {
+        // Filter out invalid pointers and consolidate
+        pointers = consolidateAddressPointers(pointers.filter(isLoadableAddressPointer));
+        // Skip if there are no pointers
+        if (pointers.length === 0)
+            return;
+        // Keep track of remaining pointers to load
         let remaining = Array.from(pointers);
         for (const loader of loaders) {
             if (loader === undefined)
@@ -53,32 +57,55 @@ export function addressPointerLoadingSequence(...loaders) {
             // Get set of addresses loaded
             const addresses = new Set(results.filter((e) => isReplaceable(e.kind)).map((event) => getReplaceableAddress(event)));
             // Remove the pointers that were loaded
-            remaining = remaining.filter((p) => !addresses.has(createReplaceableAddress(p.kind, p.pubkey, p.identifier)) || p.force === true);
+            remaining = remaining.filter((p) => !addresses.has(createReplaceableAddress(p.kind, p.pubkey, p.identifier)));
             // If there are no remaining pointers, complete
             if (remaining.length === 0)
                 return;
         }
     });
 }
+/** deep clone a loadable pointer to ensure its safe to modify */
+function cloneLoadablePointer(pointer) {
+    const clone = { ...pointer };
+    if (pointer.relays)
+        clone.relays = [...pointer.relays];
+    return clone;
+}
+/** deduplicates an array of address pointers and merges their relays array */
+export function consolidateAddressPointers(pointers) {
+    const byAddress = new Map();
+    for (const pointer of pointers) {
+        const addr = createReplaceableAddress(pointer.kind, pointer.pubkey, pointer.identifier);
+        if (byAddress.has(addr)) {
+            // duplicate, merge pointers
+            const current = byAddress.get(addr);
+            // merge relays
+            if (pointer.relays && pointer.relays.length > 0) {
+                if (current.relays)
+                    current.relays = mergeRelaySets(current.relays, pointer.relays);
+                else
+                    current.relays = pointer.relays;
+            }
+            // merge cache flag
+            if (pointer.cache === false)
+                current.cache = false;
+        }
+        else
+            byAddress.set(addr, cloneLoadablePointer(pointer));
+    }
+    // return consolidated pointers
+    return Array.from(byAddress.values());
+}
 /** Create a pre-built address pointer loader that supports batching, caching, and lookup relays */
 export function createAddressLoader(pool, opts) {
     const request = wrapUpstreamPool(pool);
-    const cacheRequest = opts?.cacheRequest ? wrapCacheRequest(opts.cacheRequest) : undefined;
     return batchLoader(
-    // Create batching sequence
-    pipe(
-    // filter out invalid pointers
-    filter(isLoadableAddressPointer), 
     // buffer requests by time or size
     bufferTime(opts?.bufferTime ?? 1000, undefined, opts?.bufferSize ?? 200), 
-    // Ingore empty buffers
-    filter((b) => b.length > 0), 
-    // consolidate buffered pointers
-    map(consolidateAddressPointers)), 
     // Create a loader for batching
     addressPointerLoadingSequence(
     // Step 1. load from cache if available
-    cacheRequest ? cacheAddressPointersLoader(cacheRequest) : undefined, 
+    opts?.cacheRequest ? cacheAddressPointersLoader(opts.cacheRequest) : undefined, 
     // Step 2. load from relay hints on pointers
     opts?.followRelayHints !== false ? relayHintsAddressPointersLoader(request) : undefined, 
     // Step 3. load from extra relays

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

@@ -3,8 +3,11 @@ import { NostrEvent } from "nostr-tools";
 import { EventPointer } from "nostr-tools/nip19";
 import { Observable } from "rxjs";
 import { CacheRequest, NostrRequest, UpstreamPool } from "../types.js";
-export type EventPointerLoader = (pointer: EventPointer) => Observable<NostrEvent>;
-export type createEventLoader = (pointers: EventPointer[]) => Observable<NostrEvent>;
+export type LoadableEventPointer = EventPointer & {
+    cache?: boolean;
+};
+export type EventPointerLoader = (pointer: LoadableEventPointer) => Observable<NostrEvent>;
+export type createEventLoader = (pointers: LoadableEventPointer[]) => Observable<NostrEvent>;
 /** Creates a loader that gets a single event from the cache */
 export declare function cacheEventsLoader(request: CacheRequest): createEventLoader;
 /** Creates a loader that gets an array of events from a list of relays */

package/dist/loaders/event-loader.js

@@ -1,24 +1,23 @@
 import { mapEventsToStore } from "applesauce-core";
-import { bufferTime, catchError, EMPTY, filter, isObservable, map, merge, of, pipe, switchMap, take, tap, } from "rxjs";
-import { makeCacheRequest, wrapCacheRequest } from "../helpers/cache.js";
+import { bufferTime, catchError, EMPTY, merge, tap } from "rxjs";
+import { makeCacheRequest } from "../helpers/cache.js";
 import { consolidateEventPointers } from "../helpers/event-pointer.js";
-import { batchLoader } from "../helpers/loaders.js";
+import { batchLoader, unwrap } from "../helpers/loaders.js";
 import { groupByRelay } from "../helpers/pointer.js";
-import { wrapGeneratorFunction } from "../operators/generator.js";
 import { wrapUpstreamPool } from "../helpers/upstream.js";
+import { wrapGeneratorFunction } from "../operators/generator.js";
 /** Creates a loader that gets a single event from the cache */
 export function cacheEventsLoader(request) {
-    return (pointers) => makeCacheRequest(request, [{ ids: pointers.map((p) => p.id) }]);
+    return (pointers) => {
+        pointers = pointers.filter((p) => p.cache !== false);
+        if (pointers.length === 0)
+            return EMPTY;
+        return makeCacheRequest(request, [{ ids: pointers.map((p) => p.id) }]);
+    };
 }
 /** Creates a loader that gets an array of events from a list of relays */
 export function relaysEventsLoader(request, relays) {
-    return (pointers) => 
-    // unwrap relays observable
-    (isObservable(relays) ? relays : of(relays)).pipe(
-    // take the first value
-    take(1), 
-    // Request events from relays
-    switchMap((relays) => request(relays, [{ ids: pointers.map((p) => p.id) }])));
+    return (pointers) => unwrap(relays, (relays) => request(relays, [{ ids: pointers.map((p) => p.id) }]));
 }
 /** Creates a loader that gets an array of events from a single relay */
 export function relayEventsLoader(request, relay) {
@@ -46,6 +45,11 @@ export function relayHintsEventsLoader(request, upstream = relayEventsLoader) {
 /** Creates a loader that tries to load events from a list of loaders in order */
 export function eventLoadingSequence(...loaders) {
     return wrapGeneratorFunction(function* (pointers) {
+        // Filter out invalid pointers and consolidate
+        pointers = consolidateEventPointers(pointers);
+        // Skip if there are no pointers
+        if (pointers.length === 0)
+            return;
         const found = new Set();
         let remaining = Array.from(pointers);
         for (const loader of loaders) {
@@ -67,20 +71,14 @@ export function eventLoadingSequence(...loaders) {
 /** Create a pre-built address pointer loader that supports batching, caching, and lookup relays */
 export function createEventLoader(pool, opts) {
     const request = wrapUpstreamPool(pool);
-    const cacheRequest = opts?.cacheRequest ? wrapCacheRequest(opts.cacheRequest) : undefined;
     return batchLoader(
     // Create batching sequence
-    pipe(
     // buffer requests by time or size
     bufferTime(opts?.bufferTime ?? 1000, undefined, opts?.bufferSize ?? 200), 
-    // Ingore empty buffers
-    filter((b) => b.length > 0), 
-    // consolidate buffered pointers
-    map(consolidateEventPointers)), 
     // Create a loader for batching
     eventLoadingSequence(
     // Step 1. load from cache if available
-    cacheRequest ? cacheEventsLoader(cacheRequest) : undefined, 
+    opts?.cacheRequest ? cacheEventsLoader(opts.cacheRequest) : undefined, 
     // Step 2. load from relay hints on pointers
     opts?.followRelayHints !== false ? relayHintsEventsLoader(request) : undefined, 
     // Step 3. load from extra relays

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

@@ -24,7 +24,7 @@ export type TagValueLoaderOptions = {
     /** Method used to load from the cache */
     cacheRequest?: CacheRequest;
     /** An array of relays to always fetch from */
-    extraRelays?: string[];
+    extraRelays?: string[] | Observable<string[]>;
     /** An event store used to deduplicate events */
     eventStore?: IEventStore;
 };

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

@@ -1,10 +1,9 @@
 import { mapEventsToStore } from "applesauce-core";
 import { mergeRelaySets } from "applesauce-core/helpers";
-import { bufferTime, filter, merge, pipe } from "rxjs";
+import { bufferTime, EMPTY, merge } from "rxjs";
 import { unique } from "../helpers/array.js";
-import { makeCacheRequest, wrapCacheRequest } from "../helpers/cache.js";
-import { batchLoader } from "../helpers/loaders.js";
-import { distinctRelaysBatch } from "../operators/distinct-relays.js";
+import { makeCacheRequest } from "../helpers/cache.js";
+import { batchLoader, unwrap } from "../helpers/loaders.js";
 import { wrapUpstreamPool } from "../helpers/upstream.js";
 /** Creates a loader that gets tag values from the cache */
 export function cacheTagValueLoader(request, tagName, opts) {
@@ -24,7 +23,7 @@ export function cacheTagValueLoader(request, tagName, opts) {
 /** Creates a loader that gets tag values from relays */
 export function relaysTagValueLoader(request, tagName, opts) {
     const filterTag = `#${tagName}`;
-    return (pointers) => {
+    return (pointers) => unwrap(opts?.extraRelays, (extraRelays) => {
         const baseFilter = {};
         if (opts?.kinds)
             baseFilter.kinds = opts.kinds;
@@ -34,7 +33,7 @@ export function relaysTagValueLoader(request, tagName, opts) {
             baseFilter.since = opts.since;
         // build request map for relays
         const requestMap = pointers.reduce((map, pointer) => {
-            const relays = mergeRelaySets(pointer.relays, opts?.extraRelays);
+            const relays = mergeRelaySets(pointer.relays, extraRelays);
             for (const relay of relays) {
                 if (!map[relay]) {
                     // create new filter for relay
@@ -49,27 +48,26 @@ export function relaysTagValueLoader(request, tagName, opts) {
         }, {});
         const requests = Object.entries(requestMap).map(([relay, filter]) => request([relay], [filter]));
         return merge(...requests);
-    };
+    });
 }
 /** Create a pre-built tag value loader that supports batching, caching, and relay hints */
 export function createTagValueLoader(pool, tagName, opts) {
     const request = wrapUpstreamPool(pool);
-    const cacheRequest = opts?.cacheRequest ? wrapCacheRequest(opts.cacheRequest) : undefined;
     return batchLoader(
-    // Create batching sequence
-    pipe(
     // buffer requests by time or size
     bufferTime(opts?.bufferTime ?? 1000, undefined, opts?.bufferSize ?? 200), 
-    // Ignore empty buffers
-    filter((b) => b.length > 0), 
-    // Only request from each relay once
-    distinctRelaysBatch((m) => m.value)), 
     // Create a loader for batching
-    (pointers) => merge(
-    // Step 1. load from cache if available
-    cacheRequest ? cacheTagValueLoader(cacheRequest, tagName, opts)(pointers) : [], 
-    // Step 2. load from relays
-    relaysTagValueLoader(request, tagName, opts)(pointers)), 
+    (pointers) => {
+        // Skip if there are no pointers
+        if (pointers.length === 0)
+            return EMPTY;
+        // Load from cache and relays in parallel
+        return merge(
+        // load from cache if available
+        opts?.cacheRequest ? cacheTagValueLoader(opts.cacheRequest, tagName, opts)(pointers) : [], 
+        // load from relays
+        relaysTagValueLoader(request, tagName, opts)(pointers));
+    }, 
     // Filter results based on requests
     (pointer, event) => event.tags.some((tag) => tag[0] === tagName && tag[1] === pointer.value), 
     // Pass all events through the store if defined

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

@@ -15,7 +15,7 @@ export type UserListsLoaderOptions = Partial<{
     /** A method used to load events from a local cache */
     cacheRequest?: CacheRequest;
     /** An array of extra relay to load from */
-    extraRelays?: string[];
+    extraRelays?: string[] | Observable<string[]>;
     /** An event store used to deduplicate events */
     eventStore: IEventStore;
 }>;

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

@@ -2,7 +2,8 @@ import { mapEventsToStore } from "applesauce-core";
 import { mergeRelaySets } from "applesauce-core/helpers";
 import { kinds } from "nostr-tools";
 import { EMPTY, identity, merge } from "rxjs";
-import { makeCacheRequest, wrapCacheRequest } from "../helpers/cache.js";
+import { makeCacheRequest } from "../helpers/cache.js";
+import { unwrap } from "../helpers/loaders.js";
 import { wrapUpstreamPool } from "../helpers/upstream.js";
 /** A list of NIP-51 list kinds that most clients will use */
 export const COMMON_LIST_KINDS = [kinds.Contacts, kinds.Mutelist, kinds.Pinlist, kinds.BookmarkList];
@@ -14,20 +15,19 @@ export const COMMON_SET_KINDS = [kinds.Bookmarksets, kinds.Followsets];
  */
 export function createUserListsLoader(pool, opts) {
     const request = wrapUpstreamPool(pool);
-    const cacheRequest = opts?.cacheRequest ? wrapCacheRequest(opts.cacheRequest) : undefined;
-    return (user) => {
+    return (user) => unwrap(opts?.extraRelays, (extraRelays) => {
         const filter = {
             kinds: opts?.kinds || [...COMMON_LIST_KINDS, ...COMMON_SET_KINDS],
             authors: [user.pubkey],
         };
         // Merge extra relays with user relays
-        const relays = opts?.extraRelays ? mergeRelaySets(user.relays, opts.extraRelays) : user.relays;
+        const relays = mergeRelaySets(user.relays, extraRelays);
         return merge(
         // Load from cache
-        cacheRequest ? makeCacheRequest(cacheRequest, [filter]) : EMPTY, 
+        opts?.cacheRequest ? makeCacheRequest(opts.cacheRequest, [filter]) : EMPTY, 
         // Load from relays
         relays ? request(relays, [filter]) : EMPTY).pipe(
         // If event store is set, deduplicate events
         opts?.eventStore ? mapEventsToStore(opts.eventStore) : identity);
-    };
+    });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-loaders",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "description": "A collection of observable based loaders built on rx-nostr",
   "type": "module",
   "main": "dist/index.js",
@@ -53,14 +53,14 @@
     }
   },
   "dependencies": {
-    "applesauce-core": "^2.0.0",
+    "applesauce-core": "^3.0.0",
     "nanoid": "^5.0.9",
     "nostr-tools": "^2.13",
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
     "@hirez_io/observer-spy": "^2.2.0",
-    "applesauce-signers": "^2.0.0",
+    "applesauce-signers": "^3.0.0",
     "typescript": "^5.8.3",
     "vitest": "^3.2.3",
     "vitest-nostr": "^0.4.1",