applesauce-sqlite 0.0.0-next-20250915145415

package/dist/relay.js

@@ -0,0 +1,166 @@
+import { EventStore } from "applesauce-core";
+import { matchFilter, verifyEvent } from "applesauce-core/helpers";
+import { createServer } from "http";
+import { WebSocket, WebSocketServer } from "ws";
+import { BetterSqlite3EventDatabase } from "./better-sqlite3/event-database.js";
+// Create the event store with SQLite backend
+const database = new BetterSqlite3EventDatabase(process.env.DATABASE_PATH || ":memory:");
+const eventStore = new EventStore(database);
+// Set validation method for event store
+eventStore.verifyEvent = verifyEvent;
+const subscriptions = new Map();
+// Create HTTP server and WebSocket server
+const server = createServer();
+const wss = new WebSocketServer({ server });
+// Handle WebSocket connections
+wss.on("connection", (ws) => {
+    console.log("New client connected");
+    ws.on("message", async (data) => {
+        try {
+            const message = JSON.parse(data.toString());
+            if (!Array.isArray(message) || message.length < 2) {
+                ws.send(JSON.stringify(["NOTICE", "Invalid message format"]));
+                return;
+            }
+            const [type, ...args] = message;
+            switch (type) {
+                case "EVENT":
+                    await handleEvent(ws, args[0]);
+                    break;
+                case "REQ":
+                    await handleReq(ws, args[0], args.slice(1));
+                    break;
+                case "CLOSE":
+                    handleClose(ws, args[0]);
+                    break;
+                default:
+                    ws.send(JSON.stringify(["NOTICE", `Unknown message type: ${type}`]));
+            }
+        }
+        catch (error) {
+            console.error("Error processing message:", error);
+            ws.send(JSON.stringify(["NOTICE", "Error processing message"]));
+        }
+    });
+    ws.on("close", () => {
+        console.log("Client disconnected");
+        // Clean up subscriptions for this WebSocket
+        for (const [subId, sub] of subscriptions.entries()) {
+            if (sub.ws === ws) {
+                subscriptions.delete(subId);
+            }
+        }
+    });
+    ws.on("error", (error) => {
+        console.error("WebSocket error:", error);
+    });
+});
+// Handle EVENT messages
+async function handleEvent(ws, event) {
+    try {
+        // Basic event validation
+        if (typeof event !== "object" || event === null)
+            throw new Error("invalid: event is not valid");
+        let added = null;
+        try {
+            added = eventStore.add(event);
+        }
+        catch (error) {
+            ws.send(JSON.stringify(["OK", event.id, false, "error: failed to validate event"]));
+            return;
+        }
+        if (!added) {
+            ws.send(JSON.stringify(["OK", event.id, false, "error: rejected event"]));
+            return;
+        }
+        if (added === event) {
+            // Its a new event because the current instance was returned
+            ws.send(JSON.stringify(["OK", event.id, true, ""]));
+        }
+        else {
+            // It was a duplicate because the "real" instance was returned
+            ws.send(JSON.stringify(["OK", event.id, true, "duplicate: event already exists"]));
+        }
+        // Broadcast to subscribers
+        broadcastToSubscribers(event);
+    }
+    catch (error) {
+        console.error("Error handling event:", error);
+        if (error instanceof Error)
+            ws.send(JSON.stringify(["OK", event.id, false, error.message]));
+        else
+            ws.send(JSON.stringify(["OK", event.id, false, "error: failed to process event"]));
+    }
+}
+// Handle REQ messages
+async function handleReq(ws, subscriptionId, filters) {
+    try {
+        // Store subscription
+        subscriptions.set(subscriptionId, {
+            id: subscriptionId,
+            filters,
+            ws,
+        });
+        // Get existing events that match filters
+        const events = eventStore.getByFilters(filters);
+        // Send matching events
+        for (const event of events) {
+            ws.send(JSON.stringify(["EVENT", subscriptionId, event]));
+        }
+        // Send EOSE (End of Stored Events)
+        ws.send(JSON.stringify(["EOSE", subscriptionId]));
+    }
+    catch (error) {
+        console.error("Error handling REQ:", error);
+        ws.send(JSON.stringify(["NOTICE", "Error processing subscription"]));
+    }
+}
+// Handle CLOSE messages
+function handleClose(ws, subscriptionId) {
+    const sub = subscriptions.get(subscriptionId);
+    if (sub && sub.ws === ws) {
+        subscriptions.delete(subscriptionId);
+    }
+}
+// Broadcast event to all subscribers with matching filters
+function broadcastToSubscribers(event) {
+    for (const [subId, sub] of subscriptions.entries()) {
+        if (sub.ws.readyState === WebSocket.OPEN) {
+            // Skip this subscription if it has a search filter (cant match search filters)
+            if (sub.filters.some((filter) => filter.search))
+                continue;
+            // Check if event matches any of the subscription filters
+            const matches = sub.filters.some((filter) => matchFilter(filter, event));
+            if (matches)
+                sub.ws.send(JSON.stringify(["EVENT", subId, event]));
+        }
+        else {
+            // Clean up closed connections
+            subscriptions.delete(subId);
+        }
+    }
+}
+// Start the server
+const PORT = process.env.PORT || 8080;
+server.listen(PORT, () => {
+    console.log(`Nostr relay server listening on port ${PORT}`);
+    console.log(`WebSocket endpoint: ws://localhost:${PORT}`);
+});
+// Subscribe to new events from the event store to broadcast them
+eventStore.insert$.subscribe((event) => {
+    broadcastToSubscribers(event);
+});
+// Graceful shutdown
+process.on("SIGINT", () => {
+    console.log("\nShutting down relay server...");
+    wss.close(() => {
+        server.close(() => {
+            database.close();
+            process.exit(0);
+        });
+    });
+});
+console.log("🚀 Nostr relay started!");
+console.log("📡 WebSocket endpoint: ws://localhost:" + (process.env.PORT || 8080));
+console.log("💾 Database: " + (process.env.DATABASE_PATH || ":memory:"));
+console.log("🛑 Press Ctrl+C to stop the server");

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

