nostr-idb 3.0.0 → 4.0.0

package/README.md

@@ -9,8 +9,6 @@ Live Examples: https://hzrd149.github.io/nostr-idb/
   - [openDB](#openDB)
   - [clearDB](#clearDB)
   - [deleteDB](#deleteDB)
-- [nostr-tools](#nostr-tools)
-  - [CacheRelay](#CacheRelay)
 - [Performance](#Performance)
 
 ## Features
@@ -18,7 +16,6 @@ Live Examples: https://hzrd149.github.io/nostr-idb/
 - Built directly on top of IndexedDB for the lowest latency
 - Caches indexes in memory
 - `NostrIDB` class with full nostr relay-like API
-- `CacheRelay` class with similar API to nostr-tool `Relay` class
 
 ## NostrIDB Class
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nostr-idb",
-  "version": "3.0.0",
+  "version": "4.0.0",
   "description": "A collection of helper methods for storing nostr events in IndexedDB",
   "author": "hzrd149",
   "license": "MIT",
@@ -30,20 +30,25 @@
     }
   },
   "dependencies": {
-    "debug": "^4.3.6",
-    "idb": "^8.0.0",
-    "nostr-tools": "~2.17.0"
+    "debug": "^4.4.3",
+    "idb": "^8.0.3",
+    "nostr-tools": "~2.17.2"
   },
   "devDependencies": {
-    "@changesets/cli": "^2.27.7",
-    "@sveltejs/vite-plugin-svelte": "^3.1.1",
-    "@tsconfig/svelte": "^5.0.4",
+    "@changesets/cli": "^2.29.7",
+    "@sveltejs/vite-plugin-svelte": "^3.1.2",
+    "@tsconfig/svelte": "^5.0.6",
     "@types/debug": "^4.1.12",
-    "esbuild": "^0.25.10",
-    "prettier": "^3.3.3",
-    "svelte": "^4.2.18",
-    "typescript": "^5.5.4",
-    "vite": "^5.3.5"
+    "@types/node": "^24.10.1",
+    "@vitest/coverage-v8": "4.0.9",
+    "@vitest/ui": "^4.0.9",
+    "esbuild": "^0.25.12",
+    "fake-indexeddb": "^6.2.5",
+    "prettier": "^3.6.2",
+    "svelte": "^4.2.20",
+    "typescript": "^5.9.3",
+    "vite": "^5.4.21",
+    "vitest": "^4.0.9"
   },
   "funding": {
     "type": "lightning",
@@ -54,6 +59,10 @@
     "prebuild": "rm -rf dist",
     "build": "tsc && node build.js",
     "build:examples": "vite build && cp examples/index.html public/index.html",
-    "format": "prettier -w ."
+    "format": "prettier -w .",
+    "test": "vitest",
+    "test:ui": "vitest --ui",
+    "test:run": "vitest run",
+    "test:coverage": "vitest run --coverage"
   }
 }

package/dist/cache/index-cache.d.ts

@@ -1,27 +0,0 @@
-import type { NostrEvent } from "nostr-tools/pure";
-declare class Index<T> extends Set<string> {
-    type: "kind" | "pubkey" | "tag";
-    key: T;
-    constructor(values: Iterable<string> | null, type: "kind" | "pubkey" | "tag", key: T);
-}
-/** In-memory cache for indexes of events */
-export declare class IndexCache {
-    kinds: Map<number, Index<number>>;
-    pubkeys: Map<string, Index<string>>;
-    tags: Map<string, Index<string>>;
-    get count(): number;
-    max: number;
-    lastUsed: Index<any>[];
-    private useIndex;
-    getKindIndex(kind: number): Index<number> | undefined;
-    setKindIndex(kind: number, uids: Iterable<string>): void;
-    getPubkeyIndex(pubkey: string): Index<string> | undefined;
-    setPubkeyIndex(pubkey: string, uids: Iterable<string>): void;
-    getTagIndex(tagAndValue: string): Index<string> | undefined;
-    setTagIndex(tagAndValue: string, uids: Iterable<string>): void;
-    addEventToIndexes(event: NostrEvent): void;
-    removeEvent(event: NostrEvent): void;
-    clear(): void;
-    pruneIndexes(): void;
-}
-export {};

package/dist/cache/index-cache.js

@@ -1,106 +0,0 @@
-import { logger } from "../debug.js";
-import { getEventTags } from "../database/common.js";
-const log = logger.extend("cache:indexes");
-class Index extends Set {
-    type;
-    key;
-    constructor(values, type, key) {
-        super(values);
-        this.type = type;
-        this.key = key;
-    }
-}
-/** In-memory cache for indexes of events */
-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, uids) {
-        const index = new Index(uids, "kind", kind);
-        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, uids) {
-        const index = new Index(uids, "pubkey", pubkey);
-        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, uids) {
-        const index = new Index(uids, "tag", tagAndValue);
-        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);
-        }
-    }
-    removeEvent(event) {
-        this.getKindIndex(event.kind)?.delete(event.id);
-        this.getPubkeyIndex(event.pubkey)?.delete(event.id);
-        const tags = getEventTags(event);
-        for (const tag of tags) {
-            this.getTagIndex(tag)?.delete(event.id);
-        }
-    }
-    clear() {
-        this.kinds.clear();
-        this.pubkeys.clear();
-        this.tags.clear();
-        this.lastUsed = [];
-    }
-    pruneIndexes() {
-        while (this.lastUsed.length > 0 && this.lastUsed.length > this.max) {
-            const index = this.lastUsed.shift();
-            if (!index)
-                return;
-            log(`Forgetting ${index.type}:${index.key}`);
-            switch (index.type) {
-                case "kind":
-                    this.kinds.delete(index.key);
-                    break;
-                case "pubkey":
-                    this.pubkeys.delete(index.key);
-                    break;
-                case "tag":
-                    this.tags.delete(index.key);
-                    break;
-            }
-        }
-    }
-}

