nostr-idb 2.0.1 → 2.1.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # nostr-idb
 
+## 2.1.0
+
+### Minor Changes
+
+- 55e853c: Add in memory eventMap to relay core
+
 ## 2.0.1
 
 ### Patch Changes

package/dist/cache/write-queue.d.ts

@@ -2,6 +2,7 @@ import { type Filter, type NostrEvent } from "nostr-tools";
 import { NostrIDB } from "../database/schema.js";
 export declare class WriteQueue {
     db: NostrIDB;
+    private queuedIds;
     private eventQueue;
     private lastUsedQueue;
     constructor(db: NostrIDB);

package/dist/cache/write-queue.js

@@ -1,21 +1,28 @@
 import { matchFilters } from "nostr-tools";
 import { addEvents, getEventUID, updateUsed } from "../database/ingest.js";
 import { logger } from "../debug.js";
-const log = logger.extend("cache:write");
+const log = logger.extend("writeQueue");
 export class WriteQueue {
     db;
+    queuedIds = new Set();
     eventQueue = [];
     lastUsedQueue = new Set();
     constructor(db) {
         this.db = db;
     }
     addEvent(event) {
+        if (this.queuedIds.has(event.id))
+            return;
         this.eventQueue.push(event);
+        this.queuedIds.add(event.id);
         this.useEvent(event);
     }
     addEvents(events) {
-        this.eventQueue.push(...events);
-        this.useEvents(events);
+        const arr = events.filter((e) => !this.queuedIds.has(e.id));
+        if (arr.length === 0)
+            return;
+        this.eventQueue.push(...arr);
+        this.useEvents(arr);
     }
     useEvent(event) {
         this.lastUsedQueue.add(getEventUID(event));
@@ -35,9 +42,10 @@ export class WriteQueue {
                 if (!event)
                     break;
                 events.push(event);
+                this.queuedIds.delete(event.id);
             }
             await addEvents(this.db, events);
-            log(`Wrote ${events.length} to database,${this.eventQueue.length} left`);
+            log(`Wrote ${events.length} to database ${this.eventQueue.length} events left`);
         }
         if (this.lastUsedQueue.size > 0) {
             await updateUsed(this.db, this.lastUsedQueue);

package/dist/database/query-filter.d.ts

@@ -1,4 +1,4 @@
-import type { Event, Filter } from "nostr-tools";
+import type { Event, Filter, NostrEvent } from "nostr-tools";
 import type { NostrIDB } from "./schema.js";
 import { IndexCache } from "../cache/index-cache.js";
 export declare function queryForPubkeys(db: NostrIDB, authors?: Filter["authors"], indexCache?: IndexCache): Set<string> | Promise<Set<string>>;
@@ -7,7 +7,7 @@ export declare function queryForKinds(db: NostrIDB, kinds?: Filter["kinds"], ind
 export declare function queryForTime(db: NostrIDB, since: number | undefined, until: number | undefined): Promise<string[]>;
 export declare function getIdsForFilter(db: NostrIDB, filter: Filter, indexCache?: IndexCache): Promise<Set<string>>;
 export declare function getIdsForFilters(db: NostrIDB, filters: Filter[], indexCache?: IndexCache): Promise<Set<string>>;
-export declare function getEventsForFilter(db: NostrIDB, filter: Filter, indexCache?: IndexCache): Promise<Event[]>;
-export declare function getEventsForFilters(db: NostrIDB, filters: Filter[], indexCache?: IndexCache): Promise<Event[]>;
+export declare function getEventsForFilter(db: NostrIDB, filter: Filter, indexCache?: IndexCache, eventMap?: Map<string, NostrEvent>): Promise<Event[]>;
+export declare function getEventsForFilters(db: NostrIDB, filters: Filter[], indexCache?: IndexCache, eventMap?: Map<string, NostrEvent>): Promise<Event[]>;
 export declare function countEventsForFilter(db: NostrIDB, filter: Filter, indexCache?: IndexCache): Promise<number>;
 export declare function countEventsForFilters(db: NostrIDB, filters: Filter[], indexCache?: IndexCache): Promise<number>;

package/dist/database/query-filter.js

@@ -174,12 +174,25 @@ export async function getIdsForFilters(db, filters, indexCache) {
     }
     return ids;
 }
-async function loadEventsByUID(db, uids, filters) {
+async function loadEventsByUID(db, uids, filters, eventMap) {
     const eventBuffer = [];
+    // load from in-memory event map
+    let remainingIds = [];
+    if (eventMap) {
+        for (const uid of uids) {
+            const event = eventMap.get(uid);
+            if (event)
+                eventBuffer.push(event);
+            else
+                remainingIds.push(uid);
+        }
+    }
+    else
+        remainingIds = uids;
     const trans = db.transaction("events", "readonly");
     const objectStore = trans.objectStore("events");
     const handleEntry = (e) => e && eventBuffer.push(e.event);
-    const promises = Array.from(uids).map((uid) => objectStore.get(uid).then(handleEntry));
+    const promises = Array.from(remainingIds).map((uid) => objectStore.get(uid).then(handleEntry));
     trans.commit();
     const sorted = await Promise.all(promises).then(() => eventBuffer.sort(sortByDate));
     let minLimit = Infinity;
@@ -191,13 +204,13 @@ async function loadEventsByUID(db, uids, filters) {
         sorted.length = minLimit;
     return sorted;
 }
-export async function getEventsForFilter(db, filter, indexCache) {
+export async function getEventsForFilter(db, filter, indexCache, eventMap) {
     const ids = await getIdsForFilter(db, filter, indexCache);
-    return await loadEventsByUID(db, Array.from(ids), [filter]);
+    return await loadEventsByUID(db, Array.from(ids), [filter], eventMap);
 }
-export async function getEventsForFilters(db, filters, indexCache) {
+export async function getEventsForFilters(db, filters, indexCache, eventMap) {
     const ids = await getIdsForFilters(db, filters, indexCache);
-    return await loadEventsByUID(db, Array.from(ids), filters);
+    return await loadEventsByUID(db, Array.from(ids), filters, eventMap);
 }
 export async function countEventsForFilter(db, filter, indexCache) {
     const ids = await getIdsForFilter(db, filter, indexCache);

package/dist/relay/relay-core.d.ts

@@ -29,6 +29,7 @@ export declare class RelayCore {
     private writeInterval?;
     private pruneInterval?;
     get running(): boolean;
+    private eventMap;
     private writeQueue;
     private indexCache;
     db: NostrIDB;
@@ -38,6 +39,7 @@ export declare class RelayCore {
     stop(): Promise<void>;
     publish(event: Event): Promise<string>;
     count(filters: Filter[]): Promise<number>;
+    private addToEventMaps;
     private executeSubscription;
     subscribe(filters: Filter[], options: Partial<SubscriptionOptions>): Subscription;
     unsubscribe(id: string): void;

package/dist/relay/relay-core.js

@@ -5,7 +5,7 @@ import { getEventsForFilters, countEventsForFilters, } from "../database/query-f
 import { sortByDate } from "../utils.js";
 import { nanoid } from "../lib/nanoid.js";
 import { logger } from "../debug.js";
-import { pruneLastUsed } from "../index.js";
+import { getEventUID, pruneLastUsed } from "../index.js";
 const defaultOptions = {
     batchWrite: 1000,
     writeInterval: 100,
@@ -22,6 +22,7 @@ export class RelayCore {
     get running() {
         return !!this.writeInterval;
     }
+    eventMap = new Map();
     writeQueue;
     indexCache;
     db;
@@ -57,6 +58,7 @@ export class RelayCore {
         if (!kinds.isEphemeralKind(event.kind)) {
             this.writeQueue.addEvent(event);
             this.indexCache.addEventToIndexes(event);
+            this.eventMap.set(getEventUID(event), event);
         }
         let subs = 0;
         for (const [id, sub] of this.subscriptions) {
@@ -70,13 +72,18 @@ export class RelayCore {
     async count(filters) {
         return await countEventsForFilters(this.db, filters);
     }
+    addToEventMaps(events) {
+        for (const event of events)
+            this.eventMap.set(getEventUID(event), event);
+    }
     async executeSubscription(sub) {
         const start = new Date().valueOf();
         log(`Running ${sub.id}`, sub.filters);
         // load any events from the write queue
         const eventsFromQueue = this.writeQueue.matchPending(sub.filters);
         // get events
-        await getEventsForFilters(this.db, sub.filters, this.indexCache).then((filterEvents) => {
+        await getEventsForFilters(this.db, sub.filters, this.indexCache, this.eventMap).then((filterEvents) => {
+            this.addToEventMaps(filterEvents);
             if (sub.onevent) {
                 const idsFromQueue = new Set(eventsFromQueue.map((e) => e.id));
                 const events = eventsFromQueue.length > 0