applesauce-core 0.0.0-next-20250912090040 → 0.0.0-next-20250913205403

package/dist/event-store/async-event-store.d.ts

@@ -0,0 +1,129 @@
+import { Filter, NostrEvent } from "nostr-tools";
+import { AddressPointer, EventPointer } from "nostr-tools/nip19";
+import { Observable, Subject } from "rxjs";
+import { AddressPointerWithoutD } from "../helpers/pointers.js";
+import { IAsyncEventDatabase, IAsyncEventStore } from "./interface.js";
+declare const AsyncEventStore_base: {
+    new (...args: any[]): {
+        [x: string]: any;
+        models: Map<import("./interface.js").ModelConstructor<any, any[], import("./interface.js").IEventStore | IAsyncEventStore>, Map<string, Observable<any>>>;
+        modelKeepWarm: number;
+        model<T extends unknown, Args extends Array<any>>(constructor: import("./interface.js").ModelConstructor<T, Args, import("./interface.js").IEventStore | IAsyncEventStore>, ...args: Args): Observable<T>;
+        filters(filters: Filter | Filter[], onlyNew?: boolean): Observable<NostrEvent>;
+        event(pointer: string | EventPointer): Observable<NostrEvent | undefined>;
+        replaceable(pointer: AddressPointer | AddressPointerWithoutD): Observable<NostrEvent | undefined>;
+        replaceable(kind: number, pubkey: string, identifier?: string): Observable<NostrEvent | undefined>;
+        addressable(pointer: AddressPointer): Observable<NostrEvent | undefined>;
+        timeline(filters: Filter | Filter[], includeOldVersion?: boolean): Observable<NostrEvent[]>;
+        profile(user: string | import("nostr-tools/nip19").ProfilePointer): Observable<import("../helpers/profile.js").ProfileContent | undefined>;
+        contacts(user: string | import("nostr-tools/nip19").ProfilePointer): Observable<import("nostr-tools/nip19").ProfilePointer[]>;
+        mutes(user: string | import("nostr-tools/nip19").ProfilePointer): Observable<import("../helpers/mutes.js").Mutes | undefined>;
+        mailboxes(user: string | import("nostr-tools/nip19").ProfilePointer): Observable<{
+            inboxes: string[];
+            outboxes: string[];
+        } | undefined>;
+        blossomServers(user: string | import("nostr-tools/nip19").ProfilePointer): Observable<URL[]>;
+        reactions(event: NostrEvent): Observable<import("nostr-tools").Event[]>;
+        thread(root: string | EventPointer | AddressPointer): Observable<import("../models/thread.js").Thread>;
+        comments(event: NostrEvent): Observable<import("nostr-tools").Event[]>;
+        events(ids: string[]): Observable<Record<string, NostrEvent | undefined>>;
+        replaceableSet(pointers: {
+            kind: number;
+            pubkey: string;
+            identifier?: string;
+        }[]): Observable<Record<string, NostrEvent | undefined>>;
+    };
+} & {
+    new (): {};
+};
+/** An async wrapper around an async event database that handles replaceable events, deletes, and models */
+export declare class AsyncEventStore extends AsyncEventStore_base implements IAsyncEventStore {
+    database: IAsyncEventDatabase;
+    /** Enable this to keep old versions of replaceable events */
+    keepOldVersions: boolean;
+    /** Enable this to keep expired events */
+    keepExpired: boolean;
+    /**
+     * A method used to verify new events before added them
+     * @returns true if the event is valid, false if it should be ignored
+     */
+    verifyEvent?: (event: NostrEvent) => boolean;
+    /** A stream of new events added to the store */
+    insert$: Subject<import("nostr-tools").Event>;
+    /** A stream of events that have been updated */
+    update$: Subject<import("nostr-tools").Event>;
+    /** A stream of events that have been removed */
+    remove$: Subject<import("nostr-tools").Event>;
+    /**
+     * A method that will be called when an event isn't found in the store
+     * @experimental
+     */
+    eventLoader?: (pointer: EventPointer) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
+    /**
+     * A method that will be called when a replaceable event isn't found in the store
+     * @experimental
+     */
+    replaceableLoader?: (pointer: AddressPointerWithoutD) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
+    /**
+     * A method that will be called when an addressable event isn't found in the store
+     * @experimental
+     */
+    addressableLoader?: (pointer: AddressPointer) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
+    constructor(database: IAsyncEventDatabase);
+    protected deletedIds: Set<string>;
+    protected deletedCoords: Map<string, number>;
+    protected checkDeleted(event: string | NostrEvent): boolean;
+    protected expirations: Map<string, number>;
+    /** Adds an event to the expiration map */
+    protected addExpiration(event: NostrEvent): void;
+    protected expirationTimeout: number | null;
+    protected nextExpirationCheck: number | null;
+    protected handleExpiringEvent(event: NostrEvent): void;
+    /** Remove expired events from the store */
+    protected pruneExpired(): Promise<void>;
+    protected handleDeleteEvent(deleteEvent: NostrEvent): Promise<void>;
+    /** Copies important metadata from and identical event to another */
+    static mergeDuplicateEvent(source: NostrEvent, dest: NostrEvent): void;
+    /**
+     * Adds an event to the store and update subscriptions
+     * @returns The existing event or the event that was added, if it was ignored returns null
+     */
+    add(event: NostrEvent, fromRelay?: string): Promise<NostrEvent | null>;
+    /** Removes an event from the store and updates subscriptions */
+    remove(event: string | NostrEvent): Promise<boolean>;
+    /** Add an event to the store and notifies all subscribes it has updated */
+    update(event: NostrEvent): Promise<void>;
+    /** Passthrough method for the database.touch */
+    touch(event: NostrEvent): Promise<void>;
+    /** Pass through method for the database.unclaimed */
+    unclaimed(): AsyncGenerator<NostrEvent>;
+    /** Removes any event that is not being used by a subscription */
+    prune(limit?: number): Promise<number>;
+    /** Check if the store has an event by id */
+    hasEvent(id: string): Promise<boolean>;
+    /** Get an event by id from the store */
+    getEvent(id: string): Promise<NostrEvent | undefined>;
+    /** Check if the store has a replaceable event */
+    hasReplaceable(kind: number, pubkey: string, d?: string): Promise<boolean>;
+    /** Gets the latest version of a replaceable event */
+    getReplaceable(kind: number, pubkey: string, identifier?: string): Promise<NostrEvent | undefined>;
+    /** Returns all versions of a replaceable event */
+    getReplaceableHistory(kind: number, pubkey: string, identifier?: string): Promise<NostrEvent[] | undefined>;
+    /** Get all events matching a filter */
+    getByFilters(filters: Filter | Filter[]): Promise<Set<NostrEvent>>;
+    /** Returns a timeline of events that match filters */
+    getTimeline(filters: Filter | Filter[]): Promise<NostrEvent[]>;
+    /** Sets the claim on the event and touches it */
+    claim(event: NostrEvent, claim: any): Promise<void>;
+    /** Checks if an event is claimed by anything */
+    isClaimed(event: NostrEvent): Promise<boolean>;
+    /** Removes a claim from an event */
+    removeClaim(event: NostrEvent, claim: any): Promise<void>;
+    /** Removes all claims on an event */
+    clearClaim(event: NostrEvent): Promise<void>;
+    /** Returns an observable that completes when an event is removed */
+    removed(id: string): Observable<never>;
+    /** Creates an observable that emits when event is updated */
+    updated(event: string | NostrEvent): Observable<NostrEvent>;
+}
+export {};

