applesauce-core 3.1.0 → 4.0.0

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

@@ -1,26 +1,20 @@
 import { kinds } from "nostr-tools";
 import { isAddressableKind } from "nostr-tools/kinds";
-import { EMPTY, filter, finalize, from, merge, mergeMap, ReplaySubject, share, take, timer } from "rxjs";
-import hash_sum from "hash-sum";
+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 { matchFilters } from "../helpers/filter.js";
 import { parseCoordinate } from "../helpers/pointers.js";
 import { addSeenRelay, getSeenRelays } from "../helpers/relays.js";
 import { unixNow } from "../helpers/time.js";
-import { UserBlossomServersModel } from "../models/blossom.js";
-import { EventModel, EventsModel, ReplaceableModel, ReplaceableSetModel, TimelineModel } from "../models/common.js";
-import { ContactsModel } from "../models/contacts.js";
-import { CommentsModel, ThreadModel } from "../models/index.js";
-import { MailboxesModel } from "../models/mailboxes.js";
-import { MuteModel } from "../models/mutes.js";
-import { ProfileModel } from "../models/profile.js";
-import { ReactionsModel } from "../models/reactions.js";
-import { EventSet } from "./event-set.js";
-/** An extended {@link EventSet} that handles replaceable events, delets, and models */
-export class EventStore {
+import { EventMemory } from "./event-memory.js";
+import { EventStoreModelMixin } from "./model-mixin.js";
+/** A wrapper around an event database that handles replaceable events, deletes, and models */
+export class EventStore extends EventStoreModelMixin(class {
+}) {
     database;
+    /** Optional memory database for ensuring single event instances */
+    memory;
     /** Enable this to keep old versions of replaceable events */
     keepOldVersions = false;
     /** Enable this to keep expired events */
@@ -31,11 +25,11 @@ export class EventStore {
      */
     verifyEvent;
     /** A stream of new events added to the store */
-    insert$;
+    insert$ = new Subject();
     /** A stream of events that have been updated */
-    update$;
+    update$ = new Subject();
     /** A stream of events that have been removed */
-    remove$;
+    remove$ = new Subject();
     /**
      * A method that will be called when an event isn't found in the store
      * @experimental
@@ -51,27 +45,31 @@ export class EventStore {
      * @experimental
      */
     addressableLoader;
-    constructor() {
-        this.database = new EventSet();
-        // verify events before they are added to the database
-        this.database.onBeforeInsert = (event) => {
-            // Ignore events that are invalid
-            if (this.verifyEvent && this.verifyEvent(event) === false)
-                return false;
-            else
-                return true;
-        };
+    constructor(database = new EventMemory()) {
+        super();
+        if (database) {
+            this.database = database;
+            this.memory = new EventMemory();
+        }
+        else {
+            // If no database is provided, its the same as having a memory database
+            this.database = this.memory = new EventMemory();
+        }
         // when events are added to the database, add the symbol
-        this.database.insert$.subscribe((event) => {
+        this.insert$.subscribe((event) => {
             Reflect.set(event, EventStoreSymbol, this);
         });
         // when events are removed from the database, remove the symbol
-        this.database.remove$.subscribe((event) => {
+        this.remove$.subscribe((event) => {
             Reflect.deleteProperty(event, EventStoreSymbol);
         });
-        this.insert$ = this.database.insert$;
-        this.update$ = this.database.update$;
-        this.remove$ = this.database.remove$;
+    }
+    mapToMemory(event) {
+        if (event === undefined)
+            return undefined;
+        if (!this.memory)
+            return event;
+        return this.memory.add(event);
     }
     // delete state
     deletedIds = new Set();
@@ -137,9 +135,7 @@ export class EventStore {
         for (const id of ids) {
             this.deletedIds.add(id);
             // remove deleted events in the database
-            const event = this.database.getEvent(id);
-            if (event)
-                this.database.remove(event);
+            this.remove(id);
         }
         const coords = getDeleteCoordinates(deleteEvent);
         for (const coord of coords) {
@@ -152,7 +148,7 @@ export class EventStore {
             const events = this.database.getReplaceableHistory(parsed.kind, parsed.pubkey, parsed.identifier) ?? [];
             for (const event of events) {
                 if (event.created_at < deleteEvent.created_at)
-                    this.database.remove(event);
+                    this.remove(event);
             }
         }
     }
@@ -173,6 +169,7 @@ export class EventStore {
      * @returns The existing event or the event that was added, if it was ignored returns null
      */
     add(event, fromRelay) {
+        // Handle delete events differently
         if (event.kind === kinds.EventDeletion)
             this.handleDeleteEvent(event);
         // Ignore if the event was deleted
@@ -193,32 +190,38 @@ export class EventStore {
                 return existing[0];
             }
         }
-        else if (this.database.hasEvent(event.id)) {
-            // Duplicate event, copy symbols and return existing event
-            const existing = this.database.getEvent(event.id);
-            if (existing) {
-                EventStore.mergeDuplicateEvent(event, existing);
-                return existing;
-            }
+        // Verify event before inserting into the database
+        if (this.verifyEvent && this.verifyEvent(event) === false)
+            return null;
+        // Always add event to memory
+        const existing = this.memory?.add(event);
+        // If the memory returned a different instance, this is a duplicate event
+        if (existing && existing !== event) {
+            // Copy cached symbols and return existing event
+            EventStore.mergeDuplicateEvent(event, existing);
+            // attach relay this event was from
+            if (fromRelay)
+                addSeenRelay(existing, fromRelay);
+            return existing;
         }
         // Insert event into database
-        const inserted = this.database.add(event);
-        // If the event was ignored, return null
-        if (inserted === null)
-            return null;
+        const inserted = this.mapToMemory(this.database.add(event));
         // Copy cached data if its a duplicate event
         if (event !== inserted)
             EventStore.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 = this.database.getReplaceableHistory(event.kind, event.pubkey, identifier);
-            if (existing) {
+            if (existing && existing.length > 0) {
                 const older = Array.from(existing).filter((e) => e.created_at < event.created_at);
                 for (const old of older)
-                    this.database.remove(old);
+                    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)
@@ -230,108 +233,103 @@ export class EventStore {
             this.handleExpiringEvent(inserted);
         return inserted;
     }
-    /** Removes an event from the database and updates subscriptions */
+    /** Removes an event from the store and updates subscriptions */
     remove(event) {
-        return this.database.remove(event);
+        let instance = this.memory?.getEvent(typeof event === "string" ? event : event.id);
+        // Remove from memory if available
+        if (this.memory)
+            this.memory.remove(event);
+        // Remove the event from the database
+        const removed = this.database.remove(event);
+        // If the event was removed, notify the subscriptions
+        if (removed && instance) {
+            this.remove$.next(instance);
+        }
+        return removed;
     }
     /** Add an event to the store and notifies all subscribes it has updated */
     update(event) {
-        return this.database.update(event);
-    }
-    /** Removes any event that is not being used by a subscription */
-    prune(max) {
-        return this.database.prune(max);
+        // Map the event to the current instance in the database
+        const e = this.database.add(event);
+        if (!e)
+            return false;
+        // Notify the database that the event has updated
+        this.database.update?.(event);
+        this.update$.next(event);
+        return true;
     }
     /** Check if the store has an event by id */
     hasEvent(id) {
-        return this.database.hasEvent(id);
+        // Check if the event exists in memory first, then in the database
+        return this.memory?.hasEvent(id) || this.database.hasEvent(id);
     }
     /** Get an event by id from the store */
     getEvent(id) {
-        return this.database.getEvent(id);
+        // Get the event from memory first, then from the database
+        return this.memory?.getEvent(id) ?? this.mapToMemory(this.database.getEvent(id));
     }
     /** Check if the store has a replaceable event */
     hasReplaceable(kind, pubkey, d) {
-        return this.database.hasReplaceable(kind, pubkey, d);
+        // Check if the event exists in memory first, then in the database
+        return this.memory?.hasReplaceable(kind, pubkey, d) || this.database.hasReplaceable(kind, pubkey, d);
     }
     /** Gets the latest version of a replaceable event */
     getReplaceable(kind, pubkey, identifier) {
-        return this.database.getReplaceable(kind, pubkey, identifier);
+        // Get the event from memory first, then from the database
+        return (this.memory?.getReplaceable(kind, pubkey, identifier) ??
+            this.mapToMemory(this.database.getReplaceable(kind, pubkey, identifier)));
     }
     /** Returns all versions of a replaceable event */
     getReplaceableHistory(kind, pubkey, identifier) {
-        return this.database.getReplaceableHistory(kind, pubkey, identifier);
+        // Get the events from memory first, then from the database
+        return (this.memory?.getReplaceableHistory(kind, pubkey, identifier) ??
+            this.database.getReplaceableHistory(kind, pubkey, identifier)?.map((e) => this.mapToMemory(e) ?? e));
     }
     /** Get all events matching a filter */
     getByFilters(filters) {
-        return this.database.getByFilters(filters);
+        // NOTE: no way to read from memory since memory won't have the full set of events
+        const events = this.database.getByFilters(filters);
+        // Map events to memory if available for better performance
+        if (this.memory)
+            return events.map((e) => this.mapToMemory(e));
+        else
+            return events;
     }
     /** Returns a timeline of events that match filters */
     getTimeline(filters) {
-        return this.database.getTimeline(filters);
+        const events = this.database.getTimeline(filters);
+        if (this.memory)
+            return events.map((e) => this.mapToMemory(e));
+        else
+            return events;
+    }
+    /** Passthrough method for the database.touch */
+    touch(event) {
+        return this.memory?.touch(event);
     }
     /** Sets the claim on the event and touches it */
     claim(event, claim) {
-        this.database.claim(event, claim);
+        return this.memory?.claim(event, claim);
     }
     /** Checks if an event is claimed by anything */
     isClaimed(event) {
-        return this.database.isClaimed(event);
+        return this.memory?.isClaimed(event) ?? false;
     }
     /** Removes a claim from an event */
     removeClaim(event, claim) {
-        this.database.removeClaim(event, claim);
+        return this.memory?.removeClaim(event, claim);
     }
     /** Removes all claims on an event */
     clearClaim(event) {
-        this.database.clearClaim(event);
+        return this.memory?.clearClaim(event);
     }
-    /** A directory of all active models */
-    models = new Map();
-    /** How long a model should be kept "warm" while nothing is subscribed to it */
-    modelKeepWarm = 60_000;
-    /** Get or create a model on the event store */
-    model(constructor, ...args) {
-        let models = this.models.get(constructor);
-        if (!models) {
-            models = new Map();
-            this.models.set(constructor, models);
-        }
-        const key = constructor.getKey ? constructor.getKey(...args) : hash_sum(args);
-        let model = models.get(key);
-        // Create the model if it does not exist
-        if (!model) {
-            const cleanup = () => {
-                // Remove the model from the cache if its the same one
-                if (models.get(key) === model)
-                    models.delete(key);
-            };
-            model = constructor(...args)(this).pipe(
-            // remove the model when its unsubscribed
-            finalize(cleanup), 
-            // only subscribe to models once for all subscriptions
-            share({
-                connector: () => new ReplaySubject(1),
-                resetOnComplete: () => timer(this.modelKeepWarm),
-                resetOnRefCountZero: () => timer(this.modelKeepWarm),
-            }));
-            // Add the model to the cache
-            models.set(key, model);
-        }
-        return model;
+    /** Pass through method for the database.unclaimed */
+    unclaimed() {
+        return this.memory?.unclaimed() || (function* () { })();
     }
-    /**
-     * Creates an observable that streams all events that match the filter
-     * @param filters
-     * @param [onlyNew=false] Only subscribe to new events
-     */
-    filters(filters, onlyNew = false) {
-        filters = Array.isArray(filters) ? filters : [filters];
-        return merge(
-        // merge existing events
-        onlyNew ? EMPTY : from(this.getByFilters(filters)), 
-        // subscribe to future events
-        this.insert$.pipe(filter((e) => matchFilters(filters, e))));
+    /** Removes any event that is not being used by a subscription */
+    prune(limit) {
+        return this.memory?.prune(limit) ?? 0;
     }
     /** Returns an observable that completes when an event is removed */
     removed(id) {
@@ -348,83 +346,6 @@ export class EventStore {
     }
     /** Creates an observable that emits when event is updated */
     updated(event) {
-        return this.database.update$.pipe(filter((e) => e.id === event || e === event));
-    }
-    // Helper methods for creating models
-    /** Creates a {@link EventModel} */
-    event(pointer) {
-        if (typeof pointer === "string")
-            pointer = { id: pointer };
-        return this.model(EventModel, pointer);
-    }
-    replaceable(...args) {
-        let pointer;
-        // Parse arguments
-        if (args.length === 1) {
-            pointer = args[0];
-        }
-        else if (args.length === 3 || args.length === 2) {
-            let [kind, pubkey, identifier] = args;
-            pointer = { kind, pubkey, identifier };
-        }
-        if (!pointer)
-            throw new Error("Invalid arguments, expected address pointer or kind, pubkey, identifier");
-        return this.model(ReplaceableModel, pointer);
-    }
-    /** Subscribe to an addressable event by pointer */
-    addressable(pointer) {
-        return this.model(ReplaceableModel, pointer);
-    }
-    /** Creates a {@link TimelineModel} */
-    timeline(filters, includeOldVersion = false) {
-        return this.model(TimelineModel, filters, includeOldVersion);
-    }
-    /** Subscribe to a users profile */
-    profile(user) {
-        return this.model(ProfileModel, user);
-    }
-    /** Subscribe to a users contacts */
-    contacts(user) {
-        if (typeof user === "string")
-            user = { pubkey: user };
-        return this.model(ContactsModel, user);
-    }
-    /** Subscribe to a users mutes */
-    mutes(user) {
-        if (typeof user === "string")
-            user = { pubkey: user };
-        return this.model(MuteModel, user);
-    }
-    /** Subscribe to a users NIP-65 mailboxes */
-    mailboxes(user) {
-        if (typeof user === "string")
-            user = { pubkey: user };
-        return this.model(MailboxesModel, user);
-    }
-    /** Subscribe to a users blossom servers */
-    blossomServers(user) {
-        if (typeof user === "string")
-            user = { pubkey: user };
-        return this.model(UserBlossomServersModel, user);
-    }
-    /** Subscribe to an event's reactions */
-    reactions(event) {
-        return this.model(ReactionsModel, event);
-    }
-    /** Subscribe to a thread */
-    thread(root) {
-        return this.model(ThreadModel, root);
-    }
-    /** Subscribe to a event's comments */
-    comments(event) {
-        return this.model(CommentsModel, event);
-    }
-    /** @deprecated use multiple {@link EventModel} instead */
-    events(ids) {
-        return this.model(EventsModel, ids);
-    }
-    /** @deprecated use multiple {@link ReplaceableModel} instead */
-    replaceableSet(pointers) {
-        return this.model(ReplaceableSetModel, pointers);
+        return this.update$.pipe(filter((e) => e.id === event || e === event));
     }
 }

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

@@ -1,3 +1,4 @@
+export * from "./async-event-store.js";
+export * from "./event-memory.js";
 export * from "./event-store.js";
-export * from "./event-set.js";
 export * from "./interface.js";

package/dist/event-store/index.js

@@ -1,3 +1,4 @@
+export * from "./async-event-store.js";
+export * from "./event-memory.js";
 export * from "./event-store.js";
-export * from "./event-set.js";
 export * from "./interface.js";

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

@@ -1,28 +1,44 @@
 import { Filter, NostrEvent } from "nostr-tools";
 import { AddressPointer, EventPointer, ProfilePointer } from "nostr-tools/nip19";
 import { Observable } from "rxjs";
-import { LRU } from "../helpers/lru.js";
-import { Mutes } from "../helpers/mutes.js";
+import { AddressPointerWithoutD } from "../helpers/pointers.js";
 import { ProfileContent } from "../helpers/profile.js";
+import { Mutes } from "../helpers/mutes.js";
 import { Thread } from "../models/thread.js";
-import { AddressPointerWithoutD } from "../helpers/pointers.js";
 /** The read interface for an event store */
 export interface IEventStoreRead {
     /** Check if the event store has an event with id */
     hasEvent(id: string): boolean;
-    /** Check if the event store has a replaceable event */
-    hasReplaceable(kind: number, pubkey: string, identifier?: string): boolean;
     /** Get an event by id */
     getEvent(id: string): NostrEvent | undefined;
+    /** Check if the event store has a replaceable event */
+    hasReplaceable(kind: number, pubkey: string, identifier?: string): boolean;
     /** Get a replaceable event */
     getReplaceable(kind: number, pubkey: string, identifier?: string): NostrEvent | undefined;
     /** Get the history of a replaceable event */
     getReplaceableHistory(kind: number, pubkey: string, identifier?: string): NostrEvent[] | undefined;
     /** Get all events that match the filters */
-    getByFilters(filters: Filter | Filter[]): Set<NostrEvent>;
+    getByFilters(filters: Filter | Filter[]): NostrEvent[];
     /** Get a timeline of events that match the filters */
     getTimeline(filters: Filter | Filter[]): NostrEvent[];
 }
+/** The async read interface for an event store */
+export interface IAsyncEventStoreRead {
+    /** Check if the event store has an event with id */
+    hasEvent(id: string): Promise<boolean>;
+    /** Get an event by id */
+    getEvent(id: string): Promise<NostrEvent | undefined>;
+    /** Check if the event store has a replaceable event */
+    hasReplaceable(kind: number, pubkey: string, identifier?: string): Promise<boolean>;
+    /** Get a replaceable event */
+    getReplaceable(kind: number, pubkey: string, identifier?: string): Promise<NostrEvent | undefined>;
+    /** Get the history of a replaceable event */
+    getReplaceableHistory(kind: number, pubkey: string, identifier?: string): Promise<NostrEvent[] | undefined>;
+    /** Get all events that match the filters */
+    getByFilters(filters: Filter | Filter[]): Promise<NostrEvent[]>;
+    /** Get a timeline of events that match the filters */
+    getTimeline(filters: Filter | Filter[]): Promise<NostrEvent[]>;
+}
 /** The stream interface for an event store */
 export interface IEventStoreStreams {
     /** A stream of new events added to the store */
@@ -41,8 +57,19 @@ export interface IEventStoreActions {
     /** Notify the store that an event has updated */
     update(event: NostrEvent): void;
 }
+/** The async actions for an event store */
+export interface IAsyncEventStoreActions {
+    /** Add an event to the store */
+    add(event: NostrEvent): Promise<NostrEvent | null>;
+    /** Remove an event from the store */
+    remove(event: string | NostrEvent): Promise<boolean>;
+    /** Notify the store that an event has updated */
+    update(event: NostrEvent): Promise<void>;
+}
 /** The claim interface for an event store */
 export interface IEventClaims {
+    /** Tell the store that this event was used */
+    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 */
@@ -51,59 +78,105 @@ export interface IEventClaims {
     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>;
 }
 /** An event store that can be subscribed to */
-export interface IEventStoreSubscriptions {
-    /** Susbscribe to an event by id */
+export interface IEventSubscriptions {
+    /** Subscribe to an event by id */
     event(id: string | EventPointer): Observable<NostrEvent | undefined>;
     /** Subscribe to a replaceable event by pointer */
     replaceable(pointer: AddressPointerWithoutD): Observable<NostrEvent | undefined>;
+    /** Subscribe to a replaceable event with legacy arguments */
+    replaceable(kind: number, pubkey: string, identifier?: string): Observable<NostrEvent | undefined>;
     /** Subscribe to an addressable event by pointer */
     addressable(pointer: AddressPointer): Observable<NostrEvent | undefined>;
     /** Subscribe to a batch of events that match the filters */
-    filter(filters: Filter | Filter[]): Observable<NostrEvent[]>;
+    filters(filters: Filter | Filter[], onlyNew?: boolean): Observable<NostrEvent>;
+    /** Subscribe to a sorted timeline of events that match the filters */
+    timeline(filters: Filter | Filter[], onlyNew?: boolean): Observable<NostrEvent[]>;
+}
+/** @deprecated use {@link IEventSubscriptions} instead */
+export interface IEventStoreSubscriptions extends IEventSubscriptions {
 }
 /** Methods for creating common models */
-export interface IEventStoreModels {
-    model<T extends unknown, Args extends Array<any>>(constructor: ModelConstructor<T, Args>, ...args: Args): Observable<T>;
-    event(id: string): Observable<NostrEvent | undefined>;
-    replaceable(pointer: AddressPointerWithoutD): Observable<NostrEvent | undefined>;
-    addressable(pointer: AddressPointer): Observable<NostrEvent | undefined>;
-    timeline(filters: Filter | Filter[], includeOldVersion?: boolean): Observable<NostrEvent[]>;
+export interface IEventModelMixin<TStore extends IEventStore | IAsyncEventStore> {
+    model<T extends unknown, Args extends Array<any>>(constructor: ModelConstructor<T, Args, TStore>, ...args: Args): Observable<T>;
+    /** @deprecated use multiple {@link EventModel} instead */
     events(ids: string[]): Observable<Record<string, NostrEvent | undefined>>;
+    /** @deprecated use multiple {@link ReplaceableModel} instead */
     replaceableSet(pointers: (AddressPointer | AddressPointerWithoutD)[]): Observable<Record<string, NostrEvent | undefined>>;
 }
-/** A computed view of an event set or event store */
-export type Model<T extends unknown> = (events: IEventStore) => Observable<T>;
-/** A constructor for a {@link Model} */
-export type ModelConstructor<T extends unknown, Args extends Array<any>> = ((...args: Args) => Model<T>) & {
-    getKey?: (...args: Args) => string;
-};
-/** The base interface for a set of events */
-export interface IEventSet extends IEventStoreRead, IEventStoreStreams, IEventStoreActions, IEventClaims {
-    events: LRU<NostrEvent>;
-}
-export interface IEventStore extends IEventStoreRead, IEventStoreStreams, IEventStoreActions, IEventStoreModels, IEventClaims {
-    /** Enable this to keep old versions of replaceable events */
-    keepOldVersions: boolean;
-    /** Enable this to keep expired events */
-    keepExpired: boolean;
-    filters(filters: Filter | Filter[]): Observable<NostrEvent>;
-    updated(id: string | NostrEvent): Observable<NostrEvent>;
-    removed(id: string): Observable<never>;
-    replaceable(kind: number, pubkey: string, identifier?: string): Observable<NostrEvent | undefined>;
-    replaceable(pointer: AddressPointerWithoutD): Observable<NostrEvent | undefined>;
-    eventLoader?: (pointer: EventPointer) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
-    replaceableLoader?: (pointer: AddressPointerWithoutD) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
-    addressableLoader?: (pointer: AddressPointer) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
+/** Methods for creating helpful models */
+export interface IEventHelpfulSubscriptions {
+    /** Subscribe to a users profile */
     profile(user: string | ProfilePointer): Observable<ProfileContent | undefined>;
+    /** Subscribe to a users contacts */
     contacts(user: string | ProfilePointer): Observable<ProfilePointer[]>;
+    /** Subscribe to a users mutes */
     mutes(user: string | ProfilePointer): Observable<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<NostrEvent[]>;
+    /** Subscribe to a thread */
     thread(root: string | EventPointer | AddressPointer): Observable<Thread>;
+    /** Subscribe to a event's comments */
+    comments(event: NostrEvent): Observable<NostrEvent[]>;
+}
+/** @deprecated use {@link IEventModelMixin} instead */
+export interface IEventStoreModels extends IEventModelMixin<IEventStore> {
+}
+/** The interface that is passed to the model for creating subscriptions */
+export type ModelEventStore<TStore extends IEventStore | IAsyncEventStore> = IEventStoreStreams & IEventSubscriptions & IEventModelMixin<TStore> & IEventFallbackLoaders & TStore;
+/** A computed view of an event set or event store */
+export type Model<T extends unknown, TStore extends IEventStore | IAsyncEventStore = IEventStore | IAsyncEventStore> = (events: ModelEventStore<TStore>) => Observable<T>;
+/** A constructor for a {@link Model} */
+export type ModelConstructor<T extends unknown, Args extends Array<any>, TStore extends IEventStore | IAsyncEventStore = IEventStore> = ((...args: Args) => Model<T, TStore>) & {
+    getKey?: (...args: Args) => string;
+};
+/** The base interface for a database of events */
+export interface IEventDatabase extends IEventStoreRead {
+    /** Add an event to the database */
+    add(event: NostrEvent): NostrEvent;
+    /** Remove an event from the database */
+    remove(event: string | NostrEvent): boolean;
+    /** Notifies the database that an event has updated */
+    update?: (event: NostrEvent) => void;
+}
+/** The async base interface for a set of events */
+export interface IAsyncEventDatabase extends IAsyncEventStoreRead {
+    /** Add an event to the database */
+    add(event: NostrEvent): Promise<NostrEvent>;
+    /** Remove an event from the database */
+    remove(event: string | NostrEvent): Promise<boolean>;
+    /** Notifies the database that an event has updated */
+    update?: (event: NostrEvent) => void;
+}
+/** The base interface for the in-memory database of events */
+export interface IEventMemory extends IEventStoreRead, IEventClaims {
+    /** Add an event to the store */
+    add(event: NostrEvent): NostrEvent;
+    /** Remove an event from the store */
+    remove(event: string | NostrEvent): boolean;
+}
+/** A set of methods that an event store will use to load single events it does not have */
+export interface IEventFallbackLoaders {
+    /** A method that will be called when an event isn't found in the store */
+    eventLoader?: (pointer: EventPointer) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
+    /** A method that will be called when a replaceable event isn't found in the store */
+    replaceableLoader?: (pointer: AddressPointerWithoutD) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
+    /** A method that will be called when an addressable event isn't found in the store */
+    addressableLoader?: (pointer: AddressPointer) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
+}
+/** The async event store interface */
+export interface IAsyncEventStore extends IAsyncEventStoreRead, IEventStoreStreams, IEventSubscriptions, IAsyncEventStoreActions, IEventModelMixin<IAsyncEventStore>, IEventHelpfulSubscriptions, IEventClaims, IEventFallbackLoaders {
+}
+/** The sync event store interface */
+export interface IEventStore extends IEventStoreRead, IEventStoreStreams, IEventSubscriptions, IEventStoreActions, IEventModelMixin<IEventStore>, IEventHelpfulSubscriptions, IEventClaims, IEventFallbackLoaders {
 }