applesauce-sqlite 0.0.0-next-20250915145415

package/dist/bun/methods.d.ts

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

package/dist/bun/methods.js

@@ -0,0 +1,152 @@
+import { getIndexableTags, getReplaceableIdentifier } from "applesauce-core/helpers";
+import { CREATE_SEARCH_TABLE_STATEMENT, DELETE_SEARCH_CONTENT_STATEMENT, INSERT_SEARCH_CONTENT_STATEMENT, } from "../helpers/search.js";
+import { buildFiltersQuery, rowToEvent } from "../helpers/sql.js";
+import { CREATE_EVENT_TAGS_TABLE_STATEMENT, CREATE_EVENTS_TABLE_STATEMENT, CREATE_INDEXES_STATEMENTS, DELETE_EVENT_STATEMENT, DELETE_EVENT_TAGS_STATEMENT, GET_ALL_EVENTS_STATEMENT, GET_EVENT_STATEMENT, GET_REPLACEABLE_HISTORY_STATEMENT, GET_REPLACEABLE_STATEMENT, HAS_EVENT_STATEMENT, HAS_REPLACEABLE_STATEMENT, INSERT_EVENT_STATEMENT, INSERT_EVENT_TAG_STATEMENT, } from "../helpers/statements.js";
+/** Create and migrate the `events`, `event_tags`, and search tables */
+export function createTables(db, search = true) {
+    // Create the events table
+    db.exec(CREATE_EVENTS_TABLE_STATEMENT.sql);
+    // Create the event_tags table
+    db.exec(CREATE_EVENT_TAGS_TABLE_STATEMENT.sql);
+    // Create the FTS5 search table
+    if (search) {
+        db.exec(CREATE_SEARCH_TABLE_STATEMENT.sql);
+    }
+    // Create indexes
+    CREATE_INDEXES_STATEMENTS.forEach((indexStatement) => {
+        db.exec(indexStatement.sql);
+    });
+}
+/** Inserts search content for an event */
+export function insertSearchContent(db, event, contentFormatter) {
+    const searchableContent = contentFormatter(event);
+    // Insert/update directly into the FTS5 table
+    const stmt = db.query(INSERT_SEARCH_CONTENT_STATEMENT.sql);
+    stmt.run(event.id, searchableContent, event.kind, event.pubkey, event.created_at);
+}
+/** Removes search content for an event */
+export function deleteSearchContent(db, eventId) {
+    const stmt = db.query(DELETE_SEARCH_CONTENT_STATEMENT.sql);
+    stmt.run(eventId);
+}
+/** Inserts an event into the `events`, `event_tags`, and search tables of a database */
+export function insertEvent(db, event, contentFormatter) {
+    const identifier = getReplaceableIdentifier(event);
+    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;
+    });
+    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);
+        return result.changes > 0;
+    });
+    return transaction();
+}
+/** Checks if an event exists */
+export function hasEvent(db, id) {
+    const stmt = db.query(HAS_EVENT_STATEMENT.sql);
+    const result = stmt.get(id);
+    if (!result)
+        return false;
+    return result.count > 0;
+}
+/** Gets a single event from a database */
+export function getEvent(db, id) {
+    const stmt = db.query(GET_EVENT_STATEMENT.sql);
+    const row = stmt.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);
+    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);
+}
+/** 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);
+    if (!result)
+        return false;
+    return result.count > 0;
+}
+/** Get all events that match the filters (includes NIP-50 search support) */
+export function getEventsByFilters(db, filters) {
+    const query = buildFiltersQuery(filters);
+    if (!query)
+        return new Set();
+    const eventSet = new Set();
+    const stmt = db.query(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) {
+    const transaction = db.transaction(() => {
+        // 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);
+        for (const event of events) {
+            insertSearchContent(db, event, contentFormatter);
+        }
+    });
+    transaction();
+}

package/dist/helpers/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./search.js";
+export * from "./sql.js";
+export * from "./statements.js";

package/dist/helpers/index.js

@@ -0,0 +1,3 @@
+export * from "./search.js";
+export * from "./sql.js";
+export * from "./statements.js";

package/dist/helpers/search.d.ts

@@ -0,0 +1,16 @@
+import { Filter, 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 & {
+    search?: string;
+    order?: "created_at" | "rank";
+};
+/** Content formatter function type for search indexing */
+export type SearchContentFormatter = (event: NostrEvent) => string;
+/** Default search content formatter - returns the raw content */
+export declare const defaultSearchContentFormatter: SearchContentFormatter;
+/** Enhanced search content formatter that includes tags and special handling for kind 0 events */
+export declare const enhancedSearchContentFormatter: SearchContentFormatter;

package/dist/helpers/search.js

@@ -0,0 +1,60 @@
+// SQL schema for FTS5 search table - stores formatted searchable content directly
+export const CREATE_SEARCH_TABLE_STATEMENT = {
+    sql: `CREATE VIRTUAL TABLE IF NOT EXISTS events_search USING fts5(
+    event_id UNINDEXED,
+    content,
+    kind UNINDEXED,
+    pubkey UNINDEXED,
+    created_at UNINDEXED
+  )`,
+};
+export const INSERT_SEARCH_CONTENT_STATEMENT = {
+    sql: `INSERT OR REPLACE INTO events_search (event_id, content, kind, pubkey, created_at)
+        VALUES (?, ?, ?, ?, ?)`,
+};
+export const DELETE_SEARCH_CONTENT_STATEMENT = {
+    sql: `DELETE FROM events_search WHERE event_id = ?`,
+};
+/** 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", "description", "d"];
+    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;
+};

package/dist/helpers/sql.d.ts

@@ -0,0 +1,15 @@
+import { NostrEvent } from "applesauce-core/helpers";
+import { FilterWithSearch } from "./search.js";
+import { EventRow } from "./statements.js";
+/** Convert database row to NostrEvent */
+export declare function rowToEvent(row: EventRow): NostrEvent;
+/** Builds conditions for a single filter */
+export declare function buildFilterConditions(filter: FilterWithSearch): {
+    conditions: string[];
+    params: any[];
+    search: boolean;
+};
+export declare function buildFiltersQuery(filters: FilterWithSearch | FilterWithSearch[]): {
+    sql: string;
+    params: any[];
+} | null;

package/dist/helpers/sql.js

@@ -0,0 +1,122 @@
+/** 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 };
+}

package/dist/helpers/sqlite.d.ts

@@ -0,0 +1,66 @@
+import { Filter, NostrEvent } from "applesauce-core/helpers";
+import { Database } from "better-sqlite3";
+export declare const CREATE_EVENTS_TABLE = "\nCREATE TABLE IF NOT EXISTS events (\n  id TEXT PRIMARY KEY,\n  kind INTEGER NOT NULL,\n  pubkey TEXT NOT NULL,\n  created_at INTEGER NOT NULL,\n  content TEXT NOT NULL,\n  tags TEXT,\n  sig TEXT NOT NULL,\n  identifier TEXT NOT NULL DEFAULT ''\n);\n";
+export declare const CREATE_EVENT_TAGS_TABLE = "\nCREATE TABLE IF NOT EXISTS event_tags (\n  event_id TEXT NOT NULL,\n  tag_name TEXT NOT NULL,\n  tag_value TEXT NOT NULL,\n  FOREIGN KEY (event_id) REFERENCES events(id) ON DELETE CASCADE,\n  PRIMARY KEY (event_id, tag_name, tag_value)\n);\n";
+export declare const CREATE_SEARCH_TABLE = "\nCREATE VIRTUAL TABLE IF NOT EXISTS events_search USING fts5(\n  event_id UNINDEXED,\n  content,\n  kind UNINDEXED,\n  pubkey UNINDEXED,\n  created_at UNINDEXED\n);\n";
+export declare const CREATE_INDEXES: string[];
+export type EventRow = {
+    id: string;
+    kind: number;
+    pubkey: string;
+    created_at: number;
+    content: string;
+    tags: string;
+    sig: string;
+};
+/** Filter with search field */
+export type FilterWithSearch = Filter & {
+    search?: string;
+    order?: "created_at" | "rank";
+};
+/** Content formatter function type for search indexing */
+export type SearchContentFormatter = (event: NostrEvent) => string;
+/** Default search content formatter - returns the raw content */
+export declare const defaultSearchContentFormatter: SearchContentFormatter;
+/** Enhanced search content formatter that includes tags and special handling for kind 0 events */
+export declare const enhancedSearchContentFormatter: SearchContentFormatter;
+/** Create and migrate the `events`, `event_tags`, and search tables */
+export declare function createTables(db: Database, search?: boolean): void;
+/** Inserts search content for an event */
+export declare function insertSearchContent(db: Database, event: NostrEvent, contentFormatter: SearchContentFormatter): void;
+/** Removes search content for an event */
+export declare function deleteSearchContent(db: Database, eventId: string): void;
+/** Inserts an event into the `events`, `event_tags`, and search tables of a database */
+export declare function insertEvent(db: Database, event: NostrEvent, contentFormatter?: SearchContentFormatter): boolean;
+/** Insert indexable tags for an event into the event_tags table */
+export declare function insertEventTags(db: Database, event: NostrEvent): void;
+/** Removes an event by id from the `events`, `event_tags`, and search tables of a database */
+export declare function deleteEvent(db: Database, id: string): boolean;
+/** Checks if an event exists */
+export declare function hasEvent(db: Database, id: string): boolean;
+/** Gets a single event from a database */
+export declare function getEvent(db: Database, id: string): NostrEvent | undefined;
+/** Gets the latest replaceable event from a database */
+export declare function getReplaceable(db: Database, kind: number, pubkey: string, identifier: string): NostrEvent | undefined;
+/** Gets the history of a replaceable event from a database */
+export declare function getReplaceableHistory(db: Database, kind: number, pubkey: string, identifier: string): NostrEvent[];
+/** Checks if a replaceable event exists in a database */
+export declare function hasReplaceable(db: Database, kind: number, pubkey: string, identifier?: string): boolean;
+/** Convert database row to NostrEvent */
+export declare function rowToEvent(row: EventRow): NostrEvent;
+/** Builds conditions for a single filter */
+export declare function buildFilterConditions(filter: FilterWithSearch): {
+    conditions: string[];
+    params: any[];
+    search: boolean;
+};
+export declare function buildFiltersQuery(filters: FilterWithSearch | FilterWithSearch[]): {
+    sql: string;
+    params: any[];
+} | null;
+/** Get all events that match the filters (includes NIP-50 search support) */
+export declare function getEventsByFilters(db: Database, filters: FilterWithSearch | FilterWithSearch[]): Set<NostrEvent>;
+/** Search events using FTS5 full-text search (convenience wrapper around getEventsByFilters) */
+export declare function searchEvents(db: Database, search: string, options?: Filter): NostrEvent[];
+/** Rebuild the FTS5 search index for all events */
+export declare function rebuildSearchIndex(db: Database, contentFormatter: SearchContentFormatter): void;