applesauce-sqlite 0.0.0-next-20250918142212 → 0.0.0-next-20250923113611

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-sqlite",
-  "version": "0.0.0-next-20250918142212",
+  "version": "0.0.0-next-20250923113611",
   "description": "sqlite event databases for applesauce",
   "type": "module",
   "main": "dist/index.js",
@@ -82,17 +82,18 @@
     }
   },
   "dependencies": {
-    "applesauce-core": "0.0.0-next-20250918142212"
+    "applesauce-core": "0.0.0-next-20250923113611"
   },
   "optionalDependencies": {
-    "better-sqlite3": "^12.2.0",
-    "@libsql/client": "^0.15.15"
+    "@libsql/client": "^0.15.15",
+    "better-sqlite3": "^12.2.0"
   },
   "devDependencies": {
     "@hirez_io/observer-spy": "^2.2.0",
     "@types/better-sqlite3": "^7.6.13",
     "@types/ws": "^8.5.13",
-    "applesauce-signers": "0.0.0-next-20250918142212",
+    "applesauce-signers": "0.0.0-next-20250923113611",
+    "rimraf": "^6.0.1",
     "typescript": "^5.7.3",
     "vitest": "^3.2.4",
     "vitest-websocket-mock": "^0.5.0",
@@ -103,6 +104,7 @@
     "url": "lightning:nostrudel@geyser.fund"
   },
   "scripts": {
+    "prebuild": "rimraf dist",
     "build": "tsc",
     "watch:build": "tsc --watch > /dev/null",
     "test": "vitest run --passWithNoTests",

package/dist/helpers/sqlite.d.ts

@@ -1,66 +0,0 @@
-import { Filter, NostrEvent } from "applesauce-core/helpers";
-import { Database } from "better-sqlite3";
-export declare const CREATE_EVENTS_TABLE = "\nCREATE TABLE IF NOT EXISTS events (\n  id TEXT PRIMARY KEY,\n  kind INTEGER NOT NULL,\n  pubkey TEXT NOT NULL,\n  created_at INTEGER NOT NULL,\n  content TEXT NOT NULL,\n  tags TEXT,\n  sig TEXT NOT NULL,\n  identifier TEXT NOT NULL DEFAULT ''\n);\n";
-export declare const CREATE_EVENT_TAGS_TABLE = "\nCREATE TABLE IF NOT EXISTS event_tags (\n  event_id TEXT NOT NULL,\n  tag_name TEXT NOT NULL,\n  tag_value TEXT NOT NULL,\n  FOREIGN KEY (event_id) REFERENCES events(id) ON DELETE CASCADE,\n  PRIMARY KEY (event_id, tag_name, tag_value)\n);\n";
-export declare const CREATE_SEARCH_TABLE = "\nCREATE VIRTUAL TABLE IF NOT EXISTS events_search USING fts5(\n  event_id UNINDEXED,\n  content,\n  kind UNINDEXED,\n  pubkey UNINDEXED,\n  created_at UNINDEXED\n);\n";
-export declare const CREATE_INDEXES: string[];
-export type EventRow = {
-    id: string;
-    kind: number;
-    pubkey: string;
-    created_at: number;
-    content: string;
-    tags: string;
-    sig: string;
-};
-/** Filter with search field */
-export type FilterWithSearch = Filter & {
-    search?: string;
-    order?: "created_at" | "rank";
-};
-/** Content formatter function type for search indexing */
-export type SearchContentFormatter = (event: NostrEvent) => string;
-/** Default search content formatter - returns the raw content */
-export declare const defaultSearchContentFormatter: SearchContentFormatter;
-/** Enhanced search content formatter that includes tags and special handling for kind 0 events */
-export declare const enhancedSearchContentFormatter: SearchContentFormatter;
-/** Create and migrate the `events`, `event_tags`, and search tables */
-export declare function createTables(db: Database, search?: boolean): void;
-/** Inserts search content for an event */
-export declare function insertSearchContent(db: Database, event: NostrEvent, contentFormatter: SearchContentFormatter): void;
-/** Removes search content for an event */
-export declare function deleteSearchContent(db: Database, eventId: string): void;
-/** Inserts an event into the `events`, `event_tags`, and search tables of a database */
-export declare function insertEvent(db: Database, event: NostrEvent, contentFormatter?: SearchContentFormatter): boolean;
-/** Insert indexable tags for an event into the event_tags table */
-export declare function insertEventTags(db: Database, event: NostrEvent): void;
-/** Removes an event by id from the `events`, `event_tags`, and search tables of a database */
-export declare function deleteEvent(db: Database, id: string): boolean;
-/** Checks if an event exists */
-export declare function hasEvent(db: Database, id: string): boolean;
-/** Gets a single event from a database */
-export declare function getEvent(db: Database, id: string): NostrEvent | undefined;
-/** Gets the latest replaceable event from a database */
-export declare function getReplaceable(db: Database, kind: number, pubkey: string, identifier: string): NostrEvent | undefined;
-/** Gets the history of a replaceable event from a database */
-export declare function getReplaceableHistory(db: Database, kind: number, pubkey: string, identifier: string): NostrEvent[];
-/** Checks if a replaceable event exists in a database */
-export declare function hasReplaceable(db: Database, kind: number, pubkey: string, identifier?: string): boolean;
-/** Convert database row to NostrEvent */
-export declare function rowToEvent(row: EventRow): NostrEvent;
-/** Builds conditions for a single filter */
-export declare function buildFilterConditions(filter: FilterWithSearch): {
-    conditions: string[];
-    params: any[];
-    search: boolean;
-};
-export declare function buildFiltersQuery(filters: FilterWithSearch | FilterWithSearch[]): {
-    sql: string;
-    params: any[];
-} | null;
-/** Get all events that match the filters (includes NIP-50 search support) */
-export declare function getEventsByFilters(db: Database, filters: FilterWithSearch | FilterWithSearch[]): Set<NostrEvent>;
-/** Search events using FTS5 full-text search (convenience wrapper around getEventsByFilters) */
-export declare function searchEvents(db: Database, search: string, options?: Filter): NostrEvent[];
-/** Rebuild the FTS5 search index for all events */
-export declare function rebuildSearchIndex(db: Database, contentFormatter: SearchContentFormatter): void;

package/dist/helpers/sqlite.js

@@ -1,367 +0,0 @@
-import { logger } from "applesauce-core";
-import { getIndexableTags, getReplaceableIdentifier } from "applesauce-core/helpers";
-const log = logger.extend("sqlite:tables");
-// SQL schema for Nostr events
-export const CREATE_EVENTS_TABLE = `
-CREATE TABLE IF NOT EXISTS events (
-  id TEXT PRIMARY KEY,
-  kind INTEGER NOT NULL,
-  pubkey TEXT NOT NULL,
-  created_at INTEGER NOT NULL,
-  content TEXT NOT NULL,
-  tags TEXT,
-  sig TEXT NOT NULL,
-  identifier TEXT NOT NULL DEFAULT ''
-);
-`;
-// SQL schema for event tags (for efficient tag filtering)
-export const CREATE_EVENT_TAGS_TABLE = `
-CREATE TABLE IF NOT EXISTS event_tags (
-  event_id TEXT NOT NULL,
-  tag_name TEXT NOT NULL,
-  tag_value TEXT NOT NULL,
-  FOREIGN KEY (event_id) REFERENCES events(id) ON DELETE CASCADE,
-  PRIMARY KEY (event_id, tag_name, tag_value)
-);
-`;
-// SQL schema for FTS5 search table - stores formatted searchable content directly
-export const CREATE_SEARCH_TABLE = `
-CREATE VIRTUAL TABLE IF NOT EXISTS events_search USING fts5(
-  event_id UNINDEXED,
-  content,
-  kind UNINDEXED,
-  pubkey UNINDEXED,
-  created_at UNINDEXED
-);
-`;
-export const CREATE_INDEXES = [
-    // Events table indexes
-    `CREATE INDEX IF NOT EXISTS kind_idx ON events(kind);`,
-    `CREATE INDEX IF NOT EXISTS pubkey_idx ON events(pubkey);`,
-    `CREATE INDEX IF NOT EXISTS created_at_idx ON events(created_at);`,
-    `CREATE INDEX IF NOT EXISTS identifier_idx ON events(identifier);`,
-    // Event tags table indexes for efficient tag filtering
-    `CREATE INDEX IF NOT EXISTS event_tags_event_id_idx ON event_tags(event_id);`,
-    `CREATE INDEX IF NOT EXISTS event_tags_name_value_idx ON event_tags(tag_name, tag_value);`,
-];
-/** Default search content formatter - returns the raw content */
-export const defaultSearchContentFormatter = (event) => {
-    return event.content;
-};
-/** Enhanced search content formatter that includes tags and special handling for kind 0 events */
-export const enhancedSearchContentFormatter = (event) => {
-    let searchableContent = event.content;
-    // Special handling for kind 0 (profile metadata) events
-    if (event.kind === 0) {
-        try {
-            const profile = JSON.parse(event.content);
-            const profileFields = [];
-            // Include common profile fields in search
-            if (profile.name)
-                profileFields.push(profile.name);
-            if (profile.display_name)
-                profileFields.push(profile.display_name);
-            if (profile.about)
-                profileFields.push(profile.about);
-            if (profile.nip05)
-                profileFields.push(profile.nip05);
-            if (profile.lud16)
-                profileFields.push(profile.lud16);
-            searchableContent = profileFields.join(" ");
-        }
-        catch (e) {
-            // If JSON parsing fails, use the raw content
-            searchableContent = event.content;
-        }
-    }
-    // Include relevant tags in the searchable content
-    const relevantTags = ["t", "subject", "title", "summary", "d"]; // hashtags, subject, title, summary, identifier
-    const tagContent = [];
-    for (const tag of event.tags) {
-        if (tag.length >= 2 && relevantTags.includes(tag[0])) {
-            tagContent.push(tag[1]);
-        }
-    }
-    // Combine content with tag content
-    if (tagContent.length > 0) {
-        searchableContent += " " + tagContent.join(" ");
-    }
-    return searchableContent;
-};
-/** Create and migrate the `events`, `event_tags`, and search tables */
-export function createTables(db, search = true) {
-    // Create the events table
-    log("Creating events table");
-    db.exec(CREATE_EVENTS_TABLE);
-    // Create the event_tags table
-    log("Creating event_tags table");
-    db.exec(CREATE_EVENT_TAGS_TABLE);
-    // Create the FTS5 search table
-    if (search) {
-        log("Creating events_search FTS5 table");
-        db.exec(CREATE_SEARCH_TABLE);
-    }
-    // Create indexes
-    log("Creating indexes");
-    CREATE_INDEXES.forEach((indexSql) => {
-        db.exec(indexSql);
-    });
-}
-/** Inserts search content for an event */
-export function insertSearchContent(db, event, contentFormatter) {
-    const searchableContent = contentFormatter(event);
-    // Insert/update directly into the FTS5 table
-    const stmt = db.prepare(`
-    INSERT OR REPLACE INTO events_search (event_id, content, kind, pubkey, created_at)
-    VALUES (?, ?, ?, ?, ?)
-  `);
-    stmt.run(event.id, searchableContent, event.kind, event.pubkey, event.created_at);
-}
-/** Removes search content for an event */
-export function deleteSearchContent(db, eventId) {
-    const stmt = db.prepare(`DELETE FROM events_search WHERE event_id = ?`);
-    stmt.run(eventId);
-}
-/** Inserts an event into the `events`, `event_tags`, and search tables of a database */
-export function insertEvent(db, event, contentFormatter) {
-    const identifier = getReplaceableIdentifier(event);
-    return db.transaction(() => {
-        // Insert/update the main event
-        const stmt = db.prepare(`
-      INSERT OR REPLACE INTO events (id, kind, pubkey, created_at, content, tags, sig, identifier)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-    `);
-        const result = stmt.run(event.id, event.kind, event.pubkey, event.created_at, event.content, JSON.stringify(event.tags), event.sig, identifier);
-        // Insert indexable tags into the event_tags table
-        insertEventTags(db, event);
-        // Insert searchable content into the search tables
-        if (contentFormatter)
-            insertSearchContent(db, event, contentFormatter);
-        return result.changes > 0;
-    })();
-}
-/** Insert indexable tags for an event into the event_tags table */
-export function insertEventTags(db, event) {
-    // Clear existing tags for this event first
-    const deleteStmt = db.prepare(`DELETE FROM event_tags WHERE event_id = ?`);
-    deleteStmt.run(event.id);
-    // Get only the indexable tags using applesauce-core helper
-    const indexableTags = getIndexableTags(event);
-    if (indexableTags && indexableTags.size > 0) {
-        const insertStmt = db.prepare(`INSERT OR IGNORE INTO event_tags (event_id, tag_name, tag_value) VALUES (?, ?, ?)`);
-        for (const tagString of indexableTags) {
-            // Parse the "tagName:tagValue" format
-            const [name, value] = tagString.split(":");
-            if (name && value)
-                insertStmt.run(event.id, name, value);
-        }
-    }
-}
-/** Removes an event by id from the `events`, `event_tags`, and search tables of a database */
-export function deleteEvent(db, id) {
-    return db.transaction(() => {
-        // Delete from event_tags first (foreign key constraint)
-        const deleteTagsStmt = db.prepare(`DELETE FROM event_tags WHERE event_id = ?`);
-        deleteTagsStmt.run(id);
-        // Delete from search tables
-        deleteSearchContent(db, id);
-        // Delete from events table
-        const deleteEventStmt = db.prepare(`DELETE FROM events WHERE id = ?`);
-        const result = deleteEventStmt.run(id);
-        return result.changes > 0;
-    })();
-}
-/** Checks if an event exists */
-export function hasEvent(db, id) {
-    const stmt = db.prepare(`SELECT COUNT(*) as count FROM events WHERE id = ?`);
-    const result = stmt.get(id);
-    if (!result)
-        return false;
-    return result.count > 0;
-}
-/** Gets a single event from a database */
-export function getEvent(db, id) {
-    const stmt = db.prepare(`SELECT * FROM events WHERE id = ?`);
-    const row = stmt.get(id);
-    return row && rowToEvent(row);
-}
-/** Gets the latest replaceable event from a database */
-export function getReplaceable(db, kind, pubkey, identifier) {
-    const stmt = db.prepare(`SELECT * FROM events WHERE kind = ? AND pubkey = ? AND identifier = ? ORDER BY created_at DESC LIMIT 1`);
-    const row = stmt.get(kind, pubkey, identifier);
-    return row && rowToEvent(row);
-}
-/** Gets the history of a replaceable event from a database */
-export function getReplaceableHistory(db, kind, pubkey, identifier) {
-    const stmt = db.prepare(`SELECT * FROM events WHERE kind = ? AND pubkey = ? AND identifier = ? ORDER BY created_at DESC`);
-    return stmt.all(kind, pubkey, identifier).map(rowToEvent);
-}
-/** Checks if a replaceable event exists in a database */
-export function hasReplaceable(db, kind, pubkey, identifier = "") {
-    const stmt = db.prepare(`SELECT COUNT(*) as count FROM events WHERE kind = ? AND pubkey = ? AND identifier = ?`);
-    const result = stmt.get(kind, pubkey, identifier);
-    if (!result)
-        return false;
-    return result.count > 0;
-}
-/** Convert database row to NostrEvent */
-export function rowToEvent(row) {
-    return {
-        id: row.id,
-        kind: row.kind,
-        pubkey: row.pubkey,
-        created_at: row.created_at,
-        content: row.content,
-        tags: JSON.parse(row.tags || "[]"),
-        sig: row.sig,
-    };
-}
-/** Builds conditions for a single filter */
-export function buildFilterConditions(filter) {
-    const conditions = [];
-    const params = [];
-    let search = false;
-    // Handle NIP-50 search filter
-    if (filter.search && filter.search.trim()) {
-        conditions.push(`events_search MATCH ?`);
-        params.push(filter.search.trim());
-        search = true;
-    }
-    // Handle IDs filter
-    if (filter.ids && filter.ids.length > 0) {
-        const placeholders = filter.ids.map(() => `?`).join(", ");
-        conditions.push(`events.id IN (${placeholders})`);
-        params.push(...filter.ids);
-    }
-    // Handle kinds filter
-    if (filter.kinds && filter.kinds.length > 0) {
-        const placeholders = filter.kinds.map(() => `?`).join(", ");
-        conditions.push(`events.kind IN (${placeholders})`);
-        params.push(...filter.kinds);
-    }
-    // Handle authors filter (pubkeys)
-    if (filter.authors && filter.authors.length > 0) {
-        const placeholders = filter.authors.map(() => `?`).join(", ");
-        conditions.push(`events.pubkey IN (${placeholders})`);
-        params.push(...filter.authors);
-    }
-    // Handle since filter (timestamp >= since)
-    if (filter.since !== undefined) {
-        conditions.push(`events.created_at >= ?`);
-        params.push(filter.since);
-    }
-    // Handle until filter (timestamp <= until)
-    if (filter.until !== undefined) {
-        conditions.push(`events.created_at <= ?`);
-        params.push(filter.until);
-    }
-    // Handle tag filters (e.g., #e, #p, #t, #d, etc.)
-    for (const [key, values] of Object.entries(filter)) {
-        if (key.startsWith("#") && values && Array.isArray(values) && values.length > 0) {
-            const tagName = key.slice(1); // Remove the '#' prefix
-            // Use the event_tags table for efficient tag filtering
-            const placeholders = values.map(() => "?").join(", ");
-            conditions.push(`events.id IN (
-        SELECT DISTINCT event_id
-        FROM event_tags
-        WHERE tag_name = ? AND tag_value IN (${placeholders})
-      )`);
-            // Add parameters: tagName first, then all the tag values
-            params.push(tagName, ...values);
-        }
-    }
-    return { conditions, params, search };
-}
-export function buildFiltersQuery(filters) {
-    const filterArray = Array.isArray(filters) ? filters : [filters];
-    if (filterArray.length === 0)
-        return null;
-    // Build queries for each filter (OR logic between filters)
-    const filterQueries = [];
-    const allParams = [];
-    let globalLimit;
-    // Build the final query with proper ordering and limit
-    let fromClause = "events";
-    let orderBy = "events.created_at DESC, events.id ASC";
-    for (const filter of filterArray) {
-        const { conditions, params, search } = buildFilterConditions(filter);
-        if (search) {
-            // Override the from clause to join the events_search table
-            fromClause = "events INNER JOIN events_search ON events.id = events_search.event_id";
-            // Set the order by clause based on the filter order
-            switch (filter.order) {
-                case "created_at":
-                    orderBy = "events.created_at DESC, events.id ASC";
-                    break;
-                case "rank":
-                    orderBy = "events_search.rank, events.created_at DESC";
-                    break;
-            }
-        }
-        if (conditions.length === 0) {
-            // If no conditions, this filter matches all events
-            filterQueries.push("1=1");
-        }
-        else {
-            // AND logic within a single filter
-            filterQueries.push(`(${conditions.join(" AND ")})`);
-        }
-        allParams.push(...params);
-        // Track the most restrictive limit across all filters
-        if (filter.limit !== undefined) {
-            globalLimit = globalLimit === undefined ? filter.limit : Math.min(globalLimit, filter.limit);
-        }
-    }
-    // Combine all filter conditions with OR logic
-    const whereClause = filterQueries.length > 0 ? `WHERE ${filterQueries.join(" OR ")}` : "";
-    let query = `
-      SELECT DISTINCT events.* FROM ${fromClause}
-      ${whereClause}
-      ORDER BY ${orderBy}
-    `;
-    // Apply global limit if specified
-    if (globalLimit !== undefined && globalLimit > 0) {
-        query += ` LIMIT ?`;
-        allParams.push(globalLimit);
-    }
-    return { sql: query, params: allParams };
-}
-/** Get all events that match the filters (includes NIP-50 search support) */
-export function getEventsByFilters(db, filters) {
-    const query = buildFiltersQuery(filters);
-    if (!query)
-        return new Set();
-    const eventSet = new Set();
-    const stmt = db.prepare(query.sql);
-    const rows = stmt.all(...query.params);
-    // Convert rows to events and add to set
-    for (const row of rows)
-        eventSet.add(rowToEvent(row));
-    return eventSet;
-}
-/** Search events using FTS5 full-text search (convenience wrapper around getEventsByFilters) */
-export function searchEvents(db, search, options) {
-    if (!search.trim())
-        return [];
-    // Build filter with search and other options
-    const filter = {
-        search: search.trim(),
-        ...options,
-    };
-    // Use the main filter system which now supports search
-    const results = getEventsByFilters(db, filter);
-    return Array.from(results);
-}
-/** Rebuild the FTS5 search index for all events */
-export function rebuildSearchIndex(db, contentFormatter) {
-    db.transaction(() => {
-        // Clear existing search data
-        db.exec(`DELETE FROM events_search;`);
-        // Rebuild from all events
-        const stmt = db.prepare(`SELECT * FROM events`);
-        const events = stmt.all().map(rowToEvent);
-        for (const event of events) {
-            insertSearchContent(db, event, contentFormatter);
-        }
-    })();
-}

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

@@ -1,53 +0,0 @@
-import { IEventDatabase } from "applesauce-core";
-import { Filter, NostrEvent } from "applesauce-core/helpers";
-import { type Database as TDatabase } from "better-sqlite3";
-import { defaultSearchContentFormatter, enhancedSearchContentFormatter, type SearchContentFormatter } from "./helpers/sqlite.js";
-export { defaultSearchContentFormatter, enhancedSearchContentFormatter, type SearchContentFormatter };
-/** Options for the SqliteEventDatabase */
-export type SqliteEventDatabaseOptions = {
-    search?: boolean;
-    searchContentFormatter?: SearchContentFormatter;
-};
-export declare class SqliteEventDatabase implements IEventDatabase {
-    db: TDatabase;
-    /** If search is enabled */
-    private search;
-    /** The search content formatter */
-    private searchContentFormatter;
-    constructor(database?: string | TDatabase, options?: SqliteEventDatabaseOptions);
-    /** Store a Nostr event in the database */
-    add(event: NostrEvent): NostrEvent;
-    /** Delete an event by ID */
-    remove(id: string): boolean;
-    /** Checks if an event exists */
-    hasEvent(id: string): boolean;
-    /** Get an event by its ID */
-    getEvent(id: string): NostrEvent | undefined;
-    /** Get the latest replaceable event For replaceable events (10000-19999), returns the most recent event */
-    getReplaceable(kind: number, pubkey: string, identifier?: string): NostrEvent | undefined;
-    /** Checks if a replaceable event exists */
-    hasReplaceable(kind: number, pubkey: string, identifier?: string): boolean;
-    /** Returns all the versions of a replaceable event */
-    getReplaceableHistory(kind: number, pubkey: string, identifier?: string): NostrEvent[];
-    /** Get all events that match the filters (supports NIP-50 search field) */
-    getByFilters(filters: (Filter & {
-        search?: string;
-    }) | (Filter & {
-        search?: string;
-    })[]): Set<NostrEvent>;
-    /** Get a timeline of events that match the filters (returns array in chronological order, supports NIP-50 search) */
-    getTimeline(filters: (Filter & {
-        search?: string;
-    }) | (Filter & {
-        search?: string;
-    })[]): NostrEvent[];
-    /** Set the search content formatter */
-    setSearchContentFormatter(formatter: SearchContentFormatter): void;
-    /** Get the current search content formatter */
-    getSearchContentFormatter(): SearchContentFormatter;
-    /** Rebuild the search index for all events */
-    rebuildSearchIndex(): void;
-    /** Close the database connection */
-    close(): void;
-    [Symbol.dispose](): void;
-}

package/dist/sqlite-event-database.js

@@ -1,105 +0,0 @@
-import { logger } from "applesauce-core";
-import { insertEventIntoDescendingList } from "applesauce-core/helpers";
-import Database from "better-sqlite3";
-import { createTables, defaultSearchContentFormatter, deleteEvent, enhancedSearchContentFormatter, getEvent, getEventsByFilters, getReplaceable, getReplaceableHistory, hasEvent, hasReplaceable, insertEvent, rebuildSearchIndex, } from "./helpers/sqlite.js";
-const log = logger.extend("SqliteEventDatabase");
-// Export the search content formatters and types for external use
-export { defaultSearchContentFormatter, enhancedSearchContentFormatter };
-export class SqliteEventDatabase {
-    db;
-    /** If search is enabled */
-    search;
-    /** The search content formatter */
-    searchContentFormatter;
-    constructor(database = ":memory:", options) {
-        this.db = typeof database === "string" ? new Database(database) : database;
-        this.search = options?.search ?? true;
-        this.searchContentFormatter = options?.searchContentFormatter ?? enhancedSearchContentFormatter;
-        // Setup the database tables and indexes
-        createTables(this.db, this.search);
-    }
-    /** Store a Nostr event in the database */
-    add(event) {
-        try {
-            insertEvent(this.db, event, this.search ? this.searchContentFormatter : undefined);
-            return event;
-        }
-        catch (error) {
-            log("Error inserting event:", error);
-            throw error;
-        }
-    }
-    /** Delete an event by ID */
-    remove(id) {
-        try {
-            // Remove event from database
-            return deleteEvent(this.db, id);
-        }
-        catch (error) {
-            return false;
-        }
-    }
-    /** Checks if an event exists */
-    hasEvent(id) {
-        return hasEvent(this.db, id);
-    }
-    /** Get an event by its ID */
-    getEvent(id) {
-        return getEvent(this.db, id);
-    }
-    /** Get the latest replaceable event For replaceable events (10000-19999), returns the most recent event */
-    getReplaceable(kind, pubkey, identifier = "") {
-        return getReplaceable(this.db, kind, pubkey, identifier);
-    }
-    /** Checks if a replaceable event exists */
-    hasReplaceable(kind, pubkey, identifier = "") {
-        return hasReplaceable(this.db, kind, pubkey, identifier);
-    }
-    /** Returns all the versions of a replaceable event */
-    getReplaceableHistory(kind, pubkey, identifier = "") {
-        return getReplaceableHistory(this.db, kind, pubkey, identifier);
-    }
-    /** Get all events that match the filters (supports NIP-50 search field) */
-    getByFilters(filters) {
-        try {
-            // If search is disabled, remove the search field from the filters
-            if (!this.search && (Array.isArray(filters) ? filters.some((f) => "search" in f) : "search" in filters))
-                throw new Error("Search is disabled");
-            return getEventsByFilters(this.db, filters);
-        }
-        catch (error) {
-            return new Set();
-        }
-    }
-    /** Get a timeline of events that match the filters (returns array in chronological order, supports NIP-50 search) */
-    getTimeline(filters) {
-        const events = this.getByFilters(filters);
-        const timeline = [];
-        for (const event of events)
-            insertEventIntoDescendingList(timeline, event);
-        return timeline;
-    }
-    /** Set the search content formatter */
-    setSearchContentFormatter(formatter) {
-        this.searchContentFormatter = formatter;
-    }
-    /** Get the current search content formatter */
-    getSearchContentFormatter() {
-        return this.searchContentFormatter;
-    }
-    /** Rebuild the search index for all events */
-    rebuildSearchIndex() {
-        if (!this.search)
-            throw new Error("Search is disabled");
-        rebuildSearchIndex(this.db, this.searchContentFormatter);
-        log("Search index rebuilt successfully");
-    }
-    /** Close the database connection */
-    close() {
-        log("Closing database connection");
-        this.db.close();
-    }
-    [Symbol.dispose]() {
-        this.close();
-    }
-}