@bod.ee/db 0.7.0

package/tests/rules.test.ts

@@ -0,0 +1,78 @@
+import { describe, test, expect } from 'bun:test';
+import { RulesEngine } from '../src/server/RulesEngine.ts';
+
+describe('RulesEngine', () => {
+  test('no rules = open access', () => {
+    const r = new RulesEngine();
+    expect(r.check('read', 'users/u1', null)).toBe(true);
+    expect(r.check('write', 'users/u1', null)).toBe(true);
+  });
+
+  test('static true/false rules', () => {
+    const r = new RulesEngine({
+      rules: {
+        'public': { read: () => true, write: () => false },
+      },
+    });
+    expect(r.check('read', 'public/data', null)).toBe(true);
+    expect(r.check('write', 'public/data', null)).toBe(false);
+  });
+
+  test('wildcard capture', () => {
+    const r = new RulesEngine({
+      rules: {
+        'users/$uid': {
+          write: (ctx) => ctx.auth?.uid === ctx.params.uid,
+        },
+      },
+    });
+    expect(r.check('write', 'users/u1', { uid: 'u1' })).toBe(true);
+    expect(r.check('write', 'users/u1', { uid: 'u2' })).toBe(false);
+    expect(r.check('write', 'users/u1', null)).toBe(false);
+  });
+
+  test('most specific rule wins', () => {
+    const r = new RulesEngine({
+      rules: {
+        'data': { read: () => false },
+        'data/public': { read: () => true },
+      },
+    });
+    expect(r.check('read', 'data/public/stuff', null)).toBe(true);
+    expect(r.check('read', 'data/private', null)).toBe(false);
+  });
+
+  test('rule with auth check', () => {
+    const r = new RulesEngine({
+      rules: {
+        'admin': {
+          read: (ctx) => ctx.auth?.role === 'admin',
+          write: (ctx) => ctx.auth?.role === 'admin',
+        },
+      },
+    });
+    expect(r.check('read', 'admin/config', { role: 'admin' })).toBe(true);
+    expect(r.check('read', 'admin/config', { role: 'user' })).toBe(false);
+    expect(r.check('read', 'admin/config', null)).toBe(false);
+  });
+
+  test('rule exception returns deny', () => {
+    const r = new RulesEngine({
+      rules: {
+        'buggy': {
+          read: () => { throw new Error('oops'); },
+        },
+      },
+    });
+    expect(r.check('read', 'buggy/path', null)).toBe(false);
+  });
+
+  test('unmatched op defaults to open', () => {
+    const r = new RulesEngine({
+      rules: {
+        'users': { read: () => true }, // no write rule
+      },
+    });
+    expect(r.check('write', 'users/u1', null)).toBe(true);
+  });
+});

package/tests/sse.test.ts

@@ -0,0 +1,78 @@
+import { describe, test, expect, afterEach } from 'bun:test';
+import { BodDB } from '../src/server/BodDB.ts';
+
+let db: BodDB;
+
+afterEach(() => {
+  db?.close();
+});
+
+describe('SSE Transport', () => {
+  test('GET /sse/path streams value events', async () => {
+    db = new BodDB({ port: 0 });
+    const server = db.serve();
+    const port = server.port;
+
+    const controller = new AbortController();
+    const res = await fetch(`http://localhost:${port}/sse/users/u1`, { signal: controller.signal });
+    expect(res.headers.get('content-type')).toBe('text/event-stream');
+
+    const reader = res.body!.getReader();
+    const decoder = new TextDecoder();
+
+    // Read initial SSE comment
+    await reader.read();
+
+    // Write after SSE connection is established
+    setTimeout(() => db.set('users/u1', { name: 'Alice' }), 50);
+
+    const { value } = await reader.read();
+    const text = decoder.decode(value);
+    expect(text).toContain('data: ');
+
+    const jsonStr = text.split('data: ')[1].split('\n')[0];
+    const event = JSON.parse(jsonStr);
+    expect(event.type).toBe('value');
+    expect(event.data).toEqual({ name: 'Alice' });
+
+    controller.abort();
+  });
+
+  test('GET /sse/path?event=child streams child events', async () => {
+    db = new BodDB({ port: 0 });
+    const server = db.serve();
+    const port = server.port;
+
+    const controller = new AbortController();
+    const res = await fetch(`http://localhost:${port}/sse/users?event=child`, { signal: controller.signal });
+
+    const reader = res.body!.getReader();
+    const decoder = new TextDecoder();
+
+    // Read initial SSE comment
+    await reader.read();
+
+    setTimeout(() => db.set('users/u1', { name: 'Alice' }), 50);
+
+    const { value } = await reader.read();
+    const text = decoder.decode(value);
+    const jsonStr = text.split('data: ')[1].split('\n')[0];
+    const event = JSON.parse(jsonStr);
+    expect(event.type).toBe('child');
+    expect(event.key).toBe('u1');
+
+    controller.abort();
+  });
+
+  test('SSE respects rules', async () => {
+    db = new BodDB({
+      port: 0,
+      rules: { 'secret': { read: false } },
+    });
+    const server = db.serve();
+    const port = server.port;
+
+    const res = await fetch(`http://localhost:${port}/sse/secret/data`);
+    expect(res.status).toBe(403);
+  });
+});

