applesauce-core 0.0.0-next-20241125223343 → 0.0.0-next-20241126192236

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

@@ -3,6 +3,7 @@ import { Subject } from "rxjs";
 import { LRU } from "../helpers/lru.js";
 /**
  * An in-memory database for nostr events
+ * NOTE: does not handle replaceable events
  */
 export declare class Database {
     protected log: import("debug").Debugger;
@@ -13,6 +14,7 @@ export declare class Database {
     protected created_at: NostrEvent[];
     /** LRU cache of last events touched */
     events: LRU<import("nostr-tools").Event>;
+    protected replaceable: Map<string, import("nostr-tools").Event[]>;
     /** A stream of events inserted into the database */
     inserted: Subject<import("nostr-tools").Event>;
     /** A stream of events that have been updated */
@@ -27,18 +29,20 @@ export declare class Database {
     protected getTagIndex(tagAndValue: string): Set<import("nostr-tools").Event>;
     /** Moves an event to the top of the LRU cache */
     touch(event: NostrEvent): void;
-    hasEvent(uid: string): import("nostr-tools").Event | undefined;
-    getEvent(uid: string): import("nostr-tools").Event | undefined;
+    /** 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 database contains a replaceable event without touching it */
     hasReplaceable(kind: number, pubkey: string, d?: string): boolean;
-    /** Gets a replaceable event and touches it */
-    getReplaceable(kind: number, pubkey: string, d?: string): import("nostr-tools").Event | undefined;
+    /** Gets an array of replaceable events */
+    getReplaceable(kind: number, pubkey: string, d?: string): NostrEvent[] | undefined;
     /** Inserts an event into the database and notifies all subscriptions */
-    addEvent(event: NostrEvent): import("nostr-tools").Event;
+    addEvent(event: NostrEvent): NostrEvent;
     /** Inserts and event into the database and notifies all subscriptions that the event has updated */
-    updateEvent(event: NostrEvent): import("nostr-tools").Event;
+    updateEvent(event: NostrEvent): NostrEvent;
     /** Deletes an event from the database and notifies all subscriptions */
-    deleteEvent(eventOrUID: string | NostrEvent): boolean;
+    deleteEvent(eventOrId: string | NostrEvent): boolean;
     /** Sets the claim on the event and touches it */
     claimEvent(event: NostrEvent, claim: any): void;
     /** Checks if an event is claimed by anything */
@@ -47,14 +51,14 @@ export declare class Database {
     removeClaim(event: NostrEvent, claim: any): void;
     /** Removes all claims on an event */
     clearClaim(event: NostrEvent): void;
-    iterateAuthors(authors: Iterable<string>): Generator<import("nostr-tools").Event, void, unknown>;
-    iterateTag(tag: string, values: Iterable<string>): Generator<import("nostr-tools").Event, void, unknown>;
-    iterateKinds(kinds: Iterable<number>): Generator<import("nostr-tools").Event, void, unknown>;
-    iterateTime(since: number | undefined, until: number | undefined): Generator<never, Set<import("nostr-tools").Event>, unknown>;
-    iterateIds(ids: Iterable<string>): Generator<import("nostr-tools").Event, void, unknown>;
+    iterateAuthors(authors: Iterable<string>): Generator<NostrEvent>;
+    iterateTag(tag: string, values: Iterable<string>): Generator<NostrEvent>;
+    iterateKinds(kinds: Iterable<number>): Generator<NostrEvent>;
+    iterateTime(since: number | undefined, until: number | undefined): Generator<NostrEvent>;
+    iterateIds(ids: Iterable<string>): Generator<NostrEvent>;
     /** Returns all events that match the filter */
     getEventsForFilter(filter: Filter): Set<NostrEvent>;
-    getForFilters(filters: Filter[]): Set<import("nostr-tools").Event>;
+    getForFilters(filters: Filter[]): Set<NostrEvent>;
     /** Remove the oldest events that are not claimed */
     prune(limit?: number): number;
 }

package/dist/event-store/database.js

@@ -1,11 +1,12 @@
 import { binarySearch, insertEventIntoDescendingList } from "nostr-tools/utils";
 import { Subject } from "rxjs";
-import { FromCacheSymbol, getEventUID, getIndexableTags, getReplaceableUID } from "../helpers/event.js";
+import { FromCacheSymbol, getEventUID, getIndexableTags, getReplaceableUID, isReplaceable } from "../helpers/event.js";
 import { INDEXABLE_TAGS } from "./common.js";
 import { logger } from "../logger.js";
 import { LRU } from "../helpers/lru.js";
 /**
  * An in-memory database for nostr events
+ * NOTE: does not handle replaceable events
  */
 export class Database {
     log = logger.extend("Database");
@@ -16,6 +17,7 @@ export class Database {
     created_at = [];
     /** LRU cache of last events touched */
     events = new LRU();
+    replaceable = new Map();
     /** A stream of events inserted into the database */
     inserted = new Subject();
     /** A stream of events that have been updated */
@@ -56,35 +58,36 @@ export class Database {
     }
     /** Moves an event to the top of the LRU cache */
     touch(event) {
-        this.events.set(getEventUID(event), event);
+        this.events.set(event.id, event);
     }
-    hasEvent(uid) {
-        return this.events.get(uid);
+    /** Checks if the database contains an event without touching it */
+    hasEvent(id) {
+        return this.events.has(id);
     }
-    getEvent(uid) {
-        return this.events.get(uid);
+    /** Gets a single event based on id */
+    getEvent(id) {
+        return this.events.get(id);
     }
     /** Checks if the database contains a replaceable event without touching it */
     hasReplaceable(kind, pubkey, d) {
-        return this.events.has(getReplaceableUID(kind, pubkey, d));
+        const events = this.replaceable.get(getReplaceableUID(kind, pubkey, d));
+        return !!events && events.length > 0;
     }
-    /** Gets a replaceable event and touches it */
+    /** Gets an array of replaceable events */
     getReplaceable(kind, pubkey, d) {
-        return this.events.get(getReplaceableUID(kind, pubkey, d));
+        return this.replaceable.get(getReplaceableUID(kind, pubkey, d));
     }
     /** Inserts an event into the database and notifies all subscriptions */
     addEvent(event) {
-        const uid = getEventUID(event);
-        const current = this.events.get(uid);
-        if (current && event.created_at <= current.created_at) {
+        const id = event.id;
+        const current = this.events.get(id);
+        if (current) {
             // if this is a duplicate event, transfer some import symbols
-            if (current.id === event.id) {
-                if (event[FromCacheSymbol])
-                    current[FromCacheSymbol] = event[FromCacheSymbol];
-            }
+            if (event[FromCacheSymbol])
+                current[FromCacheSymbol] = event[FromCacheSymbol];
             return current;
         }
-        this.events.set(uid, event);
+        this.events.set(id, event);
         this.getKindIndex(event.kind).add(event);
         this.getAuthorsIndex(event.pubkey).add(event);
         for (const tag of getIndexableTags(event)) {
@@ -92,7 +95,18 @@ export class Database {
                 this.getTagIndex(tag).add(event);
             }
         }
+        // insert into time index
         insertEventIntoDescendingList(this.created_at, event);
+        // insert into replaceable index
+        if (isReplaceable(event.kind)) {
+            const uid = getEventUID(event);
+            let array = this.replaceable.get(uid);
+            if (!this.replaceable.has(uid)) {
+                array = [];
+                this.replaceable.set(uid, array);
+            }
+            insertEventIntoDescendingList(array, event);
+        }
         this.inserted.next(event);
         return event;
     }
@@ -103,13 +117,13 @@ export class Database {
         return inserted;
     }
     /** Deletes an event from the database and notifies all subscriptions */
-    deleteEvent(eventOrUID) {
-        let event = typeof eventOrUID === "string" ? this.events.get(eventOrUID) : eventOrUID;
+    deleteEvent(eventOrId) {
+        let event = typeof eventOrId === "string" ? this.events.get(eventOrId) : eventOrId;
         if (!event)
             throw new Error("Missing event");
-        const uid = getEventUID(event);
+        const id = event.id;
         // only remove events that are known
-        if (!this.events.has(uid))
+        if (!this.events.has(id))
             return false;
         this.getAuthorsIndex(event.pubkey).delete(event);
         this.getKindIndex(event.kind).delete(event);
@@ -121,7 +135,16 @@ export class Database {
         // remove from created_at index
         const i = this.created_at.indexOf(event);
         this.created_at.splice(i, 1);
-        this.events.delete(uid);
+        this.events.delete(id);
+        // remove from replaceable index
+        if (isReplaceable(event.kind)) {
+            const uid = getEventUID(event);
+            const array = this.replaceable.get(uid);
+            if (array && array.includes(event)) {
+                const idx = array.indexOf(event);
+                array.splice(idx, 1);
+            }
+        }
         this.deleted.next(event);
         return true;
     }

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

@@ -3,28 +3,39 @@ import { Observable } from "rxjs";
 import { Database } from "./database.js";
 export declare class EventStore {
     database: Database;
+    /** Whether to keep old versions of replaceable events */
+    keepOldVersions: boolean;
     constructor();
     /** Adds an event to the database */
-    add(event: NostrEvent, fromRelay?: string): import("nostr-tools").Event;
+    add(event: NostrEvent, fromRelay?: string): NostrEvent;
     protected deletedIds: Set<string>;
     protected deletedCoords: Map<string, number>;
     protected handleDeleteEvent(deleteEvent: NostrEvent): void;
     protected checkDeleted(event: NostrEvent): boolean;
     /** Add an event to the store and notifies all subscribes it has updated */
-    update(event: NostrEvent): import("nostr-tools").Event;
-    getAll(filters: Filter[]): Set<import("nostr-tools").Event>;
-    hasEvent(uid: string): import("nostr-tools").Event | undefined;
-    getEvent(uid: string): import("nostr-tools").Event | undefined;
+    update(event: NostrEvent): NostrEvent;
+    getAll(filters: Filter[]): Set<NostrEvent>;
+    hasEvent(uid: string): boolean;
+    getEvent(uid: string): NostrEvent | undefined;
     hasReplaceable(kind: number, pubkey: string, d?: string): boolean;
-    getReplaceable(kind: number, pubkey: string, d?: string): import("nostr-tools").Event | undefined;
+    /** Gets the latest version of a replaceable event */
+    getReplaceable(kind: number, pubkey: string, d?: string): NostrEvent | undefined;
+    /** Returns all versions of a replaceable event */
+    getAllReplaceable(kind: number, pubkey: string, d?: string): NostrEvent[] | undefined;
     /** Creates an observable that updates a single event */
-    event(uid: string): Observable<import("nostr-tools").Event | undefined>;
+    event(id: string): Observable<NostrEvent | undefined>;
     /** Creates an observable that subscribes to multiple events */
-    events(uids: string[]): Observable<Map<string, import("nostr-tools").Event>>;
-    /** Creates an observable that updates a single replaceable event */
-    replaceable(kind: number, pubkey: string, d?: string): Observable<import("nostr-tools").Event | undefined>;
+    events(ids: string[]): Observable<Map<string, NostrEvent>>;
+    /** Creates an observable with the latest version of a replaceable event */
+    replaceable(kind: number, pubkey: string, d?: string): Observable<NostrEvent | undefined>;
+    /** Creates an observable with the latest versions of replaceable events */
+    replaceableSet(pointers: {
+        kind: number;
+        pubkey: string;
+        identifier?: string;
+    }[]): Observable<Map<string, NostrEvent>>;
     /** Creates an observable that streams all events that match the filter */
-    stream(filters: Filter[]): Observable<import("nostr-tools").Event>;
+    stream(filters: Filter[]): Observable<NostrEvent>;
     /** Creates an observable that updates with an array of sorted events */
-    timeline(filters: Filter[]): Observable<import("nostr-tools").Event[]>;
+    timeline(filters: Filter[], keepOldVersions?: boolean): Observable<NostrEvent[]>;
 }

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

@@ -1,14 +1,16 @@
 import { kinds } from "nostr-tools";
 import { insertEventIntoDescendingList } from "nostr-tools/utils";
+import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
 import { Observable } from "rxjs";
 import { Database } from "./database.js";
-import { getEventUID, getReplaceableUID } from "../helpers/event.js";
+import { getEventUID, getReplaceableUID, getTagValue, isReplaceable } from "../helpers/event.js";
 import { matchFilters } from "../helpers/filter.js";
 import { addSeenRelay } from "../helpers/relays.js";
 import { getDeleteIds } from "../helpers/delete.js";
-import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
 export class EventStore {
     database;
+    /** Whether to keep old versions of replaceable events */
+    keepOldVersions = false;
     constructor() {
         this.database = new Database();
     }
@@ -16,9 +18,24 @@ export class EventStore {
     add(event, fromRelay) {
         if (event.kind === kinds.EventDeletion)
             this.handleDeleteEvent(event);
+        // ignore if the event was deleted
         if (this.checkDeleted(event))
             return event;
+        // insert event into database
         const inserted = this.database.addEvent(event);
+        // remove all old version of the replaceable event
+        if (!this.keepOldVersions && isReplaceable(event.kind)) {
+            const current = this.database.getReplaceable(event.kind, event.pubkey, getTagValue(event, "d"));
+            if (current) {
+                const older = Array.from(current).filter((e) => e.created_at < event.created_at);
+                for (const old of older)
+                    this.database.deleteEvent(old);
+                // skip inserting this event because its not the newest
+                if (current.length !== older.length)
+                    return current[0];
+            }
+        }
+        // attach relay this event was from
         if (fromRelay)
             addSeenRelay(inserted, fromRelay);
         return inserted;
@@ -69,13 +86,107 @@ export class EventStore {
     hasReplaceable(kind, pubkey, d) {
         return this.database.hasReplaceable(kind, pubkey, d);
     }
+    /** Gets the latest version of a replaceable event */
     getReplaceable(kind, pubkey, d) {
+        return this.database.getReplaceable(kind, pubkey, d)?.[0];
+    }
+    /** Returns all versions of a replaceable event */
+    getAllReplaceable(kind, pubkey, d) {
         return this.database.getReplaceable(kind, pubkey, d);
     }
     /** Creates an observable that updates a single event */
-    event(uid) {
+    event(id) {
+        return new Observable((observer) => {
+            let current = this.database.getEvent(id);
+            if (current) {
+                observer.next(current);
+                this.database.claimEvent(current, observer);
+            }
+            // subscribe to future events
+            const inserted = this.database.inserted.subscribe((event) => {
+                if (event.id === id) {
+                    current = event;
+                    observer.next(event);
+                    this.database.claimEvent(event, observer);
+                }
+            });
+            // subscribe to updated events
+            const updated = this.database.updated.subscribe((event) => {
+                if (event.id === id)
+                    observer.next(current);
+            });
+            // subscribe to deleted events
+            const deleted = this.database.deleted.subscribe((event) => {
+                if (current?.id === event.id) {
+                    this.database.removeClaim(current, observer);
+                    current = undefined;
+                    observer.next(undefined);
+                }
+            });
+            return () => {
+                deleted.unsubscribe();
+                updated.unsubscribe();
+                inserted.unsubscribe();
+                if (current)
+                    this.database.removeClaim(current, observer);
+            };
+        });
+    }
+    /** Creates an observable that subscribes to multiple events */
+    events(ids) {
+        return new Observable((observer) => {
+            const events = new Map();
+            for (const id of ids) {
+                const event = this.getEvent(id);
+                if (event) {
+                    events.set(id, event);
+                    this.database.claimEvent(event, observer);
+                }
+            }
+            observer.next(events);
+            // subscribe to future events
+            const inserted = this.database.inserted.subscribe((event) => {
+                const id = event.id;
+                if (ids.includes(id) && !events.has(id)) {
+                    events.set(id, event);
+                    observer.next(events);
+                    // claim new event
+                    this.database.claimEvent(event, observer);
+                }
+            });
+            // subscribe to updated events
+            const updated = this.database.updated.subscribe((event) => {
+                if (ids.includes(event.id))
+                    observer.next(events);
+            });
+            // subscribe to deleted events
+            const deleted = this.database.deleted.subscribe((event) => {
+                const id = event.id;
+                if (ids.includes(id)) {
+                    const current = events.get(id);
+                    if (current) {
+                        this.database.removeClaim(current, observer);
+                        events.delete(id);
+                        observer.next(events);
+                    }
+                }
+            });
+            return () => {
+                inserted.unsubscribe();
+                deleted.unsubscribe();
+                updated.unsubscribe();
+                for (const [_uid, event] of events) {
+                    this.database.removeClaim(event, observer);
+                }
+            };
+        });
+    }
+    /** Creates an observable with the latest version of a replaceable event */
+    replaceable(kind, pubkey, d) {
         return new Observable((observer) => {
-            let current = this.database.getEvent(uid);
+            const uid = getReplaceableUID(kind, pubkey, d);
+            // get latest version
+            let current = this.database.getReplaceable(kind, pubkey, d)?.[0];
             if (current) {
                 observer.next(current);
                 this.database.claimEvent(current, observer);
@@ -92,14 +203,14 @@ export class EventStore {
                     this.database.claimEvent(current, observer);
                 }
             });
-            // subscribe to updates
+            // subscribe to updated events
             const updated = this.database.updated.subscribe((event) => {
                 if (event === current)
                     observer.next(event);
             });
             // subscribe to deleted events
             const deleted = this.database.deleted.subscribe((event) => {
-                if (getEventUID(event) === uid && current) {
+                if (getEventUID(event) === uid && event === current) {
                     this.database.removeClaim(current, observer);
                     current = undefined;
                     observer.next(undefined);
@@ -114,66 +225,63 @@ export class EventStore {
             };
         });
     }
-    /** Creates an observable that subscribes to multiple events */
-    events(uids) {
+    /** Creates an observable with the latest versions of replaceable events */
+    replaceableSet(pointers) {
         return new Observable((observer) => {
+            const coords = pointers.map((p) => getReplaceableUID(p.kind, p.pubkey, p.identifier));
             const events = new Map();
-            for (const uid of uids) {
-                const e = this.getEvent(uid);
-                if (e) {
-                    events.set(uid, e);
-                    this.database.claimEvent(e, observer);
+            const handleEvent = (event) => {
+                const uid = getEventUID(event);
+                const current = events.get(uid);
+                if (current) {
+                    if (event.created_at > current.created_at) {
+                        this.database.removeClaim(current, observer);
+                    }
+                    else
+                        return;
                 }
+                events.set(uid, event);
+                this.database.claimEvent(event, observer);
+            };
+            // get latest version
+            for (const pointer of pointers) {
+                const events = this.database.getReplaceable(pointer.kind, pointer.pubkey, pointer.identifier);
+                if (events)
+                    for (const event of events)
+                        handleEvent(event);
             }
-            observer.next(events);
             // subscribe to future events
             const inserted = this.database.inserted.subscribe((event) => {
-                const uid = getEventUID(event);
-                if (uids.includes(uid)) {
-                    const current = events.get(uid);
-                    // remove old claim
-                    if (!current || event.created_at > current.created_at) {
-                        if (current)
-                            this.database.removeClaim(current, observer);
-                        events.set(uid, event);
-                        observer.next(events);
-                        // claim new event
-                        this.database.claimEvent(event, observer);
-                    }
+                if (isReplaceable(event.kind) && coords.includes(getEventUID(event))) {
+                    handleEvent(event);
+                    observer.next(events);
                 }
             });
-            // subscribe to updates
+            // subscribe to updated events
             const updated = this.database.updated.subscribe((event) => {
-                const uid = getEventUID(event);
-                if (uids.includes(uid))
+                if (isReplaceable(event.kind) && coords.includes(getEventUID(event))) {
                     observer.next(events);
+                }
             });
             // subscribe to deleted events
             const deleted = this.database.deleted.subscribe((event) => {
                 const uid = getEventUID(event);
-                if (uids.includes(uid)) {
-                    const current = events.get(uid);
-                    if (current) {
-                        this.database.removeClaim(current, observer);
-                        events.delete(uid);
-                        observer.next(events);
-                    }
+                if (events.has(uid)) {
+                    events.delete(uid);
+                    this.database.removeClaim(event, observer);
+                    observer.next(events);
                 }
             });
             return () => {
                 inserted.unsubscribe();
                 deleted.unsubscribe();
                 updated.unsubscribe();
-                for (const [_uid, event] of events) {
+                for (const [_id, event] of events) {
                     this.database.removeClaim(event, observer);
                 }
             };
         });
     }
-    /** Creates an observable that updates a single replaceable event */
-    replaceable(kind, pubkey, d) {
-        return this.event(getReplaceableUID(kind, pubkey, d));
-    }
     /** Creates an observable that streams all events that match the filter */
     stream(filters) {
         return new Observable((observer) => {
@@ -202,60 +310,58 @@ export class EventStore {
         });
     }
     /** Creates an observable that updates with an array of sorted events */
-    timeline(filters) {
+    timeline(filters, keepOldVersions = this.keepOldVersions) {
         return new Observable((observer) => {
             const seen = new Map();
             const timeline = [];
-            // build initial timeline
-            const events = this.database.getForFilters(filters);
-            for (const event of events) {
+            // NOTE: only call this if we know the event is in timeline
+            const removeFromTimeline = (event) => {
+                timeline.splice(timeline.indexOf(event), 1);
+                if (!keepOldVersions && isReplaceable(event.kind))
+                    seen.delete(getEventUID(event));
+                this.database.removeClaim(event, observer);
+            };
+            // inserts an event into the timeline and handles replaceable events
+            const insertIntoTimeline = (event) => {
+                // remove old versions
+                if (!keepOldVersions && isReplaceable(event.kind)) {
+                    const uid = getEventUID(event);
+                    const old = seen.get(uid);
+                    if (old) {
+                        if (event.created_at > old.created_at)
+                            removeFromTimeline(old);
+                        else
+                            return;
+                    }
+                    seen.set(uid, event);
+                }
+                // insert into timeline
                 insertEventIntoDescendingList(timeline, event);
                 this.database.claimEvent(event, observer);
-                seen.set(getEventUID(event), event);
-            }
+            };
+            // build initial timeline
+            const events = this.database.getForFilters(filters);
+            for (const event of events)
+                insertIntoTimeline(event);
             observer.next([...timeline]);
             // subscribe to future events
             const inserted = this.database.inserted.subscribe((event) => {
                 if (matchFilters(filters, event)) {
-                    const uid = getEventUID(event);
-                    let current = seen.get(uid);
-                    if (current) {
-                        if (event.created_at > current.created_at) {
-                            // replace event
-                            timeline.splice(timeline.indexOf(current), 1, event);
-                            observer.next([...timeline]);
-                            // update the claim
-                            seen.set(uid, event);
-                            this.database.removeClaim(current, observer);
-                            this.database.claimEvent(event, observer);
-                        }
-                    }
-                    else {
-                        insertEventIntoDescendingList(timeline, event);
-                        observer.next([...timeline]);
-                        // claim new event
-                        this.database.claimEvent(event, observer);
-                        seen.set(getEventUID(event), event);
-                    }
+                    insertIntoTimeline(event);
+                    observer.next([...timeline]);
                 }
             });
-            // subscribe to updates
+            // subscribe to updated events
             const updated = this.database.updated.subscribe((event) => {
-                if (seen.has(getEventUID(event))) {
+                if (timeline.includes(event)) {
                     observer.next([...timeline]);
                 }
             });
-            // subscribe to removed events
+            // subscribe to deleted events
             const deleted = this.database.deleted.subscribe((event) => {
-                const uid = getEventUID(event);
-                let current = seen.get(uid);
-                if (current) {
-                    // remove the event
-                    timeline.splice(timeline.indexOf(current), 1);
+                if (timeline.includes(event)) {
+                    removeFromTimeline(event);
                     observer.next([...timeline]);
-                    // remove the claim
-                    seen.delete(uid);
-                    this.database.removeClaim(current, observer);
                 }
             });
             return () => {
@@ -263,9 +369,10 @@ export class EventStore {
                 deleted.unsubscribe();
                 updated.unsubscribe();
                 // remove all claims
-                for (const [_, event] of seen) {
+                for (const event of timeline) {
                     this.database.removeClaim(event, observer);
                 }
+                // forget seen replaceable events
                 seen.clear();
             };
         });

package/dist/helpers/filter.d.ts

@@ -6,7 +6,5 @@ import { Filter, NostrEvent } from "nostr-tools";
 export declare function matchFilter(filter: Filter, event: NostrEvent): boolean;
 /** Copied from nostr-tools */
 export declare function matchFilters(filters: Filter[], event: NostrEvent): boolean;
-/** Stringify filters in a predictable way */
-export declare function stringifyFilter(filter: Filter | Filter[]): string;
 /** Check if two filters are equal */
 export declare function isFilterEqual(a: Filter | Filter[], b: Filter | Filter[]): boolean;

package/dist/helpers/filter.js

@@ -1,5 +1,5 @@
 import { getIndexableTags } from "./event.js";
-import stringify from "json-stringify-deterministic";
+import equal from "fast-deep-equal";
 /**
  * Copied from nostr-tools and modified to use getIndexableTags
  * @see https://github.com/nbd-wtf/nostr-tools/blob/a61cde77eacc9518001f11d7f67f1a50ae05fd80/filter.ts
@@ -40,11 +40,7 @@ export function matchFilters(filters, event) {
     }
     return false;
 }
-/** Stringify filters in a predictable way */
-export function stringifyFilter(filter) {
-    return stringify(filter);
-}
 /** Check if two filters are equal */
 export function isFilterEqual(a, b) {
-    return stringifyFilter(a) === stringifyFilter(b);
+    return equal(a, b);
 }

package/dist/observable/get-value.d.ts

@@ -0,0 +1,2 @@
+import { Observable } from "rxjs";
+export declare function getValue<T>(observable: Observable<T>): T | Promise<T>;

package/dist/observable/get-value.js

@@ -0,0 +1,13 @@
+import { BehaviorSubject } from "rxjs";
+export function getValue(observable) {
+    if (observable instanceof BehaviorSubject)
+        return observable.value;
+    if (Reflect.has(observable, "value"))
+        return Reflect.get(observable, "value");
+    return new Promise((res) => {
+        const sub = observable.subscribe((v) => {
+            res(v);
+            sub.unsubscribe();
+        });
+    });
+}

package/dist/observable/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./getValue.js";
+export * from "./get-value.js";
 export * from "./share-latest-value.js";

package/dist/observable/index.js

@@ -1,2 +1,2 @@
-export * from "./getValue.js";
+export * from "./get-value.js";
 export * from "./share-latest-value.js";

package/dist/queries/simple.d.ts

@@ -1,13 +1,13 @@
 import { Filter, NostrEvent } from "nostr-tools";
 import { Query } from "../query-store/index.js";
 /** Creates a Query that returns a single event or undefined */
-export declare function SingleEventQuery(uid: string): Query<NostrEvent | undefined>;
+export declare function SingleEventQuery(id: string): Query<NostrEvent | undefined>;
 /** Creates a Query that returns a multiple events in a map */
-export declare function MultipleEventsQuery(uids: string[]): Query<Map<string, NostrEvent>>;
+export declare function MultipleEventsQuery(ids: string[]): Query<Map<string, NostrEvent>>;
 /** Creates a Query returning the latest version of a replaceable event */
 export declare function ReplaceableQuery(kind: number, pubkey: string, d?: string): Query<NostrEvent | undefined>;
 /** Creates a Query that returns an array of sorted events matching the filters */
-export declare function TimelineQuery(filters: Filter | Filter[]): Query<NostrEvent[]>;
+export declare function TimelineQuery(filters: Filter | Filter[], keepOldVersions?: boolean): Query<NostrEvent[]>;
 /** Creates a Query that returns a directory of events by their UID */
 export declare function ReplaceableSetQuery(pointers: {
     kind: number;

package/dist/queries/simple.js

@@ -1,17 +1,17 @@
-import stringify from "json-stringify-deterministic";
 import { getReplaceableUID } from "../helpers/event.js";
+import hash_sum from "hash-sum";
 /** Creates a Query that returns a single event or undefined */
-export function SingleEventQuery(uid) {
+export function SingleEventQuery(id) {
     return {
-        key: uid,
-        run: (events) => events.event(uid),
+        key: id,
+        run: (events) => events.event(id),
     };
 }
 /** Creates a Query that returns a multiple events in a map */
-export function MultipleEventsQuery(uids) {
+export function MultipleEventsQuery(ids) {
     return {
-        key: uids.join(","),
-        run: (events) => events.events(uids),
+        key: ids.join(","),
+        run: (events) => events.events(ids),
     };
 }
 /** Creates a Query returning the latest version of a replaceable event */
@@ -22,17 +22,16 @@ export function ReplaceableQuery(kind, pubkey, d) {
     };
 }
 /** Creates a Query that returns an array of sorted events matching the filters */
-export function TimelineQuery(filters) {
+export function TimelineQuery(filters, keepOldVersions) {
     return {
-        key: stringify(filters),
-        run: (events) => events.timeline(Array.isArray(filters) ? filters : [filters]),
+        key: hash_sum(filters) + (keepOldVersions ? "-history" : ""),
+        run: (events) => events.timeline(Array.isArray(filters) ? filters : [filters], keepOldVersions),
     };
 }
 /** Creates a Query that returns a directory of events by their UID */
 export function ReplaceableSetQuery(pointers) {
-    const cords = pointers.map((pointer) => getReplaceableUID(pointer.kind, pointer.pubkey, pointer.identifier));
     return {
-        key: stringify(pointers),
-        run: (events) => events.events(cords),
+        key: hash_sum(pointers),
+        run: (events) => events.replaceableSet(pointers),
     };
 }

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

@@ -32,7 +32,7 @@ export declare class QueryStore {
         identifier?: string;
     }[]): Observable<Map<string, import("nostr-tools").Event>>;
     /** Returns an array of events that match the filter */
-    timeline(filters: Filter | Filter[]): Observable<import("nostr-tools").Event[]>;
+    timeline(filters: Filter | Filter[], keepOldVersions?: boolean): Observable<import("nostr-tools").Event[]>;
     /** Returns the parsed profile (0) for a pubkey */
     profile(pubkey: string): Observable<import("../helpers/profile.js").ProfileContent | undefined>;
     /** Returns all reactions for an event (supports replaceable events) */

package/dist/query-store/index.js

@@ -38,8 +38,8 @@ export class QueryStore {
         return this.runQuery(Queries.ReplaceableSetQuery)(pointers);
     }
     /** Returns an array of events that match the filter */
-    timeline(filters) {
-        return this.runQuery(Queries.TimelineQuery)(filters);
+    timeline(filters, keepOldVersions) {
+        return this.runQuery(Queries.TimelineQuery)(filters, keepOldVersions);
     }
     /** Returns the parsed profile (0) for a pubkey */
     profile(pubkey) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "0.0.0-next-20241125223343",
+  "version": "0.0.0-next-20241126192236",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -54,7 +54,8 @@
   "dependencies": {
     "@scure/base": "^1.1.9",
     "debug": "^4.3.7",
-    "json-stringify-deterministic": "^1.0.12",
+    "fast-deep-equal": "^3.1.3",
+    "hash-sum": "^2.0.0",
     "light-bolt11-decoder": "^3.2.0",
     "nanoid": "^5.0.7",
     "nostr-tools": "^2.10.3",
@@ -63,6 +64,7 @@
   "devDependencies": {
     "@jest/globals": "^29.7.0",
     "@types/debug": "^4.1.12",
+    "@types/hash-sum": "^1.0.2",
     "@types/jest": "^29.5.13",
     "jest": "^29.7.0",
     "jest-extended": "^4.0.2",