applesauce-core 0.9.0 → 0.11.0

package/README.md

@@ -1,6 +1,6 @@
 # applesauce-core
 
-AppleSauce Core is an interpretation layer for nostr clients, Push events into the in-memory [database](https://hzrd149.github.io/applesauce/classes/Database.html) and get nicely formatted data out with [queries](https://hzrd149.github.io/applesauce/modules/Queries)
+AppleSauce Core is an interpretation layer for nostr clients, Push events into the in-memory [database](https://hzrd149.github.io/applesauce/typedoc/classes/Database.html) and get nicely formatted data out with [queries](https://hzrd149.github.io/applesauce/typedoc/modules/Queries)
 
 # Example
 

package/dist/__tests__/fixtures.d.ts

@@ -0,0 +1,8 @@
+import type { NostrEvent } from "nostr-tools";
+export declare class FakeUser {
+    key: Uint8Array<ArrayBufferLike>;
+    pubkey: string;
+    event(data?: Partial<NostrEvent>): NostrEvent;
+    note(content?: string, extra?: Partial<NostrEvent>): import("nostr-tools").Event;
+    profile(profile: any, extra?: Partial<NostrEvent>): import("nostr-tools").Event;
+}

package/dist/__tests__/fixtures.js

@@ -0,0 +1,20 @@
+import { finalizeEvent, generateSecretKey, getPublicKey, kinds } from "nostr-tools";
+import { unixNow } from "../helpers/time.js";
+export class FakeUser {
+    key = generateSecretKey();
+    pubkey = getPublicKey(this.key);
+    event(data) {
+        return finalizeEvent({
+            kind: data?.kind ?? kinds.ShortTextNote,
+            content: data?.content || "",
+            created_at: data?.created_at ?? unixNow(),
+            tags: data?.tags || [],
+        }, this.key);
+    }
+    note(content = "Hello World", extra) {
+        return this.event({ kind: kinds.ShortTextNote, content, ...extra });
+    }
+    profile(profile, extra) {
+        return this.event({ kind: kinds.Metadata, content: JSON.stringify({ ...profile }), ...extra });
+    }
+}

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

@@ -0,0 +1,259 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { kinds } from "nostr-tools";
+import { subscribeSpyTo } from "@hirez_io/observer-spy";
+import { EventStore } from "../event-store.js";
+import { addSeenRelay, getSeenRelays } from "../../helpers/relays.js";
+import { getEventUID } from "../../helpers/event.js";
+import { FakeUser } from "../../__tests__/fixtures.js";
+let eventStore;
+beforeEach(() => {
+    eventStore = new EventStore();
+});
+const user = new FakeUser();
+const profile = user.profile({ name: "fake user" });
+const note = user.note();
+describe("add", () => {
+    it("should return original event in case of duplicates", () => {
+        const a = { ...profile };
+        expect(eventStore.add(a)).toBe(a);
+        const b = { ...profile };
+        expect(eventStore.add(b)).toBe(a);
+        const c = { ...profile };
+        expect(eventStore.add(c)).toBe(a);
+    });
+    it("should merge seen relays on duplicate events", () => {
+        const a = { ...profile };
+        addSeenRelay(a, "wss://relay.a.com");
+        eventStore.add(a);
+        const b = { ...profile };
+        addSeenRelay(b, "wss://relay.b.com");
+        eventStore.add(b);
+        expect(eventStore.getEvent(profile.id)).toBeDefined();
+        expect([...getSeenRelays(eventStore.getEvent(profile.id))]).toEqual(expect.arrayContaining(["wss://relay.a.com", "wss://relay.b.com"]));
+    });
+    it("should ignore deleted events", () => {
+        const deleteEvent = {
+            id: "delete event id",
+            kind: kinds.EventDeletion,
+            created_at: profile.created_at + 100,
+            pubkey: user.pubkey,
+            tags: [["e", profile.id]],
+            sig: "this should be ignored for the test",
+            content: "test",
+        };
+        // add delete event first
+        eventStore.add(deleteEvent);
+        // now event should be ignored
+        eventStore.add(profile);
+        expect(eventStore.getEvent(profile.id)).toBeUndefined();
+    });
+});
+describe("verifyEvent", () => {
+    it("should be called for all events added", () => {
+        const verifyEvent = vi.fn().mockReturnValue(true);
+        eventStore.verifyEvent = verifyEvent;
+        eventStore.add(profile);
+        expect(verifyEvent).toHaveBeenCalledWith(profile);
+    });
+    it("should not be called for duplicate events", () => {
+        const verifyEvent = vi.fn().mockReturnValue(true);
+        eventStore.verifyEvent = verifyEvent;
+        const a = { ...profile };
+        eventStore.add(a);
+        expect(verifyEvent).toHaveBeenCalledWith(a);
+        const b = { ...profile };
+        eventStore.add(b);
+        expect(verifyEvent).toHaveBeenCalledTimes(1);
+        const c = { ...profile };
+        eventStore.add(c);
+        expect(verifyEvent).toHaveBeenCalledTimes(1);
+    });
+});
+describe("deleted", () => {
+    it("should complete when event is removed", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.removed(profile.id));
+        eventStore.remove(profile);
+        expect(spy.getValues()).toEqual([]);
+        expect(spy.receivedComplete()).toBe(true);
+    });
+});
+describe("event", () => {
+    it("should emit existing event", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.event(profile.id));
+        expect(spy.getValues()).toEqual([profile]);
+    });
+    it("should emit then event when its added", () => {
+        const spy = subscribeSpyTo(eventStore.event(profile.id));
+        expect(spy.getValues()).toEqual([]);
+        eventStore.add(profile);
+        expect(spy.getValues()).toEqual([profile]);
+    });
+    it("should emit undefined when event is removed", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.event(profile.id));
+        expect(spy.getValues()).toEqual([profile]);
+        eventStore.remove(profile);
+        expect(spy.getValues()).toEqual([profile, undefined]);
+    });
+    it("should emit new value if event is re-added", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.event(profile.id));
+        eventStore.remove(profile);
+        eventStore.add(profile);
+        expect(spy.getValues()).toEqual([profile, undefined, profile]);
+    });
+    it("should not complete when event is removed", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.event(profile.id));
+        eventStore.remove(profile);
+        expect(spy.receivedComplete()).toBe(false);
+    });
+    it("should not emit any values if there are no events", () => {
+        const spy = subscribeSpyTo(eventStore.event(profile.id));
+        expect(spy.receivedNext()).toBe(false);
+    });
+});
+describe("events", () => {
+    it("should emit existing events", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.events([profile.id]));
+        expect(spy.getValues()).toEqual([{ [profile.id]: profile }]);
+    });
+    it("should remove events when they are removed", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.events([profile.id]));
+        expect(spy.getValues()).toEqual([{ [profile.id]: profile }]);
+        eventStore.remove(profile);
+        expect(spy.getValues()).toEqual([{ [profile.id]: profile }, {}]);
+    });
+    it("should add events back if then are re-added", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.events([profile.id]));
+        eventStore.remove(profile);
+        eventStore.add(profile);
+        expect(spy.getValues()).toEqual([{ [profile.id]: profile }, {}, { [profile.id]: profile }]);
+    });
+    it("should not emit any values if there are no events", () => {
+        const spy = subscribeSpyTo(eventStore.events([profile.id]));
+        expect(spy.receivedNext()).toBe(false);
+    });
+});
+describe("replaceable", () => {
+    it("should not emit till there is an event", () => {
+        const spy = subscribeSpyTo(eventStore.replaceable(0, user.pubkey));
+        expect(spy.receivedNext()).toBe(false);
+    });
+    it("should emit existing events", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.replaceable(0, user.pubkey));
+        expect(spy.getValues()).toEqual([profile]);
+    });
+    it("should emit undefined when event is removed", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.replaceable(0, user.pubkey));
+        eventStore.remove(profile);
+        expect(spy.getValues()).toEqual([profile, undefined]);
+    });
+    it("should not complete when event is removed", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.replaceable(0, user.pubkey));
+        eventStore.remove(profile);
+        expect(spy.receivedComplete()).toBe(false);
+    });
+    it("should emit event when re-added", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.replaceable(0, user.pubkey));
+        eventStore.remove(profile);
+        eventStore.add(profile);
+        expect(spy.getValues()).toEqual([profile, undefined, profile]);
+    });
+    it("should claim event", () => {
+        eventStore.add(profile);
+        eventStore.replaceable(0, user.pubkey).subscribe();
+        expect(eventStore.database.isClaimed(profile)).toBe(true);
+    });
+    it("should remove claim when event is removed", () => {
+        eventStore.add(profile);
+        eventStore.replaceable(0, user.pubkey).subscribe();
+        eventStore.remove(profile);
+        expect(eventStore.database.isClaimed(profile)).toBe(false);
+    });
+    it("should ignore older events added later", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.replaceable(0, user.pubkey));
+        eventStore.add(user.profile({ name: "old name" }, { created_at: profile.created_at - 500 }));
+        eventStore.add(user.profile({ name: "really old name" }, { created_at: profile.created_at - 1000 }));
+        expect(spy.getValues()).toEqual([profile]);
+    });
+});
+describe("timeline", () => {
+    it("should emit an empty array if there are not events", () => {
+        const spy = subscribeSpyTo(eventStore.timeline({ kinds: [1] }));
+        expect(spy.getValues()).toEqual([[]]);
+    });
+    it("should emit existing events", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.timeline({ kinds: [0] }));
+        expect(spy.getValues()).toEqual([[profile]]);
+    });
+    it("should emit new events", () => {
+        const spy = subscribeSpyTo(eventStore.timeline({ kinds: [0, 1] }));
+        eventStore.add(profile);
+        eventStore.add(note);
+        expect(spy.getValues()).toEqual([[], [profile], [note, profile]]);
+    });
+    it("should remove event when its removed", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.timeline({ kinds: [0] }));
+        eventStore.remove(profile);
+        expect(spy.getValues()).toEqual([[profile], []]);
+    });
+    it("should not emit when other events are removed", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.timeline({ kinds: [0] }));
+        eventStore.add(note);
+        eventStore.remove(note);
+        expect(spy.getValues()).toEqual([[profile]]);
+    });
+    it("should ignore older events added later", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.timeline({ kinds: [0] }));
+        eventStore.add(user.profile({ name: "old-name" }, { created_at: profile.created_at - 1000 }));
+        expect(spy.getValues()).toEqual([[profile]]);
+    });
+});
+describe("replaceableSet", () => {
+    it("should not emit if there are not events", () => {
+        const spy = subscribeSpyTo(eventStore.replaceableSet([{ kind: 0, pubkey: user.pubkey }]));
+        expect(spy.receivedNext()).toBe(false);
+    });
+    it("should emit existing events", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.replaceableSet([{ kind: 0, pubkey: user.pubkey }]));
+        expect(spy.getValues()).toEqual([{ [getEventUID(profile)]: profile }]);
+    });
+    it("should remove event when removed", () => {
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.replaceableSet([{ kind: 0, pubkey: user.pubkey }]));
+        eventStore.remove(profile);
+        expect(spy.getValues()).toEqual([{ [getEventUID(profile)]: profile }, {}]);
+    });
+    it("should replace older events", () => {
+        const event2 = { ...profile, created_at: profile.created_at + 100, id: "newer-event" };
+        const uid = getEventUID(profile);
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.replaceableSet([{ kind: 0, pubkey: user.pubkey }]));
+        eventStore.add(event2);
+        expect(spy.getValues()).toEqual([{ [uid]: profile }, { [uid]: event2 }]);
+    });
+    it("should ignore old events added later", () => {
+        const old = user.profile({ name: "old-name" }, { created_at: profile.created_at - 1000 });
+        const uid = getEventUID(profile);
+        eventStore.add(profile);
+        const spy = subscribeSpyTo(eventStore.replaceableSet([{ kind: 0, pubkey: user.pubkey }]));
+        eventStore.add(old);
+        expect(spy.getValues()).toEqual([{ [uid]: profile }]);
+    });
+});

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,12 +14,15 @@ 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 */
     updated: Subject<import("nostr-tools").Event>;
