applesauce-core 0.10.0 → 0.11.0

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

@@ -1,57 +1,49 @@
 import { kinds } from "nostr-tools";
 import { insertEventIntoDescendingList } from "nostr-tools/utils";
 import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
-import { Observable } from "rxjs";
+import { defer, distinctUntilChanged, EMPTY, endWith, filter, finalize, from, map, merge, mergeMap, mergeWith, of, repeat, scan, take, takeUntil, tap, } from "rxjs";
 import { Database } from "./database.js";
-import { getEventUID, getReplaceableUID, getTagValue, isReplaceable } from "../helpers/event.js";
+import { getEventUID, getReplaceableIdentifier, getReplaceableUID, getTagValue, isReplaceable, } from "../helpers/event.js";
 import { matchFilters } from "../helpers/filter.js";
-import { addSeenRelay } from "../helpers/relays.js";
+import { addSeenRelay, getSeenRelays } from "../helpers/relays.js";
 import { getDeleteCoordinates, getDeleteIds } from "../helpers/delete.js";
+import { claimEvents } from "../observable/claim-events.js";
+import { claimLatest } from "../observable/claim-latest.js";
+function sortDesc(a, b) {
+    return b.created_at - a.created_at;
+}
 export class EventStore {
     database;
     /** Enable this to keep old versions of replaceable events */
     keepOldVersions = false;
+    /** A method used to verify new events before added them */
+    verifyEvent;
     constructor() {
         this.database = new Database();
+        this.database.onBeforeInsert = (event) => {
+            // reject events that are invalid
+            if (this.verifyEvent && this.verifyEvent(event) === false)
+                throw new Error("Invalid event");
+        };
     }
-    /** Adds an event to the database and update subscriptions */
-    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;
-    }
-    /** Removes an event from the database and updates subscriptions */
-    remove(event) {
+    // delete state
+    deletedIds = new Set();
+    deletedCoords = new Map();
+    checkDeleted(event) {
         if (typeof event === "string")
-            return this.database.deleteEvent(event);
-        else if (this.database.hasEvent(event.id)) {
-            return this.database.deleteEvent(event.id);
-        }
-        else
+            return this.deletedIds.has(event);
+        else {
+            if (this.deletedIds.has(event.id))
+                return true;
+            if (isParameterizedReplaceableKind(event.kind)) {
+                const deleted = this.deletedCoords.get(getEventUID(event));
+                if (deleted)
+                    return deleted > event.created_at;
+            }
             return false;
+        }
     }
-    deletedIds = new Set();
-    deletedCoords = new Map();
+    // handling delete events
     handleDeleteEvent(deleteEvent) {
         const ids = getDeleteIds(deleteEvent);
         for (const id of ids) {
@@ -59,7 +51,7 @@ export class EventStore {
             // remove deleted events in the database
             const event = this.database.getEvent(id);
             if (event)
-                this.database.deleteEvent(event);
+                this.database.removeEvent(event);
         }
         const coords = getDeleteCoordinates(deleteEvent);
         for (const coord of coords) {
@@ -67,18 +59,53 @@ export class EventStore {
             // remove deleted events in the database
             const event = this.database.getEvent(coord);
             if (event && event.created_at < deleteEvent.created_at)
-                this.database.deleteEvent(event);
+                this.database.removeEvent(event);
         }
     }
-    checkDeleted(event) {
-        if (this.deletedIds.has(event.id))
-            return true;
-        if (isParameterizedReplaceableKind(event.kind)) {
-            const deleted = this.deletedCoords.get(getEventUID(event));
-            if (deleted)
-                return deleted > event.created_at;
+    /** Copies important metadata from and identical event to another */
+    static mergeDuplicateEvent(source, dest) {
+        const relays = getSeenRelays(source);
+        if (relays) {
+            for (const relay of relays)
+                addSeenRelay(dest, relay);
+        }
+    }
+    /**
+     * Adds an event to the database and update subscriptions
+     * @throws
+     */
+    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);
+        // 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);
+        // remove all old version of the replaceable event
+        if (!this.keepOldVersions && isReplaceable(event.kind)) {
+            const existing = this.database.getReplaceable(event.kind, event.pubkey, getTagValue(event, "d"));
+            if (existing) {
+                const older = Array.from(existing).filter((e) => e.created_at < event.created_at);
+                for (const old of older)
+                    this.database.removeEvent(old);
+                // return the newest version of the replaceable event
+                // most of the time this will be === event, but not always
+                if (existing.length !== older.length)
+                    return existing[0];
+            }
         }
-        return false;
+        return inserted;
+    }
+    /** Removes an event from the database and updates subscriptions */
+    remove(event) {
+        return this.database.removeEvent(event);
     }
     /** Removes any event that is not being used by a subscription */
     prune(max) {
@@ -88,15 +115,18 @@ export class EventStore {
     update(event) {
         return this.database.updateEvent(event);
     }
+    /** Get all events matching a filter */
     getAll(filters) {
         return this.database.getForFilters(filters);
     }
+    /** Check if the store has an event */
     hasEvent(uid) {
         return this.database.hasEvent(uid);
     }
     getEvent(uid) {
         return this.database.getEvent(uid);
     }
+    /** Check if the store has a replaceable event */
     hasReplaceable(kind, pubkey, d) {
         return this.database.hasReplaceable(kind, pubkey, d);
     }
@@ -108,282 +138,191 @@ export class EventStore {
     getReplaceableHistory(kind, pubkey, d) {
         return this.database.getReplaceable(kind, pubkey, d);
     }
-    /** Creates an observable that updates a single event */
+    /**
+     * Creates an observable that streams all events that match the filter and remains open
+     * @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.getAll(filters)), 
+        // subscribe to future events
+        this.database.inserted.pipe(filter((e) => matchFilters(filters, e))));
+    }
+    /** Returns an observable that completes when an event is removed */
+    removed(id) {
+        const deleted = this.checkDeleted(id);
+        if (deleted)
+            return EMPTY;
+        return this.database.removed.pipe(
+        // listen for removed events
+        filter((e) => e.id === id), 
+        // complete as soon as we find a matching removed event
+        take(1), 
+        // switch to empty
+        mergeMap(() => EMPTY));
+    }
+    /** Creates an observable that emits when event is updated */
+    updated(id) {
+        return this.database.updated.pipe(filter((e) => e.id === id));
+    }
+    /** Creates an observable that subscribes to a single event */
     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);
-            };
-        });
+        return merge(
+        // get current event and ignore if there is none
+        defer(() => {
+            let event = this.getEvent(id);
+            return event ? of(event) : EMPTY;
+        }), 
+        // subscribe to updates
+        this.database.inserted.pipe(filter((e) => e.id === id)), 
+        // subscribe to updates
+        this.updated(id), 
+        // emit undefined when deleted
+        this.removed(id).pipe(endWith(undefined))).pipe(
+        // claim all events
+        claimEvents(this.database));
     }
     /** 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);
-                }
+        return merge(
+        // lazily get existing events
+        defer(() => from(ids.map((id) => this.getEvent(id)))), 
+        // subscribe to new events
+        this.database.inserted.pipe(filter((e) => ids.includes(e.id))), 
+        // subscribe to updates
+        this.database.updated.pipe(filter((e) => ids.includes(e.id)))).pipe(
+        // ignore empty messages
+        filter((e) => !!e), 
+        // claim all events until cleanup
+        claimEvents(this.database), 
+        // watch for removed events
+        mergeWith(this.database.removed.pipe(filter((e) => ids.includes(e.id)), map((e) => e.id))), 
+        // merge all events into a directory
+        scan((dir, event) => {
+            if (typeof event === "string") {
+                // delete event by id
+                const clone = { ...dir };
+                delete clone[event];
+                return clone;
             }
-            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);
-                }
-            };
-        });
+            else {
+                // add even to directory
+                return { ...dir, [event.id]: event };
+            }
+        }, {}));
     }
-    /** Creates an observable with the latest version of a replaceable event */
+    /** Creates an observable that subscribes to the latest version of a replaceable event */
     replaceable(kind, pubkey, d) {
-        return new Observable((observer) => {
-            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);
-            }
-            // subscribe to future events
-            const inserted = this.database.inserted.subscribe((event) => {
-                if (getEventUID(event) === uid && (!current || event.created_at > current.created_at)) {
-                    // remove old claim
-                    if (current)
-                        this.database.removeClaim(current, observer);
-                    current = event;
-                    observer.next(event);
-                    // claim new event
-                    this.database.claimEvent(current, observer);
-                }
-            });
-            // 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 && event === current) {
-                    this.database.removeClaim(current, observer);
-                    current = undefined;
-                    observer.next(undefined);
-                }
-            });
-            return () => {
-                inserted.unsubscribe();
-                deleted.unsubscribe();
-                updated.unsubscribe();
-                if (current)
-                    this.database.removeClaim(current, observer);
-            };
-        });
+        let current = undefined;
+        return merge(
+        // lazily get current event
+        defer(() => {
+            let event = this.getReplaceable(kind, pubkey, d);
+            return event ? of(event) : EMPTY;
+        }), 
+        // subscribe to new events
+        this.database.inserted.pipe(filter((e) => e.pubkey == pubkey && e.kind === kind && (d !== undefined ? getReplaceableIdentifier(e) === d : true)))).pipe(
+        // only update if event is newer
+        distinctUntilChanged((prev, event) => prev.created_at >= event.created_at), 
+        // Hacky way to extract the current event so takeUntil can access it
+        tap((event) => (current = event)), 
+        // complete when event is removed
+        takeUntil(this.database.removed.pipe(filter((e) => e.id === current?.id))), 
+        // emit undefined when removed
+        endWith(undefined), 
+        // keep the observable hot
+        repeat(), 
+        // claim latest event
+        claimLatest(this.database));
     }