@@ -0,0 +1,53 @@
+import { IEventDatabase } from "applesauce-core";
+import { Filter, NostrEvent } from "applesauce-core/helpers";
+import { type Database as TDatabase } from "better-sqlite3";
+import { defaultSearchContentFormatter, enhancedSearchContentFormatter, type SearchContentFormatter } from "./helpers/sqlite.js";
+export { defaultSearchContentFormatter, enhancedSearchContentFormatter, type SearchContentFormatter };
+/** Options for the SqliteEventDatabase */
+export type SqliteEventDatabaseOptions = {
+    search?: boolean;
+    searchContentFormatter?: SearchContentFormatter;
+};
+export declare class SqliteEventDatabase implements IEventDatabase {
+    db: TDatabase;
+    /** If search is enabled */
+    private search;
+    /** The search content formatter */
+    private searchContentFormatter;
+    constructor(database?: string | TDatabase, options?: SqliteEventDatabaseOptions);
+    /** Store a Nostr event in the database */
+    add(event: NostrEvent): NostrEvent;
+    /** Delete an event by ID */
+    remove(id: string): boolean;
+    /** 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 */
+    getReplaceable(kind: number, pubkey: string, identifier?: string): NostrEvent | undefined;
+    /** Checks if a replaceable event exists */
+    hasReplaceable(kind: number, pubkey: string, identifier?: string): boolean;
+    /** Returns all the versions of a replaceable event */
+    getReplaceableHistory(kind: number, pubkey: string, identifier?: string): NostrEvent[];
+    /** Get all events that match the filters (supports NIP-50 search field) */
+    getByFilters(filters: (Filter & {
+        search?: string;
+    }) | (Filter & {
+        search?: string;
+    })[]): 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;
+    })[]): 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(): void;
+    /** Close the database connection */
+    close(): void;
+    [Symbol.dispose](): void;
+}

package/dist/sqlite-event-database.js

