applesauce-core 0.0.0-next-20250212001252 → 0.0.0-next-20250213170222

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

@@ -0,0 +1,252 @@
+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";
+let eventStore;
+beforeEach(() => {
+    eventStore = new EventStore();
+});
+const event = {
+    content: '{"name":"hzrd149","picture":"https://cdn.hzrd149.com/5ed3fe5df09a74e8c126831eac999364f9eb7624e2b86d521521b8021de20bdc.png","about":"JavaScript developer working on some nostr stuff\\n- noStrudel https://nostrudel.ninja/ \\n- Blossom https://github.com/hzrd149/blossom \\n- Applesauce https://hzrd149.github.io/applesauce/","website":"https://hzrd149.com","nip05":"_@hzrd149.com","lud16":"hzrd1499@minibits.cash","pubkey":"266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5","display_name":"hzrd149","displayName":"hzrd149","banner":""}',
+    created_at: 1738362529,
+    id: "e9df8d5898c4ccfbd21fcd59f3f48abb3ff0ab7259b19570e2f1756de1e9306b",
+    kind: 0,
+    pubkey: "266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5",
+    sig: "465a47b93626a587bf81dadc2b306b8f713a62db31d6ce1533198e9ae1e665a6eaf376a03250bf9ffbb02eb9059c8eafbd37ae1092d05d215757575bd8357586",
+    tags: [],
+};
+const kind1 = {
+    content: "Except for Substack, what is the simplest way to make a mailing list that can also be browsed on the web?\n\nNo one is doing the Nostr Weekly Report, so maybe I'll start it.",
+    created_at: 1739384412,
+    id: "00006c0cbf210d920242ab472337e690f21db94116bd905259eebfad5ade7232",
+    kind: 1,
+    pubkey: "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d",
+    sig: "6ebd9c34fcdad8ced3ddd9e6eef6e0d0fa77d15d86fe02af33b48dc79714f0f92d3eec77f300ccc8f237217838f9d802bbd65ac7f477705d236dbd99a45c6c34",
+    tags: [["nonce", "13835058055282193107", "16"]],
+};
+describe("add", () => {
+    it("should return original event in case of duplicates", () => {
+        const a = { ...event };
+        expect(eventStore.add(a)).toBe(a);
+        const b = { ...event };
+        expect(eventStore.add(b)).toBe(a);
+        const c = { ...event };
+        expect(eventStore.add(c)).toBe(a);
+    });
+    it("should merge seen relays on duplicate events", () => {
+        const a = { ...event };
+        addSeenRelay(a, "wss://relay.a.com");
+        eventStore.add(a);
+        const b = { ...event };
+        addSeenRelay(b, "wss://relay.b.com");
+        eventStore.add(b);
+        expect(eventStore.getEvent(event.id)).toBeDefined();
+        expect([...getSeenRelays(eventStore.getEvent(event.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: event.created_at + 100,
+            pubkey: event.pubkey,
+            tags: [["e", event.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(event);
+        expect(eventStore.getEvent(event.id)).toBeUndefined();
+    });
+});
+describe("verifyEvent", () => {
+    it("should be called for all events added", () => {
+        const verifyEvent = vi.fn().mockReturnValue(true);
+        eventStore.verifyEvent = verifyEvent;
+        eventStore.add(event);
+        expect(verifyEvent).toHaveBeenCalledWith(event);
+    });
+    it("should not be called for duplicate events", () => {
+        const verifyEvent = vi.fn().mockReturnValue(true);
+        eventStore.verifyEvent = verifyEvent;
+        const a = { ...event };
+        eventStore.add(a);
+        expect(verifyEvent).toHaveBeenCalledWith(a);
+        const b = { ...event };
+        eventStore.add(b);
+        expect(verifyEvent).toHaveBeenCalledTimes(1);
+        const c = { ...event };
+        eventStore.add(c);
+        expect(verifyEvent).toHaveBeenCalledTimes(1);
+    });
+});
+describe("deleted", () => {
+    it("should complete when event is removed", () => {
+        eventStore.add(event);
+        const spy = subscribeSpyTo(eventStore.removed(event.id));
+        eventStore.remove(event);
+        expect(spy.getValues()).toEqual([]);
+        expect(spy.receivedComplete()).toBe(true);
+    });
+});
+describe("event", () => {
+    it("should emit existing event", () => {
+        eventStore.add(event);
+        const spy = subscribeSpyTo(eventStore.event(event.id));
+        expect(spy.getValues()).toEqual([event]);
+    });
+    it("should emit then event when its added", () => {
+        const spy = subscribeSpyTo(eventStore.event(event.id));
+        expect(spy.getValues()).toEqual([]);
+        eventStore.add(event);
+        expect(spy.getValues()).toEqual([event]);
+    });
+    it("should emit undefined when event is removed", () => {
+        eventStore.add(event);
+        const spy = subscribeSpyTo(eventStore.event(event.id));
+        expect(spy.getValues()).toEqual([event]);
+        eventStore.remove(event);
+        expect(spy.getValues()).toEqual([event, undefined]);
+    });
+    it("should emit new value if event is re-added", () => {
+        eventStore.add(event);
+        const spy = subscribeSpyTo(eventStore.event(event.id));
+        eventStore.remove(event);
+        eventStore.add(event);
+        expect(spy.getValues()).toEqual([event, undefined, event]);
+    });
+    it("should not complete when event is removed", () => {
+        eventStore.add(event);
+        const spy = subscribeSpyTo(eventStore.event(event.id));
+        eventStore.remove(event);
+        expect(spy.receivedComplete()).toBe(false);
+    });
+    it("should not emit any values if there are no events", () => {
+        const spy = subscribeSpyTo(eventStore.event(event.id));
+        expect(spy.receivedNext()).toBe(false);
+    });
+});
+describe("events", () => {
+    it("should emit existing events", () => {
+        eventStore.add(event);
+        const spy = subscribeSpyTo(eventStore.events([event.id]));
+        expect(spy.getValues()).toEqual([{ [event.id]: event }]);
+    });
+    it("should remove events when they are removed", () => {
+        eventStore.add(event);
+        const spy = subscribeSpyTo(eventStore.events([event.id]));
+        expect(spy.getValues()).toEqual([{ [event.id]: event }]);
+        eventStore.remove(event);
+        expect(spy.getValues()).toEqual([{ [event.id]: event }, {}]);
+    });
+    it("should add events back if then are re-added", () => {
+        eventStore.add(event);
+        const spy = subscribeSpyTo(eventStore.events([event.id]));
+        eventStore.remove(event);
+        eventStore.add(event);
+        expect(spy.getValues()).toEqual([{ [event.id]: event }, {}, { [event.id]: event }]);
+    });
+    it("should not emit any values if there are no events", () => {
+        const spy = subscribeSpyTo(eventStore.events([event.id]));
+        expect(spy.receivedNext()).toBe(false);
+    });
+});
+describe("replaceable", () => {
+    it("should not emit till there is an event", () => {
+        const spy = subscribeSpyTo(eventStore.replaceable(0, event.pubkey));
+        expect(spy.receivedNext()).toBe(false);
+    });
+    it("should emit existing events", () => {
+        eventStore.add(event);
+        const spy = subscribeSpyTo(eventStore.replaceable(0, event.pubkey));
+        expect(spy.getValues()).toEqual([event]);
+    });
+    it("should emit undefined when event is removed", () => {
+        eventStore.add(event);
+        const spy = subscribeSpyTo(eventStore.replaceable(0, event.pubkey));
+        eventStore.remove(event);
+        expect(spy.getValues()).toEqual([event, undefined]);
+    });
+    it("should not complete when event is removed", () => {
+        eventStore.add(event);
+        const spy = subscribeSpyTo(eventStore.replaceable(0, event.pubkey));
+        eventStore.remove(event);
+        expect(spy.receivedComplete()).toBe(false);
+    });
+    it("should emit event when re-added", () => {
+        eventStore.add(event);
+        const spy = subscribeSpyTo(eventStore.replaceable(0, event.pubkey));
+        eventStore.remove(event);
+        eventStore.add(event);
+        expect(spy.getValues()).toEqual([event, undefined, event]);
+    });
+    it("should claim event", () => {
+        eventStore.add(event);
+        eventStore.replaceable(0, event.pubkey).subscribe();
+        expect(eventStore.database.isClaimed(event)).toBe(true);
+    });
+    it("should remove claim when event is removed", () => {
+        eventStore.add(event);
+        eventStore.replaceable(0, event.pubkey).subscribe();
+        eventStore.remove(event);
+        expect(eventStore.database.isClaimed(event)).toBe(false);
+    });
+});
+describe("timeline", () => {
+    it("should not emit if there are not events", () => {
+        const spy = subscribeSpyTo(eventStore.timeline({ kinds: [1] }));
+        expect(spy.receivedNext()).toBe(false);
+    });
+    it("should emit existing events", () => {
+        eventStore.add(event);
+        const spy = subscribeSpyTo(eventStore.timeline({ kinds: [0] }));
+        expect(spy.getValues()).toEqual([[event]]);
+    });
+    it("should emit new events", () => {
+        const spy = subscribeSpyTo(eventStore.timeline({ kinds: [0, 1] }));
+        eventStore.add(event);
+        eventStore.add(kind1);
+        expect(spy.getValues()).toEqual([[event], [kind1, event]]);
+    });
+    it("should remove event when its removed", () => {
+        eventStore.add(event);
+        const spy = subscribeSpyTo(eventStore.timeline({ kinds: [0] }));
+        eventStore.remove(event);
+        expect(spy.getValues()).toEqual([[event], []]);
+    });
+    it("should not emit when other events are removed", () => {
+        eventStore.add(event);
+        const spy = subscribeSpyTo(eventStore.timeline({ kinds: [0] }));
+        eventStore.add(kind1);
+        eventStore.remove(kind1);
+        expect(spy.getValues()).toEqual([[event]]);
+    });
+});
+describe("replaceableSet", () => {
+    it("should not emit if there are not events", () => {
+        const spy = subscribeSpyTo(eventStore.replaceableSet([{ kind: 0, pubkey: event.pubkey }]));
+        expect(spy.receivedNext()).toBe(false);
+    });
+    it("should emit existing events", () => {
+        eventStore.add(event);
+        const spy = subscribeSpyTo(eventStore.replaceableSet([{ kind: 0, pubkey: event.pubkey }]));
+        expect(spy.getValues()).toEqual([{ [getEventUID(event)]: event }]);
+    });
+    it("should remove event when removed", () => {
+        eventStore.add(event);
+        const spy = subscribeSpyTo(eventStore.replaceableSet([{ kind: 0, pubkey: event.pubkey }]));
+        eventStore.remove(event);
+        expect(spy.getValues()).toEqual([{ [getEventUID(event)]: event }, {}]);
+    });
+    it("should replace older events", () => {
+        const event2 = { ...event, created_at: event.created_at + 100, id: "newer-event" };
+        const uid = getEventUID(event);
+        eventStore.add(event);
+        const spy = subscribeSpyTo(eventStore.replaceableSet([{ kind: 0, pubkey: event.pubkey }]));
+        eventStore.add(event2);
+        expect(spy.getValues()).toEqual([{ [uid]: event }, { [uid]: event2 }]);
+    });
+});

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

@@ -19,8 +19,8 @@ export declare class 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;
@@ -43,8 +43,8 @@ export declare class Database {
     addEvent(event: NostrEvent): NostrEvent;
     /** Inserts and event into the database and notifies all subscriptions that the event has updated */
     updateEvent(event: NostrEvent): NostrEvent;
-    /** Deletes an event from the database and notifies all subscriptions */
-    deleteEvent(eventOrId: string | NostrEvent): boolean;
+    /** 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 */

package/dist/event-store/database.js

@@ -22,8 +22,8 @@ export class 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() {
@@ -119,8 +119,8 @@ export class Database {
         this.updated.next(inserted);
         return inserted;
     }
-    /** Deletes an event from the database and notifies all subscriptions */
-    deleteEvent(eventOrId) {
+    /** 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");
@@ -148,7 +148,10 @@ export class Database {
                 array.splice(idx, 1);
             }
         }
-        this.deleted.next(event);
+        // 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 */
@@ -302,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

@@ -8,6 +8,12 @@ export declare class EventStore {
     /** A method used to verify new events before added them */
     verifyEvent?: (event: NostrEvent) => boolean;
     constructor();
+    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
@@ -15,22 +21,31 @@ export declare class EventStore {
     add(event: NostrEvent, fromRelay?: string): NostrEvent;
     /** Removes an event from the database and updates subscriptions */
     remove(event: string | NostrEvent): boolean;
-    protected deletedIds: Set<string>;
-    protected deletedCoords: Map<string, number>;
-    protected handleDeleteEvent(deleteEvent: NostrEvent): void;
-    protected checkDeleted(event: 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): 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;
     /** 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 */
@@ -43,12 +58,6 @@ export declare class EventStore {
         pubkey: string;
         identifier?: string;
     }[]): Observable<Record<string, NostrEvent>>;
-    /**
-     * Creates an observable that streams all events that match the filter
-     * @param filters
-     * @param [onlyNew=false] Only subscribe to new events
-     */
-    stream(filters: Filter | Filter[], onlyNew?: boolean): Observable<NostrEvent>;
     /** Creates an observable that updates with an array of sorted events */
     timeline(filters: Filter | Filter[], keepOldVersions?: boolean): Observable<NostrEvent[]>;
 }