applesauce-sqlite 0.0.0-next-20250915145415

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 hzrd149
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,115 @@
+# applesauce-sqlite
+
+A SQLite3 event database implementation for AppleSauce, providing persistent storage for Nostr events. This package extends the core `applesauce-core` functionality by replacing the default in-memory event database with a persistent SQLite database.
+
+## Key Features
+
+- **Persistent Storage**: Store Nostr events in a SQLite database that persists between application restarts
+- **Hybrid Architecture**: Combines in-memory caching with SQLite persistence for optimal performance
+- **Full Compatibility**: Drop-in replacement for the default in-memory event database
+- **Efficient Querying**: Optimized SQLite queries for filtering and retrieving Nostr events
+- **Built-in Relay**: Includes a complete Nostr relay implementation using the SQLite database
+
+## Installation
+
+```bash
+# For better-sqlite3
+npm install applesauce-sqlite better-sqlite3
+
+# For libsql
+npm install applesauce-sqlite @libsql/client
+
+# For bun / deno / native sqlite
+bun add applesauce-sqlite
+```
+
+## Basic Usage
+
+### Using an event database with EventStore
+
+```js
+import { EventStore } from "applesauce-core";
+import { BetterSqlite3EventDatabase } from "applesauce-sqlite/better-sqlite3";
+
+// Create a SQLite database (file-based or in-memory)
+const database = new BetterSqlite3EventDatabase("./events.db"); // or ":memory:" for in-memory
+
+// Create EventStore with SQLite backend
+const eventStore = new EventStore(database);
+
+// Use the event store as normal
+eventStore.add(someNostrEvent);
+
+// The events are now persisted to SQLite!
+```
+
+### With Models and Subscriptions
+
+```js
+import { EventStore } from "applesauce-core";
+import { ProfileModel, TimelineModel } from "applesauce-core/models";
+import { BetterSqlite3EventDatabase } from "applesauce-better-sqlite3";
+import { Relay } from "nostr-tools/relay";
+
+// Create persistent event store
+const database = new BetterSqlite3EventDatabase("./events.db");
+const eventStore = new EventStore(database);
+
+// Connect to a relay and store events
+const relay = await Relay.connect("wss://relay.example.com");
+const sub = relay.subscribe([{ kinds: [0, 1] }], {
+  onevent(event) {
+    eventStore.add(event); // Events are automatically persisted
+  },
+});
+
+// Use models as normal - they'll work with persisted data
+const profile = eventStore.model(ProfileModel, "npub...");
+profile.subscribe((parsed) => {
+  console.log("Profile loaded from database:", parsed);
+});
+
+// Timeline will include events from previous sessions
+const timeline = eventStore.model(TimelineModel, { kinds: [1] });
+timeline.subscribe((events) => {
+  console.log("Timeline with persisted events:", events.length);
+});
+```
+
+## Advanced Usage
+
+### Custom Relay Implementation
+
+```js
+import { EventStore } from "applesauce-core";
+import { BetterSqlite3EventDatabase } from "applesauce-better-sqlite3";
+import { WebSocketServer } from "ws";
+
+// Create your own relay with custom logic
+const database = new BetterSqlite3EventDatabase("./custom-relay.db");
+const eventStore = new EventStore(database);
+
+const wss = new WebSocketServer({ port: 8080 });
+
+wss.on("connection", (ws) => {
+  ws.on("message", (data) => {
+    const message = JSON.parse(data.toString());
+
+    if (message[0] === "EVENT") {
+      const event = message[1];
+      const added = eventStore.add(event);
+
+      if (added) {
+        ws.send(JSON.stringify(["OK", event.id, true, ""]));
+        // Broadcast to other clients...
+      } else {
+        ws.send(JSON.stringify(["OK", event.id, false, "rejected"]));
+      }
+    }
+  });
+});
+```
+
+## License
+
+MIT

package/dist/better-sqlite3/event-database.d.ts

