pluresdb 1.0.1

package/src/http/api-server.ts

@@ -0,0 +1,334 @@
+import { GunDB } from "../core/database.ts";
+import { loadConfig, saveConfig } from "../config.ts";
+
+export interface ApiServerHandle {
+  url: string;
+  close: () => void;
+}
+
+const STATIC_ROOT = new URL("../../web/svelte/dist/", import.meta.url);
+
+function corsHeaders(extra?: Record<string, string>): Headers {
+  const headers = new Headers(extra);
+  headers.set("Access-Control-Allow-Origin", "*");
+  headers.set("Access-Control-Allow-Methods", "GET,POST,PUT,DELETE,OPTIONS");
+  headers.set("Access-Control-Allow-Headers", "Content-Type, Authorization");
+  headers.set("Vary", "Origin");
+  return headers;
+}
+
+export function startApiServer(opts: { port: number; db: GunDB }): ApiServerHandle {
+  const { port, db } = opts;
+
+  const handler = async (req: Request): Promise<Response> => {
+    try {
+      const url = new URL(req.url);
+      const path = url.pathname;
+
+      if (req.method === "OPTIONS") {
+        return new Response(null, { status: 200, headers: corsHeaders() });
+      }
+
+      if (path === "/api/events") {
+        const stream = new ReadableStream({
+          start(controller) {
+            const enc = new TextEncoder();
+            const send = (evt: { id: string; node: unknown | null }) => {
+              const line = `data: ${JSON.stringify(evt)}\n\n`;
+              controller.enqueue(enc.encode(line));
+            };
+            const cb = (e: { id: string; node: unknown | null }) => send(e);
+            db.onAny(cb as any);
+            (async () => {
+              for await (const n of db.list()) send({ id: n.id, node: { id: n.id, data: n.data } });
+            })();
+            return () => db.offAny(cb as any);
+          },
+        });
+        return new Response(stream, {
+          headers: corsHeaders({ "content-type": "text/event-stream" }),
+        });
+      }
+
+      if (path.startsWith("/api/nodes/")) {
+        const id = decodeURIComponent(path.slice("/api/nodes/".length));
+        if (req.method === "GET") {
+          const val = await db.get<Record<string, unknown>>(id);
+          if (!val) return json({ error: "not found" }, 404);
+          return json(val);
+        }
+        if (req.method === "PUT") {
+          const body = await req.json().catch(() => null);
+          if (!body || typeof body !== "object" || Array.isArray(body)) {
+            return json({ error: "invalid json" }, 400);
+          }
+          await db.put(id, body as Record<string, unknown>);
+          return json({ ok: true });
+        }
+        if (req.method === "DELETE") {
+          await db.delete(id);
+          return json({ ok: true });
+        }
+        return json({ error: "method" }, 405);
+      }
+
+      if (path.startsWith("/api/")) {
+        switch (path) {
+          case "/api/config": {
+            if (req.method === "GET") {
+              const cfg = await loadConfig();
+              return json(cfg);
+            }
+            if (req.method === "POST") {
+              const body = (await req.json().catch(() => null)) as Record<string, unknown> | null;
+              if (!body) return json({ error: "missing body" }, 400);
+              const current = await loadConfig();
+              const next = { ...current, ...body } as Record<string, unknown>;
+              await saveConfig(next);
+              return json({ ok: true });
+            }
+            return json({ error: "method" }, 405);
+          }
+          case "/api/get": {
+            const id = url.searchParams.get("id");
+            if (!id) return json({ error: "missing id" }, 400);
+            const val = await db.get<Record<string, unknown>>(id);
+            return json(val);
+          }
+          case "/api/put": {
+            if (req.method !== "POST") return json({ error: "method" }, 405);
+            const body = (await req.json().catch(() => null)) as
+              | { id?: string; data?: Record<string, unknown> }
+              | null;
+            if (!body?.id || !body?.data) return json({ error: "missing body {id,data}" }, 400);
+            await db.put(body.id, body.data);
+            return json({ ok: true });
+          }
+          case "/api/delete": {
+            const id = url.searchParams.get("id");
+            if (!id) return json({ error: "missing id" }, 400);
+            await db.delete(id);
+            return json({ ok: true });
+          }
+          case "/api/search": {
+            if (req.method === "POST") {
+              const payload = (await req.json().catch(() => null)) as
+                | { query?: string | number[]; limit?: number }
+                | null;
+              if (!payload || (!payload.query && payload.query !== "")) {
+                return json({ error: "missing query" }, 400);
+              }
+              const limit = Number.isFinite(payload.limit) ? payload.limit! : 5;
+              const nodes = await db.vectorSearch(payload.query ?? "", limit);
+              return json(nodes.map((n) => ({ id: n.id, data: n.data })));
+            }
+            const q = url.searchParams.get("q") ?? "";
+            const k = Number(url.searchParams.get("k") ?? "5");
+            const nodes = await db.vectorSearch(q, Number.isFinite(k) ? k : 5);
+            return json(nodes.map((n) => ({ id: n.id, data: n.data })));
+          }
+          case "/api/list": {
+            const out: Array<{ id: string; data: Record<string, unknown> }> = [];
+            for await (const n of db.list()) {
+              out.push({ id: n.id, data: n.data as Record<string, unknown> });
+            }
+            return json(out);
+          }
+          case "/api/instances": {
+            const typeName = url.searchParams.get("type");
+            if (!typeName) return json({ error: "missing type" }, 400);
+            const nodes = await db.instancesOf(typeName);
+            return json(nodes.map((n) => ({ id: n.id, data: n.data })));
+          }
+          case "/api/history": {
+            const id = url.searchParams.get("id");
+            if (!id) return json({ error: "missing id" }, 400);
+            const history = await db.getNodeHistory(id);
+            return json(
+              history.map((h) => ({
+                id: h.id,
+                data: h.data,
+                timestamp: h.timestamp,
+                vectorClock: h.vectorClock,
+                state: h.state,
+              })),
+            );
+          }
+          case "/api/restore": {
+            const id = url.searchParams.get("id");
+            const timestamp = url.searchParams.get("timestamp");
+            if (!id || !timestamp) return json({ error: "missing id or timestamp" }, 400);
+            await db.restoreNodeVersion(id, parseInt(timestamp));
+            return json({ success: true });
+          }
+          default:
+            return json({ error: "not found" }, 404);
+        }
+      }
+
+      if (req.method === "GET") {
+        const mapPath = path === "/" ? "/index.html" : path;
+        const fileUrl = new URL(mapPath.startsWith("/") ? `.${mapPath}` : mapPath, STATIC_ROOT);
+        try {
+          const data = await Deno.readFile(fileUrl);
+          const contentType = mapPath.endsWith(".html")
+            ? "text/html; charset=utf-8"
+            : mapPath.endsWith(".js")
+              ? "application/javascript"
+              : mapPath.endsWith(".css")
+                ? "text/css"
+                : mapPath.endsWith(".json")
+                  ? "application/json"
+                  : mapPath.endsWith(".svg")
+                    ? "image/svg+xml"
+                    : mapPath.endsWith(".png")
+                      ? "image/png"
+                      : "application/octet-stream";
+          return new Response(data, { headers: corsHeaders({ "content-type": contentType }) });
+        } catch {
+          if (path === "/" || path === "/index.html") {
+            return new Response(INDEX_HTML, {
+              headers: corsHeaders({ "content-type": "text/html; charset=utf-8" }),
+            });
+          }
+        }
+      }
+
+      return new Response("Not Found", { status: 404, headers: corsHeaders() });
+    } catch (e) {
+      const msg =
+        e && typeof e === "object" && "message" in e ? String((e as any).message) : String(e);
+      return json({ error: msg }, 500);
+    }
+  };
+
+  const server = Deno.serve({ port, onListen: () => {} }, handler);
+  return {
+    url: `http://localhost:${port}`,
+    close: () => {
+      try {
+        server.shutdown();
+      } catch {
+        /* ignore */
+      }
+    },
+  };
+}
+
+function json(data: unknown, status = 200): Response {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: corsHeaders({ "content-type": "application/json" }),
+  });
+}
+
+const INDEX_HTML = `<!doctype html>
+<html>
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>PluresDB</title>
+  <style>
+  body { font-family: system-ui, sans-serif; margin: 24px; }
+  h1 { margin-top: 0; }
+  section { border: 1px solid #ddd; padding: 12px; margin-bottom: 16px; border-radius: 8px; }
+  input, textarea, button, select { font: inherit; }
+  code { background:#f5f5f5; padding:2px 4px; border-radius:4px; }
+  pre { background:#f9f9f9; padding:8px; border-radius:6px; overflow:auto; }
+  label { display:block; margin:6px 0 4px; }
+  </style>
+ </head>
+ <body>
+  <h1>PluresDB</h1>
+  <p>Reactive UI. Data updates automatically.</p>
+  <div style="display:flex; gap:16px; align-items:flex-start;">
+    <section style="flex:1; min-width:300px;">
+      <h3>Nodes</h3>
+      <input id="filter" placeholder="filter by id..." oninput="render()" />
+      <ul id="list" style="list-style:none; padding-left:0; max-height:60vh; overflow:auto;"></ul>
+      <button onclick="createNode()">Create node</button>
+    </section>
+    <section style="flex:2;">
+      <h3>Details</h3>
+      <div id="detail-empty">Select a node on the left</div>
+      <div id="detail" style="display:none;">
+        <label>Id</label>
+        <input id="d-id" disabled />
+        <label>JSON data</label>
+        <textarea id="d-json" rows="12" oninput="debouncedSave()"></textarea>
+        <div style="margin-top:8px; display:flex; gap:8px;">
+          <button onclick="delSelected()">Delete</button>
+        </div>
+      </div>
+      <h3>Vector search</h3>
+      <input id="q" placeholder="search text" oninput="debouncedSearch()" />
+      <pre id="search-out"></pre>
+    </section>
+  </div>
+  <script>
+    const state = { items: new Map(), selected: null, timer: null, stimer: null };
+    const ev = new EventSource('/api/events');
+    ev.onmessage = (e) => {
+      const evt = JSON.parse(e.data);
+      if(evt.node){ state.items.set(evt.id, evt.node.data); } else { state.items.delete(evt.id); }
+      if(state.selected === evt.id && evt.node) {
+        // Avoid clobber when user is actively editing: basic heuristic
+        const el = document.getElementById('d-json');
+        if(document.activeElement !== el) el.value = JSON.stringify(evt.node.data,null,2);
+      }
+      render();
+    };
+    function render(){
+      const list = document.getElementById('list');
+      const f = (document.getElementById('filter').value||'').toLowerCase();
+      list.innerHTML = '';
+      const ids = Array.from(state.items.keys()).filter(id=>id.toLowerCase().includes(f)).sort();
+      for(const id of ids){
+        const li = document.createElement('li');
+        li.textContent = id;
+        li.style.cursor='pointer';
+        li.style.padding='4px 6px';
+        if(id===state.selected) { li.style.background='#eef'; }
+        li.onclick=()=>select(id);
+        list.appendChild(li);
+      }
+      const hasSel = !!state.selected;
+      document.getElementById('detail-empty').style.display = hasSel? 'none':'block';
+      document.getElementById('detail').style.display = hasSel? 'block':'none';
+    }
+    async function select(id){
+      state.selected = id;
+      document.getElementById('d-id').value = id;
+      const data = state.items.get(id) ?? {};
+      document.getElementById('d-json').value = JSON.stringify(data,null,2);
+      render();
+    }
+    function debouncedSave(){
+      clearTimeout(state.timer);
+      state.timer = setTimeout(saveNow, 350);
+    }
+    async function saveNow(){
+      const id = state.selected; if(!id) return;
+      let data; try{ data = JSON.parse(document.getElementById('d-json').value); }catch{ return }
+      await fetch('/api/put', { method:'POST', headers:{'content-type':'application/json'}, body: JSON.stringify({id, data}) });
+    }
+    async function delSelected(){
+      const id = state.selected; if(!id) return;
+      await fetch('/api/delete?id='+encodeURIComponent(id));
+      state.selected = null; render();
+    }
+    async function createNode(){
+      const id = prompt('New node id:'); if(!id) return;
+      await fetch('/api/put', { method:'POST', headers:{'content-type':'application/json'}, body: JSON.stringify({id, data:{}}) });
+      select(id);
+    }
+    function debouncedSearch(){ clearTimeout(state.stimer); state.stimer = setTimeout(searchNow,300); }
+    async function searchNow(){
+      const q = document.getElementById('q').value || '';
+      const res = await fetch('/api/search?q='+encodeURIComponent(q)+'&k=5');
+      const j = await res.json();
+      document.getElementById('search-out').textContent = JSON.stringify(j,null,2);
+    }
+  </script>
+ </body>
+ </html>`;

