@bod.ee/db 0.7.0

package/tests/transforms.test.ts

@@ -0,0 +1,92 @@
+import { describe, test, expect } from 'bun:test';
+import { BodDB } from '../src/server/BodDB.ts';
+import { increment, serverTimestamp, arrayUnion, arrayRemove, ref } from '../src/shared/transforms.ts';
+
+describe('Transforms & Sentinels', () => {
+  test('increment creates/increments a number', () => {
+    const db = new BodDB({ sweepInterval: 0 });
+    db.set('counter', 0);
+    db.set('counter', increment(5));
+    expect(db.get('counter')).toBe(5);
+    db.set('counter', increment(-2));
+    expect(db.get('counter')).toBe(3);
+    // Increment on missing value starts from 0
+    db.set('new_counter', increment(1));
+    expect(db.get('new_counter')).toBe(1);
+    db.close();
+  });
+
+  test('serverTimestamp sets current time', () => {
+    const db = new BodDB({ sweepInterval: 0 });
+    const before = Date.now();
+    db.set('ts', serverTimestamp());
+    const after = Date.now();
+    const val = db.get('ts') as number;
+    expect(val).toBeGreaterThanOrEqual(before);
+    expect(val).toBeLessThanOrEqual(after);
+    db.close();
+  });
+
+  test('arrayUnion adds unique items', () => {
+    const db = new BodDB({ sweepInterval: 0 });
+    db.set('tags', ['a', 'b']);
+    db.set('tags', arrayUnion('b', 'c'));
+    expect(db.get('tags')).toEqual(['a', 'b', 'c']);
+    db.close();
+  });
+
+  test('arrayRemove removes items', () => {
+    const db = new BodDB({ sweepInterval: 0 });
+    db.set('tags', ['a', 'b', 'c']);
+    db.set('tags', arrayRemove('b'));
+    expect(db.get('tags')).toEqual(['a', 'c']);
+    db.close();
+  });
+
+  test('nested sentinels in objects', () => {
+    const db = new BodDB({ sweepInterval: 0 });
+    db.set('user/stats', { views: 10, likes: 5 });
+    db.set('user/stats', { views: increment(1), likes: increment(2) });
+    expect(db.get('user/stats')).toEqual({ views: 11, likes: 7 });
+    db.close();
+  });
+
+  test('sentinels work with merge', () => {
+    const db = new BodDB({ sweepInterval: 0 });
+    db.set('item', { count: 3, name: 'test' });
+    db.update({ 'item': { count: increment(1) } });
+    expect(db.get('item/count')).toBe(4);
+    expect(db.get('item/name')).toBe('test');
+    db.close();
+  });
+
+  test('ref sentinel stores _ref marker', () => {
+    const db = new BodDB({ sweepInterval: 0 });
+    db.set('users/u1', { name: 'Alice' });
+    db.set('posts/p1', { author: ref('users/u1'), title: 'Hello' });
+    const post = db.get('posts/p1') as Record<string, unknown>;
+    expect(post.author).toEqual({ _ref: 'users/u1' });
+    db.close();
+  });
+
+  test('ref resolution via storage.get with resolve option', () => {
+    const db = new BodDB({ sweepInterval: 0 });
+    db.set('users/u1', { name: 'Alice' });
+    db.set('posts/p1', { author: ref('users/u1'), title: 'Hello' });
+    const post = db.storage.get('posts/p1', { resolve: true }) as Record<string, unknown>;
+    expect(post.author).toEqual({ name: 'Alice' });
+    expect(post.title).toBe('Hello');
+    db.close();
+  });
+
+  test('ref resolution with specific fields', () => {
+    const db = new BodDB({ sweepInterval: 0 });
+    db.set('users/u1', { name: 'Alice' });
+    db.set('cats/c1', { name: 'Whiskers' });
+    db.set('posts/p1', { author: ref('users/u1'), cat: ref('cats/c1') });
+    const post = db.storage.get('posts/p1', { resolve: ['author'] }) as Record<string, unknown>;
+    expect(post.author).toEqual({ name: 'Alice' });
+    expect(post.cat).toEqual({ _ref: 'cats/c1' }); // Not resolved
+    db.close();
+  });
+});

package/tests/transport.test.ts

