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

package/README.md

@@ -64,7 +64,7 @@ const sub = relay.subscribe([{ kinds: [0, 1] }], {
 });
 
 // Use models as normal - they'll work with persisted data
-const profile = eventStore.model(ProfileModel, "npub...");
+const profile = eventStore.model(ProfileModel, "pubkey...");
 profile.subscribe((parsed) => {
   console.log("Profile loaded from database:", parsed);
 });

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

@@ -18,11 +18,13 @@ export declare class BetterSqlite3EventDatabase 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/better-sqlite3/event-database.js

@@ -1,6 +1,6 @@
 import { logger } from "applesauce-core";
 import Database from "better-sqlite3";
-import { createTables, deleteEvent, getEvent, getEventsByFilters, getReplaceable, getReplaceableHistory, hasEvent, hasReplaceable, insertEvent, rebuildSearchIndex, } from "../better-sqlite3/methods.js";
+import { createTables, deleteEvent, deleteEventsByFilters, 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 {
@@ -37,6 +37,13 @@ export class BetterSqlite3EventDatabase {
             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 BetterSqlite3EventDatabase {
     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/better-sqlite3/methods.d.ts

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

package/dist/better-sqlite3/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_WITH_IGNORE, 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
@@ -33,77 +33,85 @@ export function deleteSearchContent(db, eventId) {
 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);
+        // 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)
+            return false; // Event already exists, skip tags/search processing
+        // Event was inserted, continue with tags and search content
+        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
+            }
+        }
+        return true;
+    })();
 }
 /** 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);
+        // Delete from search tables if they exist
+        try {
+            deleteSearchContent(db, 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 = db.prepare(DELETE_EVENT_STATEMENT.sql).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);
+    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;
@@ -113,8 +121,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);
 }
@@ -136,10 +143,34 @@ 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);
         }
     })();
 }
+/** Removes multiple events that match the given filters from the database */
+export function deleteEventsByFilters(db, filters) {
+    const whereClause = buildDeleteFiltersQuery(filters);
+    if (!whereClause)
+        return 0;
+    return db.transaction(() => {
+        // Delete from search tables if they exist
+        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);
+        return result.changes;
+    })();
+}

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

@@ -18,11 +18,13 @@ export declare class BunSqliteEventDatabase 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/bun/event-database.js

