@bod.ee/db 0.7.0 → 0.9.0

package/admin/server.ts

@@ -1,7 +1,5 @@
 import { BodDB } from '../src/server/BodDB.ts';
 import { join } from 'path';
-import { statSync } from 'fs';
-import { cpus, totalmem } from 'os';
 import { rules } from './rules.ts';
 
 const DB_PATH = process.env.DB_PATH ?? join(import.meta.dir, '../.tmp/bod-db-admin.sqlite');
@@ -10,7 +8,43 @@ const PORT = process.env.PORT ? Number(process.env.PORT) : 4400;
 import { increment, serverTimestamp, arrayUnion, arrayRemove } from '../src/shared/transforms.ts';
 
 const ADMIN_TOKEN = process.env.ADMIN_TOKEN;
-const db = new BodDB({ path: DB_PATH, rules, sweepInterval: 60000, fts: {}, vectors: { dimensions: 384 } });
+const SOURCE_PORT = PORT + 1;
+
+// ── Source DB — a separate BodDB instance acting as a remote data source ─────
+const sourceDb = new BodDB({
+  path: ':memory:',
+  sweepInterval: 0,
+  replication: { role: 'primary' },
+});
+sourceDb.replication!.start();
+sourceDb.serve({ port: SOURCE_PORT });
+
+// Seed source with demo data
+sourceDb.set('catalog/widgets', { name: 'Widget A', price: 29.99, stock: 150 });
+sourceDb.set('catalog/gadgets', { name: 'Gadget B', price: 49.99, stock: 75 });
+sourceDb.set('catalog/gizmos', { name: 'Gizmo C', price: 19.99, stock: 300 });
+sourceDb.set('alerts/sys-1', { level: 'warn', msg: 'CPU spike detected', ts: Date.now() });
+sourceDb.set('alerts/sys-2', { level: 'info', msg: 'Backup completed', ts: Date.now() });
+console.log(`Source DB: :memory: on port ${SOURCE_PORT}`);
+
+// ── Main DB — subscribes to source via feed subscription ─────────────────────
+const db = new BodDB({
+  path: DB_PATH,
+  rules,
+  sweepInterval: 60000,
+  fts: {},
+  vectors: { dimensions: 384 },
+  vfs: { storageRoot: join(import.meta.dir, '../.tmp/vfs') },
+  replication: {
+    role: 'primary',
+    sources: [{
+      url: `ws://localhost:${SOURCE_PORT}`,
+      paths: ['catalog', 'alerts'],
+      localPrefix: 'source',
+      id: 'admin-demo-source',
+    }],
+  },
+});
 console.log(`DB: ${DB_PATH}`);
 
 // Seed only if empty