@@ -0,0 +1,105 @@
+import { logger } from "applesauce-core";
+import { insertEventIntoDescendingList } from "applesauce-core/helpers";
+import Database from "better-sqlite3";
+import { createTables, defaultSearchContentFormatter, deleteEvent, enhancedSearchContentFormatter, getEvent, getEventsByFilters, getReplaceable, getReplaceableHistory, hasEvent, hasReplaceable, insertEvent, rebuildSearchIndex, } from "./helpers/sqlite.js";
+const log = logger.extend("SqliteEventDatabase");
+// Export the search content formatters and types for external use
+export { defaultSearchContentFormatter, enhancedSearchContentFormatter };
+export class SqliteEventDatabase {
+    db;
+    /** If search is enabled */
+    search;
+    /** The search content formatter */
+    searchContentFormatter;
+    constructor(database = ":memory:", options) {
+        this.db = typeof database === "string" ? new Database(database) : database;
+        this.search = options?.search ?? true;
+        this.searchContentFormatter = options?.searchContentFormatter ?? enhancedSearchContentFormatter;
+        // Setup the database tables and indexes
+        createTables(this.db, this.search);
+    }
+    /** Store a Nostr event in the database */
+    add(event) {
+        try {
+            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 */
+    remove(id) {
+        try {
+            // Remove event from database
+            return deleteEvent(this.db, id);
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /** Checks if an event exists */
+    hasEvent(id) {
+        return hasEvent(this.db, id);
+    }
+    /** Get an event by its ID */
+    getEvent(id) {
+        return getEvent(this.db, id);
+    }
+    /** Get the latest replaceable event For replaceable events (10000-19999), returns the most recent event */
+    getReplaceable(kind, pubkey, identifier = "") {
+        return getReplaceable(this.db, kind, pubkey, identifier);
+    }
+    /** Checks if a replaceable event exists */
+    hasReplaceable(kind, pubkey, identifier = "") {
+        return hasReplaceable(this.db, kind, pubkey, identifier);
+    }
+    /** Returns all the versions of a replaceable event */
+    getReplaceableHistory(kind, pubkey, identifier = "") {
+        return getReplaceableHistory(this.db, kind, pubkey, identifier);
+    }
+    /** Get all events that match the filters (supports NIP-50 search field) */
+    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 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) */
+    getTimeline(filters) {
+        const events = 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 */
+    rebuildSearchIndex() {
+        if (!this.search)
+            throw new Error("Search is disabled");
+        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/package.json

@@ -0,0 +1,113 @@
+{
+  "name": "applesauce-sqlite",
+  "version": "0.0.0-next-20250915145415",
+  "description": "sqlite event databases for applesauce",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "keywords": [
+    "nostr",
+    "applesauce"
+  ],
+  "author": "hzrd149",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./helpers": {
+      "import": "./dist/helpers/index.js",
+      "require": "./dist/helpers/index.js",
+      "types": "./dist/helpers/index.d.ts"
+    },
+    "./helpers/*": {
+      "import": "./dist/helpers/*.js",
+      "require": "./dist/helpers/*.js",
+      "types": "./dist/helpers/*.d.ts"
+    },
+    "./better-sqlite3": {
+      "import": "./dist/better-sqlite3/index.js",
+      "require": "./dist/better-sqlite3/index.js",
+      "types": "./dist/better-sqlite3/index.d.ts"
+    },
+    "./better-sqlite3/*": {
+      "import": "./dist/better-sqlite3/*.js",
+      "require": "./dist/better-sqlite3/*.js",
+      "types": "./dist/better-sqlite3/*.d.ts"
+    },
+    "./native": {
+      "import": "./dist/native/index.js",
+      "require": "./dist/native/index.js",
+      "types": "./dist/native/index.d.ts"
+    },
+    "./native/*": {
+      "import": "./dist/native/*.js",
+      "require": "./dist/native/*.js",
+      "types": "./dist/native/*.d.ts"
+    },
+    "./deno": {
+      "import": "./dist/native/index.js",
+      "require": "./dist/native/index.js",
+      "types": "./dist/native/index.d.ts"
+    },
+    "./deno/*": {
+      "import": "./dist/native/*.js",
+      "require": "./dist/native/*.js",
+      "types": "./dist/native/*.d.ts"
+    },
+    "./bun": {
+      "import": "./dist/bun/index.js",
+      "require": "./dist/bun/index.js",
+      "types": "./dist/bun/index.d.ts"
+    },
+    "./bun/*": {
+      "import": "./dist/bun/*.js",
+      "require": "./dist/bun/*.js",
+      "types": "./dist/bun/*.d.ts"
+    },
+    "./libsql": {
+      "import": "./dist/libsql/index.js",
+      "require": "./dist/libsql/index.js",
+      "types": "./dist/libsql/index.d.ts"
+    },
+    "./libsql/*": {
+      "import": "./dist/libsql/*.js",
+      "require": "./dist/libsql/*.js",
+      "types": "./dist/libsql/*.d.ts"
+    }
+  },
+  "dependencies": {
+    "applesauce-core": "0.0.0-next-20250915145415"
+  },
+  "optionalDependencies": {
+    "better-sqlite3": "^12.2.0",
+    "@libsql/client": "^0.15.15"
+  },
+  "devDependencies": {
+    "@hirez_io/observer-spy": "^2.2.0",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/bun": "^1.2.22",
+    "@types/ws": "^8.5.13",
+    "applesauce-signers": "0.0.0-next-20250915145415",
+    "typescript": "^5.7.3",
+    "vitest": "^3.2.4",
+    "vitest-websocket-mock": "^0.5.0",
+    "ws": "^8.18.3"
+  },
+  "funding": {
+    "type": "lightning",
+    "url": "lightning:nostrudel@geyser.fund"
+  },
+  "scripts": {
+    "build": "tsc",
+    "watch:build": "tsc --watch > /dev/null",
+    "test": "vitest run --passWithNoTests",
+    "watch:test": "vitest",
+    "relay": "node dist/relay.js"
+  }
+}