@bod.ee/db 0.7.0

package/tests/e2e.test.ts

@@ -0,0 +1,284 @@
+import { describe, test, expect, afterEach } from 'bun:test';
+import { BodDB } from '../src/server/BodDB.ts';
+import { BodClient } from '../src/client/BodClient.ts';
+
+let db: BodDB;
+let client: BodClient;
+
+function setup(rules?: Record<string, any>, auth?: any) {
+  db = new BodDB({ rules, port: 0, auth });
+  const server = db.serve();
+  client = new BodClient({ url: `ws://localhost:${server.port}`, reconnect: false });
+  return server.port;
+}
+
+afterEach(() => {
+  client?.disconnect();
+  db?.close();
+});
+
+describe('E2E: BodClient CRUD', () => {
+  test('set and get', async () => {
+    setup();
+    await client.connect();
+
+    await client.set('users/u1', { name: 'Alice', role: 'admin' });
+    const val = await client.get('users/u1');
+    expect(val).toEqual({ name: 'Alice', role: 'admin' });
+  });
+
+  test('get leaf path', async () => {
+    setup();
+    await client.connect();
+
+    await client.set('users/u1', { name: 'Alice' });
+    expect(await client.get('users/u1/name')).toBe('Alice');
+  });
+
+  test('update multi-path', async () => {
+    setup();
+    await client.connect();
+
+    await client.set('users/u1', { name: 'Alice' });
+    await client.update({ 'users/u1/name': 'Bob', 'flags/dirty': true });
+    expect(await client.get('users/u1/name')).toBe('Bob');
+    expect(await client.get('flags/dirty')).toBe(true);
+  });
+
+  test('delete', async () => {
+    setup();
+    await client.connect();
+
+    await client.set('tmp/data', 'hello');
+    await client.delete('tmp/data');
+    expect(await client.get('tmp/data')).toBeNull();
+  });
+
+  test('get nonexistent returns null', async () => {
+    setup();
+    await client.connect();
+
+    expect(await client.get('nope/nothing')).toBeNull();
+  });
+});
+
+describe('E2E: BodClient Query', () => {
+  test('fluent query with filters', async () => {
+    setup();
+    await client.connect();
+
+    await client.set('users/u1', { name: 'Alice', role: 'admin' });
+    await client.set('users/u2', { name: 'Bob', role: 'user' });
+    await client.set('users/u3', { name: 'Charlie', role: 'admin' });
+
+    const result = await client.query('users')
+      .where('role', '==', 'admin')
+      .order('name')
+      .get() as any[];
+
+    expect(result.length).toBe(2);
+    expect(result[0].name).toBe('Alice');
+    expect(result[1].name).toBe('Charlie');
+  });
+
+  test('query with limit and offset', async () => {
+    setup();
+    await client.connect();
+
+    await client.set('items/a', { v: 1 });
+    await client.set('items/b', { v: 2 });
+    await client.set('items/c', { v: 3 });
+
+    const result = await client.query('items')
+      .order('v')
+      .offset(1)
+      .limit(1)
+      .get() as any[];
+
+    expect(result.length).toBe(1);
+    expect(result[0].v).toBe(2);
+  });
+});
+
+describe('E2E: BodClient Subscriptions', () => {
+  test('value subscription receives pushes', async () => {
+    setup();
+    await client.connect();
+
+    const events: unknown[] = [];
+    client.on('users/u1', (snap) => events.push(snap.val()));
+
+    // Wait for sub to register
+    await Bun.sleep(30);
+
+    // Write from server side
+    db.set('users/u1', { name: 'Alice' });
+    await Bun.sleep(50);
+
+    expect(events.length).toBe(1);
+    expect(events[0]).toEqual({ name: 'Alice' });
+  });
+
+  test('value snapshot properties', async () => {
+    setup();
+    await client.connect();
+
+    let snap: any;
+    client.on('users/u1', (s) => { snap = s; });
+    await Bun.sleep(30);
+
+    db.set('users/u1', { name: 'Alice' });
+    await Bun.sleep(50);
+
+    expect(snap.path).toBe('users/u1');
+    expect(snap.key).toBe('u1');
+    expect(snap.exists()).toBe(true);
+    expect(snap.val()).toEqual({ name: 'Alice' });
+  });
+
+  test('child subscription receives events', async () => {
+    setup();
+    await client.connect();
+
+    const events: Array<{ type: string; key: string }> = [];
+    client.onChild('users', (e) => events.push({ type: e.type, key: e.key }));
+    await Bun.sleep(30);
+
+    db.set('users/u1', { name: 'Alice' });
+    db.set('users/u2', { name: 'Bob' });
+    await Bun.sleep(50);
+
+    expect(events.length).toBe(2);
+    expect(events[0]).toEqual({ type: 'added', key: 'u1' });
+    expect(events[1]).toEqual({ type: 'added', key: 'u2' });
+  });
+
+  test('unsubscribe stops pushes', async () => {
+    setup();
+    await client.connect();
+
+    const events: unknown[] = [];
+    const off = client.on('users/u1', (snap) => events.push(snap.val()));
+    await Bun.sleep(30);
+
+    db.set('users/u1', { name: 'Alice' });
+    await Bun.sleep(50);
+    expect(events.length).toBe(1);
+
+    off();
+    await Bun.sleep(30);
+
+    db.set('users/u1', { name: 'Bob' });
+    await Bun.sleep(50);
+    expect(events.length).toBe(1); // no new event
+  });
+
+  test('multiple clients receive updates', async () => {
+    db = new BodDB({ port: 0 });
+    const server = db.serve();
+    const port = server.port;
+
+    const c1 = new BodClient({ url: `ws://localhost:${port}`, reconnect: false });
+    const c2 = new BodClient({ url: `ws://localhost:${port}`, reconnect: false });
+    await c1.connect();
+    await c2.connect();
+
+    const e1: unknown[] = [];
+    const e2: unknown[] = [];
+    c1.on('data', (s) => e1.push(s.val()));
+    c2.on('data', (s) => e2.push(s.val()));
+    await Bun.sleep(30);
+
+    // c1 writes, both should receive
+    await c1.set('data', 'hello');
+    await Bun.sleep(50);
+
+    expect(e1.length).toBe(1);
+    expect(e2.length).toBe(1);
+    expect(e1[0]).toBe('hello');
+    expect(e2[0]).toBe('hello');
+
+    c1.disconnect();
+    c2.disconnect();
+    // Use the module-level client variable for cleanup
+    client = c1;
+  });
+});
+
+describe('E2E: Auth', () => {
+  test('auth token flow', async () => {
+    setup(
+      { 'private': { write: (ctx: any) => !!ctx.auth } },
+      (token: string) => token === 'secret' ? { uid: 'u1' } : null,
+    );
+
+    client = new BodClient({
+      url: `ws://localhost:${db.serve ? (db as any).transport?.port : 4400}`,
+      reconnect: false,
+      auth: () => 'secret',
+    });
+
+    // Re-create client pointing to actual port
+    const port = (db as any).transport?.port;
+    client = new BodClient({
+      url: `ws://localhost:${port}`,
+      reconnect: false,
+      auth: () => 'secret',
+    });
+    await client.connect();
+
+    // Should succeed after auth
+    await client.set('private/data', 'works');
+    expect(await client.get('private/data')).toBe('works');
+  });
+
+  test('bad auth rejects', async () => {
+    db = new BodDB({ port: 0, auth: (token) => token === 'good' ? { uid: 'u1' } : null });
+    const server = db.serve();
+
+    client = new BodClient({
+      url: `ws://localhost:${server.port}`,
+      reconnect: false,
+      auth: () => 'bad',
+    });
+
+    await expect(client.connect()).rejects.toThrow('Authentication failed');
+  });
+});
+
+describe('E2E: Reconnection', () => {
+  test('reconnects and re-subscribes', async () => {
+    db = new BodDB({ port: 0 });
+    const server = db.serve();
+    const port = server.port;
+
+    client = new BodClient({
+      url: `ws://localhost:${port}`,
+      reconnect: true,
+      reconnectInterval: 100,
+    });
+    await client.connect();
+
+    const events: unknown[] = [];
+    client.on('data', (s) => events.push(s.val()));
+    await Bun.sleep(30);
+
+    // Write before disconnect
+    db.set('data', 'before');
+    await Bun.sleep(50);
+    expect(events.length).toBe(1);
+
+    // Restart server on same port
+    db.stop();
+    await Bun.sleep(50);
+    db.serve({ port });
+    await Bun.sleep(300); // wait for reconnect
+
+    // Write after reconnect
+    db.set('data', 'after');
+    await Bun.sleep(100);
+
+    expect(events.length).toBe(2);
+    expect(events[1]).toBe('after');
+  });
+});

