applesauce-sqlite 0.0.0-next-20250915145415

package/dist/libsql/methods.d.ts

@@ -0,0 +1,31 @@
+import { Filter, NostrEvent } from "applesauce-core/helpers";
+import { Client, Transaction } from "@libsql/client";
+import { FilterWithSearch, SearchContentFormatter } from "../helpers/search.js";
+/** Create and migrate the `events`, `event_tags`, and search tables */
+export declare function createTables(db: Client, search?: boolean): Promise<void>;
+/** Inserts search content for an event */
+export declare function insertSearchContent(db: Client | Transaction, event: NostrEvent, contentFormatter: SearchContentFormatter): Promise<void>;
+/** Removes search content for an event */
+export declare function deleteSearchContent(db: Client | Transaction, eventId: string): Promise<void>;
+/** Inserts an event into the `events`, `event_tags`, and search tables of a database */
+export declare function insertEvent(db: Client, event: NostrEvent, contentFormatter?: SearchContentFormatter): Promise<boolean>;
+/** Insert indexable tags for an event into the event_tags table */
+export declare function insertEventTags(db: Client | Transaction, event: NostrEvent): Promise<void>;
+/** Removes an event by id from the `events`, `event_tags`, and search tables of a database */
+export declare function deleteEvent(db: Client, id: string): Promise<boolean>;
+/** Checks if an event exists */
+export declare function hasEvent(db: Client, id: string): Promise<boolean>;
+/** Gets a single event from a database */
+export declare function getEvent(db: Client, id: string): Promise<NostrEvent | undefined>;
+/** Gets the latest replaceable event from a database */
+export declare function getReplaceable(db: Client, kind: number, pubkey: string, identifier: string): Promise<NostrEvent | undefined>;
+/** Gets the history of a replaceable event from a database */
+export declare function getReplaceableHistory(db: Client, kind: number, pubkey: string, identifier: string): Promise<NostrEvent[]>;
+/** Checks if a replaceable event exists in a database */
+export declare function hasReplaceable(db: Client, kind: number, pubkey: string, identifier?: string): Promise<boolean>;
+/** Get all events that match the filters (includes NIP-50 search support) */
+export declare function getEventsByFilters(db: Client, filters: FilterWithSearch | FilterWithSearch[]): Promise<Set<NostrEvent>>;
+/** Search events using FTS5 full-text search (convenience wrapper around getEventsByFilters) */
+export declare function searchEvents(db: Client, search: string, options?: Filter): Promise<NostrEvent[]>;
+/** Rebuild the FTS5 search index for all events */
+export declare function rebuildSearchIndex(db: Client, contentFormatter: SearchContentFormatter): Promise<void>;

package/dist/libsql/methods.js