package/tests/storage.test.ts

@@ -0,0 +1,199 @@
+import { describe, test, expect } from 'bun:test';
+import { StorageEngine } from '../src/server/StorageEngine.ts';
+
+function createEngine() {
+  return new StorageEngine({ path: ':memory:' });
+}
+
+describe('StorageEngine', () => {
+  test('set and get a primitive', () => {
+    const s = createEngine();
+    s.set('foo', 'bar');
+    expect(s.get('foo')).toBe('bar');
+    s.close();
+  });
+
+  test('set and get a nested object', () => {
+    const s = createEngine();
+    s.set('users/u1', { name: 'Alice', settings: { theme: 'dark' } });
+    expect(s.get('users/u1')).toEqual({ name: 'Alice', settings: { theme: 'dark' } });
+    expect(s.get('users/u1/name')).toBe('Alice');
+    expect(s.get('users/u1/settings/theme')).toBe('dark');
+    s.close();
+  });
+
+  test('deeply nested objects (4 levels)', () => {
+    const s = createEngine();
+    s.set('a/b/c/d', { e: 'deep' });
+    expect(s.get('a/b/c/d/e')).toBe('deep');
+    expect(s.get('a')).toEqual({ b: { c: { d: { e: 'deep' } } } });
+    s.close();
+  });
+
+  test('overwrite replaces subtree', () => {
+    const s = createEngine();
+    s.set('users/u1', { name: 'Alice', age: 30 });
+    s.set('users/u1', { name: 'Bob' });
+    expect(s.get('users/u1')).toEqual({ name: 'Bob' });
+    s.close();
+  });
+
+  test('delete removes exact and subtree', () => {
+    const s = createEngine();
+    s.set('users/u1', { name: 'Alice', settings: { theme: 'dark' } });
+    s.delete('users/u1');
+    expect(s.get('users/u1')).toBeNull();
+    expect(s.get('users/u1/name')).toBeNull();
+    s.close();
+  });
+
+  test('multi-path update is atomic', () => {
+    const s = createEngine();
+    s.update({ 'users/u1/name': 'Alice', 'users/u2/name': 'Bob', 'counter': 42 });
+    expect(s.get('users/u1/name')).toBe('Alice');
+    expect(s.get('users/u2/name')).toBe('Bob');
+    expect(s.get('counter')).toBe(42);
+    s.close();
+  });
+
+  test('update merges — does not destroy untouched keys', () => {
+    const s = createEngine();
+    s.set('users/u1', { name: 'Alice', age: 30, settings: { theme: 'dark' } });
+    s.update({ 'users/u1': { name: 'Bob' } });
+    expect(s.get('users/u1')).toEqual({ name: 'Bob', age: 30, settings: { theme: 'dark' } });
+    s.close();
+  });
+
+  test('update merge replaces nested subtree for touched key', () => {
+    const s = createEngine();
+    s.set('users/u1', { name: 'Alice', settings: { theme: 'dark', lang: 'en' } });
+    s.update({ 'users/u1': { settings: { theme: 'light' } } });
+    // settings is replaced entirely (shallow merge), but name is untouched
+    expect(s.get('users/u1')).toEqual({ name: 'Alice', settings: { theme: 'light' } });
+    s.close();
+  });
+
+  test('update merge with null deletes specific key', () => {
+    const s = createEngine();
+    s.set('users/u1', { name: 'Alice', age: 30 });
+    s.update({ 'users/u1': { age: null } });
+    expect(s.get('users/u1')).toEqual({ name: 'Alice' });
+    s.close();
+  });
+
+  test('update with primitive value replaces (no merge)', () => {
+    const s = createEngine();
+    s.set('counter', 10);
+    s.update({ 'counter': 20 });
+    expect(s.get('counter')).toBe(20);
+    s.close();
+  });
+
+  test('merge standalone method', () => {
+    const s = createEngine();
+    s.set('config', { a: 1, b: 2, c: 3 });
+    s.merge('config', { b: 20, d: 4 });
+    expect(s.get('config')).toEqual({ a: 1, b: 20, c: 3, d: 4 });
+    s.close();
+  });
+
+  test('update with null deletes path', () => {
+    const s = createEngine();
+    s.set('users/u1/name', 'Alice');
+    s.update({ 'users/u1/name': null });
+    expect(s.get('users/u1/name')).toBeNull();
+    s.close();
+  });
+
+  test('get nonexistent returns null', () => {
+    const s = createEngine();
+    expect(s.get('nope')).toBeNull();
+    s.close();
+  });
+
+  test('get parent reconstructs children', () => {
+    const s = createEngine();
+    s.set('users/u1/name', 'Alice');
+    s.set('users/u2/name', 'Bob');
+    expect(s.get('users')).toEqual({ u1: { name: 'Alice' }, u2: { name: 'Bob' } });
+    s.close();
+  });
+
+  test('set array value', () => {
+    const s = createEngine();
+    s.set('tags', ['a', 'b', 'c']);
+    expect(s.get('tags')).toEqual(['a', 'b', 'c']);
+    s.close();
+  });
+
+  test('set number and boolean', () => {
+    const s = createEngine();
+    s.set('count', 42);
+    s.set('active', true);
+    expect(s.get('count')).toBe(42);
+    expect(s.get('active')).toBe(true);
+    s.close();
+  });
+
+  test('exists returns correct values', () => {
+    const s = createEngine();
+    expect(s.exists('nope')).toBe(false);
+    s.set('users/u1', { name: 'Alice' });
+    expect(s.exists('users/u1')).toBe(true);
+    expect(s.exists('users')).toBe(true);
+    expect(s.exists('users/u2')).toBe(false);
+    s.close();
+  });
+
+  test('rejects empty path', () => {
+    const s = createEngine();
+    expect(() => s.get('')).toThrow('Path cannot be empty');
+    s.close();
+  });
+
+  test('createIndex with valid field', () => {
+    const s = createEngine();
+    s.set('users/u1', { name: 'Alice', role: 'admin' });
+    expect(() => s.createIndex('users', 'role')).not.toThrow();
+    s.close();
+  });
+
+  test('createIndex rejects invalid field', () => {
+    const s = createEngine();
+    expect(() => s.createIndex('users', 'role; DROP TABLE nodes')).toThrow('Invalid index field');
+    s.close();
+  });
+});
+
+describe('StorageEngine.query', () => {
+  test('query with filter', () => {
+    const s = createEngine();
+    s.set('users/u1', { name: 'Alice', role: 'admin' });
+    s.set('users/u2', { name: 'Bob', role: 'user' });
+    s.set('users/u3', { name: 'Charlie', role: 'admin' });
+
+    const admins = s.query('users', [{ field: 'role', op: '==', value: 'admin' }]);
+    expect(admins.length).toBe(2);
+    expect(admins.map(a => a._key).sort()).toEqual(['u1', 'u3']);
+    s.close();
+  });
+
+  test('query with order and limit', () => {
+    const s = createEngine();
+    s.set('users/u1', { name: 'Charlie' });
+    s.set('users/u2', { name: 'Alice' });
+    s.set('users/u3', { name: 'Bob' });
+
+    const result = s.query('users', undefined, { field: 'name', dir: 'asc' }, 2);
+    expect(result.length).toBe(2);
+    expect(result[0].name).toBe('Alice');
+    expect(result[1].name).toBe('Bob');
+    s.close();
+  });
+
+  test('query empty path returns empty', () => {
+    const s = createEngine();
+    expect(s.query('nope')).toEqual([]);
+    s.close();
+  });
+});