@@ -0,0 +1,209 @@
+import { describe, test, expect, afterEach } from 'bun:test';
+import { BodDB } from '../src/server/BodDB.ts';
+
+let db: BodDB;
+
+function setup(rules?: Record<string, any>) {
+  db = new BodDB({ rules, port: 0 }); // port 0 = random
+  const server = db.serve();
+  return server.port;
+}
+
+afterEach(() => {
+  db?.close();
+});
+
+function ws(port: number): Promise<WebSocket> {
+  return new Promise((resolve, reject) => {
+    const socket = new WebSocket(`ws://localhost:${port}`);
+    socket.onopen = () => resolve(socket);
+    socket.onerror = (e) => reject(e);
+  });
+}
+
+function send(socket: WebSocket, msg: Record<string, unknown>): Promise<Record<string, unknown>> {
+  return new Promise((resolve) => {
+    const handler = (e: MessageEvent) => {
+      const data = JSON.parse(e.data);
+      if (data.id === msg.id) {
+        socket.removeEventListener('message', handler);
+        resolve(data);
+      }
+    };
+    socket.addEventListener('message', handler);
+    socket.send(JSON.stringify(msg));
+  });
+}
+
+describe('Transport — WebSocket', () => {
+  test('CRUD via WebSocket', async () => {
+    const port = setup();
+    const socket = await ws(port);
+
+    // Set
+    const setRes = await send(socket, { id: '1', op: 'set', path: 'users/u1', value: { name: 'Alice', role: 'admin' } });
+    expect(setRes.ok).toBe(true);
+
+    // Get
+    const getRes = await send(socket, { id: '2', op: 'get', path: 'users/u1' });
+    expect(getRes.ok).toBe(true);
+    expect(getRes.data).toEqual({ name: 'Alice', role: 'admin' });
+
+    // Update
+    const updRes = await send(socket, { id: '3', op: 'update', updates: { 'users/u1/name': 'Bob' } });
+    expect(updRes.ok).toBe(true);
+
+    const getRes2 = await send(socket, { id: '4', op: 'get', path: 'users/u1/name' });
+    expect(getRes2.data).toBe('Bob');
+
+    // Delete
+    const delRes = await send(socket, { id: '5', op: 'delete', path: 'users/u1' });
+    expect(delRes.ok).toBe(true);
+
+    const getRes3 = await send(socket, { id: '6', op: 'get', path: 'users/u1' });
+    expect(getRes3.data).toBeNull();
+
+    socket.close();
+  });
+
+  test('query via WebSocket', async () => {
+    const port = setup();
+    const socket = await ws(port);
+
+    await send(socket, { id: '1', op: 'set', path: 'users/u1', value: { name: 'Alice', role: 'admin' } });
+    await send(socket, { id: '2', op: 'set', path: 'users/u2', value: { name: 'Bob', role: 'user' } });
+
+    const qRes = await send(socket, {
+      id: '3', op: 'query', path: 'users',
+      filters: [{ field: 'role', op: '==', value: 'admin' }],
+    });
+    expect(qRes.ok).toBe(true);
+    expect((qRes.data as any[]).length).toBe(1);
+    expect((qRes.data as any[])[0].name).toBe('Alice');
+
+    socket.close();
+  });
+
+  test('value subscription via WebSocket', async () => {
+    const port = setup();
+    const socket = await ws(port);
+
+    // Subscribe
+    await send(socket, { id: '1', op: 'sub', path: 'users/u1', event: 'value' });
+
+    // Collect push messages
+    const pushes: any[] = [];
+    socket.addEventListener('message', (e: MessageEvent) => {
+      const data = JSON.parse(e.data);
+      if (data.type === 'value') pushes.push(data);
+    });
+
+    // Trigger a write from server side
+    db.set('users/u1', { name: 'Alice' });
+    await Bun.sleep(50);
+
+    expect(pushes.length).toBe(1);
+    expect(pushes[0].data).toEqual({ name: 'Alice' });
+
+    // Unsub
+    await send(socket, { id: '2', op: 'unsub', path: 'users/u1', event: 'value' });
+    db.set('users/u1', { name: 'Bob' });
+    await Bun.sleep(50);
+
+    expect(pushes.length).toBe(1); // no new push
+
+    socket.close();
+  });
+
+  test('rules block unauthorized write', async () => {
+    const port = setup({
+      'secret': {
+        read: () => false,
+        write: () => false,
+      },
+    });
+    const socket = await ws(port);
+
+    const res = await send(socket, { id: '1', op: 'set', path: 'secret/data', value: 'hack' });
+    expect(res.ok).toBe(false);
+    expect(res.code).toBe('PERMISSION_DENIED');
+
+    socket.close();
+  });
+
+  test('auth flow', async () => {
+    db = new BodDB({
+      rules: {
+        'private': {
+          write: (ctx) => !!ctx.auth,
+        },
+      },
+      port: 0,
+      auth: (token) => token === 'valid' ? { uid: 'u1' } : null,
+    });
+    const server = db.serve();
+    const socket = await ws(server.port);
+
+    // Write without auth
+    const res1 = await send(socket, { id: '1', op: 'set', path: 'private/data', value: 'test' });
+    expect(res1.ok).toBe(false);
+
+    // Auth with bad token
+    const authBad = await send(socket, { id: '2', op: 'auth', token: 'invalid' });
+    expect(authBad.ok).toBe(false);
+
+    // Auth with good token
+    const authOk = await send(socket, { id: '3', op: 'auth', token: 'valid' });
+    expect(authOk.ok).toBe(true);
+
+    // Write after auth
+    const res2 = await send(socket, { id: '4', op: 'set', path: 'private/data', value: 'test' });
+    expect(res2.ok).toBe(true);
+
+    socket.close();
+  });
+});
+
+describe('Transport — REST', () => {
+  test('GET /db/path', async () => {
+    const port = setup();
+    db.set('users/u1', { name: 'Alice' });
+
+    const res = await fetch(`http://localhost:${port}/db/users/u1`);
+    const json = await res.json();
+    expect(json.ok).toBe(true);
+    expect(json.data).toEqual({ name: 'Alice' });
+  });
+
+  test('PUT /db/path', async () => {
+    const port = setup();
+
+    const res = await fetch(`http://localhost:${port}/db/items/a`, {
+      method: 'PUT',
+      body: JSON.stringify({ v: 1 }),
+      headers: { 'Content-Type': 'application/json' },
+    });
+    const json = await res.json();
+    expect(json.ok).toBe(true);
+    expect(db.get('items/a')).toEqual({ v: 1 });
+  });
+
+  test('DELETE /db/path', async () => {
+    const port = setup();
+    db.set('tmp/data', 'hello');
+
+    const res = await fetch(`http://localhost:${port}/db/tmp/data`, { method: 'DELETE' });
+    const json = await res.json();
+    expect(json.ok).toBe(true);
+    expect(db.get('tmp/data')).toBeNull();
+  });
+
+  test('REST rules enforcement', async () => {
+    const port = setup({
+      'locked': { read: () => false, write: () => false },
+    });
+
+    const res = await fetch(`http://localhost:${port}/db/locked/path`);
+    expect(res.status).toBe(403);
+  });
+});