@@ -0,0 +1,249 @@
+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 async function createTables(db, search = true) {
+    // Create the events table
+    await db.execute(CREATE_EVENTS_TABLE_STATEMENT.sql);
+    // Create the event_tags table
+    await db.execute(CREATE_EVENT_TAGS_TABLE_STATEMENT.sql);
+    // Create the FTS5 search table
+    if (search) {
+        await db.execute(CREATE_SEARCH_TABLE_STATEMENT.sql);
+    }
+    // Create indexes
+    for (const indexStatement of CREATE_INDEXES_STATEMENTS) {
+        await db.execute(indexStatement.sql);
+    }
+}
+/** Inserts search content for an event */
+export async function insertSearchContent(db, event, contentFormatter) {
+    const searchableContent = contentFormatter(event);
+    // Insert/update directly into the FTS5 table
+    await db.execute({
+        sql: INSERT_SEARCH_CONTENT_STATEMENT.sql,
+        args: [event.id, searchableContent, event.kind, event.pubkey, event.created_at],
+    });
+}
+/** Removes search content for an event */
+export async function deleteSearchContent(db, eventId) {
+    await db.execute({
+        sql: DELETE_SEARCH_CONTENT_STATEMENT.sql,
+        args: [eventId],
+    });
+}
+/** Inserts an event into the `events`, `event_tags`, and search tables of a database */
+export async function insertEvent(db, event, contentFormatter) {
+    const identifier = getReplaceableIdentifier(event);
+    const transaction = await db.transaction();
+    try {
+        // Insert/update the main event
+        const result = await transaction.execute({
+            sql: INSERT_EVENT_STATEMENT.sql,
+            args: [
+                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
+        await insertEventTags(transaction, event);
+        // Insert searchable content into the search tables
+        if (contentFormatter)
+            await insertSearchContent(transaction, event, contentFormatter);
+        await transaction.commit();
+        return result.rowsAffected > 0;
+    }
+    catch (error) {
+        await transaction.rollback();
+        throw error;
+    }
+}
+/** Insert indexable tags for an event into the event_tags table */
+export async function insertEventTags(db, event) {
+    // Clear existing tags for this event first
+    await db.execute({
+        sql: DELETE_EVENT_TAGS_STATEMENT.sql,
+        args: [event.id],
+    });
+    // Get only the indexable tags using applesauce-core helper
+    const indexableTags = getIndexableTags(event);
+    if (indexableTags && indexableTags.size > 0) {
+        for (const tagString of indexableTags) {
+            // Parse the "tagName:tagValue" format
+            const [name, value] = tagString.split(":");
+            if (name && value) {
+                await db.execute({
+                    sql: INSERT_EVENT_TAG_STATEMENT.sql,
+                    args: [event.id, name, value],
+                });
+            }
+        }
+    }
+}
+/** Removes an event by id from the `events`, `event_tags`, and search tables of a database */
+export async function deleteEvent(db, id) {
+    const transaction = await db.transaction();
+    try {
+        // Delete from event_tags first (foreign key constraint)
+        await transaction.execute({
+            sql: DELETE_EVENT_TAGS_STATEMENT.sql,
+            args: [id],
+        });
+        // Delete from search tables
+        await deleteSearchContent(transaction, id);
+        // Delete from events table
+        const result = await transaction.execute({
+            sql: DELETE_EVENT_STATEMENT.sql,
+            args: [id],
+        });
+        await transaction.commit();
+        return result.rowsAffected > 0;
+    }
+    catch (error) {
+        await transaction.rollback();
+        throw error;
+    }
+}
+/** Checks if an event exists */
+export async function hasEvent(db, id) {
+    const result = await db.execute({
+        sql: HAS_EVENT_STATEMENT.sql,
+        args: [id],
+    });
+    if (!result.rows[0])
+        return false;
+    return result.rows[0][0] > 0;
+}
+/** Gets a single event from a database */
+export async function getEvent(db, id) {
+    const result = await db.execute({
+        sql: GET_EVENT_STATEMENT.sql,
+        args: [id],
+    });
+    const row = result.rows[0];
+    return (row &&
+        rowToEvent({
+            id: row[0],
+            kind: row[1],
+            pubkey: row[2],
+            created_at: row[3],
+            content: row[4],
+            tags: row[5],
+            sig: row[6],
+        }));
+}
+/** Gets the latest replaceable event from a database */
+export async function getReplaceable(db, kind, pubkey, identifier) {
+    const result = await db.execute({
+        sql: GET_REPLACEABLE_STATEMENT.sql,
+        args: [kind, pubkey, identifier],
+    });
+    const row = result.rows[0];
+    return (row &&
+        rowToEvent({
+            id: row[0],
+            kind: row[1],
+            pubkey: row[2],
+            created_at: row[3],
+            content: row[4],
+            tags: row[5],
+            sig: row[6],
+        }));
+}
+/** Gets the history of a replaceable event from a database */
+export async function getReplaceableHistory(db, kind, pubkey, identifier) {
+    const result = await db.execute({
+        sql: GET_REPLACEABLE_HISTORY_STATEMENT.sql,
+        args: [kind, pubkey, identifier],
+    });
+    return result.rows.map((row) => rowToEvent({
+        id: row[0],
+        kind: row[1],
+        pubkey: row[2],
+        created_at: row[3],
+        content: row[4],
+        tags: row[5],
+        sig: row[6],
+    }));
+}
+/** Checks if a replaceable event exists in a database */
+export async function hasReplaceable(db, kind, pubkey, identifier = "") {
+    const result = await db.execute({
+        sql: HAS_REPLACEABLE_STATEMENT.sql,
+        args: [kind, pubkey, identifier],
+    });
+    if (!result.rows[0])
+        return false;
+    return result.rows[0][0] > 0;
+}
+/** Get all events that match the filters (includes NIP-50 search support) */
+export async function getEventsByFilters(db, filters) {
+    const query = buildFiltersQuery(filters);
+    if (!query)
+        return new Set();
+    const eventSet = new Set();
+    const result = await db.execute({
+        sql: query.sql,
+        args: query.params,
+    });
+    // Convert rows to events and add to set
+    for (const row of result.rows) {
+        eventSet.add(rowToEvent({
+            id: row[0],
+            kind: row[1],
+            pubkey: row[2],
+            created_at: row[3],
+            content: row[4],
+            tags: row[5],
+            sig: row[6],
+        }));
+    }
+    return eventSet;
+}
+/** Search events using FTS5 full-text search (convenience wrapper around getEventsByFilters) */
+export async 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 = await getEventsByFilters(db, filter);
+    return Array.from(results);
+}
+/** Rebuild the FTS5 search index for all events */
+export async function rebuildSearchIndex(db, contentFormatter) {
+    const transaction = await db.transaction();
+    try {
+        // Clear existing search data
+        await transaction.execute(`DELETE FROM events_search;`);
+        // Rebuild from all events
+        const result = await transaction.execute(GET_ALL_EVENTS_STATEMENT.sql);
+        const events = result.rows.map((row) => rowToEvent({
+            id: row[0],
+            kind: row[1],
+            pubkey: row[2],
+            created_at: row[3],
+            content: row[4],
+            tags: row[5],
+            sig: row[6],
+        }));
+        for (const event of events) {
+            await insertSearchContent(transaction, event, contentFormatter);
+        }
+        await transaction.commit();
+    }
+    catch (error) {
+        await transaction.rollback();
+        throw error;
+    }
+}

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

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

@@ -0,0 +1,104 @@
+import { logger } from "applesauce-core";
+import { insertEventIntoDescendingList } from "applesauce-core/helpers";
+import { DatabaseSync } from "node:sqlite";
+import { enhancedSearchContentFormatter } from "../helpers/search.js";
+import { createTables, deleteEvent, getEvent, getEventsByFilters, getReplaceable, getReplaceableHistory, hasEvent, hasReplaceable, insertEvent, rebuildSearchIndex, } from "./methods.js";
+const log = logger.extend("NativeSqliteEventDatabase");
+export class NativeSqliteEventDatabase {
+    db;
+    /** If search is enabled */
+    search;
+    /** The search content formatter */
+    searchContentFormatter;
+    constructor(database = ":memory:", options) {
+        this.db = typeof database === "string" ? new DatabaseSync(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/native/index.d.ts

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

package/dist/native/index.js

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

package/dist/native/methods.d.ts

@@ -0,0 +1,31 @@
+import { Filter, NostrEvent } from "applesauce-core/helpers";
+import { DatabaseSync } from "node:sqlite";
+import { FilterWithSearch, SearchContentFormatter } from "../helpers/search.js";
+/** Create and migrate the `events`, `event_tags`, and search tables */
+export declare function createTables(db: DatabaseSync, search?: boolean): void;
+/** Inserts search content for an event */
+export declare function insertSearchContent(db: DatabaseSync, event: NostrEvent, contentFormatter: SearchContentFormatter): void;
+/** Removes search content for an event */
+export declare function deleteSearchContent(db: DatabaseSync, eventId: string): void;
+/** Inserts an event into the `events`, `event_tags`, and search tables of a database */
+export declare function insertEvent(db: DatabaseSync, event: NostrEvent, contentFormatter?: SearchContentFormatter): boolean;
+/** Insert indexable tags for an event into the event_tags table */
+export declare function insertEventTags(db: DatabaseSync, event: NostrEvent): void;
+/** Removes an event by id from the `events`, `event_tags`, and search tables of a database */
+export declare function deleteEvent(db: DatabaseSync, id: string): boolean;
+/** Checks if an event exists */
+export declare function hasEvent(db: DatabaseSync, id: string): boolean;
+/** Gets a single event from a database */
+export declare function getEvent(db: DatabaseSync, id: string): NostrEvent | undefined;
+/** Gets the latest replaceable event from a database */
+export declare function getReplaceable(db: DatabaseSync, kind: number, pubkey: string, identifier: string): NostrEvent | undefined;
+/** Gets the history of a replaceable event from a database */
+export declare function getReplaceableHistory(db: DatabaseSync, kind: number, pubkey: string, identifier: string): NostrEvent[];
+/** Checks if a replaceable event exists in a database */
+export declare function hasReplaceable(db: DatabaseSync, kind: number, pubkey: string, identifier?: string): boolean;
+/** Get all events that match the filters (includes NIP-50 search support) */
+export declare function getEventsByFilters(db: DatabaseSync, filters: FilterWithSearch | FilterWithSearch[]): Set<NostrEvent>;
+/** Search events using FTS5 full-text search (convenience wrapper around getEventsByFilters) */
+export declare function searchEvents(db: DatabaseSync, search: string, options?: Filter): NostrEvent[];
+/** Rebuild the FTS5 search index for all events */
+export declare function rebuildSearchIndex(db: DatabaseSync, contentFormatter: SearchContentFormatter): void;

package/dist/native/methods.js

@@ -0,0 +1,174 @@
+import { logger } from "applesauce-core";
+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";
+const log = logger.extend("sqlite:tables");
+/** 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_STATEMENT.sql);
+    // Create the event_tags table
+    log("Creating event_tags table");
+    db.exec(CREATE_EVENT_TAGS_TABLE_STATEMENT.sql);
+    // Create the FTS5 search table
+    if (search) {
+        log("Creating events_search FTS5 table");
+        db.exec(CREATE_SEARCH_TABLE_STATEMENT.sql);
+    }
+    // Create indexes
+    log("Creating 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);
+    // Node.js sqlite doesn't have a transaction method like better-sqlite3, so we use BEGIN/COMMIT
+    db.exec("BEGIN");
+    try {
+        // 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);
+        db.exec("COMMIT");
+        return result.changes > 0;
+    }
+    catch (error) {
+        db.exec("ROLLBACK");
+        throw error;
+    }
+}
+/** 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) {
+    db.exec("BEGIN");
+    try {
+        // 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);
+        db.exec("COMMIT");
+        return result.changes > 0;
+    }
+    catch (error) {
+        db.exec("ROLLBACK");
+        throw error;
+    }
+}
+/** 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.exec("BEGIN");
+    try {
+        // 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);
+        }
+        db.exec("COMMIT");
+    }
+    catch (error) {
+        db.exec("ROLLBACK");
+        throw error;
+    }
+}

package/dist/relay.d.ts

@@ -0,0 +1 @@
+export {};