applesauce-core 3.1.0 → 4.1.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,118 @@ 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;
+    }
+    /** Remove multiple events that match the given filters */
+    removeByFilters(filters) {
+        // Get events that will be removed for notification
+        const eventsToRemove = this.getByFilters(filters);
+        // Remove from memory if available
+        if (this.memory)
+            this.memory.removeByFilters(filters);
+        // Remove from database
+        const removedCount = this.database.removeByFilters(filters);
+        // Notify subscriptions for each removed event
+        for (const event of eventsToRemove) {
+            this.remove$.next(event);
+        }
+        return removedCount;
     }
     /** 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 +361,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";