applesauce-core 0.12.0 → 1.0.0

package/README.md

@@ -1,37 +1,55 @@
 # applesauce-core
 
-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)
+AppleSauce is a collection of utilities for building reactive nostr applications. The core package provides an in-memory event database and reactive queries to help you build nostr UIs with less code.
 
-# Example
+## Key Components
+
+- **Helpers**: Core utility methods for parsing and extracting data from nostr events
+- **EventStore**: In-memory database for storing and subscribing to nostr events
+- **QueryStore**: Manages queries and ensures efficient subscription handling
+- **Queries**: Complex subscriptions for common nostr data patterns
+
+## Documentation
+
+For detailed documentation and guides, visit:
+
+- [Getting Started](https://hzrd149.github.io/applesauce/introduction/getting-started)
+- [API Reference](https://hzrd149.github.io/applesauce/typedoc/)
+
+## Example
 
 ```js
 import { EventStore, QueryStore } from "applesauce-core";
 import { Relay } from "nostr-tools/relay";
 
-// The EventStore handles all the events
+// Create a single EventStore instance for your app
 const eventStore = new EventStore();
 
-// The QueryStore handles queries and makes sure not to run multiple of the same query
+// Create a QueryStore to manage subscriptions efficiently
 const queryStore = new QueryStore(eventStore);
 
-// Use nostr-tools or anything else to talk to relays
+// Use any nostr library for relay connections (nostr-tools, ndk, nostrify, etc...)
 const relay = await Relay.connect("wss://relay.example.com");
 
-const sub = relay.subscribe([{ authors: ["266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5"] }], {
+// Subscribe to events and add them to the store
+const sub = relay.subscribe([{ authors: ["3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d"] }], {
   onevent(event) {
     eventStore.add(event);
   },
 });
 
-// This will return an Observable<ProfileContent | undefined> of the parsed metadata
-const profile = queryStore.profile("266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5");
+// Subscribe to profile changes using ProfileQuery
+const profile = queryStore.createQuery(
+  ProfileQuery,
+  "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d",
+);
 
 profile.subscribe((parsed) => {
   if (parsed) console.log(parsed);
 });
 
-// This will return an Observable<NostrEvent[]> of all kind 1 events sorted by created_at
-const timeline = queryStore.timeline({ kinds: [1] });
+// Subscribe to a timeline of events
+const timeline = queryStore.createQuery(TimelineQuery, { kinds: [1] });
 
 timeline.subscribe((events) => {
   console.log(events);

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

@@ -31,7 +31,7 @@ describe("add", () => {
         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", () => {
+    it("should ignore old deleted events but not newer ones", () => {
         const deleteEvent = {
             id: "delete event id",
             kind: kinds.EventDeletion,
@@ -45,7 +45,82 @@ describe("add", () => {
         eventStore.add(deleteEvent);
         // now event should be ignored
         eventStore.add(profile);
+        const newProfile = user.profile({ name: "new name" }, { created_at: profile.created_at + 1000 });
+        eventStore.add(newProfile);
         expect(eventStore.getEvent(profile.id)).toBeUndefined();
+        expect(eventStore.getEvent(newProfile.id)).toBeDefined();
+    });
+    it("should remove profile events when delete event is added", () => {
+        // Add initial replaceable event
+        eventStore.add(profile);
+        expect(eventStore.getEvent(profile.id)).toBeDefined();
+        const newProfile = user.profile({ name: "new name" }, { created_at: profile.created_at + 1000 });
+        eventStore.add(newProfile);
+        const deleteEvent = {
+            id: "delete event id",
+            kind: kinds.EventDeletion,
+            created_at: profile.created_at + 100,
+            pubkey: user.pubkey,
+            tags: [["a", `${profile.kind}:${profile.pubkey}`]],
+            sig: "this should be ignored for the test",
+            content: "test",
+        };
+        // Add delete event with coordinate
+        eventStore.add(deleteEvent);
+        // Profile should be removed since delete event is newer
+        expect(eventStore.getEvent(profile.id)).toBeUndefined();
+        expect(eventStore.getEvent(newProfile.id)).toBeDefined();
+        expect(eventStore.getReplaceable(profile.kind, profile.pubkey)).toBe(newProfile);
+    });
+    it("should remove addressable replaceable events when delete event is added", () => {
+        // Add initial replaceable event
+        const event = user.event({ content: "test", kind: 30000, tags: [["d", "test"]] });
+        eventStore.add(event);
+        expect(eventStore.getEvent(event.id)).toBeDefined();
+        const newEvent = user.event({
+            ...event,
+            created_at: event.created_at + 500,
+        });
+        eventStore.add(newEvent);
+        const deleteEvent = {
+            id: "delete event id",
+            kind: kinds.EventDeletion,
+            created_at: event.created_at + 100,
+            pubkey: user.pubkey,
+            tags: [["a", `${event.kind}:${event.pubkey}:test`]],
+            sig: "this should be ignored for the test",
+            content: "test",
+        };
+        // Add delete event with coordinate
+        eventStore.add(deleteEvent);
+        // Profile should be removed since delete event is newer
+        expect(eventStore.getEvent(event.id)).toBeUndefined();
+        expect(eventStore.getEvent(newEvent.id)).toBeDefined();
+        expect(eventStore.getReplaceable(event.kind, event.pubkey, "test")).toBe(newEvent);
+    });
+});
+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", () => {
@@ -187,6 +262,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, createReplaceableAddress, 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();
@@ -72,23 +73,19 @@ export class Database {
     }
     /** Checks if the database contains a replaceable event without touching it */
     hasReplaceable(kind, pubkey, d) {
-        const events = this.replaceable.get(getReplaceableUID(kind, pubkey, d));
+        const events = this.replaceable.get(createReplaceableAddress(kind, pubkey, d));
         return !!events && events.length > 0;
     }
     /** Gets an array of replaceable events */
     getReplaceable(kind, pubkey, d) {
-        return this.replaceable.get(getReplaceableUID(kind, pubkey, d));
+        return this.replaceable.get(createReplaceableAddress(kind, pubkey, d));
     }
     /** Inserts an event into the database and notifies all subscriptions */
     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

@@ -1,14 +1,15 @@
 import { kinds } from "nostr-tools";
 import { insertEventIntoDescendingList } from "nostr-tools/utils";
-import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
+import { isAddressableKind } 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, createReplaceableAddress, 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";
 import { claimEvents } from "../observable/claim-events.js";
 import { claimLatest } from "../observable/claim-latest.js";
+import { parseCoordinate } from "../helpers/pointers.js";
 export const EventStoreSymbol = Symbol.for("event-store");
 function sortDesc(a, b) {
     return b.created_at - a.created_at;
@@ -19,8 +20,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 +41,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();
@@ -47,7 +54,7 @@ export class EventStore {
         else {
             if (this.deletedIds.has(event.id))
                 return true;
-            if (isParameterizedReplaceableKind(event.kind)) {
+            if (isAddressableKind(event.kind)) {
                 const deleted = this.deletedCoords.get(getEventUID(event));
                 if (deleted)
                     return deleted > event.created_at;
@@ -68,10 +75,16 @@ export class EventStore {
         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.removeEvent(event);
+            // Parse the nostr address coordinate
+            const parsed = parseCoordinate(coord);
+            if (!parsed)
+                continue;
+            // Remove older versions of replaceable events
+            const events = this.database.getReplaceable(parsed.kind, parsed.pubkey, parsed.identifier) ?? [];
+            for (const event of events) {
+                if (event.created_at < deleteEvent.created_at)
+                    this.database.removeEvent(event);
+            }
         }
     }
     /** Copies important metadata from and identical event to another */
@@ -81,6 +94,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 +109,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 +138,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 +201,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 +229,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 +243,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 +276,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
@@ -256,12 +295,12 @@ export class EventStore {
     }
     /** Creates an observable that subscribes to the latest version of an array of replaceable events*/
     replaceableSet(pointers) {
-        const uids = new Set(pointers.map((p) => getReplaceableUID(p.kind, p.pubkey, p.identifier)));
+        const uids = new Set(pointers.map((p) => createReplaceableAddress(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(
+        this.inserts.pipe(filter((e) => isReplaceable(e.kind) && uids.has(getEventUID(e))))).pipe(
         // filter out undefined
         filter((e) => !!e), 
         // claim all events
@@ -269,7 +308,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 +337,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,10 +1,6 @@
 import { Filter, NostrEvent } from "nostr-tools";
 import { Observable } from "rxjs";
-export interface IEventStore {
-    updates: Observable<NostrEvent>;
-    add(event: NostrEvent, fromRelay?: string): NostrEvent;
-    remove(event: string | NostrEvent): boolean;
-    update(event: NostrEvent): NostrEvent;
+export interface ISyncEventStore {
     hasEvent(id: string): boolean;
     hasReplaceable(kind: number, pubkey: string, identifier?: string): boolean;
     getEvent(id: string): NostrEvent | undefined;
@@ -12,6 +8,11 @@ export interface IEventStore {
     getReplaceableHistory(kind: number, pubkey: string, identifier?: string): NostrEvent[] | undefined;
     getAll(filters: Filter | Filter[]): Set<NostrEvent>;
     getTimeline(filters: Filter | Filter[]): NostrEvent[];
+}
+export interface IStreamEventStore {
+    inserts: Observable<NostrEvent>;
+    updates: Observable<NostrEvent>;
+    removes: Observable<NostrEvent>;
     filters(filters: Filter | Filter[]): Observable<NostrEvent>;
     updated(id: string | NostrEvent): Observable<NostrEvent>;
     removed(id: string): Observable<never>;
@@ -25,3 +26,8 @@ export interface IEventStore {
     }[]): Observable<Record<string, NostrEvent>>;
     timeline(filters: Filter | Filter[], includeOldVersion?: boolean): Observable<NostrEvent[]>;
 }
+export interface IEventStore extends ISyncEventStore, IStreamEventStore {
+    add(event: NostrEvent, fromRelay?: string): NostrEvent;
+    remove(event: string | NostrEvent): boolean;
+    update(event: NostrEvent): NostrEvent;
+}

package/dist/helpers/__tests__/bookmarks.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,88 @@
+import { describe, it, expect } from "vitest";
+import { kinds } from "nostr-tools";
+import { mergeBookmarks } from "../bookmarks.js";
+describe("mergeBookmarks", () => {
+    it("should merge bookmarks and handle duplicates", () => {
+        // Create test data with some duplicates
+        const eventPointer1 = {
+            id: "event1",
+            relays: ["wss://relay1.com/", "wss://relay2.com/"],
+            author: "author1",
+        };
+        const eventPointer2 = {
+            id: "event1", // Same ID as eventPointer1
+            relays: ["wss://relay2.com/", "wss://relay3.com/"],
+            author: "author1",
+        };
+        const eventPointer3 = {
+            id: "event2",
+            relays: ["wss://relay1.com/"],
+            author: "author2",
+        };
+        const addressPointer1 = {
+            kind: kinds.LongFormArticle,
+            pubkey: "pubkey1",
+            identifier: "article1",
+            relays: ["wss://relay1.com/", "wss://relay2.com/"],
+        };
+        const addressPointer2 = {
+            kind: kinds.LongFormArticle,
+            pubkey: "pubkey1",
+            identifier: "article1", // Same as addressPointer1
+            relays: ["wss://relay3.com/"],
+        };
+        const bookmark1 = {
+            notes: [eventPointer1],
+            articles: [addressPointer1],
+            hashtags: ["tag1", "tag2"],
+            urls: ["https://example1.com/"],
+        };
+        const bookmark2 = {
+            notes: [eventPointer2, eventPointer3],
+            articles: [addressPointer2],
+            hashtags: ["tag2", "tag3"],
+            urls: ["https://example1.com/", "https://example2.com/"],
+        };
+        const result = mergeBookmarks(bookmark1, bookmark2);
+        // Check that duplicates are properly merged
+        expect(result.notes).toHaveLength(2); // event1 should be merged, plus event2
+        expect(result.articles).toHaveLength(1); // article1 should be merged
+        expect(result.hashtags).toHaveLength(3); // unique tags
+        expect(result.urls).toHaveLength(2); // unique urls
+        // Check that relays are merged for duplicate event
+        const mergedEvent = result.notes.find((note) => note.id === "event1");
+        expect(mergedEvent?.relays).toHaveLength(3);
+        expect(mergedEvent?.relays).toContain("wss://relay1.com/");
+        expect(mergedEvent?.relays).toContain("wss://relay2.com/");
+        expect(mergedEvent?.relays).toContain("wss://relay3.com/");
+        // Check that relays are merged for duplicate article
+        const mergedArticle = result.articles[0];
+        expect(mergedArticle.relays).toHaveLength(3);
+        expect(mergedArticle.relays).toContain("wss://relay1.com/");
+        expect(mergedArticle.relays).toContain("wss://relay2.com/");
+        expect(mergedArticle.relays).toContain("wss://relay3.com/");
+        // Check that hashtags are unique
+        expect(result.hashtags).toContain("tag1");
+        expect(result.hashtags).toContain("tag2");
+        expect(result.hashtags).toContain("tag3");
+        // Check that urls are unique
+        expect(result.urls).toContain("https://example1.com/");
+        expect(result.urls).toContain("https://example2.com/");
+    });
+    it("should handle undefined bookmarks", () => {
+        const bookmark = {
+            notes: [{ id: "event1", relays: ["wss://relay1.com/"] }],
+            articles: [],
+            hashtags: ["tag1"],
+            urls: ["https://example.com/"],
+        };
+        const result = mergeBookmarks(bookmark, undefined);
+        expect(result).toEqual(bookmark);
+        expect(mergeBookmarks(undefined, undefined)).toEqual({
+            notes: [],
+            articles: [],
+            hashtags: [],
+            urls: [],
+        });
+    });
+});