package/dist/cache/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./write-queue.js";
-export * from "./index-cache.js";

package/dist/cache/index.js

@@ -1,2 +0,0 @@
-export * from "./write-queue.js";
-export * from "./index-cache.js";

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

@@ -1,21 +0,0 @@
-import type { NostrEvent } from "nostr-tools/pure";
-import { type Filter } from "nostr-tools/filter";
-import { NostrIDBDatabase } from "../database/schema.js";
-/** A queue of events to be written to the database */
-export declare class WriteQueue {
-    db: NostrIDBDatabase;
-    private queuedIds;
-    private eventQueue;
-    private lastUsedQueue;
-    /** Called for each chunk of events before they are written to the database */
-    processEvents: ((events: NostrEvent[]) => Promise<NostrEvent[] | void>) | null;
-    constructor(db: NostrIDBDatabase);
-    addEvent(event: NostrEvent): void;
-    addEvents(events: NostrEvent[]): void;
-    touch(event: NostrEvent | NostrEvent[]): void;
-    matchPending(filters: Filter[]): import("nostr-tools/core").Event[];
-    /** Write all events in the queue to the database */
-    flush(count?: number): Promise<void>;
-    /** Clear the queue */
-    clear(): void;
-}

package/dist/cache/write-queue.js

@@ -1,70 +0,0 @@
-import { matchFilters } from "nostr-tools/filter";
-import { addEvents, updateUsed, getEventUID } from "../database/index.js";
-import { logger } from "../debug.js";
-const log = logger.extend("WriteQueue");
-/** A queue of events to be written to the database */
-export class WriteQueue {
-    db;
-    queuedIds = new Set();
-    eventQueue = [];
-    lastUsedQueue = new Set();
-    /** Called for each chunk of events before they are written to the database */
-    processEvents = null;
-    constructor(db) {
-        this.db = db;
-    }
-    addEvent(event) {
-        if (this.queuedIds.has(event.id))
-            return;
-        this.eventQueue.push(event);
-        this.queuedIds.add(event.id);
-        this.touch(event);
-    }
-    addEvents(events) {
-        const arr = events.filter((e) => !this.queuedIds.has(e.id));
-        if (arr.length === 0)
-            return;
-        this.eventQueue.push(...arr);
-        this.touch(arr);
-    }
-    touch(event) {
-        if (Array.isArray(event)) {
-            for (const e of event)
-                this.lastUsedQueue.add(getEventUID(e));
-        }
-        else {
-            this.lastUsedQueue.add(getEventUID(event));
-        }
-    }
-    matchPending(filters) {
-        return this.eventQueue.filter((e) => matchFilters(filters, e));
-    }
-    /** Write all events in the queue to the database */
-    async flush(count = 1000) {
-        if (this.eventQueue.length > 0) {
-            let events = [];
-            for (let i = 0; i < count; i++) {
-                const event = this.eventQueue.shift();
-                if (!event)
-                    break;
-                events.push(event);
-                this.queuedIds.delete(event.id);
-            }
-            if (this.processEvents) {
-                events = (await this.processEvents(events)) || events;
-            }
-            await addEvents(this.db, events);
-            log(`Wrote ${events.length} to database`);
-            if (this.eventQueue.length > 0)
-                log(`${this.eventQueue.length} left`);
-        }
-        if (this.lastUsedQueue.size > 0) {
-            await updateUsed(this.db, this.lastUsedQueue);
-            this.lastUsedQueue.clear();
-        }
-    }
-    /** Clear the queue */
-    clear() {
-        this.eventQueue = [];
-    }
-}

