applesauce-loaders 0.12.0 → 2.0.0

package/dist/loaders/address-loader.js

@@ -0,0 +1,94 @@
+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 { wrapUpstreamPool } from "../helpers/upstream.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)));
+}
+/** Loads address pointers from the relay hints */
+export function relayHintsAddressPointersLoader(request) {
+    return (pointers) => {
+        const relays = mergeRelaySets(...pointers.map((p) => p.relays));
+        if (relays.length === 0)
+            return EMPTY;
+        const filters = createFiltersFromAddressPointers(pointers);
+        return request(relays, filters);
+    };
+}
+/** 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) => {
+        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) {
+        let remaining = Array.from(pointers);
+        for (const loader of loaders) {
+            if (loader === undefined)
+                continue;
+            const results = yield loader(remaining).pipe(
+            // If the loader throws an error, skip it
+            catchError(() => EMPTY));
+            // 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);
+            // If there are no remaining pointers, complete
+            if (remaining.length === 0)
+                return;
+        }
+    });
+}
+/** 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, 
+    // Step 2. load from relay hints on pointers
+    opts?.followRelayHints !== false ? relayHintsAddressPointersLoader(request) : undefined, 
+    // Step 3. load from extra relays
+    opts?.extraRelays ? relaysAddressPointersLoader(request, opts.extraRelays) : undefined, 
+    // Step 4. load from lookup relays
+    opts?.lookupRelays ? relaysAddressPointersLoader(request, opts.lookupRelays) : undefined), 
+    // Filter resutls based on requests
+    (pointer, event) => event.kind === pointer.kind &&
+        event.pubkey === pointer.pubkey &&
+        (pointer.identifier ? getReplaceableIdentifier(event) === pointer.identifier : true), 
+    // Pass all events through the store if defined
+    opts?.eventStore && mapEventsToStore(opts.eventStore));
+}

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

@@ -0,0 +1,33 @@
+import { IEventStore } from "applesauce-core";
+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>;
+/** 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 */
+export declare function relaysEventsLoader(request: NostrRequest, relays: string[] | Observable<string[]>): createEventLoader;
+/** Creates a loader that gets an array of events from a single relay */
+export declare function relayEventsLoader(request: NostrRequest, relay: string): createEventLoader;
+/** Creates a loader that creates a new loader for each relay hint and uses them to load events */
+export declare function relayHintsEventsLoader(request: NostrRequest, upstream?: (request: NostrRequest, relay: string) => createEventLoader): createEventLoader;
+/** Creates a loader that tries to load events from a list of loaders in order */
+export declare function eventLoadingSequence(...loaders: (createEventLoader | undefined)[]): createEventLoader;
+export type EventPointerLoaderOptions = Partial<{
+    /** Time interval to buffer requests in ms ( default 1000 ) */
+    bufferTime: number;
+    /** Max buffer size ( default 200 ) */
+    bufferSize: number;
+    /** An event store used to deduplicate events */
+    eventStore: IEventStore;
+    /** A method used to load events from a local cache */
+    cacheRequest: CacheRequest;
+    /** Whether to follow relay hints ( default true ) */
+    followRelayHints: boolean;
+    /** An array of relays to always fetch from */
+    extraRelays: string[] | Observable<string[]>;
+}>;
+/** Create a pre-built address pointer loader that supports batching, caching, and lookup relays */
+export declare function createEventLoader(pool: UpstreamPool, opts?: EventPointerLoaderOptions): EventPointerLoader;

package/dist/loaders/event-loader.js