package/tests/expression-rules.test.ts

@@ -0,0 +1,114 @@
+import { describe, test, expect } from 'bun:test';
+import { compileRule } from '../src/server/ExpressionRules.ts';
+import { RulesEngine } from '../src/server/RulesEngine.ts';
+
+describe('ExpressionRules — compileRule', () => {
+  test('boolean literal', () => {
+    expect(compileRule(true)({}  as any)).toBe(true);
+    expect(compileRule(false)({} as any)).toBe(false);
+  });
+
+  test('string true/false', () => {
+    expect(compileRule('true')({} as any)).toBe(true);
+    expect(compileRule('false')({} as any)).toBe(false);
+  });
+
+  test('auth.uid === $uid', () => {
+    const fn = compileRule("auth.uid === $uid");
+    expect(fn({ auth: { uid: 'u1' }, params: { uid: 'u1' }, data: null, newData: null })).toBe(true);
+    expect(fn({ auth: { uid: 'u2' }, params: { uid: 'u1' }, data: null, newData: null })).toBe(false);
+  });
+
+  test('null auth → false for auth checks', () => {
+    const fn = compileRule("auth.uid === 'u1'");
+    expect(fn({ auth: null, params: {}, data: null, newData: null })).toBe(false);
+  });
+
+  test('auth.role == admin string', () => {
+    const fn = compileRule("auth.role == 'admin'");
+    expect(fn({ auth: { role: 'admin' }, params: {}, data: null, newData: null })).toBe(true);
+    expect(fn({ auth: { role: 'user' }, params: {}, data: null, newData: null })).toBe(false);
+  });
+
+  test('logical AND', () => {
+    const fn = compileRule("auth.role == 'admin' && auth.active == true");
+    expect(fn({ auth: { role: 'admin', active: true }, params: {}, data: null, newData: null })).toBe(true);
+    expect(fn({ auth: { role: 'admin', active: false }, params: {}, data: null, newData: null })).toBe(false);
+  });
+
+  test('logical OR', () => {
+    const fn = compileRule("auth.role == 'admin' || auth.role == 'mod'");
+    expect(fn({ auth: { role: 'mod' }, params: {}, data: null, newData: null })).toBe(true);
+    expect(fn({ auth: { role: 'user' }, params: {}, data: null, newData: null })).toBe(false);
+  });
+
+  test('negation', () => {
+    const fn = compileRule("!auth.banned");
+    expect(fn({ auth: { banned: false }, params: {}, data: null, newData: null })).toBe(true);
+    expect(fn({ auth: { banned: true }, params: {}, data: null, newData: null })).toBe(false);
+  });
+
+  test('numeric comparison', () => {
+    const fn = compileRule("auth.level >= 5");
+    expect(fn({ auth: { level: 5 }, params: {}, data: null, newData: null })).toBe(true);
+    expect(fn({ auth: { level: 3 }, params: {}, data: null, newData: null })).toBe(false);
+  });
+
+  test('parenthesized expression', () => {
+    const fn = compileRule("(auth.role == 'admin') || (auth.uid === $uid)");
+    expect(fn({ auth: { role: 'user', uid: 'u1' }, params: { uid: 'u1' }, data: null, newData: null })).toBe(true);
+    expect(fn({ auth: { role: 'user', uid: 'u2' }, params: { uid: 'u1' }, data: null, newData: null })).toBe(false);
+  });
+
+  test('data and newData access', () => {
+    const fn = compileRule("newData.status != 'deleted'");
+    expect(fn({ auth: null, params: {}, data: null, newData: { status: 'active' } })).toBe(true);
+    expect(fn({ auth: null, params: {}, data: null, newData: { status: 'deleted' } })).toBe(false);
+  });
+
+  test('null comparison', () => {
+    const fn = compileRule("auth != null");
+    expect(fn({ auth: { uid: 'u1' }, params: {}, data: null, newData: null })).toBe(true);
+    expect(fn({ auth: null, params: {}, data: null, newData: null })).toBe(false);
+  });
+});
+
+describe('RulesEngine with expression strings', () => {
+  test('expression rules work in RulesEngine', () => {
+    const r = new RulesEngine({
+      rules: {
+        'users/$uid': {
+          read: true,
+          write: "auth.uid === $uid",
+        },
+      },
+    });
+    expect(r.check('read', 'users/u1', null)).toBe(true);
+    expect(r.check('write', 'users/u1', { uid: 'u1' })).toBe(true);
+    expect(r.check('write', 'users/u1', { uid: 'u2' })).toBe(false);
+  });
+
+  test('mixed function + expression rules', () => {
+    const r = new RulesEngine({
+      rules: {
+        'public': { read: true, write: false },
+        'admin': {
+          read: (ctx) => ctx.auth?.role === 'admin',
+          write: "auth.role == 'admin'",
+        },
+      },
+    });
+    expect(r.check('read', 'public/data', null)).toBe(true);
+    expect(r.check('write', 'public/data', null)).toBe(false);
+    expect(r.check('write', 'admin/config', { role: 'admin' })).toBe(true);
+    expect(r.check('write', 'admin/config', { role: 'user' })).toBe(false);
+  });
+
+  test('boolean false blocks access', () => {
+    const r = new RulesEngine({
+      rules: { 'locked': { read: false, write: false } },
+    });
+    expect(r.check('read', 'locked/path', null)).toBe(false);
+    expect(r.check('write', 'locked/path', null)).toBe(false);
+  });
+});