@@ -2,7 +2,7 @@ import { logger } from "applesauce-core";
 // @ts-ignore - bun:sqlite is a built-in module in Bun
 import { Database } from "bun: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("BunSqliteEventDatabase");
 export class BunSqliteEventDatabase {
     db;
@@ -38,6 +38,13 @@ export class BunSqliteEventDatabase {
             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);
@@ -46,7 +53,7 @@ export class BunSqliteEventDatabase {
     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/bun/methods.d.ts

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

package/dist/bun/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_WITH_IGNORE, 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
@@ -33,46 +33,50 @@ export function deleteSearchContent(db, eventId) {
 export function insertEvent(db, event, contentFormatter) {
     const identifier = getReplaceableIdentifier(event);
     const transaction = db.transaction(() => {
-        // Insert/update the main event
-        const stmt = db.query(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;
+        // Try to insert the main event with OR IGNORE
+        const result = db
+            .query(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)
+            return false; // Event already exists, skip tags/search processing
+        // Event was inserted, continue with tags and search content
+        const indexableTags = getIndexableTags(event);
+        if (indexableTags && indexableTags.size > 0) {
+            const insertStmt = db.query(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
+            }
+        }
+        return true;
     });
     return transaction();
 }
-/** 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.query(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.query(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) {
     const transaction = db.transaction(() => {
-        // Delete from event_tags first (foreign key constraint)
-        const deleteTagsStmt = db.query(DELETE_EVENT_TAGS_STATEMENT.sql);
-        deleteTagsStmt.run(id);
-        // Delete from search tables
-        deleteSearchContent(db, id);
-        // Delete from events table
-        const deleteEventStmt = db.query(DELETE_EVENT_STATEMENT.sql);
-        const result = deleteEventStmt.run(id);
+        // Delete from search tables if they exist
+        try {
+            deleteSearchContent(db, 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 = db.query(DELETE_EVENT_STATEMENT.sql).run(id);
         return result.changes > 0;
     });
     return transaction();
@@ -87,25 +91,21 @@ export function hasEvent(db, id) {
 }
 /** Gets a single event from a database */
 export function getEvent(db, id) {
-    const stmt = db.query(GET_EVENT_STATEMENT.sql);
-    const row = stmt.get(id);
+    const row = db.query(GET_EVENT_STATEMENT.sql).get(id);
     return row ? rowToEvent(row) : undefined;
 }
 /** Gets the latest replaceable event from a database */
 export function getReplaceable(db, kind, pubkey, identifier) {
-    const stmt = db.query(GET_REPLACEABLE_STATEMENT.sql);
-    const row = stmt.get(kind, pubkey, identifier);
+    const row = db.query(GET_REPLACEABLE_STATEMENT.sql).get(kind, pubkey, identifier);
     return row ? rowToEvent(row) : undefined;
 }
 /** Gets the history of a replaceable event from a database */
 export function getReplaceableHistory(db, kind, pubkey, identifier) {
-    const stmt = db.query(GET_REPLACEABLE_HISTORY_STATEMENT.sql);
-    return stmt.all(kind, pubkey, identifier).map(rowToEvent);
+    return db.query(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.query(HAS_REPLACEABLE_STATEMENT.sql);
-    const result = stmt.get(kind, pubkey, identifier);
+    const result = db.query(HAS_REPLACEABLE_STATEMENT.sql).get(kind, pubkey, identifier);
     if (!result)
         return false;
     return result.count > 0;
@@ -115,8 +115,7 @@ export function getEventsByFilters(db, filters) {
     const query = buildFiltersQuery(filters);
     if (!query)
         return [];
-    const stmt = db.query(query.sql);
-    const rows = stmt.all(...query.params);
+    const rows = db.query(query.sql).all(...query.params);
     // Map rows to events
     return rows.map(rowToEvent);
 }
@@ -138,11 +137,33 @@ export function rebuildSearchIndex(db, contentFormatter) {
         // Clear existing search data
         db.exec(`DELETE FROM events_search;`);
         // Rebuild from all events
-        const stmt = db.query(GET_ALL_EVENTS_STATEMENT.sql);
-        const events = stmt.all().map(rowToEvent);
+        const events = db.query(GET_ALL_EVENTS_STATEMENT.sql).all().map(rowToEvent);
         for (const event of events) {
             insertSearchContent(db, event, contentFormatter);
         }
     });
     transaction();
 }
+/** Removes multiple events that match the given filters from the database */
+export function deleteEventsByFilters(db, filters) {
+    const whereClause = buildDeleteFiltersQuery(filters);
+    if (!whereClause)
+        return 0;
+    const transaction = db.transaction(() => {
+        // Delete from search tables if they exist
+        try {
+            const searchDeleteQuery = `DELETE FROM search_content WHERE event_id IN (SELECT id FROM events ${whereClause.sql})`;
+            db.query(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.query(deleteEventsQuery).run(...whereClause.params);
+        return result.changes;
+    });
+    return transaction();
+}

package/dist/helpers/search.d.ts

@@ -1,10 +1,10 @@
-import { Filter, NostrEvent } from "applesauce-core/helpers";
+import { FilterWithAnd, NostrEvent } from "applesauce-core/helpers";
 import type { Statement } from "./statements.js";
 export declare const CREATE_SEARCH_TABLE_STATEMENT: Statement<[]>;
 export declare const INSERT_SEARCH_CONTENT_STATEMENT: Statement<[string, string, number, string, number]>;
 export declare const DELETE_SEARCH_CONTENT_STATEMENT: Statement<[string]>;
-/** Filter with search field */
-export type FilterWithSearch = Filter & {
+/** Filter with search field and NIP-ND AND operator support */
+export type FilterWithSearch = FilterWithAnd & {
     search?: string;
     order?: "created_at" | "rank";
 };

package/dist/helpers/sql.d.ts

@@ -13,3 +13,8 @@ export declare function buildFiltersQuery(filters: FilterWithSearch | FilterWith
     sql: string;
     params: any[];
 } | null;
+/** Builds a WHERE clause for events that match the given filters */
+export declare function buildDeleteFiltersQuery(filters: FilterWithSearch | FilterWithSearch[]): {
+    sql: string;
+    params: any[];
+} | null;

package/dist/helpers/sql.js

@@ -49,19 +49,49 @@ export function buildFilterConditions(filter) {
         conditions.push(`events.created_at <= ?`);
         params.push(filter.until);
     }
-    // Handle tag filters (e.g., #e, #p, #t, #d, etc.)
+    // Handle AND tag filters (& prefix) first - NIP-ND
+    // AND takes precedence and requires ALL values to be present
+    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 a single subquery with GROUP BY + HAVING COUNT for efficiency
+            // This is more efficient than multiple JOINs for the same tag
+            const placeholders = values.map(() => "?").join(", ");
+            conditions.push(`events.id IN (
+        SELECT event_id
+        FROM event_tags
+        WHERE tag_name = ? AND tag_value IN (${placeholders})
+        GROUP BY event_id
+        HAVING COUNT(DISTINCT tag_value) = ?
+      )`);
+            // Add parameters: tagName, all tag values, then count of values
+            params.push(tagName, ...values, values.length);
+        }
+    }
+    // Handle OR tag filters (# prefix)
+    // Skip values that are in AND tags (NIP-ND rule)
     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
+            // Check if there's a corresponding AND filter for this tag
+            const andKey = `&${tagName}`;
+            const andValues = filter[andKey];
+            // Filter out values that are in AND tags (NIP-ND rule)
+            const filteredValues = andValues
+                ? values.filter((v) => !andValues.includes(v))
+                : values;
+            // Only apply OR filter if there are values left after filtering
+            if (filteredValues.length === 0)
+                continue;
             // Use the event_tags table for efficient tag filtering
-            const placeholders = values.map(() => "?").join(", ");
+            const placeholders = filteredValues.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);
+            // Add parameters: tagName first, then all the filtered tag values
+            params.push(tagName, ...filteredValues);
         }
     }
     return { conditions, params, search };
@@ -120,3 +150,29 @@ export function buildFiltersQuery(filters) {
     }
     return { sql: query, params: allParams };
 }
+/** Builds a WHERE clause for events that match the given filters */
+export function buildDeleteFiltersQuery(filters) {
+    const filterArray = Array.isArray(filters) ? filters : [filters];
+    if (filterArray.length === 0)
+        return null;
+    const filterQueries = [];
+    const allParams = [];
+    for (const filter of filterArray) {
+        const { conditions, params } = buildFilterConditions(filter);
+        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);
+    }
+    // Combine all filter conditions with OR logic
+    const whereClause = filterQueries.length > 0 ? `WHERE ${filterQueries.join(" OR ")}` : "";
+    return {
+        sql: whereClause, // Just return the WHERE clause
+        params: allParams,
+    };
+}