-    /** A stream of events removed of the database */
-    deleted: Subject<import("nostr-tools").Event>;
+    /** A stream of events removed from the database */
+    removed: Subject<import("nostr-tools").Event>;
+    /** A method thats called before a new event is inserted */
+    onBeforeInsert?: (event: NostrEvent) => void;
     get size(): number;
     protected claims: WeakMap<import("nostr-tools").Event, any>;
     /** Index helper methods */
@@ -27,18 +31,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;
-    /** Deletes an event from the database and notifies all subscriptions */
-    deleteEvent(eventOrUID: string | NostrEvent): boolean;
+    updateEvent(event: NostrEvent): NostrEvent;
+    /** Removes an event from the database and notifies all subscriptions */
+    removeEvent(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 +53,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,12 +17,15 @@ 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 */
     updated = new Subject();
-    /** A stream of events removed of the database */
-    deleted = new Subject();
+    /** A stream of events removed from the database */
+    removed = new Subject();
+    /** A method thats called before a new event is inserted */
+    onBeforeInsert;
     get size() {
         return this.events.size;
     }
@@ -56,35 +60,37 @@ 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) {
-            // if this is a duplicate event, transfer some import symbols
-            if (current.id === event.id) {
-                if (event[FromCacheSymbol])
-                    current[FromCacheSymbol] = event[FromCacheSymbol];
-            }
+        const id = event.id;
+        const current = this.events.get(id);
+        if (current) {
+            // if this is a duplicate event, transfer some important symbols
+            if (event[FromCacheSymbol])
+                current[FromCacheSymbol] = event[FromCacheSymbol];
             return current;
         }
-        this.events.set(uid, event);
+        this.onBeforeInsert?.(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 +98,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;
     }
@@ -102,14 +119,14 @@ export class Database {
         this.updated.next(inserted);
         return inserted;
     }
-    /** Deletes an event from the database and notifies all subscriptions */
-    deleteEvent(eventOrUID) {
-        let event = typeof eventOrUID === "string" ? this.events.get(eventOrUID) : eventOrUID;
+    /** Removes an event from the database and notifies all subscriptions */
+    removeEvent(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,8 +138,20 @@ 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.deleted.next(event);
+        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);
+            }
+        }
+        // remove any claims this event has
+        this.claims.delete(event);
+        // notify subscribers this event was removed
+        this.removed.next(event);
         return true;
     }
     /** Sets the claim on the event and touches it */