package/src/index.ts

@@ -0,0 +1,28 @@
+/**
+ * Deno-first entry point for PluresDB.
+ *
+ * This module intentionally re-exports only browser/Deno compatible code.
+ * Node.js consumers should use the compiled entry at `pluresdb/node` instead.
+ */
+
+export { GunDB } from "./core/database.ts";
+export type { DatabaseOptions, ServeOptions } from "./core/database.ts";
+
+export { mergeNodes } from "./core/crdt.ts";
+export type { NodeRecord, MeshMessage, VectorClock } from "./types/index.ts";
+
+export { startApiServer } from "./http/api-server.ts";
+export type { ApiServerHandle } from "./http/api-server.ts";
+
+export { loadConfig, saveConfig } from "./config.ts";
+
+export { startMeshServer, connectToPeer } from "./network/websocket-server.ts";
+export type { MeshServer } from "./network/websocket-server.ts";
+
+export { RuleEngine } from "./logic/rules.ts";
+export type { Rule, RuleContext } from "./logic/rules.ts";
+
+export { BruteForceVectorIndex } from "./vector/index.ts";
+export type { VectorIndex, VectorIndexResult } from "./vector/index.ts";
+
+export { debugLog } from "./util/debug.ts";

package/src/logic/rules.ts

@@ -0,0 +1,44 @@
+import type { NodeRecord } from "../types/index.ts";
+
+// Minimal DB interface to avoid circular imports
+export interface DatabaseLike {
+  put(id: string, data: Record<string, unknown>): Promise<void>;
+  get<T = Record<string, unknown>>(id: string): Promise<(T & { id: string }) | null>;
+}
+
+export interface RuleContext {
+  db: DatabaseLike;
+}
+
+export type RulePredicate = (node: NodeRecord) => boolean | Promise<boolean>;
+export type RuleAction = (ctx: RuleContext, node: NodeRecord) => Promise<void>;
+
+export interface Rule {
+  name: string;
+  whenType?: string;
+  predicate?: RulePredicate;
+  action: RuleAction;
+}
+
+export class RuleEngine {
+  private readonly rules: Map<string, Rule> = new Map();
+
+  addRule(rule: Rule): void {
+    this.rules.set(rule.name, rule);
+  }
+
+  removeRule(name: string): void {
+    this.rules.delete(name);
+  }
+
+  async evaluateNode(node: NodeRecord, ctx: RuleContext): Promise<void> {
+    for (const rule of this.rules.values()) {
+      if (rule.whenType && node.type !== rule.whenType) continue;
+      if (rule.predicate) {
+        const ok = await rule.predicate(node);
+        if (!ok) continue;
+      }
+      await rule.action(ctx, node);
+    }
+  }
+}

