applesauce-sqlite 0.0.0-next-20250930093922 → 0.0.0-next-20251117143754

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

@@ -14,17 +14,21 @@ export declare class LibsqlEventDatabase implements IAsyncEventDatabase {
     /** The search content formatter */
     private searchContentFormatter;
     constructor(database: string | Client, options?: LibsqlEventDatabaseOptions);
+    /** Create a TursoWasmEventDatabase from a database and initialize it */
+    static fromClient(database: Client, options?: LibsqlEventDatabaseOptions): Promise<LibsqlEventDatabase>;
     /** Initialize the database by creating tables and indexes */
-    initialize(): Promise<void>;
+    initialize(): Promise<this>;
     /** Store a Nostr event in the database */
     add(event: NostrEvent): Promise<NostrEvent>;
     /** Delete an event by ID */
     remove(id: string): Promise<boolean>;
+    /** Remove multiple events that match the given filters */
+    removeByFilters(filters: FilterWithSearch | FilterWithSearch[]): Promise<number>;
     /** Checks if an event exists */
     hasEvent(id: string): Promise<boolean>;
     /** Get an event by its ID */
     getEvent(id: string): Promise<NostrEvent | undefined>;
-    /** Get the latest replaceable event For replaceable events (10000-19999), returns the most recent event */
+    /** Get the latest replaceable event For replaceable events (10000-19999 and 30000-39999), returns the most recent event */
     getReplaceable(kind: number, pubkey: string, identifier?: string): Promise<NostrEvent | undefined>;
     /** Checks if a replaceable event exists */
     hasReplaceable(kind: number, pubkey: string, identifier?: string): Promise<boolean>;

package/dist/libsql/event-database.js

@@ -1,7 +1,7 @@
 import { createClient } from "@libsql/client";
 import { logger } from "applesauce-core";
 import { enhancedSearchContentFormatter } from "../helpers/search.js";
-import { createTables, deleteEvent, getEvent, getEventsByFilters, getReplaceable, getReplaceableHistory, hasEvent, hasReplaceable, insertEvent, rebuildSearchIndex, } from "./methods.js";
+import { createTables, deleteEvent, deleteEventsByFilters, getEvent, getEventsByFilters, getReplaceable, getReplaceableHistory, hasEvent, hasReplaceable, insertEvent, rebuildSearchIndex, } from "./methods.js";
 const log = logger.extend("LibsqlEventDatabase");
 export class LibsqlEventDatabase {
     db;
@@ -14,9 +14,15 @@ export class LibsqlEventDatabase {
         this.search = options?.search ?? false;
         this.searchContentFormatter = options?.searchContentFormatter ?? enhancedSearchContentFormatter;
     }
+    /** Create a TursoWasmEventDatabase from a database and initialize it */
+    static async fromClient(database, options) {
+        const eventDatabase = new LibsqlEventDatabase(database, options);
+        return await eventDatabase.initialize();
+    }
     /** Initialize the database by creating tables and indexes */
     async initialize() {
         await createTables(this.db, this.search);
+        return this;
     }
     /** Store a Nostr event in the database */
     async add(event) {
@@ -39,6 +45,13 @@ export class LibsqlEventDatabase {
             return false;
         }
     }
+    /** Remove multiple events that match the given filters */
+    async removeByFilters(filters) {
+        // 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("Cannot delete with search");
+        return await deleteEventsByFilters(this.db, filters);
+    }
     /** Checks if an event exists */
     async hasEvent(id) {
         return await hasEvent(this.db, id);
@@ -47,7 +60,7 @@ export class LibsqlEventDatabase {
     async getEvent(id) {
         return await getEvent(this.db, id);
     }
-    /** Get the latest replaceable event For replaceable events (10000-19999), returns the most recent event */
+    /** Get the latest replaceable event For replaceable events (10000-19999 and 30000-39999), returns the most recent event */
     async getReplaceable(kind, pubkey, identifier = "") {
         return await getReplaceable(this.db, kind, pubkey, identifier);
     }

package/dist/libsql/methods.d.ts

@@ -9,8 +9,6 @@ export declare function insertSearchContent(db: Client | Transaction, event: Nos
 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 */
@@ -29,3 +27,5 @@ export declare function getEventsByFilters(db: Client, filters: FilterWithSearch
 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>;
+/** Removes multiple events that match the given filters from the database */
+export declare function deleteEventsByFilters(db: Client, filters: FilterWithSearch | FilterWithSearch[]): Promise<number>;

package/dist/libsql/methods.js

@@ -1,7 +1,7 @@
 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";
+import { buildFiltersQuery, buildDeleteFiltersQuery, rowToEvent } from "../helpers/sql.js";
+import { CREATE_EVENT_TAGS_TABLE_STATEMENT, CREATE_EVENTS_TABLE_STATEMENT, CREATE_INDEXES_STATEMENTS, DELETE_EVENT_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
@@ -38,7 +38,16 @@ export async function insertEvent(db, event, contentFormatter) {
     const identifier = getReplaceableIdentifier(event);
     const transaction = await db.transaction();
     try {
-        // Insert/update the main event
+        // Check if event already exists
+        const existsResult = await transaction.execute({
+            sql: HAS_EVENT_STATEMENT.sql,
+            args: [event.id],
+        });
+        if (existsResult.rows[0] && existsResult.rows[0][0] > 0) {
+            await transaction.rollback();
+            return false; // Event already exists, skip insertion
+        }
+        // Insert the event
         const result = await transaction.execute({
             sql: INSERT_EVENT_STATEMENT.sql,
             args: [
@@ -53,10 +62,28 @@ export async function insertEvent(db, event, contentFormatter) {
             ],
         });
         // Insert indexable tags into the event_tags table
-        await insertEventTags(transaction, event);
+        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],
+                    });
+                }
+            }
+        }
         // Insert searchable content into the search tables
-        if (contentFormatter)
-            await insertSearchContent(transaction, event, contentFormatter);
+        if (contentFormatter) {
+            try {
+                await insertSearchContent(transaction, event, contentFormatter);
+            }
+            catch (error) {
+                // Search table might not exist if search is disabled, ignore the error
+            }
+        }
         await transaction.commit();
         return result.rowsAffected > 0;
     }
@@ -65,40 +92,20 @@ export async function insertEvent(db, event, contentFormatter) {
         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
+        // Delete from search tables if they exist
+        try {
+            await deleteSearchContent(transaction, id);
+        }
+        catch (error) {
+            // Search table might not exist if search is disabled, ignore the error
+        }
+        // Delete from events table - this will CASCADE to event_tags automatically!
+        // The foreign key constraint: FOREIGN KEY (event_id) REFERENCES events(id) ON DELETE CASCADE
+        // ensures that all related event_tags records are deleted automatically
         const result = await transaction.execute({
             sql: DELETE_EVENT_STATEMENT.sql,
             args: [id],
@@ -246,3 +253,37 @@ export async function rebuildSearchIndex(db, contentFormatter) {
         throw error;
     }
 }
+/** Removes multiple events that match the given filters from the database */
+export async function deleteEventsByFilters(db, filters) {
+    const whereClause = buildDeleteFiltersQuery(filters);
+    if (!whereClause)
+        return 0;
+    const transaction = await db.transaction();
+    try {
+        // Delete from search tables if they exist
+        try {
+            const searchDeleteQuery = `DELETE FROM search_content WHERE event_id IN (SELECT id FROM events ${whereClause.sql})`;
+            await transaction.execute({
+                sql: searchDeleteQuery,
+                args: whereClause.params,
+            });
+        }
+        catch (error) {
+            // Search table might not exist if search is disabled, ignore the error
+        }
+        // Delete from events table - this will CASCADE to event_tags automatically!
+        // The foreign key constraint: FOREIGN KEY (event_id) REFERENCES events(id) ON DELETE CASCADE
+        // ensures that all related event_tags records are deleted automatically
+        const deleteEventsQuery = `DELETE FROM events ${whereClause.sql}`;
+        const result = await transaction.execute({
+            sql: deleteEventsQuery,
+            args: whereClause.params,
+        });
+        await transaction.commit();
+        return result.rowsAffected;
+    }
+    catch (error) {
+        await transaction.rollback();
+        throw error;
+    }
+}

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

@@ -18,11 +18,13 @@ export declare class NativeSqliteEventDatabase implements IEventDatabase {
     add(event: NostrEvent): NostrEvent;
     /** Delete an event by ID */
     remove(id: string): boolean;
+    /** Remove multiple events that match the given filters */
+    removeByFilters(filters: FilterWithSearch | FilterWithSearch[]): number;
     /** 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 */
+    /** Get the latest replaceable event For replaceable events (10000-19999 and 30000-39999), 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;

package/dist/native/event-database.js

@@ -1,7 +1,7 @@
 import { logger } from "applesauce-core";
 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";
+import { createTables, deleteEvent, deleteEventsByFilters, getEvent, getEventsByFilters, getReplaceable, getReplaceableHistory, hasEvent, hasReplaceable, insertEvent, rebuildSearchIndex, } from "./methods.js";
 const log = logger.extend("NativeSqliteEventDatabase");
 export class NativeSqliteEventDatabase {
     db;
@@ -37,6 +37,13 @@ export class NativeSqliteEventDatabase {
             return false;
         }
     }
+    /** Remove multiple events that match the given filters */
+    removeByFilters(filters) {
+        // 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("Cannot delete with search");
+        return deleteEventsByFilters(this.db, filters);
+    }
     /** Checks if an event exists */
     hasEvent(id) {
         return hasEvent(this.db, id);
@@ -45,7 +52,7 @@ export class NativeSqliteEventDatabase {
     getEvent(id) {
         return getEvent(this.db, id);
     }
-    /** Get the latest replaceable event For replaceable events (10000-19999), returns the most recent event */
+    /** Get the latest replaceable event For replaceable events (10000-19999 and 30000-39999), returns the most recent event */
     getReplaceable(kind, pubkey, identifier = "") {
         return getReplaceable(this.db, kind, pubkey, identifier);
     }

package/dist/native/methods.d.ts

@@ -9,8 +9,6 @@ export declare function insertSearchContent(db: DatabaseSync, event: NostrEvent,
 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 */
@@ -29,3 +27,5 @@ export declare function getEventsByFilters(db: DatabaseSync, filters: FilterWith
 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;
+/** Removes multiple events that match the given filters from the database */
+export declare function deleteEventsByFilters(db: DatabaseSync, filters: FilterWithSearch | FilterWithSearch[]): number;

package/dist/native/methods.js

@@ -1,8 +1,8 @@
 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";
+import { buildFiltersQuery, buildDeleteFiltersQuery, rowToEvent } from "../helpers/sql.js";
+import { CREATE_EVENT_TAGS_TABLE_STATEMENT, CREATE_EVENTS_TABLE_STATEMENT, CREATE_INDEXES_STATEMENTS, DELETE_EVENT_STATEMENT, GET_ALL_EVENTS_STATEMENT, GET_EVENT_STATEMENT, GET_REPLACEABLE_HISTORY_STATEMENT, GET_REPLACEABLE_STATEMENT, HAS_EVENT_STATEMENT, HAS_REPLACEABLE_STATEMENT, INSERT_EVENT_STATEMENT_WITH_IGNORE, 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) {
@@ -27,13 +27,11 @@ export function createTables(db, search = true) {
 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);
+    db.prepare(INSERT_SEARCH_CONTENT_STATEMENT.sql).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);
+    db.prepare(DELETE_SEARCH_CONTENT_STATEMENT.sql).run(eventId);
 }
 /** Inserts an event into the `events`, `event_tags`, and search tables of a database */
 export function insertEvent(db, event, contentFormatter) {
@@ -41,49 +39,57 @@ export function insertEvent(db, event, contentFormatter) {
     // 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);
+        // Try to insert the main event with OR IGNORE
+        const result = db
+            .prepare(INSERT_EVENT_STATEMENT_WITH_IGNORE.sql)
+            .run(event.id, event.kind, event.pubkey, event.created_at, event.content, JSON.stringify(event.tags), event.sig, identifier);
+        // If no rows were changed, the event already existed
+        if (result.changes === 0) {
+            db.exec("COMMIT");
+            return false; // Event already exists, skip tags/search processing
+        }
+        // Event was inserted, continue with tags and search content
+        // 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);
+            }
+        }
+        if (contentFormatter) {
+            try {
+                insertSearchContent(db, event, contentFormatter);
+            }
+            catch (error) {
+                // Search table might not exist if search is disabled, ignore the error
+            }
+        }
         db.exec("COMMIT");
-        return result.changes > 0;
+        return true;
     }
     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");
+    // Delete from search tables first (outside transaction to avoid rollback issues)
     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
+    }
+    catch (error) {
+        // Search table might not exist if search is disabled, ignore the error
+    }
+    db.exec("BEGIN");
+    try {
+        // Delete from events table - this will CASCADE to event_tags automatically!
+        // The foreign key constraint: FOREIGN KEY (event_id) REFERENCES events(id) ON DELETE CASCADE
+        // ensures that all related event_tags records are deleted automatically
         const deleteEventStmt = db.prepare(DELETE_EVENT_STATEMENT.sql);
         const result = deleteEventStmt.run(id);
         db.exec("COMMIT");
@@ -96,33 +102,28 @@ export function deleteEvent(db, id) {
 }
 /** Checks if an event exists */
 export function hasEvent(db, id) {
-    const stmt = db.prepare(HAS_EVENT_STATEMENT.sql);
-    const result = stmt.get(id);
+    const result = db.prepare(HAS_EVENT_STATEMENT.sql).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);
+    const row = db.prepare(GET_EVENT_STATEMENT.sql).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);
+    const row = db.prepare(GET_REPLACEABLE_STATEMENT.sql).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);
+    return db.prepare(GET_REPLACEABLE_HISTORY_STATEMENT.sql).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);
+    const result = db.prepare(HAS_REPLACEABLE_STATEMENT.sql).get(kind, pubkey, identifier);
     if (!result)
         return false;
     return result.count > 0;
@@ -132,8 +133,7 @@ export function getEventsByFilters(db, filters) {
     const query = buildFiltersQuery(filters);
     if (!query)
         return [];
-    const stmt = db.prepare(query.sql);
-    const rows = stmt.all(...query.params);
+    const rows = db.prepare(query.sql).all(...query.params);
     // Convert rows to events and add to set
     return rows.map(rowToEvent);
 }
@@ -156,8 +156,7 @@ export function rebuildSearchIndex(db, contentFormatter) {
         // 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);
+        const events = db.prepare(GET_ALL_EVENTS_STATEMENT.sql).all().map(rowToEvent);
         for (const event of events) {
             insertSearchContent(db, event, contentFormatter);
         }
@@ -168,3 +167,31 @@ export function rebuildSearchIndex(db, contentFormatter) {
         throw error;
     }
 }
+/** Removes multiple events that match the given filters from the database */
+export function deleteEventsByFilters(db, filters) {
+    const whereClause = buildDeleteFiltersQuery(filters);
+    if (!whereClause)
+        return 0;
+    db.exec("BEGIN");
+    try {
+        // Delete from search tables first (no foreign key, so do manually)
+        try {
+            const searchDeleteQuery = `DELETE FROM search_content WHERE event_id IN (SELECT id FROM events ${whereClause.sql})`;
+            db.prepare(searchDeleteQuery).run(...whereClause.params);
+        }
+        catch (error) {
+            // Search table might not exist if search is disabled, ignore the error
+        }
+        // Delete from events table - this will CASCADE to event_tags automatically!
+        // The foreign key constraint: FOREIGN KEY (event_id) REFERENCES events(id) ON DELETE CASCADE
+        // ensures that all related event_tags records are deleted automatically
+        const deleteEventsQuery = `DELETE FROM events ${whereClause.sql}`;
+        const result = db.prepare(deleteEventsQuery).run(...whereClause.params);
+        db.exec("COMMIT");
+        return Number(result.changes);
+    }
+    catch (error) {
+        db.exec("ROLLBACK");
+        throw error;
+    }
+}

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

@@ -0,0 +1,50 @@
+import { Database } from "@tursodatabase/database";
+import { IAsyncEventDatabase } from "applesauce-core";
+import { NostrEvent } from "applesauce-core/helpers";
+import { FilterWithSearch, SearchContentFormatter } from "../helpers/search.js";
+/** Options for the {@link TursoEventDatabase} */
+export type TursoEventDatabaseOptions = {
+    search?: boolean;
+    searchContentFormatter?: SearchContentFormatter;
+};
+export declare class TursoEventDatabase implements IAsyncEventDatabase {
+    db: Database;
+    /** If search is enabled */
+    private search;
+    /** The search content formatter */
+    private searchContentFormatter;
+    constructor(database: Database, options?: TursoEventDatabaseOptions);
+    /** Create a TursoEventDatabase from a database and initialize it */
+    static fromDatabase(database: string | Database, options?: TursoEventDatabaseOptions): Promise<TursoEventDatabase>;
+    /** Initialize the database by creating tables and indexes */
+    initialize(): Promise<this>;
+    /** Store a Nostr event in the database */
+    add(event: NostrEvent): Promise<NostrEvent>;
+    /** Delete an event by ID */
+    remove(id: string): Promise<boolean>;
+    /** Remove multiple events that match the given filters */
+    removeByFilters(filters: FilterWithSearch | FilterWithSearch[]): Promise<number>;
+    /** Checks if an event exists */
+    hasEvent(id: string): Promise<boolean>;
+    /** Get an event by its ID */
+    getEvent(id: string): Promise<NostrEvent | undefined>;
+    /** Get the latest replaceable event For replaceable events (10000-19999 and 30000-39999), returns the most recent event */
+    getReplaceable(kind: number, pubkey: string, identifier?: string): Promise<NostrEvent | undefined>;
+    /** Checks if a replaceable event exists */
+    hasReplaceable(kind: number, pubkey: string, identifier?: string): Promise<boolean>;
+    /** Returns all the versions of a replaceable event */
+    getReplaceableHistory(kind: number, pubkey: string, identifier?: string): Promise<NostrEvent[] | undefined>;
+    /** Get all events that match the filters (supports NIP-50 search field) */
+    getByFilters(filters: FilterWithSearch | FilterWithSearch[]): Promise<NostrEvent[]>;
+    /** Get a timeline of events that match the filters (returns array in chronological order, supports NIP-50 search) */
+    getTimeline(filters: FilterWithSearch | FilterWithSearch[]): Promise<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(): Promise<void>;
+    /** Close the database connection */
+    close(): Promise<void>;
+    [Symbol.dispose](): void;
+}