applesauce-core 0.9.0 → 0.10.0

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

@@ -1,21 +1,89 @@
+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 { getDeleteCoordinates, getDeleteIds } from "../helpers/delete.js";
 export class EventStore {
     database;
+    /** Enable this to keep old versions of replaceable events */
+    keepOldVersions = false;
     constructor() {
         this.database = new Database();
     }
-    /** Adds an event to the database */
+    /** 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) {
+        if (typeof event === "string")
+            return this.database.deleteEvent(event);
+        else if (this.database.hasEvent(event.id)) {
+            return this.database.deleteEvent(event.id);
+        }
+        else
+            return false;
+    }
+    deletedIds = new Set();
+    deletedCoords = new Map();
+    handleDeleteEvent(deleteEvent) {
+        const ids = getDeleteIds(deleteEvent);
+        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.deleteEvent(event);
+        }
+        const coords = getDeleteCoordinates(deleteEvent);
+        for (const coord of coords) {
+            this.deletedCoords.set(coord, Math.max(this.deletedCoords.get(coord) ?? 0, deleteEvent.created_at));
+            // remove deleted events in the database
+            const event = this.database.getEvent(coord);
+            if (event && event.created_at < deleteEvent.created_at)
+                this.database.deleteEvent(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;
+        }
+        return false;
+    }
+    /** Removes any event that is not being used by a subscription */
+    prune(max) {
+        return this.database.prune(max);
+    }
     /** Add an event to the store and notifies all subscribes it has updated */
     update(event) {
         return this.database.updateEvent(event);
@@ -32,93 +100,87 @@ 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 */
+    getReplaceableHistory(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(uid);
+            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 (getEventUID(event) === uid && (!current || event.created_at > current.created_at)) {
-                    // remove old claim
-                    if (current)
-                        this.database.removeClaim(current, observer);
+                if (event.id === id) {
                     current = event;
                     observer.next(event);
-                    // claim new event
-                    this.database.claimEvent(current, observer);
+                    this.database.claimEvent(event, observer);
                 }
             });
-            // subscribe to updates
+            // subscribe to updated events
             const updated = this.database.updated.subscribe((event) => {
-                if (event === current)
-                    observer.next(event);
+                if (event.id === id)
+                    observer.next(current);
             });
             // subscribe to deleted events
             const deleted = this.database.deleted.subscribe((event) => {
-                if (getEventUID(event) === uid && current) {
+                if (current?.id === event.id) {
                     this.database.removeClaim(current, observer);
                     current = undefined;
                     observer.next(undefined);
                 }
             });
             return () => {
-                inserted.unsubscribe();
                 deleted.unsubscribe();
                 updated.unsubscribe();
+                inserted.unsubscribe();
                 if (current)
                     this.database.removeClaim(current, observer);
             };
         });
     }
     /** Creates an observable that subscribes to multiple events */
-    events(uids) {
+    events(ids) {
         return new Observable((observer) => {
             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);
+            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 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);
-                    }
+                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 updates
+            // subscribe to updated events
             const updated = this.database.updated.subscribe((event) => {
-                const uid = getEventUID(event);
-                if (uids.includes(uid))
+                if (ids.includes(event.id))
                     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);
+                const id = event.id;
+                if (ids.includes(id)) {
+                    const current = events.get(id);
                     if (current) {
                         this.database.removeClaim(current, observer);
-                        events.delete(uid);
+                        events.delete(id);
                         observer.next(events);
                     }
                 }
@@ -133,92 +195,182 @@ export class EventStore {
             };
         });
     }
-    /** Creates an observable that updates a single replaceable event */
+    /** Creates an observable with the latest version of a replaceable event */
     replaceable(kind, pubkey, d) {
-        return this.event(getReplaceableUID(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);
+            };
+        });
     }
