applesauce-core 0.12.0 → 0.12.1

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

@@ -48,6 +48,30 @@ describe("add", () => {
         expect(eventStore.getEvent(profile.id)).toBeUndefined();
     });
 });
+describe("inserts", () => {
+    it("should emit newer replaceable events", () => {
+        const spy = subscribeSpyTo(eventStore.inserts);
+        eventStore.add(profile);
+        const newer = user.profile({ name: "new name" }, { created_at: profile.created_at + 100 });
+        eventStore.add(newer);
+        expect(spy.getValues()).toEqual([profile, newer]);
+    });
+    it("should not emit when older replaceable event is added", () => {
+        const spy = subscribeSpyTo(eventStore.inserts);
+        eventStore.add(profile);
+        eventStore.add(user.profile({ name: "new name" }, { created_at: profile.created_at - 1000 }));
+        expect(spy.getValues()).toEqual([profile]);
+    });
+});
+describe("removes", () => {
+    it("should emit older replaceable events when the newest replaceable event is added", () => {
+        const spy = subscribeSpyTo(eventStore.removes);
+        eventStore.add(profile);
+        const newer = user.profile({ name: "new name" }, { created_at: profile.created_at + 1000 });
+        eventStore.add(newer);
+        expect(spy.getValues()).toEqual([profile]);
+    });
+});
 describe("verifyEvent", () => {
     it("should be called for all events added", () => {
         const verifyEvent = vi.fn().mockReturnValue(true);
@@ -187,6 +211,13 @@ describe("replaceable", () => {
         eventStore.add(user.profile({ name: "really old name" }, { created_at: profile.created_at - 1000 }));
         expect(spy.getValues()).toEqual([profile]);
     });
+    it("should emit newer events", () => {
+        const spy = subscribeSpyTo(eventStore.replaceable(0, user.pubkey));
+        eventStore.add(profile);
+        const newProfile = user.profile({ name: "new name" }, { created_at: profile.created_at + 500 });
+        eventStore.add(newProfile);
+        expect(spy.getValues()).toEqual([profile, newProfile]);
+    });
 });
 describe("timeline", () => {
     it("should emit an empty array if there are not events", () => {

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

@@ -14,6 +14,7 @@ export declare class Database {
     protected created_at: NostrEvent[];
     /** LRU cache of last events touched */
     events: LRU<import("nostr-tools").Event>;
+    /** A sorted array of replaceable events by uid */
     protected replaceable: Map<string, import("nostr-tools").Event[]>;
     /** A stream of events inserted into the database */
     inserted: Subject<import("nostr-tools").Event>;

package/dist/event-store/database.js

@@ -1,6 +1,6 @@
 import { binarySearch, insertEventIntoDescendingList } from "nostr-tools/utils";
 import { Subject } from "rxjs";
-import { FromCacheSymbol, getEventUID, getIndexableTags, getReplaceableUID, isReplaceable } from "../helpers/event.js";
+import { 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";
@@ -17,6 +17,7 @@ export class Database {
     created_at = [];
     /** LRU cache of last events touched */
     events = new LRU();
+    /** A sorted array of replaceable events by uid */
     replaceable = new Map();
     /** A stream of events inserted into the database */
     inserted = new Subject();
@@ -83,12 +84,8 @@ export class Database {
     addEvent(event) {
         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];
+        if (current)
             return current;
-        }
         this.onBeforeInsert?.(event);
         this.events.set(id, event);
         this.getKindIndex(event.kind).add(event);
@@ -105,9 +102,11 @@ export class Database {
             const uid = getEventUID(event);
             let array = this.replaceable.get(uid);
             if (!this.replaceable.has(uid)) {
+                // add an empty array if there is no array
                 array = [];
                 this.replaceable.set(uid, array);
             }
+            // insert the event into the sorted array
             insertEventIntoDescendingList(array, event);
         }
         this.inserted.next(event);

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

@@ -9,8 +9,12 @@ export declare class EventStore implements IEventStore {
     keepOldVersions: boolean;
     /** A method used to verify new events before added them */
     verifyEvent?: (event: NostrEvent) => boolean;
+    /** A stream of new events added to the store */
+    inserts: Observable<NostrEvent>;
     /** A stream of events that have been updated */
     updates: Observable<NostrEvent>;
+    /** A stream of events that have been removed */
+    removes: Observable<NostrEvent>;
     constructor();
     protected deletedIds: Set<string>;
     protected deletedCoords: Map<string, number>;

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

@@ -3,7 +3,7 @@ import { insertEventIntoDescendingList } from "nostr-tools/utils";
 import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
 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, getReplaceableIdentifier, getReplaceableUID, getTagValue, isReplaceable, } from "../helpers/event.js";
+import { FromCacheSymbol, getEventUID, getReplaceableIdentifier, getReplaceableUID, getTagValue, isReplaceable, } from "../helpers/event.js";
 import { matchFilters } from "../helpers/filter.js";
 import { addSeenRelay, getSeenRelays } from "../helpers/relays.js";
 import { getDeleteCoordinates, getDeleteIds } from "../helpers/delete.js";
@@ -19,8 +19,12 @@ export class EventStore {
     keepOldVersions = false;
     /** A method used to verify new events before added them */
     verifyEvent;
+    /** A stream of new events added to the store */
+    inserts;
     /** A stream of events that have been updated */
     updates;
+    /** A stream of events that have been removed */
+    removes;
     constructor() {
         this.database = new Database();
         this.database.onBeforeInsert = (event) => {
@@ -36,7 +40,9 @@ export class EventStore {
         this.database.removed.subscribe((event) => {
             Reflect.deleteProperty(event, EventStoreSymbol);
         });
+        this.inserts = this.database.inserted;
         this.updates = this.database.updated;
+        this.removes = this.database.removed;
     }
     // delete state
     deletedIds = new Set();
@@ -81,6 +87,10 @@ export class EventStore {
             for (const relay of relays)
                 addSeenRelay(dest, relay);
         }
+        // copy the from cache symbol only if its true
+        const fromCache = Reflect.get(source, FromCacheSymbol);
+        if (fromCache && !Reflect.get(dest, FromCacheSymbol))
+            Reflect.set(dest, FromCacheSymbol, fromCache);
     }
     /**
      * Adds an event to the database and update subscriptions
@@ -92,6 +102,25 @@ export class EventStore {
         // Ignore if the event was deleted
         if (this.checkDeleted(event))
             return event;
+        // Get the replaceable identifier
+        const d = isReplaceable(event.kind) ? getTagValue(event, "d") : undefined;
+        // Don't insert the event if there is already a newer version
+        if (!this.keepOldVersions && isReplaceable(event.kind)) {
+            const existing = this.database.getReplaceable(event.kind, event.pubkey, d);
+            // If there is already a newer version, copy cached symbols and return existing event
+            if (existing && existing.length > 0 && existing[0].created_at >= event.created_at) {
+                EventStore.mergeDuplicateEvent(event, existing[0]);
+                return existing[0];
+            }
+        }
+        else if (this.database.hasEvent(event.id)) {
+            // Duplicate event, copy symbols and return existing event
+            const existing = this.database.getEvent(event.id);
+            if (existing) {
+                EventStore.mergeDuplicateEvent(event, existing);
+                return existing;
+            }
+        }
         // Insert event into database
         const inserted = this.database.addEvent(event);
         // Copy cached data if its a duplicate event
@@ -102,7 +131,7 @@ export class EventStore {
             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"));
+            const existing = this.database.getReplaceable(event.kind, event.pubkey, d);
             if (existing) {
                 const older = Array.from(existing).filter((e) => e.created_at < event.created_at);
                 for (const old of older)
@@ -165,14 +194,14 @@ export class EventStore {
         // merge existing events
         onlyNew ? EMPTY : from(this.getAll(filters)), 
         // subscribe to future events
-        this.database.inserted.pipe(filter((e) => matchFilters(filters, e))));
+        this.inserts.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(
+        return this.removes.pipe(
         // listen for removed events
         filter((e) => e.id === id), 
         // complete as soon as we find a matching removed event
@@ -193,7 +222,7 @@ export class EventStore {
             return event ? of(event) : EMPTY;
         }), 
         // subscribe to updates
-        this.database.inserted.pipe(filter((e) => e.id === id)), 
+        this.inserts.pipe(filter((e) => e.id === id)), 
         // subscribe to updates
         this.updated(id), 
         // emit undefined when deleted
@@ -207,15 +236,15 @@ export class EventStore {
         // 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))), 
+        this.inserts.pipe(filter((e) => ids.includes(e.id))), 
         // subscribe to updates
-        this.database.updated.pipe(filter((e) => ids.includes(e.id)))).pipe(
+        this.updates.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))), 
+        mergeWith(this.removes.pipe(filter((e) => ids.includes(e.id)), map((e) => e.id))), 
         // merge all events into a directory
         scan((dir, event) => {
             if (typeof event === "string") {
@@ -240,13 +269,16 @@ export class EventStore {
             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(
+        this.inserts.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), 
+        distinctUntilChanged((prev, event) => {
+            // are the events the same? i.e. is the prev event older
+            return 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))), 
+        takeUntil(this.removes.pipe(filter((e) => e.id === current?.id))), 
         // emit undefined when removed
         endWith(undefined), 
         // keep the observable hot
@@ -261,7 +293,7 @@ export class EventStore {
         // 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(
+        this.inserts.pipe(filter((e) => isReplaceable(e.kind) && uids.has(getEventUID(e))))).pipe(
         // filter out undefined
         filter((e) => !!e), 
         // claim all events
@@ -269,7 +301,7 @@ export class EventStore {
         // 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]))), 
+        mergeWith(this.removes.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);
@@ -298,11 +330,11 @@ export class EventStore {
         // claim existing events
         claimEvents(this.database), 
         // subscribe to newer events
-        mergeWith(this.database.inserted.pipe(filter((e) => matchFilters(filters, e)), 
+        mergeWith(this.inserts.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))), 
+        mergeWith(this.removes.pipe(filter((e) => matchFilters(filters, e)), map((e) => e.id))), 
         // build a timeline
         scan((timeline, event) => {
             // filter out removed events from timeline

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

@@ -1,7 +1,9 @@
 import { Filter, NostrEvent } from "nostr-tools";
 import { Observable } from "rxjs";
 export interface IEventStore {
+    inserts: Observable<NostrEvent>;
     updates: Observable<NostrEvent>;
+    removes: Observable<NostrEvent>;
     add(event: NostrEvent, fromRelay?: string): NostrEvent;
     remove(event: string | NostrEvent): boolean;
     update(event: NostrEvent): NostrEvent;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "description": "",
   "type": "module",
   "main": "dist/index.js",