-    /** Creates an observable with the latest versions of replaceable events */
+    /** Creates an observable that subscribes to the latest version of an array 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();
-            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)
-                    handleEvent(events[0]);
+        const uids = new Set(pointers.map((p) => getReplaceableUID(p.kind, p.pubkey, p.identifier)));
+        return merge(
+        // start with existing events
+        defer(() => from(pointers.map((p) => this.getReplaceable(p.kind, p.pubkey, p.identifier)))), 
+        // subscribe to new events
+        this.database.inserted.pipe(filter((e) => isReplaceable(e.kind) && uids.has(getEventUID(e))))).pipe(
+        // filter out undefined
+        filter((e) => !!e), 
+        // claim all events
+        claimEvents(this.database), 
+        // convert events to add commands
+        map((e) => ["add", e]), 
+        // watch for removed events
+        mergeWith(this.database.removed.pipe(filter((e) => isReplaceable(e.kind) && uids.has(getEventUID(e))), map((e) => ["remove", e]))), 
+        // reduce events into directory
+        scan((dir, [action, event]) => {
+            const uid = getEventUID(event);
+            if (action === "add") {
+                // add event to dir if its newer
+                if (!dir[uid] || dir[uid].created_at < event.created_at)
+                    return { ...dir, [uid]: event };
             }
-            observer.next(events);
-            // subscribe to future events
-            const inserted = this.database.inserted.subscribe((event) => {
-                if (isReplaceable(event.kind) && coords.includes(getEventUID(event))) {
-                    handleEvent(event);
-                    observer.next(events);
-                }
-            });
-            // subscribe to updated events
-            const updated = this.database.updated.subscribe((event) => {
-                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 (events.has(uid)) {
-                    events.delete(uid);
-                    this.database.removeClaim(event, observer);
-                    observer.next(events);
-                }
-            });
-            return () => {
-                inserted.unsubscribe();
-                deleted.unsubscribe();
-                updated.unsubscribe();
-                for (const [_id, event] of events) {
-                    this.database.removeClaim(event, observer);
-                }
-            };
-        });
-    }
-    /**
-     * Creates an observable that streams all events that match the filter
-     * @param filters
-     * @param [onlyNew=false] Only subscribe to new events
-     */
-    stream(filters, onlyNew = false) {
-        filters = Array.isArray(filters) ? filters : [filters];
-        return new Observable((observer) => {
-            if (!onlyNew) {
-                let events = this.database.getForFilters(filters);
-                for (const event of events)
-                    observer.next(event);
+            else if (action === "remove" && dir[uid] === event) {
+                // remove event from dir
+                let newDir = { ...dir };
+                delete newDir[uid];
+                return newDir;
             }
-            // subscribe to future events
-            const sub = this.database.inserted.subscribe((event) => {
-                if (matchFilters(filters, event))
-                    observer.next(event);
-            });
-            return () => sub.unsubscribe();
-        });
+            return dir;
+        }, {}), 
+        // ignore changes that do not modify the directory
+        distinctUntilChanged());
     }
     /** Creates an observable that updates with an array of sorted events */
     timeline(filters, keepOldVersions = false) {
         filters = Array.isArray(filters) ? filters : [filters];
-        return new Observable((observer) => {
-            const seen = new Map();
-            const timeline = [];
-            // 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);
-            };
-            // 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)) {
-                    insertIntoTimeline(event);
-                    observer.next([...timeline]);
-                }
-            });
-            // subscribe to updated events
-            const updated = this.database.updated.subscribe((event) => {
-                if (timeline.includes(event)) {
-                    observer.next([...timeline]);
+        const seen = new Map();
+        // get current events
+        return defer(() => of(Array.from(this.database.getForFilters(filters)).sort(sortDesc))).pipe(
+        // claim existing events
+        claimEvents(this.database), 
+        // subscribe to newer events
+        mergeWith(this.database.inserted.pipe(filter((e) => matchFilters(filters, e)), 
+        // claim all new events
+        claimEvents(this.database))), 
+        // subscribe to delete events
+        mergeWith(this.database.removed.pipe(filter((e) => matchFilters(filters, e)), map((e) => e.id))), 
+        // build a timeline
+        scan((timeline, event) => {
+            // filter out removed events from timeline
+            if (typeof event === "string")
+                return timeline.filter((e) => e.id !== event);
+            // initial timeline array
+            if (Array.isArray(event)) {
+                if (!keepOldVersions) {
+                    for (const e of event)
+                        if (isReplaceable(e.kind))
+                            seen.set(getEventUID(e), e);
                 }
-            });
-            // subscribe to deleted events
-            const deleted = this.database.deleted.subscribe((event) => {
-                if (timeline.includes(event)) {
-                    removeFromTimeline(event);
-                    observer.next([...timeline]);
-                }
-            });
-            return () => {
-                inserted.unsubscribe();
-                deleted.unsubscribe();
-                updated.unsubscribe();
-                // remove all claims
-                for (const event of timeline) {
-                    this.database.removeClaim(event, observer);
-                }
-                // forget seen replaceable events
-                seen.clear();
-            };
-        });
+                return event;
+            }
+            // create a new timeline and insert the event into it
+            let newTimeline = [...timeline];
+            // remove old replaceable events if enabled
+            if (!keepOldVersions && isReplaceable(event.kind)) {
+                const uid = getEventUID(event);
+                const existing = seen.get(uid);
+                // if this is an older replaceable event, exit
+                if (existing && event.created_at < existing.created_at)
+                    return timeline;
+                // update latest version
+                seen.set(uid, event);
+                // remove old event from timeline
+                if (existing)
+                    newTimeline.slice(newTimeline.indexOf(existing), 1);
+            }
+            // add event into timeline
+            insertEventIntoDescendingList(newTimeline, event);
+            return newTimeline;
+        }, []), 
+        // ignore changes that do not modify the timeline instance
+        distinctUntilChanged(), 
+        // hacky hack to clear seen on unsubscribe
+        finalize(() => seen.clear()));
     }
 }

package/dist/helpers/__tests__/blossom.test.js

@@ -0,0 +1,13 @@
+import { describe, expect, it } from "vitest";
+import { areBlossomServersEqual } from "../blossom.js";
+describe("areBlossomServersEqual", () => {
+    it("should ignore path", () => {
+        expect(areBlossomServersEqual("https://cdn.server.com/pathname", "https://cdn.server.com")).toBe(true);
+    });
+    it("should not ignore protocol", () => {
+        expect(areBlossomServersEqual("http://cdn.server.com", "https://cdn.server.com")).toBe(false);
+    });
+    it("should not ignore port", () => {
+        expect(areBlossomServersEqual("http://cdn.server.com:4658", "https://cdn.server.com")).toBe(false);
+    });
+});