@@ -0,0 +1,52 @@
+import { IEventDatabase } from "applesauce-core";
+import { Filter, NostrEvent } from "applesauce-core/helpers";
+import { type Database as TDatabase } from "better-sqlite3";
+import { SearchContentFormatter } from "../helpers/search.js";
+/** Options for the {@link BetterSqlite3EventDatabase} */
+export type BetterSqlite3EventDatabaseOptions = {
+    search?: boolean;
+    searchContentFormatter?: SearchContentFormatter;
+};
+export declare class BetterSqlite3EventDatabase implements IEventDatabase {
+    db: TDatabase;
+    /** If search is enabled */
+    private search;
+    /** The search content formatter */
+    private searchContentFormatter;
+    constructor(database?: string | TDatabase, options?: BetterSqlite3EventDatabaseOptions);
+    /** 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/better-sqlite3/event-database.js

@@ -0,0 +1,104 @@
+import { logger } from "applesauce-core";
+import { insertEventIntoDescendingList } from "applesauce-core/helpers";
+import Database from "better-sqlite3";
+import { createTables, deleteEvent, getEvent, getEventsByFilters, getReplaceable, getReplaceableHistory, hasEvent, hasReplaceable, insertEvent, rebuildSearchIndex, } from "../better-sqlite3/methods.js";
+import { enhancedSearchContentFormatter } from "../helpers/search.js";
+const log = logger.extend("BetterSqlite3EventDatabase");
+export class BetterSqlite3EventDatabase {
+    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 ?? false;
+        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();
+    }
+}

package/dist/better-sqlite3/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./event-database.js";
+export * from "./methods.js";

package/dist/better-sqlite3/index.js

@@ -0,0 +1,2 @@
+export * from "./event-database.js";
+export * from "./methods.js";

package/dist/better-sqlite3/methods.d.ts

@@ -0,0 +1,31 @@
+import { Filter, NostrEvent } from "applesauce-core/helpers";
+import { Database } from "better-sqlite3";
+import { FilterWithSearch, SearchContentFormatter } from "../helpers/search.js";
+/** 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;
+/** 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/better-sqlite3/methods.js

@@ -0,0 +1,149 @@
+import { getIndexableTags, getReplaceableIdentifier } from "applesauce-core/helpers";
+import { CREATE_SEARCH_TABLE_STATEMENT, DELETE_SEARCH_CONTENT_STATEMENT, INSERT_SEARCH_CONTENT_STATEMENT, } from "../helpers/search.js";
+import { buildFiltersQuery, rowToEvent } from "../helpers/sql.js";
+import { CREATE_EVENT_TAGS_TABLE_STATEMENT, CREATE_EVENTS_TABLE_STATEMENT, CREATE_INDEXES_STATEMENTS, DELETE_EVENT_STATEMENT, DELETE_EVENT_TAGS_STATEMENT, GET_ALL_EVENTS_STATEMENT, GET_EVENT_STATEMENT, GET_REPLACEABLE_HISTORY_STATEMENT, GET_REPLACEABLE_STATEMENT, HAS_EVENT_STATEMENT, HAS_REPLACEABLE_STATEMENT, INSERT_EVENT_STATEMENT, INSERT_EVENT_TAG_STATEMENT, } from "../helpers/statements.js";
+/** Create and migrate the `events`, `event_tags`, and search tables */
+export function createTables(db, search = true) {
+    // Create the events table
+    db.exec(CREATE_EVENTS_TABLE_STATEMENT.sql);
+    // Create the event_tags table
+    db.exec(CREATE_EVENT_TAGS_TABLE_STATEMENT.sql);
+    // Create the FTS5 search table
+    if (search) {
+        db.exec(CREATE_SEARCH_TABLE_STATEMENT.sql);
+    }
+    // Create indexes
+    CREATE_INDEXES_STATEMENTS.forEach((indexStatement) => {
+        db.exec(indexStatement.sql);
+    });
+}
+/** 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_SEARCH_CONTENT_STATEMENT.sql);
+    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_SEARCH_CONTENT_STATEMENT.sql);
+    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_EVENT_STATEMENT.sql);
+        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_EVENT_TAGS_STATEMENT.sql);
+    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_EVENT_TAG_STATEMENT.sql);
+        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_EVENT_TAGS_STATEMENT.sql);
+        deleteTagsStmt.run(id);
+        // Delete from search tables
+        deleteSearchContent(db, id);
+        // Delete from events table
+        const deleteEventStmt = db.prepare(DELETE_EVENT_STATEMENT.sql);
+        const result = deleteEventStmt.run(id);
+        return result.changes > 0;
+    })();
+}
+/** Checks if an event exists */
+export function hasEvent(db, id) {
+    const stmt = db.prepare(HAS_EVENT_STATEMENT.sql);
+    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(GET_EVENT_STATEMENT.sql);
+    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(GET_REPLACEABLE_STATEMENT.sql);
+    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(GET_REPLACEABLE_HISTORY_STATEMENT.sql);
+    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(HAS_REPLACEABLE_STATEMENT.sql);
+    const result = stmt.get(kind, pubkey, identifier);
+    if (!result)
+        return false;
+    return result.count > 0;
+}
+/** 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(GET_ALL_EVENTS_STATEMENT.sql);
+        const events = stmt.all().map(rowToEvent);
+        for (const event of events) {
+            insertSearchContent(db, event, contentFormatter);
+        }
+    })();
+}

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

@@ -0,0 +1,52 @@
+import { IEventDatabase } from "applesauce-core";
+import { Filter, NostrEvent } from "applesauce-core/helpers";
+import { Database } from "bun:sqlite";
+import { SearchContentFormatter } from "../helpers/search.js";
+/** Options for the {@link BunSqliteEventDatabase} */
+export type BunSqliteEventDatabaseOptions = {
+    search?: boolean;
+    searchContentFormatter?: SearchContentFormatter;
+};
+export declare class BunSqliteEventDatabase implements IEventDatabase {
+    db: Database;
+    /** If search is enabled */
+    private search;
+    /** The search content formatter */
+    private searchContentFormatter;
+    constructor(database?: string | Database, options?: BunSqliteEventDatabaseOptions);
+    /** 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/bun/event-database.js

@@ -0,0 +1,105 @@
+import { logger } from "applesauce-core";
+import { insertEventIntoDescendingList } from "applesauce-core/helpers";
+// @ts-ignore - bun:sqlite is a built-in module in Bun
+import { Database } from "bun:sqlite";
+import { createTables, deleteEvent, getEvent, getEventsByFilters, getReplaceable, getReplaceableHistory, hasEvent, hasReplaceable, insertEvent, rebuildSearchIndex, } from "./methods.js";
+import { enhancedSearchContentFormatter } from "../helpers/search.js";
+const log = logger.extend("BunSqliteEventDatabase");
+export class BunSqliteEventDatabase {
+    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 ?? false;
+        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();
+    }
+}

package/dist/bun/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./event-database.js";
+export * from "./methods.js";

package/dist/bun/index.js

@@ -0,0 +1,2 @@
+export * from "./event-database.js";
+export * from "./methods.js";