package/dist/database/common.d.ts

@@ -1,9 +0,0 @@
-import { type NostrEvent } from "nostr-tools/pure";
-/** An array of common indexable tags */
-export declare const INDEXABLE_TAGS: string[];
-/** Cashing symbol for event UID */
-export declare const EventUIDSymbol: unique symbol;
-/** Returns an events tags as an array of string for indexing */
-export declare function getEventTags(event: NostrEvent): string[];
-/** Returns the events Unique ID */
-export declare function getEventUID(event: NostrEvent): string;

package/dist/database/common.js

@@ -1,27 +0,0 @@
-import { isAddressableKind, isReplaceableKind } from "nostr-tools/kinds";
-const LETTERS = "abcdefghijklmnopqrstuvwxyz";
-/** An array of common indexable tags */
-export const INDEXABLE_TAGS = (LETTERS + LETTERS.toUpperCase()).split("");
-/** Cashing symbol for event UID */
-export const EventUIDSymbol = Symbol.for("event-uid");
-/** 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 && INDEXABLE_TAGS.includes(t[0]))
-        .map((t) => t[0] + t[1]);
-}
-/** Returns the events Unique ID */
-export function getEventUID(event) {
-    if (Reflect.has(event, EventUIDSymbol))
-        return Reflect.get(event, EventUIDSymbol);
-    let uid;
-    if (isReplaceableKind(event.kind) || isAddressableKind(event.kind)) {
-        const d = event.tags.find((t) => t[0] === "d")?.[1];
-        uid = "" + event.kind + ":" + event.pubkey + ":" + (d ?? "");
-    }
-    else {
-        uid = event.id;
-    }
-    Reflect.set(event, EventUIDSymbol, uid);
-    return uid;
-}

package/dist/database/database.d.ts

@@ -1,10 +0,0 @@
-import { DeleteDBCallbacks, OpenDBCallbacks } from "idb";
-import { NostrIDBDatabase, Schema } from "./schema.js";
-export declare const NOSTR_IDB_NAME = "nostr-idb";
-export declare const NOSTR_IDB_VERSION = 3;
-/** Open a database with the given name and version */
-export declare function openDB(name?: string, callbacks?: OpenDBCallbacks<Schema>): Promise<NostrIDBDatabase>;
-/** Delete a database with the given name and version */
-export declare function deleteDB(name?: string, callbacks?: DeleteDBCallbacks): Promise<void>;
-/** Clear all events and used from the database */
-export declare function clearDB(db: NostrIDBDatabase): Promise<void>;

package/dist/database/database.js