@@ -0,0 +1,92 @@
+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 { consolidateEventPointers } from "../helpers/event-pointer.js";
+import { batchLoader } from "../helpers/loaders.js";
+import { groupByRelay } from "../helpers/pointer.js";
+import { wrapGeneratorFunction } from "../operators/generator.js";
+import { wrapUpstreamPool } from "../helpers/upstream.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) }]);
+}
+/** 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) }])));
+}
+/** Creates a loader that gets an array of events from a single relay */
+export function relayEventsLoader(request, relay) {
+    return relaysEventsLoader(request, [relay]);
+}
+/** Creates a loader that creates a new loader for each relay hint and uses them to load events */
+export function relayHintsEventsLoader(request, upstream = relayEventsLoader) {
+    const loaders = new Map();
+    // Get or create a new loader for each relay
+    const getLoader = (relay) => {
+        let loader = loaders.get(relay);
+        if (!loader) {
+            loader = upstream(request, relay);
+            loaders.set(relay, loader);
+        }
+        return loader;
+    };
+    return (pointers) => {
+        // Group pointers by thier relay hints
+        const byRelay = groupByRelay(pointers);
+        // Request the pointers from each relay
+        return merge(...Array.from(byRelay).map(([relay, pointers]) => getLoader(relay)(pointers)));
+    };
+}
+/** Creates a loader that tries to load events from a list of loaders in order */
+export function eventLoadingSequence(...loaders) {
+    return wrapGeneratorFunction(function* (pointers) {
+        const found = new Set();
+        let remaining = Array.from(pointers);
+        for (const loader of loaders) {
+            if (loader === undefined)
+                continue;
+            yield loader(remaining).pipe(
+            // If the loader throws an error, skip it
+            catchError(() => EMPTY), 
+            // Record events that where found
+            tap((e) => found.add(e.id)));
+            // Remove poniters that where found
+            remaining = remaining.filter((p) => !found.has(p.id));
+            // If there are no remaining pointers, complete
+            if (remaining.length === 0)
+                return;
+        }
+    });
+}
+/** 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, 
+    // Step 2. load from relay hints on pointers
+    opts?.followRelayHints !== false ? relayHintsEventsLoader(request) : undefined, 
+    // Step 3. load from extra relays
+    opts?.extraRelays ? relaysEventsLoader(request, opts.extraRelays) : undefined), 
+    // Filter resutls based on requests
+    (pointer, event) => event.id === pointer.id, 
+    // Pass all events through the store if defined
+    opts?.eventStore && mapEventsToStore(opts.eventStore));
+}

package/dist/loaders/index.d.ts

@@ -1,10 +1,9 @@
-export * from "./loader.js";
-export * from "./replaceable-loader.js";
-export * from "./single-event-loader.js";
-export * from "./user-sets-loader.js";
-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 "./address-loader.js";
 export * from "./dns-identity-loader.js";
+export * from "./event-loader.js";
+export * from "./reactions-loader.js";
+export * from "./social-graph.js";
+export * from "./tag-value-loader.js";
+export * from "./timeline-loader.js";
+export * from "./user-lists-loader.js";
+export * from "./zaps-loader.js";

package/dist/loaders/index.js

@@ -1,10 +1,9 @@
-export * from "./loader.js";
-export * from "./replaceable-loader.js";
-export * from "./single-event-loader.js";
-export * from "./user-sets-loader.js";
-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 "./address-loader.js";
 export * from "./dns-identity-loader.js";
+export * from "./event-loader.js";
+export * from "./reactions-loader.js";
+export * from "./social-graph.js";
+export * from "./tag-value-loader.js";
+export * from "./timeline-loader.js";
+export * from "./user-lists-loader.js";
+export * from "./zaps-loader.js";

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

@@ -0,0 +1,12 @@
+import { NostrEvent } from "nostr-tools";
+import { Observable } from "rxjs";
+import { UpstreamPool } from "../types.js";
+import { TagValueLoaderOptions } from "./tag-value-loader.js";
+/** A loader that takes an event and returns zaps */
+export type ReactionsLoader = (event: NostrEvent, relays?: string[]) => Observable<NostrEvent>;
+export type ReactionsLoaderOptions = Omit<TagValueLoaderOptions, "kinds"> & {
+    /** Whether to request reactions from the relays the event was seen on ( default true ) */
+    useSeenRelays?: boolean;
+};
+/** Creates a loader that loads reaction events for a given event */
+export declare function createReactionsLoader(pool: UpstreamPool, opts?: ReactionsLoaderOptions): ReactionsLoader;

package/dist/loaders/reactions-loader.js

