applesauce-sqlite 0.0.0-next-20250915145415

package/dist/helpers/sqlite.js

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

package/dist/helpers/statements.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Generic SQL Statement type that defines a statement with its expected parameters
+ * This allows database implementations to import these and infer the parameter types
+ */
+export type Statement<TParams extends readonly unknown[] = any[], TResult = any> = {
+    /** The SQL query string */
+    sql: string;
+    /** Type information for parameters (not used at runtime, just for type inference) */
+    _params?: TParams;
+    /** Type information for result (not used at runtime, just for type inference) */
+    _result?: TResult;
+};
+/**
+ * Helper type to extract parameter types from a Statement
+ */
+export type StatementParams<T> = T extends Statement<infer P, any> ? P : never;
+/**
+ * Helper type to extract result type from a Statement
+ */
+export type StatementResult<T> = T extends Statement<any, infer R> ? R : never;
+/** Types for the `events` table */
+export type EventRow = {
+    id: string;
+    kind: number;
+    pubkey: string;
+    created_at: number;
+    content: string;
+    tags: string;
+    sig: string;
+};
+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]>;
+export declare const DELETE_EVENT_STATEMENT: Statement<[string]>;
+export declare const HAS_EVENT_STATEMENT: Statement<[string], {
+    count: number;
+}>;
+export declare const GET_EVENT_STATEMENT: Statement<[string], EventRow>;
+export declare const GET_REPLACEABLE_STATEMENT: Statement<[number, string, string], EventRow>;
+export declare const GET_REPLACEABLE_HISTORY_STATEMENT: Statement<[number, string, string], EventRow>;
+export declare const HAS_REPLACEABLE_STATEMENT: Statement<[number, string, string], {
+    count: number;
+}>;
+export declare const GET_ALL_EVENTS_STATEMENT: Statement<[], EventRow>;
+export declare const CREATE_EVENTS_TABLE_STATEMENT: Statement<[]>;
+export declare const CREATE_EVENT_TAGS_TABLE_STATEMENT: Statement<[]>;
+export declare const CREATE_INDEXES_STATEMENTS: Statement<[]>[];

package/dist/helpers/statements.js

@@ -0,0 +1,65 @@
+// Event-related statements
+export const INSERT_EVENT_STATEMENT = {
+    sql: `INSERT OR REPLACE 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 (?, ?, ?)`,
+};
+export const DELETE_EVENT_STATEMENT = {
+    sql: `DELETE FROM events WHERE id = ?`,
+};
+export const HAS_EVENT_STATEMENT = {
+    sql: `SELECT COUNT(*) as count FROM events WHERE id = ?`,
+};
+export const GET_EVENT_STATEMENT = {
+    sql: `SELECT * FROM events WHERE id = ?`,
+};
+export const GET_REPLACEABLE_STATEMENT = {
+    sql: `SELECT * FROM events WHERE kind = ? AND pubkey = ? AND identifier = ? ORDER BY created_at DESC LIMIT 1`,
+};
+export const GET_REPLACEABLE_HISTORY_STATEMENT = {
+    sql: `SELECT * FROM events WHERE kind = ? AND pubkey = ? AND identifier = ? ORDER BY created_at DESC`,
+};
+export const HAS_REPLACEABLE_STATEMENT = {
+    sql: `SELECT COUNT(*) as count FROM events WHERE kind = ? AND pubkey = ? AND identifier = ?`,
+};
+export const GET_ALL_EVENTS_STATEMENT = {
+    sql: `SELECT * FROM events`,
+};
+// SQL schema setup statements
+export const CREATE_EVENTS_TABLE_STATEMENT = {
+    sql: `CREATE TABLE IF NOT EXISTS events (
+    id TEXT PRIMARY KEY,
+    kind INTEGER NOT NULL,
+    pubkey TEXT NOT NULL,
+    created_at INTEGER NOT NULL,
+    content TEXT NOT NULL,
+    tags TEXT,
+    sig TEXT NOT NULL,
+    identifier TEXT NOT NULL DEFAULT ''
+  )`,
+};
+export const CREATE_EVENT_TAGS_TABLE_STATEMENT = {
+    sql: `CREATE TABLE IF NOT EXISTS event_tags (
+    event_id TEXT NOT NULL,
+    tag_name TEXT NOT NULL,
+    tag_value TEXT NOT NULL,
+    FOREIGN KEY (event_id) REFERENCES events(id) ON DELETE CASCADE,
+    PRIMARY KEY (event_id, tag_name, tag_value)
+  )`,
+};
+// Index creation statements
+export const CREATE_INDEXES_STATEMENTS = [
+    // Events table indexes
+    { sql: `CREATE INDEX IF NOT EXISTS kind_idx ON events(kind)` },
+    { sql: `CREATE INDEX IF NOT EXISTS pubkey_idx ON events(pubkey)` },
+    { sql: `CREATE INDEX IF NOT EXISTS created_at_idx ON events(created_at)` },
+    { sql: `CREATE INDEX IF NOT EXISTS identifier_idx ON events(identifier)` },
+    // Event tags table indexes for efficient tag filtering
+    { sql: `CREATE INDEX IF NOT EXISTS event_tags_event_id_idx ON event_tags(event_id)` },
+    { sql: `CREATE INDEX IF NOT EXISTS event_tags_name_value_idx ON event_tags(tag_name, tag_value)` },
+];

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./helpers/index.js";