@@ -1,72 +0,0 @@
-import { deleteDB as idbDeleteDB, openDB as idbOpenDB, } from "idb";
-import { isAddressableKind, isReplaceableKind } from "nostr-tools/kinds";
-import { getEventUID } from "./common.js";
-export const NOSTR_IDB_NAME = "nostr-idb";
-export const NOSTR_IDB_VERSION = 3;
-/** Open a database with the given name and version */
-export async function openDB(name = NOSTR_IDB_NAME, callbacks) {
-    return await idbOpenDB(name, NOSTR_IDB_VERSION, {
-        ...callbacks,
-        async upgrade(db, oldVersion, newVersion, transaction, event) {
-            if (oldVersion === 0) {
-                const events = db.createObjectStore("events");
-                events.createIndex("id", "event.id", { unique: true });
-                events.createIndex("pubkey", "event.pubkey");
-                events.createIndex("kind", "event.kind");
-                events.createIndex("created_at", "event.created_at");
-                events.createIndex("tags", "tags", { multiEntry: true });
-                const used = db.createObjectStore("used", { keyPath: "uid" });
-                used.createIndex("date", "date");
-            }
-            // Migrate from v1 to v2
-            if (oldVersion === 1) {
-                db.deleteObjectStore("events");
-                db.deleteObjectStore("used");
-                // @ts-ignore
-                db.deleteObjectStore("seen");
-            }
-            // Migrate replaceable event UIDs for v3
-            if (oldVersion <= 2)
-                await migrateReplaceableEventUIDs(transaction);
-            if (callbacks?.upgrade)
-                callbacks.upgrade(db, oldVersion, newVersion, transaction, event);
-        },
-    });
-}
-/** Delete a database with the given name and version */
-export async function deleteDB(name = NOSTR_IDB_NAME, callbacks) {
-    return await idbDeleteDB(name, callbacks);
-}
-/** Clear all events and used from the database */
-export async function clearDB(db) {
-    await db.clear("events");
-    await db.clear("used");
-}
-/** Migrate replaceable event UIDs for v3 */
-async function migrateReplaceableEventUIDs(transaction) {
-    const objectStore = transaction.objectStore("events");
-    let cursor = await objectStore.openCursor();
-    const eventsToMigrate = [];
-    // First pass: collect all events that need migration
-    while (cursor) {
-        const oldKey = cursor.primaryKey;
-        const record = cursor.value;
-        const event = record.event;
-        // Check if this is a replaceable event that needs migration
-        if (isReplaceableKind(event.kind) || isAddressableKind(event.kind)) {
-            const newKey = getEventUID(event);
-            // Only migrate if the key format has actually changed
-            if (oldKey !== newKey) {
-                eventsToMigrate.push({ oldKey, newKey, value: record });
-            }
-        }
-        cursor = await cursor.continue();
-    }
-    // Second pass: perform the migration
-    for (const { oldKey, newKey, value } of eventsToMigrate) {
-        // Remove the old entry
-        await objectStore.delete(oldKey);
-        // Add it back with the new key
-        await objectStore.put(value, newKey);
-    }
-}

package/dist/database/delete.d.ts

@@ -1,61 +0,0 @@
-import type { Filter } from "nostr-tools/filter";
-import { IndexCache } from "../cache/index-cache.js";
-import type { NostrIDBDatabase } from "./schema.js";
-/**
- * Delete a single event by its ID or UID
- * @param db - The database instance
- * @param eventId - The event ID or UID to delete
- * @param indexCache - Optional index cache to update
- * @returns Promise<boolean> - True if event was deleted, false if not found
- */
-export declare function deleteEvent(db: NostrIDBDatabase, eventId: string, indexCache?: IndexCache): Promise<boolean>;
-/**
- * Delete a replaceable event by pubkey and kind
- * @param db - The database instance
- * @param pubkey - The pubkey of the event author
- * @param kind - The kind of the replaceable event
- * @param identifier - Optional identifier for parameterized replaceable events
- * @param indexCache - Optional index cache to update
- * @returns Promise<boolean> - True if event was deleted, false if not found
- */
-export declare function deleteReplaceable(db: NostrIDBDatabase, pubkey: string, kind: number, identifier?: string, indexCache?: IndexCache): Promise<boolean>;
-/**
- * Delete all replaceable events for a given pubkey and kind
- * @param db - The database instance
- * @param pubkey - The pubkey of the event author
- * @param kind - The kind of the replaceable events
- * @param indexCache - Optional index cache to update
- * @returns Promise<number> - Number of events deleted
- */
-export declare function deleteAllReplaceable(db: NostrIDBDatabase, pubkey: string, kind: number, indexCache?: IndexCache): Promise<number>;
-/**
- * Delete events matching the given filter
- * @param db - The database instance
- * @param filter - The filter to match events for deletion
- * @param indexCache - Optional index cache to update
- * @returns Promise<number> - Number of events deleted
- */
-export declare function deleteByFilter(db: NostrIDBDatabase, filter: Filter, indexCache?: IndexCache): Promise<number>;
-/**
- * Delete events matching the given filters
- * @param db - The database instance
- * @param filters - Array of filters to match events for deletion
- * @param indexCache - Optional index cache to update
- * @returns Promise<number> - Number of events deleted
- */
-export declare function deleteByFilters(db: NostrIDBDatabase, filters: Filter[], indexCache?: IndexCache): Promise<number>;
-/**
- * Delete events by their IDs
- * @param db - The database instance
- * @param eventIds - Array of event IDs to delete
- * @param indexCache - Optional index cache to update
- * @returns Promise<number> - Number of events deleted
- */
-export declare function deleteEventsByIds(db: NostrIDBDatabase, eventIds: string[], indexCache?: IndexCache): Promise<number>;
-/**
- * Delete all events from the database
- * @param db - The database instance
- * @param indexCache - Optional index cache to clear
- * @returns Promise<void>
- */
-export declare function deleteAllEvents(db: NostrIDBDatabase, indexCache?: IndexCache): Promise<void>;