package/tests/file-adapter.test.ts

@@ -0,0 +1,57 @@
+import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
+import { BodDB } from '../src/server/BodDB.ts';
+import { FileAdapter } from '../src/server/FileAdapter.ts';
+import { mkdtemp, writeFile, rm } from 'fs/promises';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+describe('FileAdapter', () => {
+  let tmpDir: string;
+  let db: BodDB;
+  let adapter: FileAdapter;
+
+  beforeAll(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'zuzdb-fa-'));
+    await writeFile(join(tmpDir, 'hello.txt'), 'Hello World');
+    await writeFile(join(tmpDir, 'data.json'), '{"key": "value"}');
+
+    db = new BodDB({ sweepInterval: 0 });
+    adapter = new FileAdapter(db, { root: tmpDir, watch: false, metadata: true, indexContent: false });
+    await adapter.start();
+  });
+
+  afterAll(async () => {
+    adapter.stop();
+    db.close();
+    await rm(tmpDir, { recursive: true });
+  });
+
+  test('scans directory and stores metadata', () => {
+    const hello = db.get('files/hello.txt') as Record<string, unknown>;
+    expect(hello).not.toBeNull();
+    expect(hello.mime).toBe('text/plain');
+    expect(typeof hello.size).toBe('number');
+    expect(typeof hello.mtime).toBe('number');
+  });
+
+  test('stores metadata for json files', () => {
+    const data = db.get('files/data.json') as Record<string, unknown>;
+    expect(data).not.toBeNull();
+    expect(data.mime).toBe('application/json');
+  });
+
+  test('readContent reads file from disk', async () => {
+    const content = await adapter.readContent('hello.txt');
+    expect(content).toBe('Hello World');
+  });
+
+  test('writeContent writes to disk and syncs', async () => {
+    await adapter.writeContent('new.txt', 'New content');
+    const content = await adapter.readContent('new.txt');
+    expect(content).toBe('New content');
+
+    const meta = db.get('files/new.txt') as Record<string, unknown>;
+    expect(meta).not.toBeNull();
+    expect(meta.mime).toBe('text/plain');
+  });
+});