@@ -47,56 +81,21 @@ if (!db.get('users/alice')) {
   db.mq.push('queues/jobs', { type: 'email', to: 'alice@example.com', subject: 'Welcome' });
   db.mq.push('queues/jobs', { type: 'sms', to: '+1234567890', body: 'Your code is 1234' });
   db.mq.push('queues/jobs', { type: 'webhook', url: 'https://example.com/hook', payload: { event: 'signup' } });
-}
-
-// ── Stats written into BodDB ───────────────────────────────────────────────────
-let lastCpuUsage = process.cpuUsage();
-let lastCpuTime = performance.now();
-let lastOsCpus = cpus();
-
-function systemCpuPercent(): number {
-  const cur = cpus();
-  let idleDelta = 0, totalDelta = 0;
-  for (let i = 0; i < cur.length; i++) {
-    const prev = lastOsCpus[i]?.times ?? cur[i].times;
-    const c = cur[i].times;
-    idleDelta += c.idle - prev.idle;
-    totalDelta += (c.user + c.nice + c.sys + c.irq + c.idle) - (prev.user + prev.nice + prev.sys + prev.irq + prev.idle);
+  // VFS seed
+  if (db.vfs) {
+    db.vfs.mkdir('docs');
+    db.vfs.write('docs/readme.txt', new TextEncoder().encode('Welcome to BodDB VFS!\nThis is a demo file.'));
+    db.vfs.write('docs/config.json', new TextEncoder().encode(JSON.stringify({ theme: 'dark', lang: 'en' }, null, 2)), 'application/json');
+    db.vfs.mkdir('images');
   }
-  lastOsCpus = cur;
-  return totalDelta > 0 ? +((1 - idleDelta / totalDelta) * 100).toFixed(1) : 0;
 }
 
-function publishStats() {
-  if (!db.subs.subscriberCount('_admin')) return;
-  const now = performance.now();
-  const cpu = process.cpuUsage();
-  const elapsedUs = (now - lastCpuTime) * 1000;
-  const cpuPercent = +((cpu.user - lastCpuUsage.user + cpu.system - lastCpuUsage.system) / elapsedUs * 100).toFixed(1);
-  lastCpuUsage = cpu; lastCpuTime = now;
-
-  const mem = process.memoryUsage();
-  const nodeCount = (db.storage.db.query('SELECT COUNT(*) as n FROM nodes WHERE mq_status IS NULL').get() as any).n;
-  let dbSizeMb = 0;
-  try { dbSizeMb = +(statSync(DB_PATH).size / 1024 / 1024).toFixed(2); } catch {}
-
-  db.set('_admin/stats', {
-    process: {
-      cpuPercent,
-      heapUsedMb: +(mem.heapUsed / 1024 / 1024).toFixed(2),
-      rssMb: +(mem.rss / 1024 / 1024).toFixed(2),
-      uptimeSec: Math.floor(process.uptime()),
-    },
-    db: { nodeCount, sizeMb: dbSizeMb },
-    system: { cpuCores: cpus().length, totalMemMb: +(totalmem() / 1024 / 1024).toFixed(0), cpuPercent: systemCpuPercent() },
-    subs: db.subs.subscriberCount(),
-    clients: wsClients.size,
-    ts: Date.now(),
-  });
-}
+// ── Start replication (sources) ───────────────────────────────────────────────
+db.replication!.start().then(() => {
+  console.log(`[REPL] source feed connected → syncing catalog + alerts from :${SOURCE_PORT}`);
+}).catch(e => console.error('[REPL] source feed failed:', e));
 
-setInterval(publishStats, 1000);
-publishStats();
+// Stats are now published automatically by BodDB when _admin has subscribers
 
 // ── Server (WS + REST /db/* + UI) ─────────────────────────────────────────────
 const UI_PATH = join(import.meta.dir, 'ui.html');
@@ -115,7 +114,7 @@ interface WsData {
 const wsClients = new Set<ServerWebSocket<WsData>>();
 const server = Bun.serve({
   port: PORT,
-  fetch(req, server) {
+  async fetch(req, server) {
     const url = new URL(req.url);
 
     // WebSocket upgrade (must be before UI/REST handlers)
@@ -240,6 +239,91 @@ const server = Bun.serve({
       })();
     }
 
+    // REST: GET /replication — source config + sync status
+    if (req.method === 'GET' && url.pathname === '/replication') {
+      const sources = (db.replication?.options.sources ?? []).map(s => ({
+        url: s.url,
+        paths: s.paths,
+        localPrefix: s.localPrefix,
+        id: s.id,
+      }));
+      // Check what data synced under each source prefix
+      const synced: Record<string, unknown> = {};
+      for (const s of sources) {
+        const prefix = s.localPrefix || '';
+        synced[prefix || '(root)'] = db.get(prefix) ?? null;
+      }
+      return Response.json({ ok: true, role: db.replication?.options.role, sources, synced });
+    }
+
+    // REST: POST /replication/source-write — write to the source DB (for demo)
+    if (req.method === 'POST' && url.pathname === '/replication/source-write') {
+      return (async () => {
+        const { path, value } = await req.json() as { path: string; value: unknown };
+        sourceDb.set(path, value);
+        return Response.json({ ok: true });
+      })();
+    }
+
+    // REST: DELETE /replication/source-delete — delete on source DB
+    if (req.method === 'DELETE' && url.pathname.startsWith('/replication/source-delete/')) {
+      const path = url.pathname.slice('/replication/source-delete/'.length);
+      sourceDb.delete(path);
+      return Response.json({ ok: true });
+    }
+
+    // ── VFS REST routes (/files/*) ───────────────────────────────────────────
+    if (url.pathname.startsWith('/files/') && db.vfs) {
+      const vfsPath = decodeURIComponent(url.pathname.slice(7));
+
+      // POST /files/<path>?mkdir=1 — create directory
+      if (req.method === 'POST' && url.searchParams.get('mkdir') === '1') {
+        db.vfs.mkdir(vfsPath);
+        return Response.json({ ok: true });
+      }
+
+      // POST /files/<path> — upload
+      if (req.method === 'POST') {
+        const buf = new Uint8Array(await req.arrayBuffer());
+        const mime = req.headers.get('content-type') || undefined;
+        const stat = await db.vfs.write(vfsPath, buf, mime);
+        return Response.json({ ok: true, data: stat });
+      }
+
+      // GET /files/<path>?stat=1 — metadata
+      if (req.method === 'GET' && url.searchParams.get('stat') === '1') {
+        const stat = db.vfs.stat(vfsPath);
+        if (!stat) return Response.json({ ok: false, error: 'Not found', code: Errors.NOT_FOUND }, { status: 404 });
+        return Response.json({ ok: true, data: stat });
+      }
+
+      // GET /files/<path>?list=1 — list directory
+      if (req.method === 'GET' && url.searchParams.get('list') === '1') {
+        return Response.json({ ok: true, data: db.vfs.list(vfsPath) });
+      }
+
+      // GET /files/<path> — download
+      if (req.method === 'GET') {
+        const stat = db.vfs.stat(vfsPath);
+        if (!stat) return new Response('Not found', { status: 404 });
+        const data = await db.vfs.read(vfsPath);
+        return new Response(data, { headers: { 'Content-Type': stat.mime, 'Content-Length': String(stat.size) } });
+      }
+
+      // PUT /files/<path>?move=<dst> — move/rename
+      if (req.method === 'PUT' && url.searchParams.has('move')) {
+        const dst = url.searchParams.get('move')!;
+        db.vfs.move(vfsPath, dst);
+        return Response.json({ ok: true, data: db.vfs.stat(dst) });
+      }
+
+      // DELETE /files/<path> — delete
+      if (req.method === 'DELETE') {
+        db.vfs.remove(vfsPath);
+        return Response.json({ ok: true });
+      }
+    }
+
     return new Response('Not found', { status: 404 });
   },
   websocket: {