-    /** Creates an observable that streams all events that match the filter */
-    stream(filters) {
+    /** Creates an observable with the latest versions of replaceable events */
+    replaceableSet(pointers) {
         return new Observable((observer) => {
-            let claimed = new Set();
-            let events = this.database.getForFilters(filters);
-            for (const event of events) {
-                observer.next(event);
+            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);
-                claimed.add(event);
+            };
+            // get latest version
+            for (const pointer of pointers) {
+                const events = this.database.getReplaceable(pointer.kind, pointer.pubkey, pointer.identifier);
+                if (events)
+                    handleEvent(events[0]);
             }
+            observer.next(events);
             // subscribe to future events
-            const sub = this.database.inserted.subscribe((event) => {
-                if (matchFilters(filters, event)) {
-                    observer.next(event);
-                    this.database.claimEvent(event, observer);
-                    claimed.add(event);
+            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 () => {
-                sub.unsubscribe();
-                // remove all claims
-                for (const event of claimed)
+                inserted.unsubscribe();
+                deleted.unsubscribe();
+                updated.unsubscribe();
+                for (const [_id, event] of events) {
                     this.database.removeClaim(event, observer);
-                claimed.clear();
+                }
             };
         });
     }
+    /**
+     * 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);
+            }
+            // subscribe to future events
+            const sub = this.database.inserted.subscribe((event) => {
+                if (matchFilters(filters, event))
+                    observer.next(event);
+            });
+            return () => sub.unsubscribe();
+        });
+    }
     /** Creates an observable that updates with an array of sorted events */
-    timeline(filters) {
+    timeline(filters, keepOldVersions = false) {
+        filters = Array.isArray(filters) ? filters : [filters];
         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 () => {
@@ -226,9 +378,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/bolt11.d.ts

@@ -5,4 +5,5 @@ export type ParsedInvoice = {
     timestamp: number;
     expiry: number;
 };
+/** Parses a lightning invoice */
 export declare function parseBolt11(paymentRequest: string): ParsedInvoice;

package/dist/helpers/bolt11.js

@@ -1,4 +1,5 @@
 import { decode } from "light-bolt11-decoder";
+/** Parses a lightning invoice */
 export function parseBolt11(paymentRequest) {
     const decoded = decode(paymentRequest);
     const timestamp = decoded.sections.find((s) => s.name === "timestamp")?.value ?? 0;

package/dist/helpers/comment.d.ts

@@ -0,0 +1,48 @@
+import { NostrEvent } from "nostr-tools";
+import { ExternalPointer, ExternalIdentifiers } from "./external-id.js";
+export declare const COMMENT_KIND = 1111;
+type CommentEventPointer = {
+    id: string;
+    kind: number;
+    pubkey?: string;
+    relay?: string;
+};
+type CommentAddressPointer = {
+    id?: string;
+    kind: number;
+    pubkey: string;
+    identifier: string;
+    relay?: string;
+};
+type CommentExternalPointer = ExternalPointer<keyof ExternalIdentifiers>;
+export type CommentPointer = CommentEventPointer | CommentAddressPointer | CommentExternalPointer;
+export declare const CommentRootPointerSymbol: unique symbol;
+export declare const CommentReplyPointerSymbol: unique symbol;
+/**
+ * Gets the EventPointer from an array of tags
+ * @throws
+ */
+export declare function getCommentEventPointer(tags: string[][], root?: boolean): CommentEventPointer | null;
+/**
+ * Gets the AddressPointer from an array of tags
+ * @throws
+ */
+export declare function getCommentAddressPointer(tags: string[][], root?: boolean): CommentAddressPointer | null;
+/**
+ * Gets the ExternalPointer from an array of tags
+ * @throws
+ */
+export declare function getCommentExternalPointer(tags: string[][], root?: boolean): CommentExternalPointer | null;
+/**
+ * Returns the root pointer for a comment
+ * @throws
+ */
+export declare function getCommentRootPointer(comment: NostrEvent): CommentPointer | null;
+/**
+ * Returns the reply pointer for a comment
+ * @throws
+ */
+export declare function getCommentReplyPointer(comment: NostrEvent): CommentPointer | null;
+export declare function isCommentEventPointer(pointer: any): pointer is CommentEventPointer;
+export declare function isCommentAddressPointer(pointer: any): pointer is CommentAddressPointer;
+export {};

package/dist/helpers/comment.js

@@ -0,0 +1,116 @@
+import { getExternalPointerFromTag } from "./external-id.js";
+import { getOrComputeCachedValue } from "./cache.js";
+import { getAddressPointerFromATag } from "./pointers.js";
+import { safeRelayUrl } from "./relays.js";
+export const COMMENT_KIND = 1111;
+export const CommentRootPointerSymbol = Symbol.for("comment-root-pointer");
+export const CommentReplyPointerSymbol = Symbol.for("comment-reply-pointer");
+/**
+ * Gets the EventPointer from an array of tags
+ * @throws
+ */
+export function getCommentEventPointer(tags, root = false) {
+    const tag = tags.find((t) => t[0] === (root ? "E" : "e"));
+    const kind = tags.find((t) => t[0] === (root ? "K" : "k"))?.[1];
+    if (tag) {
+        if (!kind)
+            throw new Error("Missing kind tag");
+        const pointer = {
+            id: tag[1],
+            kind: parseInt(kind),
+            pubkey: tag[3] || undefined,
+            relay: tag[2] && (safeRelayUrl(tag[2]) ?? undefined),
+        };
+        return pointer;
+    }
+    return null;
+}
+/**
+ * Gets the AddressPointer from an array of tags
+ * @throws
+ */
+export function getCommentAddressPointer(tags, root = false) {
+    const tag = tags.find((t) => t[0] === (root ? "A" : "a"));
+    const id = tags.find((t) => t[0] === (root ? "E" : "e"))?.[1];
+    const kind = tags.find((t) => t[0] === (root ? "K" : "k"))?.[1];
+    if (tag) {
+        if (!kind)
+            throw new Error("Missing kind tag");
+        const pointer = {
+            id,
+            ...getAddressPointerFromATag(tag),
+            kind: parseInt(kind),
+        };
+        return pointer;
+    }
+    return null;
+}
+/**
+ * Gets the ExternalPointer from an array of tags
+ * @throws
+ */
+export function getCommentExternalPointer(tags, root = false) {
+    const tag = tags.find((t) => t[0] === (root ? "I" : "i"));
+    const kind = tags.find((t) => t[0] === (root ? "K" : "k"))?.[1];
+    if (tag) {
+        if (!kind)
+            throw new Error("Missing kind tag");
+        const pointer = getExternalPointerFromTag(tag);
+        return pointer;
+    }
+    return null;
+}
+/**
+ * Returns the root pointer for a comment
+ * @throws
+ */
+export function getCommentRootPointer(comment) {
+    if (comment.kind !== COMMENT_KIND)
+        throw new Error("Event is not a comment");
+    return getOrComputeCachedValue(comment, CommentRootPointerSymbol, () => {
+        // check for address pointer first since it can also have E tags
+        const A = getCommentAddressPointer(comment.tags, true);
+        if (A)
+            return A;
+        const E = getCommentEventPointer(comment.tags, true);
+        if (E)
+            return E;
+        const I = getCommentExternalPointer(comment.tags, true);
+        if (I)
+            return I;
+        return null;
+    });
+}
+/**
+ * Returns the reply pointer for a comment
+ * @throws
+ */
+export function getCommentReplyPointer(comment) {
+    if (comment.kind !== COMMENT_KIND)
+        throw new Error("Event is not a comment");
+    return getOrComputeCachedValue(comment, CommentReplyPointerSymbol, () => {
+        // check for address pointer first since it can also have E tags
+        const A = getCommentAddressPointer(comment.tags, false);
+        if (A)
+            return A;
+        const E = getCommentEventPointer(comment.tags, false);
+        if (E)
+            return E;
+        const I = getCommentExternalPointer(comment.tags, false);
+        if (I)
+            return I;
+        return null;
+    });
+}
+export function isCommentEventPointer(pointer) {
+    return (Reflect.has(pointer, "id") &&
+        Reflect.has(pointer, "kind") &&
+        !Reflect.has(pointer, "identifier") &&
+        typeof pointer.kind === "number");
+}
+export function isCommentAddressPointer(pointer) {
+    return (Reflect.has(pointer, "identifier") &&
+        Reflect.has(pointer, "pubkey") &&
+        Reflect.has(pointer, "kind") &&
+        typeof pointer.kind === "number");
+}

package/dist/helpers/content.d.ts

@@ -0,0 +1,3 @@
+import { NostrEvent } from "nostr-tools";
+/** Returns the NIP-36 content-warning for an event. returns boolean if there is no "reason" */
+export declare function getContentWarning(event: NostrEvent): string | boolean;

package/dist/helpers/content.js

@@ -0,0 +1,8 @@
+/** Returns the NIP-36 content-warning for an event. returns boolean if there is no "reason" */
+export function getContentWarning(event) {
+    const tag = event.tags.find((t) => t[0] === "content-warning");
+    if (tag)
+        return tag[1] || true;
+    else
+        return false;
+}

package/dist/helpers/delete.d.ts

@@ -0,0 +1,3 @@
+import { NostrEvent } from "nostr-tools";
+export declare function getDeleteIds(deleteEvent: NostrEvent): string[];
+export declare function getDeleteCoordinates(deleteEvent: NostrEvent): string[];

package/dist/helpers/delete.js

@@ -0,0 +1,7 @@
+import { isATag, isETag } from "./tags.js";
+export function getDeleteIds(deleteEvent) {
+    return deleteEvent.tags.filter(isETag).map((t) => t[1]);
+}
+export function getDeleteCoordinates(deleteEvent) {
+    return deleteEvent.tags.filter(isATag).map((t) => t[1]);
+}