package/dist/database/delete.js

@@ -1,154 +0,0 @@
-import { isAddressableKind, isReplaceableKind } from "nostr-tools/kinds";
-import { getIdsForFilter, getIdsForFilters } from "./query-filter.js";
-/**
- * Delete a single event by its ID or UID
- * @param db - The database instance
- * @param eventId - The event ID or UID to delete
- * @param indexCache - Optional index cache to update
- * @returns Promise<boolean> - True if event was deleted, false if not found
- */
-export async function deleteEvent(db, eventId, indexCache) {
-    const transaction = db.transaction("events", "readwrite");
-    const objectStore = transaction.objectStore("events");
-    // First check if the event exists
-    const existingEvent = await objectStore.get(eventId);
-    if (!existingEvent) {
-        await transaction.commit();
-        return false;
-    }
-    // Delete the event
-    await objectStore.delete(eventId);
-    await transaction.commit();
-    // Update index cache if provided
-    if (indexCache) {
-        const event = existingEvent.event;
-        indexCache.removeEvent(event);
-    }
-    return true;
-}
-/**
- * Delete a replaceable event by pubkey and kind
- * @param db - The database instance
- * @param pubkey - The pubkey of the event author
- * @param kind - The kind of the replaceable event
- * @param identifier - Optional identifier for parameterized replaceable events
- * @param indexCache - Optional index cache to update
- * @returns Promise<boolean> - True if event was deleted, false if not found
- */
-export async function deleteReplaceable(db, pubkey, kind, identifier, indexCache) {
-    if (!isReplaceableKind(kind) && !isAddressableKind(kind)) {
-        throw new Error(`Kind ${kind} is not replaceable`);
-    }
-    const uid = `${kind}:${pubkey}:${identifier ?? ""}`;
-    return await deleteEvent(db, uid, indexCache);
-}
-/**
- * Delete all replaceable events for a given pubkey and kind
- * @param db - The database instance
- * @param pubkey - The pubkey of the event author
- * @param kind - The kind of the replaceable events
- * @param indexCache - Optional index cache to update
- * @returns Promise<number> - Number of events deleted
- */
-export async function deleteAllReplaceable(db, pubkey, kind, indexCache) {
-    if (!isReplaceableKind(kind) && !isAddressableKind(kind)) {
-        throw new Error(`Kind ${kind} is not replaceable`);
-    }
-    const transaction = db.transaction("events", "readwrite");
-    const objectStore = transaction.objectStore("events");
-    // Get all events for this pubkey and kind
-    const pubkeyIndex = objectStore.index("pubkey");
-    const kindIndex = objectStore.index("kind");
-    const pubkeyEvents = await pubkeyIndex.getAllKeys(pubkey);
-    const kindEvents = await kindIndex.getAllKeys(kind);
-    // Find intersection of pubkey and kind events
-    const matchingEvents = pubkeyEvents.filter((id) => kindEvents.includes(id));
-    let deletedCount = 0;
-    const eventsToDelete = [];
-    // Collect events to delete and their data for cache update
-    for (const uid of matchingEvents) {
-        const eventData = await objectStore.get(uid);
-        if (eventData) {
-            eventsToDelete.push({ event: eventData.event, uid });
-            await objectStore.delete(uid);
-            deletedCount++;
-        }
-    }
-    await transaction.commit();
-    // Update index cache if provided
-    if (indexCache && eventsToDelete.length > 0) {
-        for (const { event } of eventsToDelete) {
-            indexCache.removeEvent(event);
-        }
-    }
-    return deletedCount;
-}
-/**
- * Delete events matching the given filter
- * @param db - The database instance
- * @param filter - The filter to match events for deletion
- * @param indexCache - Optional index cache to update
- * @returns Promise<number> - Number of events deleted
- */
-export async function deleteByFilter(db, filter, indexCache) {
-    const eventIds = await getIdsForFilter(db, filter, indexCache);
-    return await deleteEventsByIds(db, Array.from(eventIds), indexCache);
-}
-/**
- * Delete events matching the given filters
- * @param db - The database instance
- * @param filters - Array of filters to match events for deletion
- * @param indexCache - Optional index cache to update
- * @returns Promise<number> - Number of events deleted
- */
-export async function deleteByFilters(db, filters, indexCache) {
-    const eventIds = await getIdsForFilters(db, filters, indexCache);
-    return await deleteEventsByIds(db, Array.from(eventIds), indexCache);
-}
-/**
- * Delete events by their IDs
- * @param db - The database instance
- * @param eventIds - Array of event IDs to delete
- * @param indexCache - Optional index cache to update
- * @returns Promise<number> - Number of events deleted
- */
-export async function deleteEventsByIds(db, eventIds, indexCache) {
-    if (eventIds.length === 0)
-        return 0;
-    const transaction = db.transaction("events", "readwrite");
-    const objectStore = transaction.objectStore("events");
-    let deletedCount = 0;
-    const eventsToDelete = [];
-    // Collect events to delete and their data for cache update
-    for (const eventId of eventIds) {
-        const eventData = await objectStore.get(eventId);
-        if (eventData) {
-            eventsToDelete.push(eventData.event);
-            await objectStore.delete(eventId);
-            deletedCount++;
-        }
-    }
-    await transaction.commit();
-    // Update index cache if provided
-    if (indexCache && eventsToDelete.length > 0) {
-        for (const event of eventsToDelete) {
-            indexCache.removeEvent(event);
-        }
-    }
-    return deletedCount;
-}
-/**
- * Delete all events from the database
- * @param db - The database instance
- * @param indexCache - Optional index cache to clear
- * @returns Promise<void>
- */
-export async function deleteAllEvents(db, indexCache) {
-    const transaction = db.transaction("events", "readwrite");
-    await transaction.objectStore("events").clear();
-    await transaction.commit();
-    // Clear index cache if provided
-    if (indexCache) {
-        indexCache.clear();
-    }
-}

package/dist/database/index.d.ts

@@ -1,8 +0,0 @@
-export * from "./database.js";
-export * from "./query-filter.js";
-export * from "./query-misc.js";
-export * from "./insert.js";
-export * from "./prune.js";
-export * from "./schema.js";
-export * from "./common.js";
-export * from "./delete.js";

package/dist/database/index.js

@@ -1,8 +0,0 @@
-export * from "./database.js";
-export * from "./query-filter.js";
-export * from "./query-misc.js";
-export * from "./insert.js";
-export * from "./prune.js";
-export * from "./schema.js";
-export * from "./common.js";
-export * from "./delete.js";

package/dist/database/insert.d.ts

@@ -1,6 +0,0 @@
-import { type NostrEvent } from "nostr-tools/pure";
-import type { NostrIDBDatabase } from "./schema.js";
-/** Add events to the database */
-export declare function addEvents(db: NostrIDBDatabase, events: NostrEvent[]): Promise<void>;
-/** Update the last used timestamp of the given uids */
-export declare function updateUsed(db: NostrIDBDatabase, uids: Iterable<string>): Promise<void>;