@@ -0,0 +1,18 @@
+import { getReplaceableAddress, getSeenRelays, isReplaceable, mergeRelaySets } from "applesauce-core/helpers";
+import { kinds } from "nostr-tools";
+import { wrapUpstreamPool } from "../helpers/upstream.js";
+import { createTagValueLoader } from "./tag-value-loader.js";
+/** Creates a loader that loads reaction events for a given event */
+export function createReactionsLoader(pool, opts) {
+    const request = wrapUpstreamPool(pool);
+    const eventLoader = createTagValueLoader(request, "e", { ...opts, kinds: [kinds.Reaction] });
+    const addressableLoader = createTagValueLoader(request, "a", { ...opts, kinds: [kinds.Reaction] });
+    // Return diffrent loaders depending on if the event is addressable
+    return (event, relays) => {
+        if (opts?.useSeenRelays ?? true)
+            relays = mergeRelaySets(relays, getSeenRelays(event));
+        return isReplaceable(event.kind)
+            ? addressableLoader({ value: getReplaceableAddress(event), relays })
+            : eventLoader({ value: event.id, relays });
+    };
+}

package/dist/loaders/social-graph.d.ts

@@ -0,0 +1,21 @@
+import { IEventStore } from "applesauce-core";
+import { NostrEvent } from "nostr-tools";
+import { ProfilePointer } from "nostr-tools/nip19";
+import { Observable } from "rxjs";
+import { AddressPointerLoader } from "./address-loader.js";
+/** A loader that loads the social graph of a user out to a set distance */
+export type SocialGraphLoader = (user: ProfilePointer & {
+    distance: number;
+}) => Observable<NostrEvent>;
+export type SocialGraphLoaderOptions = Partial<{
+    /** An event store to send all the events to */
+    eventStore: IEventStore;
+    /** The number of parallel requests to make (default 300) */
+    parallel: number;
+    /** Extra relays to load from */
+    extraRelays?: string[] | Observable<string[]>;
+    /** Whether to follow relay hints in contact events */
+    hints?: boolean;
+}>;
+/** Create a social graph loader */
+export declare function createSocialGraphLoader(addressLoader: AddressPointerLoader, opts?: SocialGraphLoaderOptions): SocialGraphLoader;

package/dist/loaders/social-graph.js

@@ -0,0 +1,50 @@
+import { mapEventsToStore } from "applesauce-core";
+import { getProfilePointersFromList, mergeRelaySets } from "applesauce-core/helpers";
+import { kinds } from "nostr-tools";
+import { firstValueFrom, identity, isObservable, lastValueFrom, toArray } from "rxjs";
+import { wrapGeneratorFunction } from "../operators/generator.js";
+/** Create a social graph loader */
+export function createSocialGraphLoader(addressLoader, opts) {
+    return wrapGeneratorFunction(async function* (user) {
+        const seen = new Set();
+        const queue = [user];
+        // Maximum parallel requests (default to 300)
+        const maxParallel = opts?.parallel ?? 300;
+        // get the relays to load from
+        const relays = mergeRelaySets(user.relays, isObservable(opts?.extraRelays) ? await firstValueFrom(opts?.extraRelays) : opts?.extraRelays);
+        // Keep loading while the queue has items
+        while (queue.length > 0) {
+            // Process up to maxParallel items at once
+            const batch = queue.splice(0, maxParallel);
+            const promises = batch.map(async (pointer) => {
+                const address = {
+                    kind: kinds.Contacts,
+                    pubkey: pointer.pubkey,
+                    relays: opts?.hints ? mergeRelaySets(pointer.relays, relays) : relays,
+                };
+                // load the contacts events
+                const events = await lastValueFrom(addressLoader(address).pipe(
+                // Pass all events to the store if set
+                opts?.eventStore ? mapEventsToStore(opts.eventStore) : identity, 
+                // Conver to array
+                toArray()));
+                if (events.length === 0)
+                    return;
+                const contacts = getProfilePointersFromList(events[events.length - 1]);
+                // if the distance is greater than 0, add the contacts to the queue
+                if (pointer.distance > 0) {
+                    for (const contact of contacts) {
+                        // Dont add any contacts that have already been seen
+                        if (seen.has(contact.pubkey))
+                            continue;
+                        seen.add(contact.pubkey);
+                        // Add to queue
+                        queue.push({ ...contact, distance: pointer.distance - 1 });
+                    }
+                }
+            });
+            // Wait for all parallel operations to complete
+            await Promise.all(promises);
+        }
+    });
+}

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