package/dist/event-store/async-event-store.js

@@ -0,0 +1,323 @@
+import { kinds } from "nostr-tools";
+import { isAddressableKind } from "nostr-tools/kinds";
+import { EMPTY, filter, mergeMap, Subject, take } from "rxjs";
+import { getDeleteCoordinates, getDeleteIds } from "../helpers/delete.js";
+import { createReplaceableAddress, EventStoreSymbol, FromCacheSymbol, isReplaceable } from "../helpers/event.js";
+import { getExpirationTimestamp } from "../helpers/expiration.js";
+import { parseCoordinate } from "../helpers/pointers.js";
+import { addSeenRelay, getSeenRelays } from "../helpers/relays.js";
+import { unixNow } from "../helpers/time.js";
+// Import common models
+import { EventStoreModelMixin } from "./model-mixin.js";
+/** An async wrapper around an async event database that handles replaceable events, deletes, and models */
+export class AsyncEventStore extends EventStoreModelMixin(class {
+}) {
+    database;
+    /** Enable this to keep old versions of replaceable events */
+    keepOldVersions = false;
+    /** Enable this to keep expired events */
+    keepExpired = false;
+    /**
+     * A method used to verify new events before added them
+     * @returns true if the event is valid, false if it should be ignored
+     */
+    verifyEvent;
+    /** A stream of new events added to the store */
+    insert$ = new Subject();
+    /** A stream of events that have been updated */
+    update$ = new Subject();
+    /** A stream of events that have been removed */
+    remove$ = new Subject();
+    /**
+     * A method that will be called when an event isn't found in the store
+     * @experimental
+     */
+    eventLoader;
+    /**
+     * A method that will be called when a replaceable event isn't found in the store
+     * @experimental
+     */
+    replaceableLoader;
+    /**
+     * A method that will be called when an addressable event isn't found in the store
+     * @experimental
+     */
+    addressableLoader;
+    constructor(database) {
+        super();
+        this.database = database;
+        // when events are added to the database, add the symbol
+        this.insert$.subscribe((event) => {
+            Reflect.set(event, EventStoreSymbol, this);
+        });
+        // when events are removed from the database, remove the symbol
+        this.remove$.subscribe((event) => {
+            Reflect.deleteProperty(event, EventStoreSymbol);
+        });
+    }
+    // delete state
+    deletedIds = new Set();
+    deletedCoords = new Map();
+    checkDeleted(event) {
+        if (typeof event === "string")
+            return this.deletedIds.has(event);
+        else {
+            if (this.deletedIds.has(event.id))
+                return true;
+            if (isAddressableKind(event.kind)) {
+                const identifier = event.tags.find((t) => t[0] === "d")?.[1];
+                const deleted = this.deletedCoords.get(createReplaceableAddress(event.kind, event.pubkey, identifier));
+                if (deleted)
+                    return deleted > event.created_at;
+            }
+        }
+        return false;
+    }
+    expirations = new Map();
+    /** Adds an event to the expiration map */
+    addExpiration(event) {
+        const expiration = getExpirationTimestamp(event);
+        if (expiration && Number.isFinite(expiration))
+            this.expirations.set(event.id, expiration);
+    }
+    expirationTimeout = null;
+    nextExpirationCheck = null;
+    handleExpiringEvent(event) {
+        const expiration = getExpirationTimestamp(event);
+        if (!expiration)
+            return;
+        // Add event to expiration map
+        this.expirations.set(event.id, expiration);
+        // Exit if the next check is already less than the next expiration
+        if (this.expirationTimeout && this.nextExpirationCheck && this.nextExpirationCheck < expiration)
+            return;
+        // Set timeout to prune expired events
+        if (this.expirationTimeout)
+            clearTimeout(this.expirationTimeout);
+        const timeout = expiration - unixNow();
+        this.expirationTimeout = setTimeout(this.pruneExpired.bind(this), timeout * 1000 + 10);
+        this.nextExpirationCheck = expiration;
+    }
+    /** Remove expired events from the store */
+    async pruneExpired() {
+        const now = unixNow();
+        for (const [id, expiration] of this.expirations) {
+            if (expiration <= now) {
+                this.expirations.delete(id);
+                await this.remove(id);
+            }
+        }
+        // Cleanup timers
+        if (this.expirationTimeout)
+            clearTimeout(this.expirationTimeout);
+        this.nextExpirationCheck = null;
+        this.expirationTimeout = null;
+    }
+    // handling delete events
+    async handleDeleteEvent(deleteEvent) {
+        const ids = getDeleteIds(deleteEvent);
+        for (const id of ids) {
+            this.deletedIds.add(id);
+            // remove deleted events in the database
+            await this.remove(id);
+        }
+        const coords = getDeleteCoordinates(deleteEvent);
+        for (const coord of coords) {
+            this.deletedCoords.set(coord, Math.max(this.deletedCoords.get(coord) ?? 0, deleteEvent.created_at));
+            // Parse the nostr address coordinate
+            const parsed = parseCoordinate(coord);
+            if (!parsed)
+                continue;
+            // Remove older versions of replaceable events
+            const events = await this.database.getReplaceableHistory(parsed.kind, parsed.pubkey, parsed.identifier);
+            if (events) {
+                for (const event of events) {
+                    if (event.created_at < deleteEvent.created_at)
+                        await this.remove(event);
+                }
+            }
+        }
+    }
+    /** Copies important metadata from and identical event to another */
+    static mergeDuplicateEvent(source, dest) {
+        const relays = getSeenRelays(source);
+        if (relays) {
+            for (const relay of relays)
+                addSeenRelay(dest, relay);
+        }
+        // copy the from cache symbol only if its true
+        const fromCache = Reflect.get(source, FromCacheSymbol);
+        if (fromCache && !Reflect.get(dest, FromCacheSymbol))
+            Reflect.set(dest, FromCacheSymbol, fromCache);
+    }
+    /**
+     * Adds an event to the store and update subscriptions
+     * @returns The existing event or the event that was added, if it was ignored returns null
+     */
+    async add(event, fromRelay) {
+        // Handle delete events differently
+        if (event.kind === kinds.EventDeletion)
+            await this.handleDeleteEvent(event);
+        // Ignore if the event was deleted
+        if (this.checkDeleted(event))
+            return event;
+        // Reject expired events if keepExpired is false
+        const expiration = getExpirationTimestamp(event);
+        if (this.keepExpired === false && expiration && expiration <= unixNow())
+            return null;
+        // Get the replaceable identifier
+        const identifier = isReplaceable(event.kind) ? event.tags.find((t) => t[0] === "d")?.[1] : undefined;
+        // Don't insert the event if there is already a newer version
+        if (!this.keepOldVersions && isReplaceable(event.kind)) {
+            const existing = await this.database.getReplaceableHistory(event.kind, event.pubkey, identifier);
+            // If there is already a newer version, copy cached symbols and return existing event
+            if (existing && existing.length > 0 && existing[0].created_at >= event.created_at) {
+                AsyncEventStore.mergeDuplicateEvent(event, existing[0]);
+                return existing[0];
+            }
+        }
+        else if (await this.database.hasEvent(event.id)) {
+            // Duplicate event, copy symbols and return existing event
+            const existing = await this.database.getEvent(event.id);
+            if (existing) {
+                AsyncEventStore.mergeDuplicateEvent(event, existing);
+                return existing;
+            }
+        }
+        // Verify event before inserting into the database
+        if (this.verifyEvent && this.verifyEvent(event) === false)
+            return null;
+        // Insert event into database
+        const inserted = await this.database.add(event);
+        // If the event was ignored, return null
+        if (inserted === null)
+            return null;
+        // Copy cached data if its a duplicate event
+        if (event !== inserted)
+            AsyncEventStore.mergeDuplicateEvent(event, inserted);
+        // attach relay this event was from
+        if (fromRelay)
+            addSeenRelay(inserted, fromRelay);
+        // Emit insert$ signal
+        if (inserted === event)
+            this.insert$.next(inserted);
+        // remove all old version of the replaceable event
+        if (!this.keepOldVersions && isReplaceable(event.kind)) {
+            const existing = await this.database.getReplaceableHistory(event.kind, event.pubkey, identifier);
+            if (existing) {
+                const older = Array.from(existing).filter((e) => e.created_at < event.created_at);
+                for (const old of older)
+                    await this.remove(old);
+                // return the newest version of the replaceable event
+                // most of the time this will be === event, but not always
+                if (existing.length !== older.length)
+                    return existing[0];
+            }
+        }
+        // Add event to expiration map
+        if (this.keepExpired === false && expiration)
+            this.handleExpiringEvent(inserted);
+        return inserted;
+    }
+    /** Removes an event from the store and updates subscriptions */
+    async remove(event) {
+        // Get the current instance from the database
+        const e = await this.database.getEvent(typeof event === "string" ? event : event.id);
+        if (!e)
+            return false;
+        const removed = await this.database.remove(event);
+        if (removed && e)
+            this.remove$.next(e);
+        return removed;
+    }
+    /** Add an event to the store and notifies all subscribes it has updated */
+    async update(event) {
+        // Map the event to the current instance in the database
+        const e = await this.database.add(event);
+        if (!e)
+            return;
+        await this.database.update(event);
+        this.update$.next(event);
+    }
+    /** Passthrough method for the database.touch */
+    async touch(event) {
+        return await this.database.touch(event);
+    }
+    /** Pass through method for the database.unclaimed */
+    unclaimed() {
+        return this.database.unclaimed();
+    }
+    /** Removes any event that is not being used by a subscription */
+    async prune(limit) {
+        let removed = 0;
+        const generator = this.database.unclaimed();
+        for await (const event of generator) {
+            await this.remove(event);
+            removed++;
+            if (limit && removed >= limit)
+                break;
+        }
+        return removed;
+    }
+    /** Check if the store has an event by id */
+    async hasEvent(id) {
+        return await this.database.hasEvent(id);
+    }
+    /** Get an event by id from the store */
+    async getEvent(id) {
+        return await this.database.getEvent(id);
+    }
+    /** Check if the store has a replaceable event */
+    async hasReplaceable(kind, pubkey, d) {
+        return await this.database.hasReplaceable(kind, pubkey, d);
+    }
+    /** Gets the latest version of a replaceable event */
+    async getReplaceable(kind, pubkey, identifier) {
+        return await this.database.getReplaceable(kind, pubkey, identifier);
+    }
+    /** Returns all versions of a replaceable event */
+    async getReplaceableHistory(kind, pubkey, identifier) {
+        return await this.database.getReplaceableHistory(kind, pubkey, identifier);
+    }
+    /** Get all events matching a filter */
+    async getByFilters(filters) {
+        return await this.database.getByFilters(filters);
+    }
+    /** Returns a timeline of events that match filters */
+    async getTimeline(filters) {
+        return await this.database.getTimeline(filters);
+    }
+    /** Sets the claim on the event and touches it */
+    async claim(event, claim) {
+        return await this.database.claim(event, claim);
+    }
+    /** Checks if an event is claimed by anything */
+    async isClaimed(event) {
+        return await this.database.isClaimed(event);
+    }
+    /** Removes a claim from an event */
+    async removeClaim(event, claim) {
+        return await this.database.removeClaim(event, claim);
+    }
+    /** Removes all claims on an event */
+    async clearClaim(event) {
+        return await this.database.clearClaim(event);
+    }
+    /** Returns an observable that completes when an event is removed */
+    removed(id) {
+        const deleted = this.checkDeleted(id);
+        if (deleted)
+            return EMPTY;
+        return this.remove$.pipe(
+        // listen for removed events
+        filter((e) => e.id === id), 
+        // complete as soon as we find a matching removed event
+        take(1), 
+        // switch to empty
+        mergeMap(() => EMPTY));
+    }
+    /** Creates an observable that emits when event is updated */
+    updated(event) {
+        return this.update$.pipe(filter((e) => e.id === event || e === event));
+    }
+}

