nostr-idb 0.1.2 → 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,8 @@
+# nostr-idb
+
+## 0.2.0
+
+### Minor Changes
+
+- f223129: Added `CacheRelay` class
+- 6c04558: Add `IndexCache` for relay

package/README.md

@@ -2,9 +2,47 @@
 
 A collection of helper methods for storing nostr events in IndexedDB
 
-# Methods
+## Features
 
-## openDB
+- Built directly on top of IndexedDB for the lowest latency
+- CacheRelay class that has a similar API to to nostr-tool`s Relay class
+- Caches indexes in memory
+
+## Using the CacheRelay class
+
+The `CacheRelay` class is lightweight in-memory relay that syncs with the IndexedDB database.
+
+There are a few benefits to using it instead of the underlying `getEventsForFilters` or `addEvents` methods
+
+- Caches indexes in memory.
+- Batches write transactions
+- Almost interchangeable with nostr-tool's `Relay` class
+
+```javascript
+import { openDB, CacheRelay } from "nostr-idb";
+const db = await openDB("events");
+
+const cacheRelay = new CacheRelay(db);
+
+for (let event of events) {
+  cacheRelay.publish(event);
+}
+
+const sub = cacheRelay.subscribe([{ kinds: [1] }], {
+  onevent: (event) => {
+    console.log("got event", event);
+  },
+  oneose: () => {
+    console.log("no more events in cache");
+  },
+});
+```
+
+## Methods
+
+NOTE: all methods are async unless specified otherwise
+
+### openDB
 
 Opens a database with `name` and optional `callbacks`. see [openDB](https://www.npmjs.com/package/idb#opendb)
 
@@ -14,13 +52,13 @@ const db = await openDB("events");
 await addEvents(db, [...])
 ```
 
-## deleteDB
+### deleteDB
 
 Calls `deleteDB` from idb under the hood
 
-## getEventsForFilters
+### getEventsForFilter / getEventsForFilters
 
-Returns a sorted array of events that match the filters
+Both methods returns a sorted array of events that match the filters
 
 ```javascript
 import { openDB, addEvents, getEventsForFilters } from "nostr-idb";
@@ -37,3 +75,47 @@ const events = await getEventsForFilters(db, [
 	}
 ])
 ```
+
+### addEvent / addEvents
+
+`addEvent` and `addEvents` methods can be used to add events to the database.
+
+If possible its better to use `addEvents` and batch writes. since writing single events to the database can cause performance issues
+
+### getIdsForFilter / getIdsForFilters
+
+Similar to `getEventsForFilters` but instead of loading the whole event it just returns the ids
+
+### countEventsForFilter / countEventsForFilters
+
+Similar to `getEventsForFilters` but returns just the number of events
+
+## Index Cache
+
+Normally this is created when you create a new `CacheRelay`. but if you want to maintain your own you can use the `IndexCache` class
+
+```javascript
+import { openDB, addEvents, getEventsForFilters, IndexCache } from "nostr-idb";
+
+const indexCache = new IndexCache()
+const db = await openDB("events");
+
+// add events to db
+await addEvents(db, [...])
+
+// if indexCache is passed in getEventsForFilters will check it first and save any indexes to it
+const events = await getEventsForFilters(db, [
+	{
+		kinds: [1, 6],
+		limit: 30
+	}
+], indexCache)
+
+// add more events
+await addEvents(db, [...])
+// NOTE: don't forget to add events to in-memory indexes
+// otherwise your indexes will get out of sync
+for(let event of events){
+	indexCache.addEventToIndexes(event)
+}
+```

package/dist/database.d.ts

@@ -1,6 +1,7 @@
 import { DeleteDBCallbacks, OpenDBCallbacks } from "idb";
-import { Schema } from "./schema.js";
+import { NostrIDB, Schema } from "./schema.js";
 export declare const NOSTR_IDB_NAME = "nostr-idb";
 export declare const NOSTR_IDB_VERSION = 1;
 export declare function openDB(name?: string, callbacks?: OpenDBCallbacks<Schema>): Promise<import("idb").IDBPDatabase<Schema>>;
 export declare function deleteDB(name?: string, callbacks?: DeleteDBCallbacks): Promise<void>;