package/tests/ttl.test.ts

@@ -0,0 +1,70 @@
+import { describe, test, expect } from 'bun:test';
+import { BodDB } from '../src/server/BodDB.ts';
+
+describe('TTL / Auto-Expiry', () => {
+  /** Helper: force-expire all entries at a path by setting expires_at to 1 (way in the past) */
+  function forceExpire(db: BodDB, path: string) {
+    db.storage.db.run('UPDATE nodes SET expires_at = 1 WHERE path = ? OR path LIKE ?', [path, path + '/%']);
+  }
+
+  test('set with ttl marks for expiry', () => {
+    const db = new BodDB({ sweepInterval: 0 });
+    db.set('temp', 'hello', { ttl: 60 });
+    expect(db.get('temp')).toBe('hello');
+
+    // Not expired yet (60s TTL)
+    const swept = db.sweep();
+    expect(swept).toEqual([]);
+    expect(db.get('temp')).toBe('hello');
+    db.close();
+  });
+
+  test('expired entries are swept', () => {
+    const db = new BodDB({ sweepInterval: 0 });
+    db.set('temp', 'hello', { ttl: 60 });
+    expect(db.get('temp')).toBe('hello');
+
+    forceExpire(db, 'temp');
+    const swept = db.sweep();
+    expect(swept.length).toBeGreaterThan(0);
+    expect(db.get('temp')).toBeNull();
+    db.close();
+  });
+
+  test('non-ttl entries are not swept', () => {
+    const db = new BodDB({ sweepInterval: 0 });
+    db.set('permanent', 'stays');
+    db.set('temp', 'goes', { ttl: 60 });
+
+    forceExpire(db, 'temp');
+    db.sweep();
+    expect(db.get('permanent')).toBe('stays');
+    expect(db.get('temp')).toBeNull();
+    db.close();
+  });
+
+  test('ttl on object sets expiry on all leaves', () => {
+    const db = new BodDB({ sweepInterval: 0 });
+    db.set('session/data', { user: 'alice', token: 'abc' }, { ttl: 60 });
+    expect(db.get('session/data')).toEqual({ user: 'alice', token: 'abc' });
+
+    forceExpire(db, 'session/data');
+    db.sweep();
+    expect(db.get('session/data')).toBeNull();
+    db.close();
+  });
+
+  test('sweep triggers subscription notifications', () => {
+    const db = new BodDB({ sweepInterval: 0 });
+    db.set('temp', 'hello', { ttl: 60 });
+
+    const events: unknown[] = [];
+    db.on('temp', (snap) => events.push(snap.val()));
+
+    forceExpire(db, 'temp');
+    db.sweep();
+    expect(events.length).toBeGreaterThan(0);
+    expect(events[events.length - 1]).toBeNull();
+    db.close();
+  });
+});