@@ -1,7 +1,8 @@
-import { EventPacket, RxNostr } from "rx-nostr";
-import { logger } from "applesauce-core";
-import { CacheRequest, Loader } from "./loader.js";
-export type TabValuePointer = {
+import { IEventStore } from "applesauce-core";
+import { NostrEvent } from "nostr-tools";
+import { Observable } from "rxjs";
+import { CacheRequest, NostrRequest, UpstreamPool } from "../types.js";
+export type TagValuePointer = {
     /** The value of the tag to load */
     value: string;
     /** The relays to load from */
@@ -10,13 +11,10 @@ export type TabValuePointer = {
     force?: boolean;
 };
 export type TagValueLoaderOptions = {
-    /** the name of this loader (for debugging) */
-    name?: string;
-    /**
-     * Time interval to buffer requests in ms
-     * @default 1000
-     */
+    /** Time interval to buffer requests in ms ( default 1000 ) */
     bufferTime?: number;
+    /** Max buffer size ( default 200 ) */
+    bufferSize?: number;
     /** Restrict queries to specific kinds */
     kinds?: number[];
     /** Restrict queries to specific authors */
@@ -25,9 +23,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[];
+    /** An event store used to deduplicate events */
+    eventStore?: IEventStore;
 };
-export declare class TagValueLoader extends Loader<TabValuePointer, EventPacket> {
-    name: string;
-    protected log: typeof logger;
-    constructor(rxNostr: RxNostr, tagName: string, opts?: TagValueLoaderOptions);
-}
+export type TagValueLoader = (pointer: TagValuePointer) => Observable<NostrEvent>;
+/** Creates a loader that gets tag values from the cache */
+export declare function cacheTagValueLoader(request: CacheRequest, tagName: string, opts?: TagValueLoaderOptions): (pointers: TagValuePointer[]) => Observable<NostrEvent>;
+/** Creates a loader that gets tag values from relays */
+export declare function relaysTagValueLoader(request: NostrRequest, tagName: string, opts?: TagValueLoaderOptions): (pointers: TagValuePointer[]) => Observable<NostrEvent>;
+/** Create a pre-built tag value loader that supports batching, caching, and relay hints */
+export declare function createTagValueLoader(pool: UpstreamPool, tagName: string, opts?: TagValueLoaderOptions): TagValueLoader;

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

@@ -1,75 +1,77 @@
-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 { mapEventsToStore } from "applesauce-core";
+import { mergeRelaySets } from "applesauce-core/helpers";
+import { bufferTime, filter, merge, pipe } from "rxjs";
 import { unique } from "../helpers/array.js";
-export class TagValueLoader extends Loader {
-    name;
-    log = logger.extend("TagValueLoader");
-    constructor(rxNostr, tagName, opts) {
+import { makeCacheRequest, wrapCacheRequest } from "../helpers/cache.js";
+import { batchLoader } from "../helpers/loaders.js";
+import { distinctRelaysBatch } from "../operators/distinct-relays.js";
+import { wrapUpstreamPool } from "../helpers/upstream.js";
+/** Creates a loader that gets tag values from the cache */
+export function cacheTagValueLoader(request, tagName, opts) {
+    return (pointers) => {
+        const baseFilter = {};
+        if (opts?.kinds)
+            baseFilter.kinds = opts.kinds;
+        if (opts?.authors)
+            baseFilter.authors = opts.authors;
+        if (opts?.since)
+            baseFilter.since = opts.since;
         const filterTag = `#${tagName}`;
-        super((source) => source.pipe(
-        // batch the pointers
-        bufferTime(opts?.bufferTime ?? 1000), 
-        // filter out empty batches
-        filter((pointers) => pointers.length > 0), 
-        // only request from each relay once
-        distinctRelaysBatch((m) => m.value), 
-        // batch pointers into requests
-        mergeMap((pointers) => {
-            const baseFilter = {};
-            if (opts?.kinds)
-                baseFilter.kinds = opts.kinds;
-            if (opts?.since)
-                baseFilter.since = opts.since;
-            if (opts?.authors)
-                baseFilter.authors = opts.authors;
-            // build request map for relays
-            const requestMap = pointers.reduce((map, pointer) => {
-                const relays = pointer.relays ?? getDefaultReadRelays(rxNostr);
-                for (const relay of relays) {
-                    if (!map[relay]) {
-                        // create new filter for relay
-                        const filter = { ...baseFilter, [filterTag]: [pointer.value] };
-                        map[relay] = [filter];
-                    }
-                    else {
-                        // map for relay already exists, add the tag value
-                        const filter = map[relay][0];
-                        filter[filterTag].push(pointer.value);
-                    }
+        const filter = { ...baseFilter, [filterTag]: unique(pointers.map((p) => p.value)) };
+        return makeCacheRequest(request, [filter]);
+    };
+}
+/** Creates a loader that gets tag values from relays */
+export function relaysTagValueLoader(request, tagName, opts) {
+    const filterTag = `#${tagName}`;
+    return (pointers) => {
+        const baseFilter = {};
+        if (opts?.kinds)
+            baseFilter.kinds = opts.kinds;
+        if (opts?.authors)
+            baseFilter.authors = opts.authors;
+        if (opts?.since)
+            baseFilter.since = opts.since;
+        // build request map for relays
+        const requestMap = pointers.reduce((map, pointer) => {
+            const relays = mergeRelaySets(pointer.relays, opts?.extraRelays);
+            for (const relay of relays) {
+                if (!map[relay]) {
+                    // create new filter for relay
+                    map[relay] = { ...baseFilter, [filterTag]: [pointer.value] };
                 }
-                return map;
-            }, {});
-            let fromCache = 0;
-            const cacheRequest = opts
-                ?.cacheRequest?.([{ ...baseFilter, [filterTag]: unique(pointers.map((p) => p.value)) }])
-                .pipe(
-            // mark the event as from the cache
-            tap({
-                next: (event) => {
-                    markFromCache(event);
-                    fromCache++;
-                },
-                complete: () => {
-                    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] } });
-            });
-            this.log(`Requesting ${pointers.length} tag values from ${requests.length} relays`);
-            return cacheRequest ? merge(cacheRequest, ...requests) : merge(...requests);
-        })));
-        // 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}`);
-    }
+                else {
+                    // map for relay already exists, add the tag value
+                    map[relay][filterTag].push(pointer.value);
+                }
+            }
+            return map;
+        }, {});
+        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)), 
+    // 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
+    opts?.eventStore && mapEventsToStore(opts?.eventStore));
 }

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

