applesauce-core 3.1.0 → 4.0.0

package/dist/event-store/{event-set.js → event-memory.js}

@@ -1,15 +1,11 @@
 import { binarySearch, insertEventIntoDescendingList } from "nostr-tools/utils";
-import { Subject } from "rxjs";
 import { getIndexableTags, INDEXABLE_TAGS } from "../helpers/event-tags.js";
 import { createReplaceableAddress, isReplaceable } from "../helpers/event.js";
 import { LRU } from "../helpers/lru.js";
 import { logger } from "../logger.js";
-/**
- * A set of nostr events that can be queried and subscribed to
- * NOTE: does not handle replaceable events or any deletion logic
- */
-export class EventSet {
-    log = logger.extend("EventSet");
+/** An in-memory database of events */
+export class EventMemory {
+    log = logger.extend("EventMemory");
     /** Indexes */
     kinds = new Map();
     authors = new Map();
@@ -19,22 +15,10 @@ export class EventSet {
     events = new LRU();
     /** A sorted array of replaceable events by address */
     replaceable = new Map();
-    /** A stream of events inserted into the database */
-    insert$ = new Subject();
-    /** A stream of events that have been updated */
-    update$ = new Subject();
-    /** A stream of events removed from the database */
-    remove$ = new Subject();
-    /** A method thats called before a new event is inserted */
-    onBeforeInsert;
     /** The number of events in the event set */
     get size() {
         return this.events.size;
     }
-    /** Moves an event to the top of the LRU cache */
-    touch(event) {
-        this.events.set(event.id, event);
-    }
     /** Checks if the database contains an event without touching it */
     hasEvent(id) {
         return this.events.has(id);
@@ -61,12 +45,12 @@ export class EventSet {
     }
     /** Gets all events that match the filters */
     getByFilters(filters) {
-        return this.getEventsForFilters(Array.isArray(filters) ? filters : [filters]);
+        return Array.from(this.getEventsForFilters(Array.isArray(filters) ? filters : [filters]));
     }
     /** Gets a timeline of events that match the filters */
     getTimeline(filters) {
         const timeline = [];
-        const events = this.getEventsForFilters(Array.isArray(filters) ? filters : [filters]);
+        const events = this.getByFilters(filters);
         for (const event of events)
             insertEventIntoDescendingList(timeline, event);
         return timeline;
@@ -77,9 +61,6 @@ export class EventSet {
         const current = this.events.get(id);
         if (current)
             return current;
-        // Ignore events if before insert returns false
-        if (this.onBeforeInsert?.(event) === false)
-            return null;
         this.events.set(id, event);
         this.getKindIndex(event.kind).add(event);
         this.getAuthorsIndex(event.pubkey).add(event);
@@ -103,22 +84,13 @@ export class EventSet {
             // insert the event into the sorted array
             insertEventIntoDescendingList(array, event);
         }
-        // Notify subscribers that the event was inserted
-        this.insert$.next(event);
         return event;
     }
-    /** Inserts and event into the database and notifies all subscriptions that the event has updated */
-    update(event) {
-        const inserted = this.add(event);
-        if (inserted)
-            this.update$.next(inserted);
-        return inserted !== null;
-    }
     /** Removes an event from the database and notifies all subscriptions */
     remove(eventOrId) {
         let event = typeof eventOrId === "string" ? this.events.get(eventOrId) : eventOrId;
         if (!event)
-            throw new Error("Missing event");
+            return false;
         const id = event.id;
         // only remove events that are known
         if (!this.events.has(id))
@@ -146,12 +118,22 @@ export class EventSet {
         }
         // remove any claims this event has
         this.claims.delete(event);
-        // notify subscribers this event was removed
-        this.remove$.next(event);
         return true;
     }
+    /** Notify the database that an event has updated */
+    update(_event) {
+        // Do nothing
+    }
     /** A weak map of events that are claimed by other things */
     claims = new WeakMap();
+    /** Moves an event to the top of the LRU cache */
+    touch(event) {
+        // Make sure the event is in the database before adding it to the LRU
+        if (!this.events.has(event.id))
+            return;
+        // Move to the top of the LRU
+        this.events.set(event.id, event);
+    }
     /** Sets the claim on the event and touches it */
     claim(event, claim) {
         if (!this.claims.has(event)) {
@@ -174,6 +156,30 @@ export class EventSet {
     clearClaim(event) {
         this.claims.delete(event);
     }
+    /** Returns a generator of unclaimed events in order of least used */
+    *unclaimed() {
+        let removed = 0;
+        let cursor = this.events.first;
+        while (cursor) {
+            const event = cursor.value;
+            if (!this.isClaimed(event))
+                yield event;
+            cursor = cursor.next;
+        }
+        return removed;
+    }
+    /** Removes events that are not claimed (free up memory) */
+    prune(limit) {
+        let removed = 0;
+        const unclaimed = this.unclaimed();
+        for (const event of unclaimed) {
+            this.remove(event);
+            removed++;
+            if (limit && removed >= limit)
+                break;
+        }
+        return removed;
+    }
     /** Index helper methods */
     getKindIndex(kind) {
         if (!this.kinds.has(kind))
@@ -321,7 +327,7 @@ export class EventSet {
     /** Returns all events that match the filters */
     getEventsForFilters(filters) {
         if (filters.length === 0)
-            throw new Error("No Filters");
+            return new Set();
         let events = new Set();
         for (const filter of filters) {
             const filtered = this.getEventsForFilter(filter);
@@ -330,22 +336,6 @@ export class EventSet {
         }
         return events;
     }
-    /** Remove the oldest events that are not claimed */
-    prune(limit = 1000) {
-        let removed = 0;
-        let cursor = this.events.first;
-        while (cursor) {
-            const event = cursor.value;
-            if (!this.isClaimed(event)) {
-                this.remove(event);
-                removed++;
-                if (removed >= limit)
-                    break;
-            }
-            cursor = cursor.next;
-        }
-        return removed;
-    }
     /** Resets the event set */
     reset() {
         this.events.clear();

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

@@ -1,12 +1,47 @@
 import { Filter, NostrEvent } from "nostr-tools";
-import { Observable } from "rxjs";
-import { AddressPointer, EventPointer, ProfilePointer } from "nostr-tools/nip19";
+import { AddressPointer, EventPointer } from "nostr-tools/nip19";
+import { Observable, Subject } from "rxjs";
 import { AddressPointerWithoutD } from "../helpers/pointers.js";
-import { EventSet } from "./event-set.js";
-import { IEventStore, ModelConstructor } from "./interface.js";
-/** An extended {@link EventSet} that handles replaceable events, delets, and models */
-export declare class EventStore implements IEventStore {
-    database: EventSet;
+import { EventMemory } from "./event-memory.js";
+import { IEventDatabase, IEventStore } from "./interface.js";
+declare const EventStore_base: {
+    new (...args: any[]): {
+        [x: string]: any;
+        models: Map<import("./interface.js").ModelConstructor<any, any[], IEventStore | import("./interface.js").IAsyncEventStore>, Map<string, Observable<any>>>;
+        modelKeepWarm: number;
+        model<T extends unknown, Args extends Array<any>>(constructor: import("./interface.js").ModelConstructor<T, Args, IEventStore | import("./interface.js").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 (): {};
+};
+/** A wrapper around an event database that handles replaceable events, deletes, and models */
+export declare class EventStore extends EventStore_base implements IEventStore {
+    database: IEventDatabase;
+    /** Optional memory database for ensuring single event instances */
+    memory?: EventMemory;
     /** Enable this to keep old versions of replaceable events */
     keepOldVersions: boolean;
     /** Enable this to keep expired events */
@@ -17,11 +52,11 @@ export declare class EventStore implements IEventStore {
      */
     verifyEvent?: (event: NostrEvent) => boolean;
     /** A stream of new events added to the store */
-    insert$: Observable<NostrEvent>;
+    insert$: Subject<import("nostr-tools").Event>;
     /** A stream of events that have been updated */
-    update$: Observable<NostrEvent>;
+    update$: Subject<import("nostr-tools").Event>;
     /** A stream of events that have been removed */
-    remove$: Observable<NostrEvent>;
+    remove$: Subject<import("nostr-tools").Event>;
     /**
      * A method that will be called when an event isn't found in the store
      * @experimental
@@ -37,7 +72,9 @@ export declare class EventStore implements IEventStore {
      * @experimental
      */
     addressableLoader?: (pointer: AddressPointer) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
-    constructor();
+    constructor(database?: IEventDatabase);
+    /** A method to add all events to memory to ensure there is only ever a single instance of an event */
+    private mapToMemory;
     protected deletedIds: Set<string>;
     protected deletedCoords: Map<string, number>;
     protected checkDeleted(event: string | NostrEvent): boolean;
@@ -57,12 +94,10 @@ export declare class EventStore implements IEventStore {
      * @returns The existing event or the event that was added, if it was ignored returns null
      */
     add(event: NostrEvent, fromRelay?: string): NostrEvent | null;
-    /** Removes an event from the database and updates subscriptions */
+    /** Removes an event from the store and updates subscriptions */
     remove(event: string | NostrEvent): boolean;
     /** Add an event to the store and notifies all subscribes it has updated */
     update(event: NostrEvent): boolean;
-    /** Removes any event that is not being used by a subscription */
-    prune(max?: number): number;
     /** Check if the store has an event by id */
     hasEvent(id: string): boolean;
     /** Get an event by id from the store */
@@ -74,9 +109,11 @@ export declare class EventStore implements IEventStore {
     /** Returns all versions of a replaceable event */
     getReplaceableHistory(kind: number, pubkey: string, identifier?: string): NostrEvent[] | undefined;
     /** Get all events matching a filter */
-    getByFilters(filters: Filter | Filter[]): Set<NostrEvent>;
+    getByFilters(filters: Filter | Filter[]): NostrEvent[];
     /** Returns a timeline of events that match filters */
     getTimeline(filters: Filter | Filter[]): NostrEvent[];
+    /** Passthrough method for the database.touch */
+    touch(event: NostrEvent): void | undefined;
     /** Sets the claim on the event and touches it */
     claim(event: NostrEvent, claim: any): void;
     /** Checks if an event is claimed by anything */
@@ -85,56 +122,13 @@ export declare class EventStore implements IEventStore {
     removeClaim(event: NostrEvent, claim: any): void;
     /** Removes all claims on an event */
     clearClaim(event: NostrEvent): void;
-    /** A directory of all active models */
-    protected models: Map<ModelConstructor<any, any[]>, Map<string, Observable<any>>>;
-    /** How long a model should be kept "warm" while nothing is subscribed to it */
-    modelKeepWarm: number;
-    /** Get or create a model on the event store */
-    model<T extends unknown, Args extends Array<any>>(constructor: ModelConstructor<T, Args>, ...args: Args): Observable<T>;
-    /**
-     * Creates an observable that streams all events that match the filter
-     * @param filters
-     * @param [onlyNew=false] Only subscribe to new events
-     */
-    filters(filters: Filter | Filter[], onlyNew?: boolean): Observable<NostrEvent>;
+    /** Pass through method for the database.unclaimed */
+    unclaimed(): Generator<NostrEvent>;
+    /** Removes any event that is not being used by a subscription */
+    prune(limit?: number): number;
     /** 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>;
-    /** Creates a {@link EventModel} */
-    event(pointer: string | EventPointer): Observable<NostrEvent | undefined>;
-    /** Creates a {@link ReplaceableModel} */
-    replaceable(pointer: AddressPointer | AddressPointerWithoutD): Observable<NostrEvent | undefined>;
-    replaceable(kind: number, pubkey: string, identifier?: string): Observable<NostrEvent | undefined>;
-    /** Subscribe to an addressable event by pointer */
-    addressable(pointer: AddressPointer): Observable<NostrEvent | undefined>;
-    /** Creates a {@link TimelineModel} */
-    timeline(filters: Filter | Filter[], includeOldVersion?: boolean): Observable<NostrEvent[]>;
-    /** Subscribe to a users profile */
-    profile(user: string | ProfilePointer): Observable<import("../helpers/profile.js").ProfileContent | undefined>;
-    /** Subscribe to a users contacts */
-    contacts(user: string | ProfilePointer): Observable<ProfilePointer[]>;
-    /** Subscribe to a users mutes */
-    mutes(user: string | ProfilePointer): Observable<import("../helpers/mutes.js").Mutes | undefined>;
-    /** Subscribe to a users NIP-65 mailboxes */
-    mailboxes(user: string | ProfilePointer): Observable<{
-        inboxes: string[];
-        outboxes: string[];
-    } | undefined>;
-    /** Subscribe to a users blossom servers */
-    blossomServers(user: string | ProfilePointer): Observable<URL[]>;
-    /** Subscribe to an event's reactions */
-    reactions(event: NostrEvent): Observable<import("nostr-tools").Event[]>;
-    /** Subscribe to a thread */
-    thread(root: string | EventPointer | AddressPointer): Observable<import("../models/thread.js").Thread>;
-    /** Subscribe to a event's comments */
-    comments(event: NostrEvent): Observable<import("nostr-tools").Event[]>;
-    /** @deprecated use multiple {@link EventModel} instead */
-    events(ids: string[]): Observable<Record<string, NostrEvent | undefined>>;
-    /** @deprecated use multiple {@link ReplaceableModel} instead */
-    replaceableSet(pointers: {
-        kind: number;
-        pubkey: string;
-        identifier?: string;
-    }[]): Observable<Record<string, NostrEvent | undefined>>;
 }
+export {};