+export declare function clearDB(db: NostrIDB): Promise<void>;

package/dist/database.js

@@ -9,8 +9,9 @@ export async function openDB(name = NOSTR_IDB_NAME, callbacks) {
             events.createIndex("id", "event.id", { unique: true });
             events.createIndex("pubkey", "event.pubkey");
             events.createIndex("kind", "event.kind");
-            events.createIndex("create_at", "event.created_at");
+            events.createIndex("created_at", "event.created_at");
             events.createIndex("tags", "tags", { multiEntry: true });
+            events.createIndex("addressPointer", ["kind", "pubkey", "identifier"]);
             const seen = db.createObjectStore("seen", { keyPath: "id" });
             seen.createIndex("date", "date");
             seen.createIndex("relay", "relays", { multiEntry: true });
@@ -24,3 +25,8 @@ export async function openDB(name = NOSTR_IDB_NAME, callbacks) {
 export async function deleteDB(name = NOSTR_IDB_NAME, callbacks) {
     return await idbDeleteDB(name, callbacks);
 }
+export async function clearDB(db) {
+    await db.clear("events");
+    await db.clear("used");
+    await db.clear("seen");
+}

package/dist/index-cache.d.ts

@@ -0,0 +1,18 @@
+import { Event } from "nostr-tools";
+export declare class IndexCache {
+    kinds: Map<number, Set<string>>;
+    pubkeys: Map<string, Set<string>>;
+    tags: Map<string, Set<string>>;
+    get count(): number;
+    max: number;
+    lastUsed: Set<string>[];
+    private useIndex;
+    getKindIndex(kind: number): Set<string> | undefined;
+    setKindIndex(kind: number, index: Set<string>): void;
+    getPubkeyIndex(pubkey: string): Set<string> | undefined;
+    setPubkeyIndex(pubkey: string, index: Set<string>): void;
+    getTagIndex(tagAndValue: string): Set<string> | undefined;
+    setTagIndex(tagAndValue: string, index: Set<string>): void;
+    addEventToIndexes(event: Event): void;
+    pruneIndexes(): void;
+}

package/dist/index-cache.js

@@ -0,0 +1,63 @@
+import { getEventTags } from "./ingest";
+export class IndexCache {
+    kinds = new Map();
+    pubkeys = new Map();
+    tags = new Map();
+    get count() {
+        return this.kinds.size + this.pubkeys.size + this.tags.size;
+    }
+    max = 1000;
+    lastUsed = [];
+    useIndex(index) {
+        const i = this.lastUsed.indexOf(index);
+        if (i !== -1)
+            this.lastUsed.splice(i, i + 1);
+        this.lastUsed.push(index);
+    }
+    getKindIndex(kind) {
+        const index = this.kinds.get(kind);
+        if (index)
+            this.useIndex(index);
+        return index;
+    }
+    setKindIndex(kind, index) {
+        this.kinds.set(kind, index);
+        this.useIndex(index);
+        this.pruneIndexes();
+    }
+    getPubkeyIndex(pubkey) {
+        const index = this.pubkeys.get(pubkey);
+        if (index)
+            this.useIndex(index);
+        return index;
+    }
+    setPubkeyIndex(pubkey, index) {
+        this.pubkeys.set(pubkey, index);
+        this.useIndex(index);
+        this.pruneIndexes();
+    }
+    getTagIndex(tagAndValue) {
+        const index = this.tags.get(tagAndValue);
+        if (index)
+            this.useIndex(index);
+        return index;
+    }
+    setTagIndex(tagAndValue, index) {
+        this.tags.set(tagAndValue, index);
+        this.useIndex(index);
+        this.pruneIndexes();
+    }
+    addEventToIndexes(event) {
+        this.getKindIndex(event.kind)?.add(event.id);
+        this.getPubkeyIndex(event.pubkey)?.add(event.id);
+        const tags = getEventTags(event);
+        for (const tag of tags) {
+            this.getTagIndex(tag)?.add(event.id);
+        }
+    }
+    pruneIndexes() {
+        while (this.lastUsed.length > 0 && this.lastUsed.length > this.max) {
+            this.lastUsed.shift();
+        }
+    }
+}

package/dist/index.d.ts

@@ -2,3 +2,6 @@ export * from "./database.js";
 export * from "./query-filter.js";
 export * from "./query-misc.js";
 export * from "./ingest.js";
+export * from "./relay.js";
+export * from "./index-cache.js";
+export * from "./write-queue.js";

package/dist/index.js

@@ -2,3 +2,6 @@ export * from "./database.js";
 export * from "./query-filter.js";
 export * from "./query-misc.js";
 export * from "./ingest.js";
+export * from "./relay.js";
+export * from "./index-cache.js";
+export * from "./write-queue.js";

package/dist/ingest.d.ts

@@ -1,8 +1,16 @@
 import { IDBPTransaction } from "idb";
 import { Event } from "nostr-tools";
 import type { NostrIDB, Schema } from "./schema.js";
-export declare function createWriteTransaction(db: NostrIDB): IDBPTransaction<Schema, ["events"], "readwrite">;
+/**
+ * Returns an events tags as an array of string for indexing
+ */
 export declare function getEventTags(event: Event): string[];
+export declare function isReplaceable(kind: number): boolean;
+export type ReplaceableEventAddress = {
+    kind: number;
+    pubkey: string;
+    identifier?: string;
+};
 export declare function addEvent(db: NostrIDB, event: Event, transaction?: IDBPTransaction<Schema, ["events"], "readwrite">): Promise<void>;
 export declare function addEvents(db: NostrIDB, events: Event[]): Promise<void>;
 export declare function updateUsed(db: NostrIDB, ids: string[]): Promise<void>;

package/dist/ingest.js

@@ -1,20 +1,37 @@
 import { validateEvent } from "nostr-tools";
 import { GENERIC_TAGS } from "./common.js";
-export function createWriteTransaction(db) {
-    return db.transaction("events", "readwrite");
-}
+/**
+ * Returns an events tags as an array of string for indexing
+ */
 export function getEventTags(event) {
     return event.tags
         .filter((t) => t.length >= 2 && t[0].length === 1 && GENERIC_TAGS.includes(t[0]))
         .map((t) => t[0] + t[1]);
 }
+// based on replaceable kinds from https://github.com/nostr-protocol/nips/blob/master/01.md#kinds
+export function isReplaceable(kind) {
+    return ((kind >= 30000 && kind < 40000) ||
+        (kind >= 10000 && kind < 20000) ||
+        kind === 0 ||
+        kind === 3 ||
+        kind === 41);
+}
+function getReplaceableEventAddress(event) {
+    // only create addresses for replaceable events
+    if (!isReplaceable(event.kind))
+        return undefined;
+    // get d tag
+    const identifier = event.tags.find((t) => t[0] === "d" && t[1])?.[1];
+    return { kind: event.kind, pubkey: event.pubkey, identifier };
+}
 export async function addEvent(db, event, transaction) {
     if (!validateEvent(event))
         throw new Error("Invalid Event");
-    const trans = transaction || createWriteTransaction(db);
+    const trans = transaction || db.transaction("events", "readwrite");
     trans.objectStore("events").put({
         event,
         tags: getEventTags(event),
+        identifier: getReplaceableEventAddress(event)?.identifier,
     });
     if (!transaction)
         await trans.commit();

package/dist/query-filter.d.ts

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

@@ -1,45 +1,101 @@
 import { GENERIC_TAGS } from "./common.js";
-export function queryForPubkeys(db, authors = []) {
+import { sortByDate } from "./utils";
+export function queryForPubkeys(db, authors = [], indexCache) {
+    const loaded = [];
     const ids = new Set();
+    if (indexCache) {
+        for (const pubkey of authors) {
+            const cached = indexCache.getPubkeyIndex(pubkey);
+            if (cached) {
+                for (const id of cached)
+                    ids.add(id);
+                loaded.push(pubkey);
+            }
+        }
+    }
+    // all indexes where loaded from indexCache
+    if (loaded.length === authors.length)
+        return ids;
+    // load remaining indexes from db
     const trans = db.transaction("events", "readonly");
     const objectStore = trans.objectStore("events");
     const index = objectStore.index("pubkey");
-    const handleEvents = (result) => {
+    const handleResults = (pubkey, result) => {
         for (const id of result)
             ids.add(id);
+        // add index to cache
+        if (indexCache)
+            indexCache.setPubkeyIndex(pubkey, new Set(result));
     };
-    const promises = authors.map((pubkey) => index.getAllKeys(pubkey).then(handleEvents));
-    const result = Promise.all(promises).then(() => ids);
+    const promises = authors
+        .filter((p) => !loaded.includes(p))
+        .map((pubkey) => index.getAllKeys(pubkey).then((r) => handleResults(pubkey, r)));
     trans.commit();
-    return result;
+    return Promise.all(promises).then(() => ids);
 }
-export function queryForTag(db, tag, values) {
+export function queryForTag(db, tag, values, indexCache) {
+    const loaded = [];
     const ids = new Set();
+    if (indexCache) {
+        for (const value of values) {
+            const cached = indexCache.getTagIndex(tag + value);
+            if (cached) {
+                for (const id of cached)
+                    ids.add(id);
+                loaded.push(value);
+            }
+        }
+    }
+    // all indexes where loaded from indexCache
+    if (loaded.length === values.length)
+        return ids;
+    // load remaining indexes from db
     const trans = db.transaction("events", "readonly");
     const objectStore = trans.objectStore("events");
     const index = objectStore.index("tags");
-    const handleEvents = (result) => {
+    const handleResults = (value, result) => {
         for (const id of result)
             ids.add(id);
+        // add index to cache
+        if (indexCache)
+            indexCache.setTagIndex(tag + value, new Set(result));
     };
-    const promises = values.map((v) => index.getAllKeys(tag + v).then(handleEvents));
-    const result = Promise.all(promises).then(() => ids);
+    const promises = values.map((v) => index.getAllKeys(tag + v).then((r) => handleResults(v, r)));
     trans.commit();
-    return result;
+    return Promise.all(promises).then(() => ids);
 }
-export function queryForKinds(db, kinds = []) {
+export function queryForKinds(db, kinds = [], indexCache) {
+    const loaded = [];
     const ids = new Set();
+    // load from indexCache
+    if (indexCache) {
+        for (const kind of kinds) {
+            const cached = indexCache.getKindIndex(kind);
+            if (cached) {
+                for (const id of cached)
+                    ids.add(id);
+                loaded.push(kind);
+            }
+        }
+    }
+    // all indexes where loaded from indexCache
+    if (loaded.length === kinds.length)
+        return ids;
+    // load remaining indexes from db
     const trans = db.transaction("events", "readonly");
-    const objectStore = trans.objectStore("events");
-    const index = objectStore.index("kind");
-    const handleEvents = (result) => {
+    const index = trans.objectStore("events").index("kind");
+    const handleResults = (kind, result) => {
         for (const id of result)
             ids.add(id);
+        // add index to cache
+        if (indexCache)
+            indexCache.setKindIndex(kind, new Set(result));
     };
-    const promises = kinds.map((kind) => index.getAllKeys(kind).then(handleEvents));
-    const result = Promise.all(promises).then(() => ids);
+    const promises = kinds
+        .filter((k) => !loaded.includes(k))
+        .map((kind) => index.getAllKeys(kind).then((r) => handleResults(kind, r)));
     trans.commit();
-    return result;
+    return Promise.all(promises).then(() => ids);
 }
 export async function queryForTime(db, since, until) {
     let range;
@@ -51,11 +107,11 @@ export async function queryForTime(db, since, until) {
         range = IDBKeyRange.upperBound(until);
     else
         throw new Error("Missing since or until");
-    const arr = await db.getAllKeysFromIndex("events", "create_at", range);
+    const arr = await db.getAllKeysFromIndex("events", "created_at", range);
     const ids = new Set(arr);
     return ids;
 }
-export async function getIdsForFilter(db, filter) {
+export async function getIdsForFilter(db, filter, indexCache) {
     // search is not supported, return an empty set
     if (filter.search)
         return new Set();
@@ -78,12 +134,12 @@ export async function getIdsForFilter(db, filter) {
         const key = `#${t}`;
         const values = filter[key];
         if (values?.length)
-            and(await queryForTag(db, t, values));
+            and(await queryForTag(db, t, values, indexCache));
     }
     if (filter.authors)
-        and(await queryForPubkeys(db, filter.authors));
+        and(await queryForPubkeys(db, filter.authors, indexCache));
     if (filter.kinds)
-        and(await queryForKinds(db, filter.kinds));
+        and(await queryForKinds(db, filter.kinds, indexCache));
     // query for time last if only one is set
     if ((filter.since === undefined && filter.until) ||
         (filter.since && filter.until === undefined))
@@ -92,12 +148,12 @@ export async function getIdsForFilter(db, filter) {
         throw new Error("Empty filter");
     return ids;
 }
-export async function getIdsForFilters(db, filters) {
+export async function getIdsForFilters(db, filters, indexCache) {
     if (filters.length === 0)
         throw new Error("No Filters");
     let ids = null;
     for (const filter of filters) {
-        const filterIds = await getIdsForFilter(db, filter);
+        const filterIds = await getIdsForFilter(db, filter, indexCache);
         if (!ids)
             ids = filterIds;
         else
@@ -116,7 +172,7 @@ async function loadEventsById(db, ids, filters) {
     const index = objectStore.index("id");
     const handleEntry = (e) => e && events.push(e.event);
     const promises = Array.from(ids).map((id) => index.get(id).then(handleEntry));
-    const sorted = await Promise.all(promises).then(() => events.sort((a, b) => b.created_at - a.created_at));
+    const sorted = await Promise.all(promises).then(() => events.sort(sortByDate));
     trans.commit();
     let minLimit = Infinity;
     for (const filter of filters) {
@@ -127,19 +183,19 @@ async function loadEventsById(db, ids, filters) {
         sorted.length = minLimit;
     return sorted;
 }
-export async function getEventsForFilter(db, filter) {
-    const ids = await getIdsForFilter(db, filter);
+export async function getEventsForFilter(db, filter, indexCache) {
+    const ids = await getIdsForFilter(db, filter, indexCache);
     return await loadEventsById(db, Array.from(ids), [filter]);
 }
-export async function getEventsForFilters(db, filters) {
-    const ids = await getIdsForFilters(db, filters);
+export async function getEventsForFilters(db, filters, indexCache) {
+    const ids = await getIdsForFilters(db, filters, indexCache);
     return await loadEventsById(db, Array.from(ids), filters);
 }
-export async function countEventsForFilter(db, filter) {
-    const ids = await getIdsForFilter(db, filter);
+export async function countEventsForFilter(db, filter, indexCache) {
+    const ids = await getIdsForFilter(db, filter, indexCache);
     return ids.size;
 }
-export async function countEventsForFilters(db, filters) {
-    const ids = await getIdsForFilters(db, filters);
+export async function countEventsForFilters(db, filters, indexCache) {
+    const ids = await getIdsForFilters(db, filters, indexCache);
     return ids.size;
 }

package/dist/query-misc.d.ts

@@ -1,4 +1,7 @@
+import type { Event } from "nostr-tools";
 import { NostrIDB } from "./schema.js";
+import { ReplaceableEventAddress } from "./ingest";
+export declare function getEventsFromAddressPointers(db: NostrIDB, pointers: ReplaceableEventAddress[]): Promise<Event<number>[]>;
 export declare function countEventsByPubkeys(db: NostrIDB): Promise<Record<string, number>>;
 export declare function countEventsByKind(db: NostrIDB): Promise<Record<string, number>>;
 export declare function countEvents(db: NostrIDB): Promise<number>;

package/dist/query-misc.js

@@ -1,3 +1,21 @@
+export async function getEventsFromAddressPointers(db, pointers) {
+    const trans = db.transaction("events", "readonly");
+    const index = trans.objectStore("events").index("addressPointer");
+    const events = {};
+    const promises = pointers.map(async (pointer) => {
+        const key = [pointer.kind, pointer.pubkey, pointer.identifier];
+        const row = await index.get(key);
+        if (row) {
+            const keyStr = key.join(":");
+            const existing = events[keyStr];
+            if (!existing || row.event.created_at > existing.created_at)
+                events[keyStr] = row.event;
+        }
+    });
+    const sorted = await Promise.all(promises).then(() => Object.values(events).sort((a, b) => b.created_at - a.created_at));
+    trans.commit();
+    return sorted;
+}
 export async function countEventsByPubkeys(db) {
     let cursor = await db
         .transaction("events", "readonly")

package/dist/relay.d.ts

@@ -0,0 +1,51 @@
+import { Event, Filter } from "nostr-tools";
+import { NostrIDB } from "./schema";
+export interface SimpleRelay {
+    url: string;
+    publish(event: Event): Promise<string>;
+    connected: boolean;
+    connect(): Promise<void>;
+    close(): void;
+    count(filters: Filter[], params?: {
+        id?: string | null;
+    }): Promise<number>;
+    subscribe(filters: Filter[], options: SimpleSubscriptionOptions): SimpleSubscription;
+}
+export type SimpleSubscriptionOptions = {
+    onevent?: (event: Event) => void;
+    oneose?: () => void;
+    onclose?: (reason: string) => void;
+};
+export type SimpleSubscription = SimpleSubscriptionOptions & {
+    id: string;
+    filters: Filter[];
+    close(message?: string): void;
+};
+export type CacheRelayOptions = {
+    /** Defaults to 1000 */
+    batchWrite?: number;
+    /** Defaults to 100 */
+    writeInterval?: number;
+    /** number of indexes to cache in memory. defaults to 1000 */
+    cacheIndexes?: number;
+};
+export declare class CacheRelay implements SimpleRelay {
+    get url(): string;
+    get connected(): boolean;
+    private options;
+    private interval?;
+    private db;
+    private writeQueue;
+    private indexCache;
+    private nextId;
+    private subscriptions;
+    constructor(db: NostrIDB, opts?: CacheRelayOptions);
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    publish(event: Event): Promise<string>;
+    count(filters: Filter[], params?: {
+        id?: string | null;
+    }): Promise<number>;
+    private executeSubscription;
+    subscribe(filters: Filter[], options: Partial<SimpleSubscriptionOptions>): SimpleSubscription;
+}

package/dist/relay.js

@@ -0,0 +1,92 @@
+import { matchFilters } from "nostr-tools";
+import { WriteQueue } from "./write-queue";
+import { countEventsForFilters, getEventsForFilters } from "./query-filter";
+import { sortByDate } from "./utils";
+import { IndexCache } from "./index-cache";
+const defaultOptions = {
+    batchWrite: 1000,
+    writeInterval: 100,
+    cacheIndexes: 1000,
+};
+export class CacheRelay {
+    get url() {
+        return "[Internal]";
+    }
+    get connected() {
+        return !!this.interval;
+    }
+    options;
+    interval;
+    db;
+    writeQueue;
+    indexCache;
+    nextId = 0;
+    subscriptions = new Set();
+    constructor(db, opts = {}) {
+        this.db = db;
+        this.writeQueue = new WriteQueue(db);
+        this.options = { ...defaultOptions, ...opts };
+        this.indexCache = new IndexCache();
+        this.indexCache.max = this.options.cacheIndexes;
+    }
+    async connect() {
+        this.interval = window.setInterval(() => {
+            this.writeQueue.flush(this.options.batchWrite);
+        }, this.options.writeInterval);
+    }
+    async close() {
+        if (this.interval) {
+            window.clearInterval(this.interval);
+            this.interval = undefined;
+        }
+    }
+    async publish(event) {
+        this.writeQueue.addEvent(event);
+        this.indexCache.addEventToIndexes(event);
+        let subs = 0;
+        for (const { onevent, filters } of this.subscriptions) {
+            if (onevent && matchFilters(filters, event)) {
+                onevent(event);
+                subs++;
+            }
+        }
+        return `Sent to ${subs} subscriptions`;
+    }
+    async count(filters, params) {
+        return await countEventsForFilters(this.db, filters);
+    }
+    async executeSubscription(sub) {
+        // load any events from the write queue
+        const eventsFromQueue = this.writeQueue.queue.filter((e) => matchFilters(sub.filters, e));
+        // get events
+        await getEventsForFilters(this.db, sub.filters, this.indexCache).then((filterEvents) => {
+            if (sub.onevent) {
+                const idsFromQueue = new Set(eventsFromQueue.map((e) => e.id));
+                const events = eventsFromQueue.length > 0
+                    ? [
+                        ...filterEvents.filter((e) => !idsFromQueue.has(e.id)),
+                        ...eventsFromQueue,
+                    ].sort(sortByDate)
+                    : filterEvents;
+                for (const event of events) {
+                    sub.onevent(event);
+                }
+            }
+            if (sub.oneose)
+                sub.oneose();
+        });
+    }
+    subscribe(filters, options) {
+        const id = this.nextId++;
+        const sub = {
+            id: String(id),
+            filters,
+            close: () => this.subscriptions.delete(sub),
+            fire: () => this.executeSubscription(sub),
+            ...options,
+        };
+        this.subscriptions.add(sub);
+        this.executeSubscription(sub);
+        return sub;
+    }
+}

package/dist/schema.d.ts

@@ -7,13 +7,15 @@ export interface Schema extends DBSchema {
         value: {
             event: Event;
             tags: string[];
+            identifier?: string;
         };
         indexes: {
             id: string;
             pubkey: string;
             kind: number;
-            create_at: number;
+            created_at: number;
             tags: string;
+            addressPointer: [number, string, string | undefined];
         };
     };
     seen: {

package/dist/utils.d.ts

@@ -0,0 +1,2 @@
+import { Event } from "nostr-tools";
+export declare function sortByDate(a: Event, b: Event): number;

package/dist/utils.js

@@ -0,0 +1,3 @@
+export function sortByDate(a, b) {
+    return b.created_at - a.created_at;
+}

package/dist/write-queue.d.ts

@@ -0,0 +1,11 @@
+import type { Event } from "nostr-tools";
+import { NostrIDB } from "./schema";
+export declare class WriteQueue {
+    db: NostrIDB;
+    queue: Event[];
+    constructor(db: NostrIDB);
+    addEvent(event: Event): void;
+    addEvents(events: Event[]): void;
+    flush(count?: number): Promise<number>;
+    clear(): void;
+}

package/dist/write-queue.js

@@ -0,0 +1,29 @@
+import { addEvents, updateUsed } from "./ingest";
+export class WriteQueue {
+    db;
+    queue = [];
+    constructor(db) {
+        this.db = db;
+    }
+    addEvent(event) {
+        this.queue.push(event);
+    }
+    addEvents(events) {
+        this.queue.push(...events);
+    }
+    async flush(count = 1000) {
+        const events = [];
+        for (let i = 0; i < count; i++) {
+            const event = this.queue.shift();
+            if (!event)
+                break;
+            events.push(event);
+        }
+        await addEvents(this.db, events);
+        await updateUsed(this.db, events.map((e) => e.id));
+        return events.length;
+    }
+    clear() {
+        this.queue = [];
+    }
+}

package/package.json

@@ -1,7 +1,10 @@
 {
   "name": "nostr-idb",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "A collection of helper methods for storing nostr events in IndexedDB",
+  "author": {
+    "name": "hzrd149"
+  },
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -24,7 +27,7 @@
     "nostr-tools": "^1.17.0"
   },
   "devDependencies": {
-    "@types/debug": "^4.1.12",
+    "@changesets/cli": "^2.27.1",
     "@types/react": "^18.2.37",
     "@types/react-dom": "^18.2.15",
     "@vitejs/plugin-react-swc": "^3.5.0",
@@ -34,5 +37,9 @@
     "react-dom": "^18.2.0",
     "typescript": "^5.3.3",
     "vite": "^5.0.0"
+  },
+  "funding": {
+    "type": "lightning",
+    "url": "lightning:hzrd149@getalby.com"
   }
 }