package/tests/vector.test.ts

@@ -0,0 +1,69 @@
+import { describe, test, expect } from 'bun:test';
+import { BodDB } from '../src/server/BodDB.ts';
+
+describe('VectorEngine', () => {
+  const dims = 4; // Small for tests
+
+  test('store and search vectors', () => {
+    const db = new BodDB({ sweepInterval: 0, vectors: { dimensions: dims } });
+    db.set('docs/d1', { text: 'hello' });
+    db.set('docs/d2', { text: 'world' });
+    db.set('docs/d3', { text: 'other' });
+
+    db.vectors!.store('docs/d1', [1, 0, 0, 0]);
+    db.vectors!.store('docs/d2', [0.9, 0.1, 0, 0]);
+    db.vectors!.store('docs/d3', [0, 0, 1, 0]);
+
+    const results = db.vectorSearch({ query: [1, 0, 0, 0] });
+    expect(results.length).toBe(3);
+    expect(results[0].path).toBe('docs/d1'); // Most similar
+    expect(results[0].score).toBeCloseTo(1.0, 3);
+    expect(results[1].path).toBe('docs/d2'); // Second most similar
+    db.close();
+  });
+
+  test('search with prefix filter', () => {
+    const db = new BodDB({ sweepInterval: 0, vectors: { dimensions: dims } });
+    db.vectors!.store('cats/c1', [1, 0, 0, 0]);
+    db.vectors!.store('dogs/d1', [0.9, 0.1, 0, 0]);
+
+    const results = db.vectorSearch({ query: [1, 0, 0, 0], path: 'cats' });
+    expect(results.length).toBe(1);
+    expect(results[0].path).toBe('cats/c1');
+    db.close();
+  });
+
+  test('search with threshold', () => {
+    const db = new BodDB({ sweepInterval: 0, vectors: { dimensions: dims } });
+    db.vectors!.store('a', [1, 0, 0, 0]);
+    db.vectors!.store('b', [0, 1, 0, 0]); // Orthogonal, similarity ~0
+
+    const results = db.vectorSearch({ query: [1, 0, 0, 0], threshold: 0.5 });
+    expect(results.length).toBe(1);
+    expect(results[0].path).toBe('a');
+    db.close();
+  });
+
+  test('search with limit', () => {
+    const db = new BodDB({ sweepInterval: 0, vectors: { dimensions: dims } });
+    for (let i = 0; i < 10; i++) {
+      db.vectors!.store(`item/${i}`, [Math.random(), Math.random(), Math.random(), Math.random()]);
+    }
+
+    const results = db.vectorSearch({ query: [1, 0, 0, 0], limit: 3 });
+    expect(results.length).toBe(3);
+    db.close();
+  });
+
+  test('throws without vectors config', () => {
+    const db = new BodDB({ sweepInterval: 0 });
+    expect(() => db.vectorSearch({ query: [1, 0, 0, 0] })).toThrow('Vectors not configured');
+    db.close();
+  });
+
+  test('dimension mismatch throws', () => {
+    const db = new BodDB({ sweepInterval: 0, vectors: { dimensions: dims } });
+    expect(() => db.vectors!.store('a', [1, 0])).toThrow('Expected 4 dimensions');
+    db.close();
+  });
+});

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    // Enable latest features
+    "lib": ["ESNext", "DOM"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}