package/dist/event-store/event-database.d.ts

@@ -0,0 +1,74 @@
+import { Filter, NostrEvent } from "nostr-tools";
+import { LRU } from "../helpers/lru.js";
+import { IEventDatabase } from "./interface.js";
+/** An in-memory database of events */
+export declare class InMemoryEventDatabase implements IEventDatabase {
+    protected log: import("debug").Debugger;
+    /** Indexes */
+    protected kinds: Map<number, Set<import("nostr-tools").Event>>;
+    protected authors: Map<string, Set<import("nostr-tools").Event>>;
+    protected tags: LRU<Set<import("nostr-tools").Event>>;
+    protected created_at: NostrEvent[];
+    /** LRU cache of last events touched */
+    events: LRU<import("nostr-tools").Event>;
+    /** A sorted array of replaceable events by address */
+    protected replaceable: Map<string, import("nostr-tools").Event[]>;
+    /** The number of events in the event set */
+    get size(): number;
+    /** Checks if the database contains an event without touching it */
+    hasEvent(id: string): boolean;
+    /** Gets a single event based on id */
+    getEvent(id: string): NostrEvent | undefined;
+    /** Checks if the event set has a replaceable event */
+    hasReplaceable(kind: number, pubkey: string, identifier?: string): boolean;
+    /** Gets the latest replaceable event */
+    getReplaceable(kind: number, pubkey: string, identifier?: string): NostrEvent | undefined;
+    /** Gets the history of a replaceable event */
+    getReplaceableHistory(kind: number, pubkey: string, identifier?: string): NostrEvent[] | undefined;
+    /** Gets all events that match the filters */
+    getByFilters(filters: Filter | Filter[]): Set<NostrEvent>;
+    /** Gets a timeline of events that match the filters */
+    getTimeline(filters: Filter | Filter[]): NostrEvent[];
+    /** Inserts an event into the database and notifies all subscriptions */
+    add(event: NostrEvent): NostrEvent | null;
+    /** Removes an event from the database and notifies all subscriptions */
+    remove(eventOrId: string | NostrEvent): boolean;
+    /** Notify the database that an event has updated */
+    update(_event: NostrEvent): void;
+    /** A weak map of events that are claimed by other things */
+    protected claims: WeakMap<import("nostr-tools").Event, any>;
+    /** Moves an event to the top of the LRU cache */
+    touch(event: NostrEvent): void;
+    /** Sets the claim on the event and touches it */
+    claim(event: NostrEvent, claim: any): void;
+    /** Checks if an event is claimed by anything */
+    isClaimed(event: NostrEvent): boolean;
+    /** Removes a claim from an event */
+    removeClaim(event: NostrEvent, claim: any): void;
+    /** Removes all claims on an event */
+    clearClaim(event: NostrEvent): void;
+    /** Returns a generator of unclaimed events in order of least used */
+    unclaimed(): Generator<NostrEvent>;
+    /** Index helper methods */
+    protected getKindIndex(kind: number): Set<import("nostr-tools").Event>;
+    protected getAuthorsIndex(author: string): Set<import("nostr-tools").Event>;
+    protected getTagIndex(tagAndValue: string): Set<import("nostr-tools").Event>;
+    /** Iterates over all events by author */
+    iterateAuthors(authors: Iterable<string>): Generator<NostrEvent>;
+    /** Iterates over all events by indexable tag and value */
+    iterateTag(tag: string, values: Iterable<string>): Generator<NostrEvent>;
+    /** Iterates over all events by kind */
+    iterateKinds(kinds: Iterable<number>): Generator<NostrEvent>;
+    /** Iterates over all events by time */
+    iterateTime(since: number | undefined, until: number | undefined): Generator<NostrEvent>;
+    /** Iterates over all events by id */
+    iterateIds(ids: Iterable<string>): Generator<NostrEvent>;
+    /** Returns all events that match the filter */
+    getEventsForFilter(filter: Filter): Set<NostrEvent>;
+    /** Returns all events that match the filters */
+    getEventsForFilters(filters: Filter[]): Set<NostrEvent>;
+    /** Resets the event set */
+    reset(): void;
+}
+/** @deprecated use {@link InMemoryEventDatabase} instead */
+export declare const EventSet: typeof InMemoryEventDatabase;