package/tests/fts.test.ts

@@ -0,0 +1,58 @@
+import { describe, test, expect } from 'bun:test';
+import { BodDB } from '../src/server/BodDB.ts';
+
+describe('FTS5 Full-Text Search', () => {
+  test('index and search text', () => {
+    const db = new BodDB({ sweepInterval: 0, fts: {} });
+    db.set('articles/a1', { title: 'Hello World', body: 'This is a test article' });
+    db.set('articles/a2', { title: 'Goodbye', body: 'Another article about testing' });
+    db.index('articles/a1', 'Hello World This is a test article');
+    db.index('articles/a2', 'Goodbye Another article about testing');
+
+    const results = db.search({ text: 'article' });
+    expect(results.length).toBe(2);
+    expect(results.some(r => r.path === 'articles/a1')).toBe(true);
+    db.close();
+  });
+
+  test('search with path prefix filter', () => {
+    const db = new BodDB({ sweepInterval: 0, fts: {} });
+    db.set('posts/p1', { text: 'hello' });
+    db.set('comments/c1', { text: 'hello there' });
+    db.index('posts/p1', 'hello');
+    db.index('comments/c1', 'hello there');
+
+    const results = db.search({ text: 'hello', path: 'posts' });
+    expect(results.length).toBe(1);
+    expect(results[0].path).toBe('posts/p1');
+    db.close();
+  });
+
+  test('search with limit', () => {
+    const db = new BodDB({ sweepInterval: 0, fts: {} });
+    for (let i = 0; i < 10; i++) {
+      db.set(`items/i${i}`, { text: `item ${i}` });
+      db.index(`items/i${i}`, `item ${i}`);
+    }
+
+    const results = db.search({ text: 'item', limit: 3 });
+    expect(results.length).toBe(3);
+    db.close();
+  });
+
+  test('index by fields', () => {
+    const db = new BodDB({ sweepInterval: 0, fts: {} });
+    db.set('docs/d1', { title: 'TypeScript Guide', body: 'Learn TS' });
+    db.index('docs/d1', ['title', 'body']);
+
+    const results = db.search({ text: 'TypeScript' });
+    expect(results.length).toBe(1);
+    db.close();
+  });
+
+  test('throws without fts config', () => {
+    const db = new BodDB({ sweepInterval: 0 });
+    expect(() => db.search({ text: 'test' })).toThrow('FTS not configured');
+    db.close();
+  });
+});