@bod.ee/db 0.10.2 → 0.12.1

package/tests/optimization.test.ts

@@ -0,0 +1,392 @@
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { BodDB } from '../src/server/BodDB.ts';
+import { SubscriptionEngine, SubscriptionEngineOptions } from '../src/server/SubscriptionEngine.ts';
+import { StorageEngine } from '../src/server/StorageEngine.ts';
+import { BodClient, BodClientOptions } from '../src/client/BodClient.ts';
+import { encryptPrivateKey, decryptPrivateKey, generateEd25519KeyPair } from '../src/shared/keyAuth.ts';
+
+// --- Phase A ---
+
+describe('A1: Request Timeout', () => {
+  test('sendRaw rejects after timeout', async () => {
+    const client = new BodClient({ url: 'ws://localhost:19999', requestTimeout: 100 });
+    // Can't connect, so sendRaw will reject with "Not connected" before timeout
+    // Test the option is set
+    expect(client.options.requestTimeout).toBe(100);
+  });
+
+  test('default timeout is 30000', () => {
+    const client = new BodClient();
+    expect(client.options.requestTimeout).toBe(30000);
+  });
+});
+
+describe('A2: Connection Cap + Message Size Limit', () => {
+  let db: BodDB;
+
+  afterEach(() => db?.close());
+
+  test('maxConnections option defaults to 10000', () => {
+    db = new BodDB({ path: ':memory:' });
+    const server = db.serve({ port: 0 });
+    expect(db.transport!.options.maxConnections).toBe(10000);
+    server.stop(true);
+  });
+
+  test('maxMessageSize option defaults to 1MB', () => {
+    db = new BodDB({ path: ':memory:' });
+    const server = db.serve({ port: 0 });
+    expect(db.transport!.options.maxMessageSize).toBe(1_048_576);
+    server.stop(true);
+  });
+
+  test('maxSubscriptionsPerClient option defaults to 500', () => {
+    db = new BodDB({ path: ':memory:' });
+    const server = db.serve({ port: 0 });
+    expect(db.transport!.options.maxSubscriptionsPerClient).toBe(500);
+    server.stop(true);
+  });
+});
+
+describe('A3: Try-Catch in Subscription Callbacks', () => {
+  test('throwing callback does not prevent other callbacks', () => {
+    const subs = new SubscriptionEngine();
+    const results: string[] = [];
+
+    subs.onValue('test', () => { throw new Error('boom'); });
+    subs.onValue('test', (snap) => { results.push(snap.path); });
+
+    subs.notify(['test'], () => 'value');
+
+    expect(results).toEqual(['test']);
+  });
+
+  test('throwing child callback does not prevent other callbacks', () => {
+    const subs = new SubscriptionEngine();
+    const results: string[] = [];
+
+    subs.onChild('a', () => { throw new Error('boom'); });
+    subs.onChild('a', (ev) => { results.push(ev.key); });
+
+    subs.notify(['a/b'], () => 'value');
+
+    expect(results).toEqual(['b']);
+  });
+});
+
+describe('A4: Subscription Caps', () => {
+  test('global subscription cap throws when exceeded', () => {
+    const subs = new SubscriptionEngine({ maxSubscriptions: 2 });
+    subs.onValue('a', () => {});
+    subs.onValue('b', () => {});
+    expect(() => subs.onValue('c', () => {})).toThrow('Subscription limit reached');
+  });
+
+  test('child subscription counts towards cap', () => {
+    const subs = new SubscriptionEngine({ maxSubscriptions: 1 });
+    subs.onChild('a', () => {});
+    expect(() => subs.onValue('b', () => {})).toThrow('Subscription limit reached');
+  });
+});
+
+describe('A5: Lazy Stats Publisher', () => {
+  test('stats publisher skips when no _admin subscribers', () => {
+    const db = new BodDB({ path: ':memory:' });
+    // No subscribers — startStatsPublisher should not set _admin/stats
+    db.startStatsPublisher();
+    // Wait a tick for the interval
+    const stats = db.get('_admin/stats');
+    expect(stats).toBeNull();
+    db.close();
+  });
+});
+
+describe('A6: Batch snapshotExisting / existsMany', () => {
+  test('existsMany returns correct set', () => {
+    const storage = new StorageEngine({ path: ':memory:' });
+    storage.set('users/u1/name', 'Alice');
+    storage.set('users/u2/name', 'Bob');
+
+    const result = storage.existsMany(['users/u1', 'users/u2', 'users/u3']);
+    expect(result.has('users/u1')).toBe(true);
+    expect(result.has('users/u2')).toBe(true);
+    expect(result.has('users/u3')).toBe(false);
+    storage.close();
+  });
+
+  test('existsMany with empty input returns empty set', () => {
+    const storage = new StorageEngine({ path: ':memory:' });
+    expect(storage.existsMany([]).size).toBe(0);
+    storage.close();
+  });
+});
+
+describe('A7: Configurable PBKDF2 Iterations', () => {
+  test('encrypt/decrypt with custom iterations', () => {
+    const kp = generateEd25519KeyPair();
+    const enc = encryptPrivateKey(kp.privateKey, 'password', 1000);
+    const dec = decryptPrivateKey(enc.encrypted, enc.salt, enc.iv, enc.authTag, 'password', 1000);
+    expect(Buffer.from(dec).toString('base64')).toBe(Buffer.from(kp.privateKey).toString('base64'));
+  });
+
+  test('wrong iterations fails to decrypt', () => {
+    const kp = generateEd25519KeyPair();
+    const enc = encryptPrivateKey(kp.privateKey, 'password', 1000);
+    expect(() => decryptPrivateKey(enc.encrypted, enc.salt, enc.iv, enc.authTag, 'password', 2000)).toThrow();
+  });
+
+  test('KeyAuthEngine passes iterations to createAccount', () => {
+    const db = new BodDB({ path: ':memory:', keyAuth: { pbkdf2Iterations: 1000 } });
+    expect(db.keyAuth!.options.pbkdf2Iterations).toBe(1000);
+    // Creating an account should work with reduced iterations
+    const result = db.keyAuth!.createAccount('testpass', [], 'TestUser');
+    expect(result.fingerprint).toBeTruthy();
+    db.close();
+  });
+});
+
+// --- Phase B ---
+
+describe('B1: SQL Push-Down for Queries', () => {
+  test('query on push rows uses SQL push-down', () => {
+    const db = new BodDB({ path: ':memory:' });
+    for (let i = 0; i < 20; i++) {
+      db.push('items', { name: `item-${i}`, category: i % 2 === 0 ? 'even' : 'odd', score: i });
+    }
+    const results = db.query('items').where('category', '==', 'even').get();
+    expect(results.length).toBe(10);
+    for (const r of results) {
+      expect((r as any).category).toBe('even');
+    }
+    db.close();
+  });
+
+  test('query on push rows with order + limit', () => {
+    const db = new BodDB({ path: ':memory:' });
+    for (let i = 0; i < 10; i++) {
+      db.push('items', { name: `item-${i}`, score: i });
+    }
+    const results = db.query('items').where('score', '>=', 5).order('score', 'desc').limit(3).get();
+    expect(results.length).toBe(3);
+    expect((results[0] as any).score).toBe(9);
+    db.close();
+  });
+
+  test('query on flattened rows still works (JS fallback)', () => {
+    const db = new BodDB({ path: ':memory:' });
+    db.set('users/u1', { name: 'Alice', role: 'admin', age: 30 });
+    db.set('users/u2', { name: 'Bob', role: 'user', age: 25 });
+    db.set('users/u3', { name: 'Carol', role: 'admin', age: 35 });
+    const results = db.query('users').where('role', '==', 'admin').get();
+    expect(results.length).toBe(2);
+    db.close();
+  });
+});
+
+describe('B2: Broadcast Groups', () => {
+  let db: BodDB;
+  let port: number;
+
+  beforeEach(() => {
+    db = new BodDB({ path: ':memory:' });
+    const server = db.serve({ port: 0 });
+    port = server.port;
+  });
+
+  afterEach(() => db?.close());
+
+  test('multiple clients on same path share broadcast', async () => {
+    const clients = Array.from({ length: 3 }, () => new BodClient({ url: `ws://localhost:${port}`, requestTimeout: 5000 }));
+    await Promise.all(clients.map(c => c.connect()));
+
+    const received: unknown[][] = [[], [], []];
+    clients.forEach((c, i) => c.on('shared/path', (snap) => received[i].push(snap.val())));
+
+    await new Promise(r => setTimeout(r, 50));
+    db.set('shared/path', 'hello');
+    await new Promise(r => setTimeout(r, 100));
+
+    for (let i = 0; i < 3; i++) {
+      expect(received[i].length).toBeGreaterThanOrEqual(1);
+      expect(received[i][received[i].length - 1]).toBe('hello');
+    }
+
+    clients.forEach(c => c.disconnect());
+  });
+});
+
+describe('B3: Async Batched Notifications', () => {
+  test('asyncNotify coalesces multiple writes in same tick', async () => {
+    const subs = new SubscriptionEngine({ asyncNotify: true });
+    const notifications: string[] = [];
+    subs.onValue('data', (snap) => notifications.push(snap.path));
+
+    // Three rapid queueNotify calls in same tick
+    subs.queueNotify(['data'], () => 1);
+    subs.queueNotify(['data'], () => 2);
+    subs.queueNotify(['data'], () => 3);
+
+    // Not delivered yet (microtask pending)
+    expect(notifications.length).toBe(0);
+
+    // Wait for microtask
+    await new Promise(r => queueMicrotask(r));
+    await new Promise(r => setTimeout(r, 0));
+
+    // Should be coalesced into one notification
+    expect(notifications.length).toBe(1);
+  });
+
+  test('sync notify still works when asyncNotify is false', () => {
+    const subs = new SubscriptionEngine({ asyncNotify: false });
+    const notifications: string[] = [];
+    subs.onValue('data', (snap) => notifications.push(snap.path));
+
+    subs.queueNotify(['data'], () => 1);
+    subs.queueNotify(['data'], () => 2);
+
+    // Delivered synchronously (asyncNotify=false falls back to sync notify)
+    expect(notifications.length).toBe(2);
+  });
+});
+
+describe('B4: Batch Re-Subscribe Protocol', () => {
+  let db: BodDB;
+  let port: number;
+
+  beforeEach(() => {
+    db = new BodDB({ path: ':memory:' });
+    const server = db.serve({ port: 0 });
+    port = server.port;
+  });
+
+  afterEach(() => db?.close());
+
+  test('batch-sub registers multiple subscriptions at once', async () => {
+    const client = new BodClient({ url: `ws://localhost:${port}`, requestTimeout: 5000 });
+    await client.connect();
+
+    // Use internal send to call batch-sub directly
+    const result = await (client as any).send('batch-sub', {
+      subscriptions: [
+        { path: 'a', event: 'value' },
+        { path: 'b', event: 'value' },
+        { path: 'c', event: 'child' },
+      ],
+    }) as { subscribed: number };
+
+    expect(result.subscribed).toBe(3);
+
+    // Verify subs work
+    const received: unknown[] = [];
+    client.on('a', (snap) => received.push(snap.val()));
+    await new Promise(r => setTimeout(r, 50));
+    db.set('a', 'test');
+    await new Promise(r => setTimeout(r, 100));
+    expect(received.length).toBeGreaterThanOrEqual(1);
+
+    client.disconnect();
+  });
+});
+
+describe('B5: Cursor-Based Stream Materialize', () => {
+  test('cursor-based materialize returns batched results', () => {
+    const db = new BodDB({ path: ':memory:' });
+    for (let i = 0; i < 10; i++) {
+      db.push('events', { id: i, data: `event-${i}` });
+    }
+
+    // Iterate with cursor until exhausted
+    let allData: Record<string, unknown> = {};
+    let cursor: string | undefined;
+    let iterations = 0;
+    do {
+      const r = db.stream.materialize('events', { keepKey: 'id', batchSize: 3, cursor }) as { data: Record<string, unknown>; nextCursor?: string };
+      Object.assign(allData, r.data);
+      cursor = r.nextCursor;
+      iterations++;
+    } while (cursor);
+
+    expect(iterations).toBeGreaterThan(1);
+    expect(Object.keys(allData).length).toBe(10);
+
+    db.close();
+  });
+
+  test('full materialize still works (backward compat)', () => {
+    const db = new BodDB({ path: ':memory:' });
+    for (let i = 0; i < 5; i++) {
+      db.push('events', { id: i });
+    }
+    const result = db.stream.materialize('events', { keepKey: 'id' });
+    expect(Object.keys(result).length).toBe(5);
+    db.close();
+  });
+});
+
+describe('B6: Batched Replication Events', () => {
+  test('transaction batches repl events', () => {
+    const db = new BodDB({ path: ':memory:', replication: { role: 'primary' } });
+    db.replication!['_started'] = true;
+    db.replication!['startPrimary']();
+
+    // Do a transaction with 3 writes
+    db.transaction((tx) => {
+      tx.set('a', 1);
+      tx.set('b', 2);
+      tx.set('c', 3);
+    });
+
+    // All 3 should have been emitted to _repl
+    const replEvents = db.storage.query('_repl');
+    expect(replEvents.length).toBe(3);
+
+    db.close();
+  });
+
+  test('non-transactional writes emit immediately', () => {
+    const db = new BodDB({ path: ':memory:', replication: { role: 'primary' } });
+    db.replication!['_started'] = true;
+    db.replication!['startPrimary']();
+
+    db.set('x', 'val');
+    const replEvents = db.storage.query('_repl');
+    expect(replEvents.length).toBe(1);
+
+    db.close();
+  });
+});
+
+describe('B7: Auth Rate Limiting', () => {
+  test('lockout after max failures', () => {
+    const db = new BodDB({
+      path: ':memory:',
+      keyAuth: { maxAuthFailures: 3, authLockoutSeconds: 60 },
+    });
+    const engine = db.keyAuth!;
+
+    // Register an account
+    const kp = generateEd25519KeyPair();
+    engine.registerDevice(kp.publicKeyBase64);
+
+    // Get a valid challenge
+    for (let i = 0; i < 3; i++) {
+      const challenge = engine.challenge();
+      // Send wrong signature
+      engine.verify(kp.publicKeyBase64, Buffer.from('bad-sig').toString('base64'), challenge.nonce);
+    }
+
+    // Now locked out — even a valid attempt should fail
+    const challenge = engine.challenge();
+    const result = engine.verify(kp.publicKeyBase64, Buffer.from('bad').toString('base64'), challenge.nonce);
+    expect(result).toBeNull();
+
+    db.close();
+  });
+
+  test('rate limit disabled by default', () => {
+    const db = new BodDB({ path: ':memory:', keyAuth: {} });
+    expect(db.keyAuth!.options.maxAuthFailures).toBe(0);
+    db.close();
+  });
+});