@@ -1,22 +1,24 @@
-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 { CacheTimelineLoader } from "./cache-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> {
-    id: string;
-    loading$: BehaviorSubject<boolean>;
-    get loading(): boolean;
-    requests: RelayFilterMap<TimelessFilter>;
-    protected log: typeof logger;
-    protected cache?: CacheTimelineLoader;
-    protected loaders: Map<string, RelayTimelineLoader>;
-    constructor(rxNostr: RxNostr, requests: RelayFilterMap<TimelessFilter>, opts?: TimelineLoaderOptions);
-    static simpleFilterMap(relays: string[], filters: TimelessFilter[]): RelayFilterMap<TimelessFilter>;
-}
+import { IEventStore } from "applesauce-core";
+import { NostrEvent } from "nostr-tools";
+import { Observable } from "rxjs";
+import { CacheRequest, FilterRequest, NostrRequest, TimelessFilter, UpstreamPool } from "../types.js";
+/** A loader that optionally takes a timestamp to load till and returns a stream of events */
+export type TimelineLoader = (since?: number) => Observable<NostrEvent>;
+/** Common options for timeline loaders */
+export type CommonTimelineLoaderOptions = Partial<{
+    limit: number;
+}>;
+/** A loader that loads blocks of events until none are returned or the since timestamp is reached */
+export declare function filterBlockLoader(request: FilterRequest, filters: TimelessFilter[], opts?: CommonTimelineLoaderOptions): TimelineLoader;
+/** Creates a loader that loads a timeline from a cache */
+export declare function cacheTimelineLoader(request: CacheRequest, filters: TimelessFilter[], opts?: CommonTimelineLoaderOptions): TimelineLoader;
+/** Creates a timeline loader that loads the same filters from multiple relays */
+export declare function relaysTimelineLoader(request: NostrRequest, relays: string[], filters: TimelessFilter[], opts?: CommonTimelineLoaderOptions): TimelineLoader;
+export type TimelineLoaderOptions = Partial<{
+    /** A method used to load the timeline from the cache */
+    cache: CacheRequest;
+    /** An event store to pass all the events to */
+    eventStore: IEventStore;
+}> & CommonTimelineLoaderOptions;
+/** A common timeline loader that takes an array of relays and a cache method */
+export declare function createTimelineLoader(pool: UpstreamPool, relays: string[], filters: TimelessFilter[] | TimelessFilter, opts?: TimelineLoaderOptions): TimelineLoader;