@@ -179,27 +208,21 @@ export class Database {
         let sinceIndex = this.created_at.length - 1;
         let start = until
             ? binarySearch(this.created_at, (mid) => {
-                if (mid.created_at === until)
-                    return -1;
                 return mid.created_at - until;
             })
             : undefined;
-        if (start && start[1])
+        if (start)
             untilIndex = start[0];
         const end = since
             ? binarySearch(this.created_at, (mid) => {
-                if (mid.created_at === since)
-                    return 1;
-                return since - mid.created_at;
+                return mid.created_at - since;
             })
             : undefined;
-        if (end && end[1])
+        if (end)
             sinceIndex = end[0];
-        const events = new Set();
-        for (let i = untilIndex; i <= sinceIndex; i++) {
-            events.add(this.created_at[i]);
+        for (let i = untilIndex; i < sinceIndex; i++) {
+            yield this.created_at[i];
         }
-        return events;
     }
     *iterateIds(ids) {
         for (const id of ids) {
@@ -282,7 +305,7 @@ export class Database {
         while (cursor) {
             const event = cursor.value;
             if (!this.isClaimed(event)) {
-                this.deleteEvent(event);
+                this.removeEvent(event);
                 removed++;
                 if (removed >= limit)
                     break;

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

@@ -3,24 +3,61 @@ import { Observable } from "rxjs";
 import { Database } from "./database.js";
 export declare class EventStore {
     database: Database;
+    /** Enable this to keep old versions of replaceable events */
+    keepOldVersions: boolean;
+    /** A method used to verify new events before added them */
+    verifyEvent?: (event: NostrEvent) => boolean;
     constructor();
-    /** Adds an event to the database */
-    add(event: NostrEvent, fromRelay?: string): import("nostr-tools").Event;
+    protected deletedIds: Set<string>;
+    protected deletedCoords: Map<string, number>;
+    protected checkDeleted(event: string | NostrEvent): boolean;
+    protected handleDeleteEvent(deleteEvent: NostrEvent): void;
+    /** Copies important metadata from and identical event to another */
+    static mergeDuplicateEvent(source: NostrEvent, dest: NostrEvent): void;
+    /**
+     * Adds an event to the database and update subscriptions
+     * @throws
+     */
+    add(event: NostrEvent, fromRelay?: string): NostrEvent;
+    /** Removes an event from the database and updates subscriptions */
+    remove(event: string | NostrEvent): boolean;
+    /** Removes any event that is not being used by a subscription */
+    prune(max?: number): number;
     /** 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;
+    /** Get all events matching a filter */
+    getAll(filters: Filter[]): Set<NostrEvent>;
+    /** Check if the store has an event */
+    hasEvent(uid: string): boolean;
+    getEvent(uid: string): NostrEvent | undefined;
+    /** Check if the store has a replaceable event */
     hasReplaceable(kind: number, pubkey: string, d?: string): boolean;
-    getReplaceable(kind: number, pubkey: string, d?: string): import("nostr-tools").Event | undefined;
-    /** Creates an observable that updates a single event */
-    event(uid: string): Observable<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 */
+    getReplaceableHistory(kind: number, pubkey: string, d?: string): NostrEvent[] | undefined;
+    /**
+     * 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: Filter | Filter[], onlyNew?: boolean): Observable<NostrEvent>;
+    /** Returns an observable that completes when an event is removed */
+    removed(id: string): Observable<never>;
+    /** Creates an observable that emits when event is updated */
+    updated(id: string): Observable<NostrEvent>;
+    /** Creates an observable that subscribes to a single event */
+    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>;
-    /** Creates an observable that streams all events that match the filter */
-    stream(filters: Filter[]): Observable<import("nostr-tools").Event>;
+    events(ids: string[]): Observable<Record<string, NostrEvent>>;
+    /** Creates an observable that subscribes to the latest version of a replaceable event */
+    replaceable(kind: number, pubkey: string, d?: string): Observable<NostrEvent | undefined>;
+    /** Creates an observable that subscribes to the latest version of an array of replaceable events*/
+    replaceableSet(pointers: {
+        kind: number;
+        pubkey: string;
+        identifier?: string;
+    }[]): Observable<Record<string, NostrEvent>>;
     /** Creates an observable that updates with an array of sorted events */
-    timeline(filters: Filter[]): Observable<import("nostr-tools").Event[]>;
+    timeline(filters: Filter | Filter[], keepOldVersions?: boolean): Observable<NostrEvent[]>;
 }