applesauce-sqlite 4.0.0 → 4.1.0

package/dist/turso/methods.js

@@ -0,0 +1,145 @@
+import { getIndexableTags, getReplaceableIdentifier } from "applesauce-core/helpers";
+import { buildDeleteFiltersQuery, buildFiltersQuery, rowToEvent } from "../helpers/sql.js";
+import { CREATE_SEARCH_TABLE_STATEMENT, DELETE_SEARCH_CONTENT_STATEMENT, INSERT_SEARCH_CONTENT_STATEMENT, } from "../helpers/search.js";
+import { CREATE_EVENT_TAGS_TABLE_STATEMENT, CREATE_EVENTS_TABLE_STATEMENT, CREATE_INDEXES_STATEMENTS, DELETE_EVENT_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 = false) {
+    // Create the events table
+    await db.exec(CREATE_EVENTS_TABLE_STATEMENT.sql);
+    // Create the event_tags table
+    await db.exec(CREATE_EVENT_TAGS_TABLE_STATEMENT.sql);
+    // Create search table if search is enabled
+    if (search) {
+        await db.exec(CREATE_SEARCH_TABLE_STATEMENT.sql);
+    }
+    // Create indexes
+    for (const indexStatement of CREATE_INDEXES_STATEMENTS) {
+        await db.exec(indexStatement.sql);
+    }
+}
+/** Inserts an event into the `events`, `event_tags` */
+export async function insertEvent(db, event, searchContentFormatter) {
+    const identifier = getReplaceableIdentifier(event);
+    return await db.transaction(async () => {
+        // Try to insert the main event with OR IGNORE
+        const result = await db
+            .prepare(INSERT_EVENT_STATEMENT.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 processing
+        // Event was inserted, continue with tags
+        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)
+                    await insertStmt.run(event.id, name, value);
+            }
+        }
+        // Insert search content if search is enabled
+        if (searchContentFormatter) {
+            try {
+                const searchContent = searchContentFormatter(event);
+                await db
+                    .prepare(INSERT_SEARCH_CONTENT_STATEMENT.sql)
+                    .run(event.id, searchContent, event.kind, event.pubkey, event.created_at);
+            }
+            catch (error) {
+                // Search table might not exist if search is disabled, ignore the error
+            }
+        }
+        return result.changes > 0;
+    })();
+}
+/** Removes an event by id from the `events`, `event_tags` */
+export async function deleteEvent(db, id) {
+    return await db.transaction(async () => {
+        // Delete from search table first if it exists
+        try {
+            await db.prepare(DELETE_SEARCH_CONTENT_STATEMENT.sql).run(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 db.prepare(DELETE_EVENT_STATEMENT.sql).run(id);
+        return result.changes > 0;
+    })();
+}
+/** Checks if an event exists */
+export async function hasEvent(db, id) {
+    const result = await db.prepare(HAS_EVENT_STATEMENT.sql).get(id);
+    if (!result)
+        return false;
+    return result.count > 0;
+}
+/** Gets a single event from a database */
+export async function getEvent(db, id) {
+    const row = await db.prepare(GET_EVENT_STATEMENT.sql).get(id);
+    return row && rowToEvent(row);
+}
+/** Gets the latest replaceable event from a database */
+export async function getReplaceable(db, kind, pubkey, identifier) {
+    const row = await 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 async function getReplaceableHistory(db, kind, pubkey, identifier) {
+    const rows = await db.prepare(GET_REPLACEABLE_HISTORY_STATEMENT.sql).all(kind, pubkey, identifier);
+    return rows.map(rowToEvent);
+}
+/** Checks if a replaceable event exists in a database */
+export async function hasReplaceable(db, kind, pubkey, identifier = "") {
+    const result = await db.prepare(HAS_REPLACEABLE_STATEMENT.sql).get(kind, pubkey, identifier);
+    if (!result)
+        return false;
+    return result.count > 0;
+}
+/** Get all events that match the filters */
+export async function getEventsByFilters(db, filters) {
+    const query = buildFiltersQuery(filters);
+    if (!query)
+        return [];
+    const rows = await db.prepare(query.sql).all(...query.params);
+    // Convert rows to events and add to set
+    return rows.map(rowToEvent);
+}
+/** 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;
+    return await db.transaction(async () => {
+        // 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 db.prepare(deleteEventsQuery).run(...whereClause.params);
+        return result.changes;
+    })();
+}
+/** Rebuild the search index for all events */
+export async function rebuildSearchIndex(db, searchContentFormatter) {
+    try {
+        // Clear the search table
+        await db.exec("DELETE FROM events_search");
+        // Get all events and rebuild the search index
+        const events = await db.prepare("SELECT * FROM events").all();
+        for (const eventRow of events) {
+            const event = rowToEvent(eventRow);
+            const searchContent = searchContentFormatter(event);
+            await db
+                .prepare(INSERT_SEARCH_CONTENT_STATEMENT.sql)
+                .run(event.id, searchContent, event.kind, event.pubkey, event.created_at);
+        }
+    }
+    catch (error) {
+        // Search table might not exist if search is disabled, throw a more descriptive error
+        throw new Error("Search table does not exist. Make sure search is enabled when creating the database.");
+    }
+}

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

@@ -0,0 +1,36 @@
+import { Database } from "@tursodatabase/database-wasm";
+import { IAsyncEventDatabase } from "applesauce-core";
+import { Filter, NostrEvent } from "applesauce-core/helpers";
+/** Options for the {@link TursoWasmEventDatabase} */
+export type TursoWasmEventDatabaseOptions = {};
+export declare class TursoWasmEventDatabase implements IAsyncEventDatabase {
+    db: Database;
+    constructor(database: Database, _options?: TursoWasmEventDatabaseOptions);
+    /** Create a TursoWasmEventDatabase from a database and initialize it */
+    static fromDatabase(database: Database, options?: TursoWasmEventDatabaseOptions): Promise<TursoWasmEventDatabase>;
+    /** 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: Filter | Filter[]): 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: Filter | Filter[]): Promise<NostrEvent[]>;
+    /** Get a timeline of events that match the filters (returns array in chronological order, supports NIP-50 search) */
+    getTimeline(filters: Filter | Filter[]): Promise<NostrEvent[]>;
+    /** Close the database connection */
+    close(): Promise<void>;
+    [Symbol.dispose](): void;
+}

package/dist/turso-wasm/event-database.js

@@ -0,0 +1,90 @@
+import { logger } from "applesauce-core";
+import { createTables, deleteEvent, deleteEventsByFilters, getEvent, getEventsByFilters, getReplaceable, getReplaceableHistory, hasEvent, hasReplaceable, insertEvent, } from "./methods.js";
+const log = logger.extend("TursoWasmEventDatabase");
+export class TursoWasmEventDatabase {
+    db;
+    constructor(database, _options) {
+        this.db = database;
+    }
+    /** Create a TursoWasmEventDatabase from a database and initialize it */
+    static async fromDatabase(database, options) {
+        const eventDatabase = new TursoWasmEventDatabase(database, options);
+        return await eventDatabase.initialize();
+    }
+    /** Initialize the database by creating tables and indexes */
+    async initialize() {
+        await createTables(this.db);
+        return this;
+    }
+    /** Store a Nostr event in the database */
+    async add(event) {
+        try {
+            await insertEvent(this.db, event);
+            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;
+        }
+    }
+    /** Remove multiple events that match the given filters */
+    async removeByFilters(filters) {
+        return await deleteEventsByFilters(this.db, filters);
+    }
+    /** 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 and 30000-39999), 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) {
+        // If search is disabled, remove the search field from the filters
+        if (Array.isArray(filters) ? filters.some((f) => "search" in f) : "search" in filters)
+            throw new Error("Search is not supported");
+        return await getEventsByFilters(this.db, filters);
+    }
+    /** Get a timeline of events that match the filters (returns array in chronological order, supports NIP-50 search) */
+    async getTimeline(filters) {
+        if (Array.isArray(filters) ? filters.some((f) => "search" in f) : "search" in filters)
+            throw new Error("Search is not supported");
+        // No need to sort since query defaults to created_at descending order
+        return await this.getByFilters(filters);
+    }
+    /** Close the database connection */
+    async close() {
+        log("Closing database connection");
+        await this.db.close();
+    }
+    [Symbol.dispose]() {
+        // Note: dispose is synchronous, but close is async
+        // This is a limitation of the dispose pattern
+        this.close().catch((error) => {
+            log("Error closing database in dispose:", error);
+        });
+    }
+}

package/dist/turso-wasm/index.d.ts

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

package/dist/turso-wasm/index.js

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

package/dist/turso-wasm/methods.d.ts

@@ -0,0 +1,22 @@
+import { Database } from "@tursodatabase/database-wasm";
+import { Filter, NostrEvent } from "applesauce-core/helpers";
+/** Create and migrate the `events`, `event_tags`, and search tables */
+export declare function createTables(db: Database): Promise<void>;
+/** Inserts an event into the `events`, `event_tags` */
+export declare function insertEvent(db: Database, event: NostrEvent): Promise<boolean>;
+/** Removes an event by id from the `events`, `event_tags` */
+export declare function deleteEvent(db: Database, id: string): Promise<boolean>;
+/** Checks if an event exists */
+export declare function hasEvent(db: Database, id: string): Promise<boolean>;
+/** Gets a single event from a database */
+export declare function getEvent(db: Database, id: string): Promise<NostrEvent | undefined>;
+/** Gets the latest replaceable event from a database */
+export declare function getReplaceable(db: Database, kind: number, pubkey: string, identifier: string): Promise<NostrEvent | undefined>;
+/** Gets the history of a replaceable event from a database */
+export declare function getReplaceableHistory(db: Database, kind: number, pubkey: string, identifier: string): Promise<NostrEvent[]>;
+/** Checks if a replaceable event exists in a database */
+export declare function hasReplaceable(db: Database, kind: number, pubkey: string, identifier?: string): Promise<boolean>;
+/** Get all events that match the filters */
+export declare function getEventsByFilters(db: Database, filters: Filter | Filter[]): Promise<NostrEvent[]>;
+/** Removes multiple events that match the given filters from the database */
+export declare function deleteEventsByFilters(db: Database, filters: Filter | Filter[]): Promise<number>;

package/dist/turso-wasm/methods.js

@@ -0,0 +1,101 @@
+import { getIndexableTags, getReplaceableIdentifier } from "applesauce-core/helpers";
+import { buildDeleteFiltersQuery, buildFiltersQuery, rowToEvent } from "../helpers/sql.js";
+import { CREATE_EVENT_TAGS_TABLE_STATEMENT, CREATE_EVENTS_TABLE_STATEMENT, CREATE_INDEXES_STATEMENTS, DELETE_EVENT_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) {
+    // Create the events table
+    await db.exec(CREATE_EVENTS_TABLE_STATEMENT.sql);
+    // Create the event_tags table
+    await db.exec(CREATE_EVENT_TAGS_TABLE_STATEMENT.sql);
+    // Create indexes
+    for (const indexStatement of CREATE_INDEXES_STATEMENTS) {
+        await db.exec(indexStatement.sql);
+    }
+}
+/** Inserts an event into the `events`, `event_tags` */
+export async function insertEvent(db, event) {
+    const identifier = getReplaceableIdentifier(event);
+    return await db.transaction(async () => {
+        // Try to insert the main event with OR IGNORE
+        const result = await db
+            .prepare(INSERT_EVENT_STATEMENT.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 processing
+        // Event was inserted, continue with tags
+        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)
+                    await insertStmt.run(event.id, name, value);
+            }
+        }
+        return result.changes > 0;
+    })();
+}
+/** Removes an event by id from the `events`, `event_tags` */
+export async function deleteEvent(db, id) {
+    return await db.transaction(async () => {
+        // 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 db.prepare(DELETE_EVENT_STATEMENT.sql).run(id);
+        return result.changes > 0;
+    })();
+}
+/** Checks if an event exists */
+export async function hasEvent(db, id) {
+    const result = await db.prepare(HAS_EVENT_STATEMENT.sql).get(id);
+    if (!result)
+        return false;
+    return result.count > 0;
+}
+/** Gets a single event from a database */
+export async function getEvent(db, id) {
+    const row = await db.prepare(GET_EVENT_STATEMENT.sql).get(id);
+    return row && rowToEvent(row);
+}
+/** Gets the latest replaceable event from a database */
+export async function getReplaceable(db, kind, pubkey, identifier) {
+    const row = await 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 async function getReplaceableHistory(db, kind, pubkey, identifier) {
+    const rows = await db.prepare(GET_REPLACEABLE_HISTORY_STATEMENT.sql).all(kind, pubkey, identifier);
+    return rows.map(rowToEvent);
+}
+/** Checks if a replaceable event exists in a database */
+export async function hasReplaceable(db, kind, pubkey, identifier = "") {
+    const result = await db.prepare(HAS_REPLACEABLE_STATEMENT.sql).get(kind, pubkey, identifier);
+    if (!result)
+        return false;
+    return result.count > 0;
+}
+/** Get all events that match the filters */
+export async function getEventsByFilters(db, filters) {
+    const query = buildFiltersQuery(filters);
+    if (!query)
+        return [];
+    const rows = await db.prepare(query.sql).all(...query.params);
+    // Convert rows to events and add to set
+    return rows.map(rowToEvent);
+}
+/** 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;
+    return await db.transaction(async () => {
+        // 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 db.prepare(deleteEventsQuery).run(...whereClause.params);
+        return result.changes;
+    })();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-sqlite",
-  "version": "4.0.0",
+  "version": "4.1.0",
   "description": "sqlite event databases for applesauce",
   "type": "module",
   "main": "dist/index.js",
@@ -79,20 +79,43 @@
       "import": "./dist/libsql/*.js",
       "require": "./dist/libsql/*.js",
       "types": "./dist/libsql/*.d.ts"
+    },
+    "./turso-wasm": {
+      "import": "./dist/turso-wasm/index.js",
+      "require": "./dist/turso-wasm/index.js",
+      "types": "./dist/turso-wasm/index.d.ts"
+    },
+    "./turso-wasm/*": {
+      "import": "./dist/turso-wasm/*.js",
+      "require": "./dist/turso-wasm/*.js",
+      "types": "./dist/turso-wasm/*.d.ts"
+    },
+    "./turso": {
+      "import": "./dist/turso/index.js",
+      "require": "./dist/turso/index.js",
+      "types": "./dist/turso/index.d.ts"
+    },
+    "./turso/*": {
+      "import": "./dist/turso/*.js",
+      "require": "./dist/turso/*.js",
+      "types": "./dist/turso/*.d.ts"
     }
   },
   "dependencies": {
-    "applesauce-core": "^4.0.0"
+    "applesauce-core": "^4.1.0"
   },
   "optionalDependencies": {
     "@libsql/client": "^0.15.15",
+    "@tursodatabase/database": "^0.2.2",
+    "@tursodatabase/database-wasm": "^0.2.2",
     "better-sqlite3": "^12.2.0"
   },
   "devDependencies": {
     "@hirez_io/observer-spy": "^2.2.0",
     "@types/better-sqlite3": "^7.6.13",
     "@types/ws": "^8.5.13",
-    "applesauce-signers": "^4.0.0",
+    "applesauce-signers": "^4.1.0",
+    "nostr-tools": "^2.17.0",
     "rimraf": "^6.0.1",
     "typescript": "^5.7.3",
     "vitest": "^3.2.4",