package/dist/helpers/statements.d.ts

@@ -28,6 +28,17 @@ export type EventRow = {
     tags: string;
     sig: string;
 };
+export declare const INSERT_EVENT_STATEMENT_WITH_IGNORE: Statement<[
+    string,
+    number,
+    string,
+    number,
+    string,
+    string,
+    string,
+    string
+]>;
+/** For implementations that don't support OR IGNORE (libsql, turso-wasm) */
 export declare const INSERT_EVENT_STATEMENT: Statement<[string, number, string, number, string, string, string, string]>;
 export declare const DELETE_EVENT_TAGS_STATEMENT: Statement<[string]>;
 export declare const INSERT_EVENT_TAG_STATEMENT: Statement<[string, string, string]>;

package/dist/helpers/statements.js

@@ -1,13 +1,18 @@
 // Event-related statements
+export const INSERT_EVENT_STATEMENT_WITH_IGNORE = {
+    sql: `INSERT OR IGNORE INTO events (id, kind, pubkey, created_at, content, tags, sig, identifier)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+};
+/** For implementations that don't support OR IGNORE (libsql, turso-wasm) */
 export const INSERT_EVENT_STATEMENT = {
-    sql: `INSERT OR REPLACE INTO events (id, kind, pubkey, created_at, content, tags, sig, identifier)
+    sql: `INSERT INTO events (id, kind, pubkey, created_at, content, tags, sig, identifier)
         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
 };
 export const DELETE_EVENT_TAGS_STATEMENT = {
     sql: `DELETE FROM event_tags WHERE event_id = ?`,
 };
 export const INSERT_EVENT_TAG_STATEMENT = {
-    sql: `INSERT OR IGNORE INTO event_tags (event_id, tag_name, tag_value) VALUES (?, ?, ?)`,
+    sql: `INSERT INTO event_tags (event_id, tag_name, tag_value) VALUES (?, ?, ?)`,
 };
 export const DELETE_EVENT_STATEMENT = {
     sql: `DELETE FROM events WHERE id = ?`,