package/src/main.rs

@@ -0,0 +1,3 @@
+fn main() {
+    println!("Hello, world!");
+}

package/src/main.ts

@@ -0,0 +1,190 @@
+import { GunDB } from "./core/database.ts";
+import { debugLog } from "./util/debug.ts";
+import { startApiServer } from "./http/api-server.ts";
+import { loadConfig, saveConfig } from "./config.ts";
+
+function printUsage() {
+  console.log(
+    [
+      "Usage:",
+      "  deno run -A src/main.ts serve [--port <port>] [--kv <path>] [ws://peer ...]",
+      "  deno run -A src/main.ts put <id> <json> [--kv <path>]",
+      "  deno run -A src/main.ts get <id> [--kv <path>]",
+      "  deno run -A src/main.ts delete <id> [--kv <path>]",
+      "  deno run -A src/main.ts vsearch <query> <k> [--kv <path>]",
+      "  deno run -A src/main.ts type <id> <TypeName> [--kv <path>]",
+      "  deno run -A src/main.ts instances <TypeName> [--kv <path>]",
+      "  deno run -A src/main.ts list [--kv <path>]",
+      "",
+    ].join("\n"),
+  );
+}
+
+if (import.meta.main) {
+  const [cmd, ...rest] = Deno.args;
+  switch (cmd) {
+    case "serve": {
+      const cfg = await loadConfig();
+      let port = cfg.port ?? 8080;
+      let kvPath: string | undefined = cfg.kvPath;
+      const pi = rest.indexOf("--port");
+      if (pi >= 0 && rest[pi + 1]) {
+        const n = Number(rest[pi + 1]);
+        if (Number.isFinite(n)) port = n;
+      }
+      const ki = rest.indexOf("--kv");
+      if (ki >= 0 && rest[ki + 1]) kvPath = rest[ki + 1];
+      const peers = (cfg.peers ?? []).concat(
+        rest.filter((v) => v.startsWith("ws://") || v.startsWith("wss://")),
+      );
+
+      const db = new GunDB();
+      await db.ready(kvPath);
+      db.serve({ port });
+      for (const p of peers) db.connect(p);
+
+      const api = startApiServer({ port: port + (cfg.apiPortOffset ?? 1), db });
+      console.log(`PluresDB node serving on ws://localhost:${port}`);
+      console.log(`HTTP API/UI on ${api.url}`);
+      if (peers.length) console.log("Connected to peers:", peers.join(", "));
+
+      // Keep process alive
+      await new Promise(() => {});
+      break;
+    }
+    case "put": {
+      const [id, json, ...flags] = rest;
+      if (!id || !json) {
+        printUsage();
+        Deno.exit(1);
+      }
+      let kvPath: string | undefined;
+      const ki = flags.indexOf("--kv");
+      if (ki >= 0 && flags[ki + 1]) kvPath = flags[ki + 1];
+      const db = new GunDB();
+      await db.ready(kvPath);
+      const obj = JSON.parse(json);
+      await db.put(id, obj);
+      console.log("ok");
+      await db.close();
+      break;
+    }
+    case "get": {
+      const [id, ...flags] = rest;
+      if (!id) {
+        printUsage();
+        Deno.exit(1);
+      }
+      let kvPath: string | undefined;
+      const ki = flags.indexOf("--kv");
+      if (ki >= 0 && flags[ki + 1]) kvPath = flags[ki + 1];
+      const db = new GunDB();
+      await db.ready(kvPath);
+      const val = await db.get<Record<string, unknown>>(id);
+      console.log(JSON.stringify(val));
+      await db.close();
+      break;
+    }
+    case "delete": {
+      const [id, ...flags] = rest;
+      if (!id) {
+        printUsage();
+        Deno.exit(1);
+      }
+      let kvPath: string | undefined;
+      const ki = flags.indexOf("--kv");
+      if (ki >= 0 && flags[ki + 1]) kvPath = flags[ki + 1];
+      const db = new GunDB();
+      await db.ready(kvPath);
+      await db.delete(id);
+      console.log("ok");
+      await db.close();
+      break;
+    }
+    case "vsearch": {
+      const [query, kRaw, ...flags] = rest;
+      if (!query || !kRaw) {
+        printUsage();
+        Deno.exit(1);
+      }
+      const k = Number(kRaw);
+      if (!Number.isFinite(k)) {
+        printUsage();
+        Deno.exit(1);
+      }
+      let kvPath: string | undefined;
+      const ki = flags.indexOf("--kv");
+      if (ki >= 0 && flags[ki + 1]) kvPath = flags[ki + 1];
+      const db = new GunDB();
+      await db.ready(kvPath);
+      const results = await db.vectorSearch(query, k);
+      console.log(JSON.stringify(results.map((n) => ({ id: n.id, data: n.data }))));
+      await db.close();
+      break;
+    }
+    case "type": {
+      const [id, typeName, ...flags] = rest;
+      if (!id || !typeName) {
+        printUsage();
+        Deno.exit(1);
+      }
+      let kvPath: string | undefined;
+      const ki = flags.indexOf("--kv");
+      if (ki >= 0 && flags[ki + 1]) kvPath = flags[ki + 1];
+      const db = new GunDB();
+      await db.ready(kvPath);
+      await db.setType(id, typeName);
+      console.log("ok");
+      await db.close();
+      break;
+    }
+    case "instances": {
+      const [typeName, ...flags] = rest;
+      if (!typeName) {
+        printUsage();
+        Deno.exit(1);
+      }
+      let kvPath: string | undefined;
+      const ki = flags.indexOf("--kv");
+      if (ki >= 0 && flags[ki + 1]) kvPath = flags[ki + 1];
+      const db = new GunDB();
+      await db.ready(kvPath);
+      const rows = await db.instancesOf(typeName);
+      console.log(JSON.stringify(rows.map((n) => ({ id: n.id, data: n.data }))));
+      await db.close();
+      break;
+    }
+    case "list": {
+      const flags = rest;
+      let kvPath: string | undefined;
+      const ki = flags.indexOf("--kv");
+      if (ki >= 0 && flags[ki + 1]) kvPath = flags[ki + 1];
+      const db = new GunDB();
+      await db.ready(kvPath);
+      const nodes = await db.getAll();
+      const out = nodes.map((node) => ({ id: node.id, data: node.data as Record<string, unknown> }));
+      console.log(JSON.stringify(out));
+      await db.close();
+      break;
+    }
+    case "config": {
+      const cfg = await loadConfig();
+      console.log(JSON.stringify(cfg, null, 2));
+      break;
+    }
+    case "config:set": {
+      const [key, value] = rest;
+      if (!key || value === undefined) {
+        printUsage();
+        Deno.exit(1);
+      }
+      const cfg = await loadConfig();
+      (cfg as any)[key] = /^[0-9]+$/.test(value) ? Number(value) : value;
+      await saveConfig(cfg);
+      console.log("ok");
+      break;
+    }
+    default:
+      printUsage();
+  }
+}