applesauce-loaders 0.0.0-next-20241207161834

package/LICENSE

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

package/README.md

@@ -0,0 +1,72 @@
+# applesauce-loaders
+
+A collection of observable based loaders built on top of [rx-nostr](https://penpenpng.github.io/rx-nostr/)
+
+## 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 { 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",
+});
+
+const replaceableLoader = new ReplaceableLoader(rxNostr, {
+  bufferTime: 1000,
+  // cache relays will always be checked first
+  cacheRelays: ["ws://localhost:4869/"],
+  // lookup relays are used as a fallback if the event cant be found
+  lookupRelays: ["wss://purplepag.es/"],
+});
+
+// start the loader by subscribing to it
+replaceableLoader.subscribe((packet) => {
+  // send all loaded events to the event store
+  eventStore.add(packet.event, packet.from);
+});
+
+// start loading some replaceable events
+replaceableLoader.next({
+  kind: 0,
+  pubkey: "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d",
+  relays: ["wss://pyramid.fiatjaf.com/"],
+});
+
+// load a parameterized replaceable event
+replaceableLoader.next({
+  kind: 30000,
+  pubkey: "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d",
+  identifier: "list of bad people",
+  relays: ["wss://pyramid.fiatjaf.com/"],
+});
+
+// if no relays are provided only the cache and lookup relays will be checked
+replaceableLoader.next({
+  kind: 3,
+  pubkey: "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d",
+});
+
+// passing a new relay will cause it to be loaded again
+replaceableLoader.next({
+  kind: 0,
+  pubkey: "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d",
+  relays: ["wss://relay.westernbtc.com/"],
+});
+
+// or force it to load it again from the same relays
+replaceableLoader.next({
+  kind: 0,
+  pubkey: "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d",
+  relays: ["wss://pyramid.fiatjaf.com/"],
+  force: true,
+});
+```

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

@@ -0,0 +1,16 @@
+import { AddressPointerWithoutD } from "applesauce-core/helpers";
+import { LazyFilter } from "rx-nostr";
+/** Converts an array of address pointers to a filter */
+export declare function createFilterFromAddressPointers(pointers: AddressPointerWithoutD[]): LazyFilter;
+/** Takes a set of address pointers, groups them, then returns filters for the groups */
+export declare function createFiltersFromAddressPointers(pointers: AddressPointerWithoutD[]): LazyFilter[];
+/** Checks if a relay will understand an address pointer */
+export declare function isLoadableAddressPointer<T extends AddressPointerWithoutD>(pointer: T): boolean;
+/** Group an array of address pointers by kind */
+export declare function groupAddressPointersByKind(pointers: AddressPointerWithoutD[]): Map<number, AddressPointerWithoutD[]>;
+/** Group an array of address pointers by pubkey */
+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<number, AddressPointerWithoutD[]> | Map<string, AddressPointerWithoutD[]>;
+export declare function getRelaysFromPointers(pointers: AddressPointerWithoutD[]): Set<string>;
+export declare function getAddressPointerId<T extends AddressPointerWithoutD>(pointer: T): string;

package/dist/helpers/address-pointer.js

@@ -0,0 +1,67 @@
+import { getReplaceableUID } from "applesauce-core/helpers";
+import { isParameterizedReplaceableKind, isReplaceableKind } from "nostr-tools/kinds";
+import { unique } from "./array.js";
+/** Converts an array of address pointers to a filter */
+export function createFilterFromAddressPointers(pointers) {
+    const filter = {};
+    filter.kinds = unique(pointers.map((p) => p.kind));
+    filter.authors = unique(pointers.map((p) => p.pubkey));
+    const identifiers = unique(pointers.map((p) => p.identifier).filter((d) => !!d));
+    if (identifiers.length > 0)
+        filter["#d"] = identifiers;
+    return filter;
+}
+/** Takes a set of address pointers, groups them, then returns filters for the groups */
+export function createFiltersFromAddressPointers(pointers) {
+    const groups = groupAddressPointersByPubkeyOrKind(pointers);
+    return Array.from(groups.values()).map((pointers) => createFilterFromAddressPointers(pointers));
+}
+/** Checks if a relay will understand an address pointer */
+export function isLoadableAddressPointer(pointer) {
+    if (isParameterizedReplaceableKind(pointer.kind))
+        return !!pointer.identifier;
+    else
+        return isReplaceableKind(pointer.kind);
+}
+/** Group an array of address pointers by kind */
+export function groupAddressPointersByKind(pointers) {
+    const byKind = new Map();
+    for (const pointer of pointers) {
+        if (byKind.has(pointer.kind))
+            byKind.get(pointer.kind).push(pointer);
+        else
+            byKind.set(pointer.kind, [pointer]);
+    }
+    return byKind;
+}
+/** Group an array of address pointers by pubkey */
+export function groupAddressPointersByPubkey(pointers) {
+    const byPubkey = new Map();
+    for (const pointer of pointers) {
+        if (byPubkey.has(pointer.pubkey))
+            byPubkey.get(pointer.pubkey).push(pointer);
+        else
+            byPubkey.set(pointer.pubkey, [pointer]);
+    }
+    return byPubkey;
+}
+/** Groups address pointers by kind or pubkey depending on which is most optimal */
+export function groupAddressPointersByPubkeyOrKind(pointers) {
+    const kinds = new Set(pointers.map((p) => p.kind));
+    const pubkeys = new Set(pointers.map((p) => p.pubkey));
+    return pubkeys.size > kinds.size ? groupAddressPointersByKind(pointers) : groupAddressPointersByPubkey(pointers);
+}
+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;
+}
+export function getAddressPointerId(pointer) {
+    return getReplaceableUID(pointer.kind, pointer.pubkey, pointer.identifier);
+}

package/dist/helpers/array.d.ts

@@ -0,0 +1,4 @@
+/** Does not preserve order */
+export declare function unique<T>(arr: T[]): T[];
+/** split array into a set of arrays no larger than batchSize */
+export declare function reduceToBatches<T>(arr: T[], batchSize: number): T[][];

package/dist/helpers/array.js

@@ -0,0 +1,21 @@
+/** Does not preserve order */
+export function unique(arr) {
+    return Array.from(new Set(arr));
+}
+/** split array into a set of arrays no larger than batchSize */
+export function reduceToBatches(arr, batchSize) {
+    const batches = [];
+    for (const value of arr) {
+        if (batches.length === 0) {
+            batches.push([value]);
+            continue;
+        }
+        const current = batches[batches.length - 1];
+        if (current.length <= batchSize) {
+            current.push(value);
+        }
+        else
+            batches.push([value]);
+    }
+    return batches;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * as Loaders from "./loaders/index.js";
+export * as Operators from "./operators/index.js";

package/dist/index.js

@@ -0,0 +1,2 @@
+export * as Loaders from "./loaders/index.js";
+export * as Operators from "./operators/index.js";

package/dist/loaders/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./loader.js";
+export * from "./replaceable-loader.js";
+export * from "./single-relay-replaceable-loader.js";

package/dist/loaders/index.js

@@ -0,0 +1,3 @@
+export * from "./loader.js";
+export * from "./replaceable-loader.js";
+export * from "./single-relay-replaceable-loader.js";

package/dist/loaders/loader.d.ts

@@ -0,0 +1,14 @@
+import { Observable, OperatorFunction, Subject, Subscribable } from "rxjs";
+export interface ILoader<T, R> extends Subscribable<R> {
+    next: (value: T) => void;
+    pipe: Observable<R>["pipe"];
+}
+/** Base loader class */
+export declare class Loader<T, R> implements ILoader<T, R> {
+    protected subject: Subject<T>;
+    protected observable: Observable<R>;
+    pipe: Observable<R>["pipe"];
+    subscribe: Observable<R>["subscribe"];
+    constructor(transform: OperatorFunction<T, R>);
+    next(value: T): void;
+}

package/dist/loaders/loader.js

@@ -0,0 +1,17 @@
+import { Subject } from "rxjs";
+/** Base loader class */
+export class Loader {
+    subject = new Subject();
+    observable;
+    pipe;
+    subscribe;
+    constructor(transform) {
+        this.observable = this.subject.pipe(transform);
+        // copy pipe function
+        this.pipe = this.observable.pipe.bind(this.observable);
+        this.subscribe = this.observable.subscribe.bind(this.observable);
+    }
+    next(value) {
+        this.subject.next(value);
+    }
+}

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

@@ -0,0 +1,28 @@
+import { EventPacket, RxNostr } from "rx-nostr";
+import { logger } from "applesauce-core";
+import { Loader } from "./loader.js";
+export type LoadableAddressPointer = {
+    kind: number;
+    pubkey: string;
+    /** Optional "d" tag for paramaritized replaceable */
+    identifier?: string;
+    /** Relays to load from */
+    relays?: string[];
+    /** Load this address pointer even if it has already been loaded */
+    force?: boolean;
+};
+export type ReplaceableLoaderOptions = {
+    /**
+     * Time interval to buffer requests in ms
+     * @default 1000
+     */
+    bufferTime?: number;
+    /** The cache relays to check first */
+    cacheRelays?: string[];
+    /** Fallback lookup relays to check when event cant be found */
+    lookupRelays?: string[];
+};
+export declare class ReplaceableLoader extends Loader<LoadableAddressPointer, EventPacket> {
+    log: typeof logger;
+    constructor(rxNostr: RxNostr, opts?: ReplaceableLoaderOptions);
+}

package/dist/loaders/replaceable-loader.js

@@ -0,0 +1,146 @@
+import { share, tap, from, filter, bufferTime, map } from "rxjs";
+import { getEventUID, getReplaceableUID, markFromCache } from "applesauce-core/helpers";
+import { logger } from "applesauce-core";
+import { nanoid } from "nanoid";
+import { Loader } from "./loader.js";
+import { generatorSequence } from "../operators/generator-sequence.js";
+import { replaceableRequest } from "../operators/address-pointers-request.js";
+import { getAddressPointerId, getRelaysFromPointers, isLoadableAddressPointer } from "../helpers/address-pointer.js";
+import { unique } from "../helpers/array.js";
+/** 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;
+}
+/** A generator that tries to load the address pointers from the cache first, then tries the relays */
+function* cacheFirstSequence(rxNostr, pointers, log, opts) {
+    const id = nanoid(8);
+    log = log.extend(id);
+    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)));
+            // if there where results, filter out any pointers that where found
+            remaining = remaining.filter((pointer) => {
+                const found = coordinates.has(getReplaceableUID(pointer.kind, pointer.pubkey, pointer.identifier));
+                if (found && pointer.force !== true)
+                    return false;
+                else
+                    return true;
+            });
+            if (remaining.length === 0)
+                return true;
+        }
+        return false;
+    };
+    // first attempt, load from cache relays
+    if (opts?.cacheRelays && opts?.cacheRelays.length > 0) {
+        log(`Checking cache`, opts.cacheRelays, remaining);
+        const results = yield from([remaining]).pipe(replaceableRequest(rxNostr, opts.cacheRelays, id), 
+        // mark the event as from the cache
+        tap((p) => markFromCache(p.event)));
+        if (handleResults(results))
+            return;
+    }
+    // finished loading from the cache, load from pointer relays
+    if (pointerRelays.length > 0) {
+        log(`Requesting`, pointerRelays, remaining);
+        const results = yield from([remaining]).pipe(replaceableRequest(rxNostr, pointerRelays, id));
+        if (handleResults(results))
+            return;
+    }
+    // finally load from lookup relays
+    if (opts?.lookupRelays) {
+        // make sure we aren't asking a relay twice
+        const relays = opts.lookupRelays.filter((r) => !pointerRelays.includes(r));
+        if (relays.length > 0) {
+            log(`Request from lookup`, relays, remaining);
+            const results = yield from([remaining]).pipe(replaceableRequest(rxNostr, relays, id));
+            if (handleResults(results))
+                return;
+        }
+    }
+}
+/** Batches address pointers and consolidates them */
+function multiRelayBatcher(buffer) {
+    return (source) => source.pipe(
+    // buffer on time
+    bufferTime(buffer), 
+    // ignore empty buffers
+    filter((buffer) => buffer.length > 0), 
+    // consolidate buffered pointers
+    map((pointers) => {
+        const byId = new Map();
+        for (const pointer of pointers) {
+            const id = getAddressPointerId(pointer);
+            if (byId.has(id)) {
+                // duplicate, merge pointers
+                const current = byId.get(id);
+                // merge relays
+                if (pointer.relays) {
+                    if (current.relays)
+                        current.relays = unique([...current.relays, ...pointer.relays]);
+                    else
+                        current.relays = pointer.relays;
+                }
+                // merge force flag
+                if (pointer.force !== undefined) {
+                    current.force = current.force || pointer.force;
+                }
+            }
+            else
+                byId.set(id, cloneLoadablePointer(pointer));
+        }
+        // return consolidated pointers
+        return Array.from(byId.values());
+    }), 
+    // ignore empty buffer
+    filter((buffer) => buffer.length > 0), 
+    // ensure pointers are only requested from each relay once
+    map((pointers) => {
+        const requestedFrom = new Map();
+        return pointers.filter((pointer) => {
+            // if this pointer does not have any relays or is forced, skip
+            if (!pointer.relays)
+                return true;
+            if (pointer.force)
+                return true;
+            const id = getAddressPointerId(pointer);
+            let set = requestedFrom.get(id);
+            if (!set) {
+                set = new Set();
+                requestedFrom.set(id, set);
+            }
+            // remove any relays that have already been used
+            pointer.relays = pointer.relays.filter((relay) => !set.has(relay));
+            // remember used relays
+            for (const relay of pointer.relays)
+                set.add(relay);
+            // if there are no new relays, ignore pointer
+            return pointer.relays.length > 0;
+        });
+    }), 
+    // ignore empty buffer
+    filter((buffer) => buffer.length > 0));
+}
+export class ReplaceableLoader extends Loader {
+    log = logger.extend("ReplaceableLoader");
+    constructor(rxNostr, opts) {
+        super((source) => {
+            return source.pipe(
+            // filter out invalid pointers
+            filter(isLoadableAddressPointer), 
+            // TODO: needs a new batching method that takes the multiple relays (and force) into account
+            // batch and filter
+            multiRelayBatcher(opts?.bufferTime ?? 1000), 
+            // check cache, relays, lookup relays in that order
+            generatorSequence((pointers) => cacheFirstSequence(rxNostr, pointers, this.log, opts)), 
+            // share the response with all subscribers
+            share());
+        });
+    }
+}

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

@@ -0,0 +1,14 @@
+import { EventPacket, RxNostr } from "rx-nostr";
+import { Loader } from "./loader.js";
+import { LoadableAddressPointer } from "./replaceable-loader.js";
+export type SingleRelayReplaceableOptions = Partial<{
+    /**
+     * Wait X ms before making a request
+     * @default 1000
+     */
+    bufferTime: number;
+}>;
+/** A wrapper class around {@link singleRelayBatcher'}, {@link replaceableRequest}, and share */
+export declare class SingleRelayReplaceableLoader extends Loader<LoadableAddressPointer, EventPacket> {
+    constructor(rxNostr: RxNostr, relay: string, opts?: SingleRelayReplaceableOptions);
+}

package/dist/loaders/single-relay-replaceable-loader.js

@@ -0,0 +1,50 @@
+import { bufferTime, filter, from, map, mergeMap, share } from "rxjs";
+import { getReplaceableUID } from "applesauce-core/helpers";
+import { Loader } from "./loader.js";
+import { isLoadableAddressPointer } from "../helpers/address-pointer.js";
+import { replaceableRequest } from "../operators/address-pointers-request.js";
+const defaultRelayReplaceableLoaderOptions = {
+    bufferTime: 1000,
+};
+/** Ensures an address pointer is only loaded once from a relay */
+function singleRelayBatcher(opts) {
+    return (source) => {
+        const loaded = new Set();
+        const options = opts ? { ...defaultRelayReplaceableLoaderOptions, ...opts } : defaultRelayReplaceableLoaderOptions;
+        return source.pipe(
+        // buffer the requests, so we only send requests every second
+        bufferTime(options.bufferTime), 
+        // ignore empty batches
+        filter((batch) => batch.length > 0), 
+        // filter out duplicates
+        map((batch) => {
+            const filtered = [];
+            for (const pointer of batch) {
+                const uid = getReplaceableUID(pointer.kind, pointer.pubkey, pointer.identifier);
+                if (!loaded.has(uid)) {
+                    filtered.push(pointer);
+                    loaded.add(uid);
+                }
+                else if (pointer.force)
+                    filtered.push(pointer);
+            }
+            return filtered;
+        }), 
+        // ignore empty batches
+        filter((batch) => batch.length > 0));
+    };
+}
+/** A wrapper class around {@link singleRelayBatcher'}, {@link replaceableRequest}, and share */
+export class SingleRelayReplaceableLoader extends Loader {
+    constructor(rxNostr, relay, opts) {
+        super((source) => source.pipe(
+        // ignore invalid address pointers
+        filter(isLoadableAddressPointer), 
+        // batch and filter
+        singleRelayBatcher(opts), 
+        // breakout the batches so they can complete
+        mergeMap((pointers) => from([pointers]).pipe(replaceableRequest(rxNostr, [relay]))), 
+        // share the response with all subscribers
+        share()));
+    }
+}

package/dist/operators/address-pointers-request.d.ts

@@ -0,0 +1,5 @@
+import { EventPacket, RxNostr } from "rx-nostr";
+import { OperatorFunction } from "rxjs";
+import { AddressPointerWithoutD } from "applesauce-core/helpers";
+/** Makes a request to relays for every set of address pointers */
+export declare function replaceableRequest<T extends AddressPointerWithoutD>(rxNostr: RxNostr, relays: string[], id?: string): OperatorFunction<T[], EventPacket>;

package/dist/operators/address-pointers-request.js

@@ -0,0 +1,27 @@
+import { map, tap } from "rxjs";
+import { nanoid } from "nanoid";
+import { logger } from "applesauce-core";
+import { relaysRequest } from "./relay-request.js";
+import { createFiltersFromAddressPointers } from "../helpers/address-pointer.js";
+/** Makes a request to relays for every set of address pointers */
+export function replaceableRequest(rxNostr, relays, id) {
+    return (source) => {
+        id = id || nanoid(8);
+        const log = logger.extend(`replaceableRequest:${id}`);
+        return source.pipe(
+        // convert pointers to filters
+        map(createFiltersFromAddressPointers), 
+        // make requests
+        tap((filters) => {
+            log(`Requesting`, relays, filters);
+        }), 
+        // make requests
+        relaysRequest(rxNostr, relays, id), 
+        // log when complete
+        tap({
+            complete: () => {
+                log(`Complete`);
+            },
+        }));
+    };
+}

package/dist/operators/generator-sequence.d.ts

@@ -0,0 +1,3 @@
+import { Observable, OperatorFunction } from "rxjs";
+/** Keeps retrying a value until the generator returns */
+export declare function generatorSequence<T, R>(createGenerator: (value: T) => Generator<Observable<R>, undefined, R[] | undefined>): OperatorFunction<T, R>;

package/dist/operators/generator-sequence.js

@@ -0,0 +1,45 @@
+import { Observable } from "rxjs";
+/** Keeps retrying a value until the generator returns */
+export function generatorSequence(createGenerator) {
+    return (source) => {
+        return new Observable((observer) => {
+            let complete = false;
+            const sub = source.subscribe({
+                next: (value) => {
+                    const generator = createGenerator(value);
+                    const next = (prevResults) => {
+                        const result = generator.next(prevResults);
+                        // generator complete, exit
+                        if (result.done)
+                            return;
+                        const results = [];
+                        result.value.subscribe({
+                            next: (v) => {
+                                // track results and pass along values
+                                results.push(v);
+                                observer.next(v);
+                            },
+                            error: (err) => {
+                                observer.error(err);
+                            },
+                            complete: () => {
+                                // if the upstream observable was complete. exit
+                                if (complete)
+                                    return observer.complete();
+                                // run next step
+                                next(results);
+                            },
+                        });
+                    };
+                    // start running steps
+                    next();
+                },
+                complete: () => {
+                    // source is complete
+                    complete = true;
+                },
+            });
+            return () => sub.unsubscribe();
+        });
+    };
+}

package/dist/operators/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./generator-sequence.js";
+export * from "./relay-request.js";
+export * from "./max-filters.js";
+export * from "./address-pointers-request.js";

package/dist/operators/index.js

@@ -0,0 +1,4 @@
+export * from "./generator-sequence.js";
+export * from "./relay-request.js";
+export * from "./max-filters.js";
+export * from "./address-pointers-request.js";

package/dist/operators/max-filters.d.ts

@@ -0,0 +1,4 @@
+import { LazyFilter } from "rx-nostr";
+import { OperatorFunction } from "rxjs";
+/** Splits a batch of filters into multiple requests if necessary */
+export declare function splitMaxFiltersPerRequest(maxFiltersPerRequest: number): OperatorFunction<LazyFilter[], LazyFilter[]>;

package/dist/operators/max-filters.js

@@ -0,0 +1,8 @@
+import { mergeMap } from "rxjs";
+import { reduceToBatches } from "../helpers/array.js";
+/** Splits a batch of filters into multiple requests if necessary */
+export function splitMaxFiltersPerRequest(maxFiltersPerRequest) {
+    return (source) => source.pipe(
+    // batch the filters into sets no larger than maxFiltersPerRequest
+    mergeMap((filters) => reduceToBatches(filters, maxFiltersPerRequest)));
+}

package/dist/operators/relay-request.d.ts

@@ -0,0 +1,4 @@
+import { EventPacket, LazyFilter, RxNostr } from "rx-nostr";
+import { OperatorFunction } from "rxjs";
+/** Makes a request to relays for every set of filters */
+export declare function relaysRequest(rxNostr: RxNostr, relays: string[], id?: string): OperatorFunction<LazyFilter | LazyFilter[], EventPacket>;

package/dist/operators/relay-request.js

@@ -0,0 +1,9 @@
+import { createRxOneshotReq } from "rx-nostr";
+import { map, mergeAll } from "rxjs";
+/** Makes a request to relays for every set of filters */
+export function relaysRequest(rxNostr, relays, id) {
+    return (source) => source.pipe(map((filters) => {
+        const req = createRxOneshotReq({ filters, rxReqId: id });
+        return rxNostr.use(req, { on: { relays } });
+    }), mergeAll());
+}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "applesauce-loaders",
+  "version": "0.0.0-next-20241207161834",
+  "description": "A collection of observable based loaders built on rx-nostr",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "keywords": [
+    "nostr"
+  ],
+  "author": "hzrd149",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./loaders": {
+      "import": "./dist/loaders/index.js",
+      "types": "./dist/loaders/index.d.ts"
+    },
+    "./loaders/*": {
+      "import": "./dist/loaders/*.js",
+      "types": "./dist/loaders/*.d.ts"
+    },
+    "./operators": {
+      "import": "./dist/operators/index.js",
+      "types": "./dist/operators/index.d.ts"
+    },
+    "./operators/*": {
+      "import": "./dist/operators/*.js",
+      "types": "./dist/operators/*.d.ts"
+    }
+  },
+  "dependencies": {
+    "applesauce-core": "0.0.0-next-20241207161834",
+    "nanoid": "^5.0.9",
+    "nostr-tools": "^2.10.3",
+    "rx-nostr": "^3.4.1",
+    "rxjs": "^7.8.1"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.7.0",
+    "@types/jest": "^29.5.13",
+    "jest": "^29.7.0",
+    "jest-extended": "^4.0.2",
+    "typescript": "^5.6.3"
+  },
+  "jest": {
+    "roots": [
+      "dist"
+    ],
+    "setupFilesAfterEnv": [
+      "jest-extended/all"
+    ]
+  },
+  "funding": {
+    "type": "lightning",
+    "url": "lightning:nostrudel@geyser.fund"
+  },
+  "scripts": {
+    "build": "tsc",
+    "watch:build": "tsc --watch > /dev/null",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js --passWithNoTests",
+    "watch:test": "(trap 'kill 0' SIGINT; pnpm run build -w > /dev/null & pnpm run test --watch)"
+  }
+}