package/dist/index.js

@@ -0,0 +1 @@
+export * from "./helpers/index.js";

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

@@ -0,0 +1,54 @@
+import { IAsyncEventDatabase } from "applesauce-core";
+import { Filter, NostrEvent } from "applesauce-core/helpers";
+import { Client } from "@libsql/client";
+import { SearchContentFormatter } from "../helpers/search.js";
+/** Options for the {@link LibsqlEventDatabase} */
+export type LibsqlEventDatabaseOptions = {
+    search?: boolean;
+    searchContentFormatter?: SearchContentFormatter;
+};
+export declare class LibsqlEventDatabase implements IAsyncEventDatabase {
+    db: Client;
+    /** If search is enabled */
+    private search;
+    /** The search content formatter */
+    private searchContentFormatter;
+    constructor(database: string | Client, options?: LibsqlEventDatabaseOptions);
+    /** Initialize the database by creating tables and indexes */
+    initialize(): Promise<void>;
+    /** Store a Nostr event in the database */
+    add(event: NostrEvent): Promise<NostrEvent>;
+    /** Delete an event by ID */
+    remove(id: string): Promise<boolean>;
+    /** 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 */
+    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: (Filter & {
+        search?: string;
+    }) | (Filter & {
+        search?: string;
+    })[]): Promise<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;
+    })[]): 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(): void;
+    [Symbol.dispose](): void;
+}

package/dist/libsql/event-database.js

@@ -0,0 +1,106 @@
+import { logger } from "applesauce-core";
+import { insertEventIntoDescendingList } from "applesauce-core/helpers";
+import { createClient } from "@libsql/client";
+import { createTables, deleteEvent, getEvent, getEventsByFilters, getReplaceable, getReplaceableHistory, hasEvent, hasReplaceable, insertEvent, rebuildSearchIndex, } from "./methods.js";
+import { enhancedSearchContentFormatter } from "../helpers/search.js";
+const log = logger.extend("LibsqlEventDatabase");
+export class LibsqlEventDatabase {
+    db;
+    /** If search is enabled */
+    search;
+    /** The search content formatter */
+    searchContentFormatter;
+    constructor(database, options) {
+        this.db = typeof database === "string" ? createClient({ url: database }) : database;
+        this.search = options?.search ?? false;
+        this.searchContentFormatter = options?.searchContentFormatter ?? enhancedSearchContentFormatter;
+    }
+    /** Initialize the database by creating tables and indexes */
+    async initialize() {
+        await createTables(this.db, this.search);
+    }
+    /** Store a Nostr event in the database */
+    async add(event) {
+        try {
+            await 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 */
+    async remove(id) {
+        try {
+            // Remove event from database
+            return await deleteEvent(this.db, id);
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /** Checks if an event exists */
+    async hasEvent(id) {
+        return await hasEvent(this.db, id);
+    }
+    /** Get an event by its ID */
+    async getEvent(id) {
+        return await getEvent(this.db, id);
+    }
+    /** Get the latest replaceable event For replaceable events (10000-19999), returns the most recent event */
+    async getReplaceable(kind, pubkey, identifier = "") {
+        return await getReplaceable(this.db, kind, pubkey, identifier);
+    }
+    /** Checks if a replaceable event exists */
+    async hasReplaceable(kind, pubkey, identifier = "") {
+        return await hasReplaceable(this.db, kind, pubkey, identifier);
+    }
+    /** Returns all the versions of a replaceable event */
+    async getReplaceableHistory(kind, pubkey, identifier = "") {
+        return await getReplaceableHistory(this.db, kind, pubkey, identifier);
+    }
+    /** Get all events that match the filters (supports NIP-50 search field) */
+    async 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 await 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) */
+    async getTimeline(filters) {
+        const events = await 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 */
+    async rebuildSearchIndex() {
+        if (!this.search)
+            throw new Error("Search is disabled");
+        await 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/libsql/index.d.ts

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

package/dist/libsql/index.js

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