@bod.ee/db 0.7.0

package/tests/mq-flow.test.ts

@@ -0,0 +1,204 @@
+import { describe, test, expect } from 'bun:test';
+import { BodDB } from '../src/server/BodDB.ts';
+
+describe('MQ end-to-end flow', () => {
+  test('full worker lifecycle: push → fetch → process → ack/nack → retry → DLQ', () => {
+    const db = new BodDB({
+      path: ':memory:',
+      sweepInterval: 0,
+      mq: { visibilityTimeout: 2, maxDeliveries: 3 },
+    });
+
+    // ── Producer pushes 5 jobs ──
+    const keys: string[] = [];
+    for (let i = 1; i <= 5; i++) {
+      keys.push(db.mq.push('queues/jobs', { task: `job-${i}`, attempt: 0 }));
+    }
+    console.log(`\n📥 Pushed 5 jobs: ${keys.join(', ')}`);
+
+    let peek = db.mq.peek('queues/jobs', 10);
+    console.log(`📋 Peek: ${peek.length} messages, all ${peek.map(m => m.status).join(', ')}`);
+    expect(peek).toHaveLength(5);
+    expect(peek.every(m => m.status === 'pending')).toBe(true);
+
+    // ── Worker 1 fetches batch of 3 ──
+    const batch1 = db.mq.fetch('queues/jobs', 3);
+    console.log(`\n👷 Worker 1 claimed ${batch1.length} jobs: ${batch1.map(m => m.key).join(', ')}`);
+    expect(batch1).toHaveLength(3);
+    expect(batch1.every(m => m.status === 'inflight')).toBe(true);
+    expect(batch1.every(m => m.deliveryCount === 1)).toBe(true);
+
+    // ── Worker 2 fetches — gets remaining 2 ──
+    const batch2 = db.mq.fetch('queues/jobs', 5);
+    console.log(`👷 Worker 2 claimed ${batch2.length} jobs: ${batch2.map(m => m.key).join(', ')}`);
+    expect(batch2).toHaveLength(2);
+
+    // ── Worker 3 fetches — gets nothing (all inflight) ──
+    const batch3 = db.mq.fetch('queues/jobs', 5);
+    console.log(`👷 Worker 3 claimed ${batch3.length} jobs (none available)`);
+    expect(batch3).toHaveLength(0);
+
+    // ── Peek now shows all 5 as inflight ──
+    peek = db.mq.peek('queues/jobs', 10);
+    console.log(`📋 Peek: ${peek.map(m => `${m.key.slice(0,6)}=${m.status}`).join(', ')}`);
+    expect(peek.every(m => m.status === 'inflight')).toBe(true);
+
+    // ── Worker 1: ack job 1 (success), nack job 2 (transient error), ack job 3 ──
+    db.mq.ack('queues/jobs', batch1[0].key);
+    console.log(`\n✅ Worker 1 acked ${batch1[0].key.slice(0,8)} (job-1 done)`);
+
+    db.mq.nack('queues/jobs', batch1[1].key);
+    console.log(`🔄 Worker 1 nacked ${batch1[1].key.slice(0,8)} (job-2 retry)`);
+
+    db.mq.ack('queues/jobs', batch1[2].key);
+    console.log(`✅ Worker 1 acked ${batch1[2].key.slice(0,8)} (job-3 done)`);
+
+    // ── Worker 2: ack both ──
+    db.mq.ack('queues/jobs', batch2[0].key);
+    db.mq.ack('queues/jobs', batch2[1].key);
+    console.log(`✅ Worker 2 acked both (job-4, job-5 done)`);
+
+    // ── Peek: only job-2 remains (pending after nack) ──
+    peek = db.mq.peek('queues/jobs', 10);
+    console.log(`\n📋 Peek after processing: ${peek.length} remaining`);
+    expect(peek).toHaveLength(1);
+    expect(peek[0].key).toBe(batch1[1].key);
+    expect(peek[0].status).toBe('pending');
+    expect(peek[0].deliveryCount).toBe(1);
+
+    // ── Retry: Worker fetches job-2 again, fails again ──
+    const retry1 = db.mq.fetch('queues/jobs', 1);
+    expect(retry1).toHaveLength(1);
+    expect(retry1[0].deliveryCount).toBe(2);
+    console.log(`\n🔄 Retry 1: job-2 deliveryCount=${retry1[0].deliveryCount}`);
+    db.mq.nack('queues/jobs', retry1[0].key);
+
+    const retry2 = db.mq.fetch('queues/jobs', 1);
+    expect(retry2).toHaveLength(1);
+    expect(retry2[0].deliveryCount).toBe(3);
+    console.log(`🔄 Retry 2: job-2 deliveryCount=${retry2[0].deliveryCount}`);
+
+    // Worker doesn't ack or nack — simulates crash. Message stays inflight.
+    // Expire it manually (simulating visibility timeout)
+    db.storage.db.run(`UPDATE nodes SET mq_inflight_until = 1 WHERE mq_status = 'inflight'`);
+
+    // ── Sweep: deliveryCount=3 >= maxDeliveries=3 → DLQ ──
+    const sweepResult = db.mq.sweep();
+    console.log(`\n🧹 Sweep: reclaimed=${sweepResult.reclaimed}, dlq'd=${sweepResult.dlqd}`);
+    expect(sweepResult.reclaimed).toBe(0);
+    expect(sweepResult.dlqd).toBe(1);
+
+    // ── Queue is now empty ──
+    peek = db.mq.peek('queues/jobs', 10);
+    console.log(`📋 Queue after sweep: ${peek.length} messages`);
+    expect(peek).toHaveLength(0);
+
+    // ── DLQ has the failed job ──
+    const dlq = db.mq.dlq('queues/jobs');
+    console.log(`💀 DLQ: ${dlq.length} dead letters`);
+    expect(dlq).toHaveLength(1);
+    expect((dlq[0].data as any).task).toBe('job-2');
+
+    // ── Verify isolation: normal CRUD unaffected ──
+    expect(db.get('queues/jobs')).toBeNull();
+    db.set('queues/jobs/metadata', { created: Date.now() });
+    expect(db.get('queues/jobs/metadata')).toBeTruthy();
+    // DLQ still there
+    expect(db.mq.dlq('queues/jobs')).toHaveLength(1);
+
+    console.log(`\n🎉 Full flow complete — 5 pushed, 4 processed, 1 DLQ'd, CRUD isolated`);
+    db.close();
+  });
+
+  test('competing workers with visibility timeout reclaim', () => {
+    const db = new BodDB({
+      path: ':memory:',
+      sweepInterval: 0,
+      mq: { visibilityTimeout: 1, maxDeliveries: 10 },
+    });
+
+    // Push 3 jobs
+    db.mq.push('q/work', { id: 'a' });
+    db.mq.push('q/work', { id: 'b' });
+    db.mq.push('q/work', { id: 'c' });
+
+    // Worker 1 fetches all 3
+    const w1 = db.mq.fetch('q/work', 10);
+    expect(w1).toHaveLength(3);
+    console.log(`\n👷 W1 claimed 3`);
+
+    // Worker 2 gets nothing
+    expect(db.mq.fetch('q/work', 10)).toHaveLength(0);
+    console.log(`👷 W2 gets nothing (all inflight)`);
+
+    // Worker 1 crashes — expire all
+    db.storage.db.run(`UPDATE nodes SET mq_inflight_until = 1 WHERE mq_status = 'inflight'`);
+
+    // Sweep reclaims
+    const result = db.mq.sweep();
+    expect(result.reclaimed).toBe(3);
+    console.log(`🧹 Sweep reclaimed ${result.reclaimed}`);
+
+    // Worker 2 now gets all 3
+    const w2 = db.mq.fetch('q/work', 10);
+    expect(w2).toHaveLength(3);
+    expect(w2.every(m => m.deliveryCount === 2)).toBe(true);
+    console.log(`👷 W2 claimed ${w2.length}, all deliveryCount=2`);
+
+    // Ack all
+    for (const m of w2) db.mq.ack('q/work', m.key);
+    expect(db.mq.peek('q/work')).toHaveLength(0);
+    console.log(`✅ All acked, queue empty`);
+
+    db.close();
+  });
+
+  test('idempotent push + purge flow', () => {
+    const db = new BodDB({ path: ':memory:', sweepInterval: 0 });
+
+    // Idempotent push: same key → same message
+    const k1 = db.mq.push('q/jobs', { type: 'email' }, { idempotencyKey: 'email-123' });
+    const k2 = db.mq.push('q/jobs', { type: 'email-v2' }, { idempotencyKey: 'email-123' });
+    expect(k1).toBe(k2);
+    expect(db.mq.peek('q/jobs')).toHaveLength(1);
+    console.log(`\n🔑 Idempotent push: same key returned`);
+
+    // Different key → new message
+    const k3 = db.mq.push('q/jobs', { type: 'sms' }, { idempotencyKey: 'sms-456' });
+    expect(k3).not.toBe(k1);
+    expect(db.mq.peek('q/jobs')).toHaveLength(2);
+
+    // Fetch one, purge rest
+    const fetched = db.mq.fetch('q/jobs', 1);
+    const purged = db.mq.purge('q/jobs');
+    expect(purged).toBe(1); // only pending one purged
+    console.log(`🗑️ Purged ${purged} pending, ${fetched.length} still inflight`);
+
+    // Inflight one still visible in peek
+    const remaining = db.mq.peek('q/jobs');
+    expect(remaining).toHaveLength(1);
+    expect(remaining[0].status).toBe('inflight');
+
+    db.close();
+  });
+
+  test('subscription notifications during MQ operations', () => {
+    const db = new BodDB({ path: ':memory:', sweepInterval: 0 });
+    const events: string[] = [];
+
+    // Subscribe to queue path via child subscription
+    const unsub = db.onChild('queues', (ev) => {
+      events.push(`${ev.type}:${ev.key}`);
+    });
+
+    const key = db.mq.push('queues/jobs', { n: 1 });
+    // Push should trigger child added on 'queues'
+    console.log(`\n📡 Events after push: ${JSON.stringify(events)}`);
+
+    db.mq.ack('queues/jobs', key);
+    console.log(`📡 Events after ack: ${JSON.stringify(events)}`);
+
+    unsub();
+    db.close();
+  });
+});

package/tests/mq.test.ts

@@ -0,0 +1,326 @@
+import { describe, test, expect, beforeEach } from 'bun:test';
+import { BodDB } from '../src/server/BodDB.ts';
+
+let db: BodDB;
+
+beforeEach(() => {
+  db = new BodDB({ path: ':memory:', sweepInterval: 0 });
+});
+
+describe('MQEngine', () => {
+  test('push + fetch claims exactly one message', () => {
+    db.mq.push('queues/jobs', { type: 'email' });
+    db.mq.push('queues/jobs', { type: 'sms' });
+
+    const msgs = db.mq.fetch('queues/jobs', 1);
+    expect(msgs).toHaveLength(1);
+    expect(msgs[0].data).toEqual({ type: 'email' });
+    expect(msgs[0].deliveryCount).toBe(1);
+  });
+
+  test('fetch returns multiple messages', () => {
+    db.mq.push('queues/jobs', { n: 1 });
+    db.mq.push('queues/jobs', { n: 2 });
+    db.mq.push('queues/jobs', { n: 3 });
+
+    const msgs = db.mq.fetch('queues/jobs', 5);
+    expect(msgs).toHaveLength(3);
+  });
+
+  test('fetched messages are not re-fetched (inflight)', () => {
+    db.mq.push('queues/jobs', { n: 1 });
+    const first = db.mq.fetch('queues/jobs', 1);
+    expect(first).toHaveLength(1);
+
+    const second = db.mq.fetch('queues/jobs', 1);
+    expect(second).toHaveLength(0);
+  });
+
+  test('ack deletes the row', () => {
+    db.mq.push('queues/jobs', { n: 1 });
+    const msgs = db.mq.fetch('queues/jobs', 1);
+    db.mq.ack('queues/jobs', msgs[0].key);
+
+    // Should be gone — peek returns nothing
+    const peeked = db.mq.peek('queues/jobs');
+    expect(peeked).toHaveLength(0);
+  });
+
+  test('nack releases to pending (re-fetchable)', () => {
+    db.mq.push('queues/jobs', { n: 1 });
+    const msgs = db.mq.fetch('queues/jobs', 1);
+    db.mq.nack('queues/jobs', msgs[0].key);
+
+    const refetched = db.mq.fetch('queues/jobs', 1);
+    expect(refetched).toHaveLength(1);
+    expect(refetched[0].key).toBe(msgs[0].key);
+    expect(refetched[0].deliveryCount).toBe(2);
+  });
+
+  test('peek does not claim messages', () => {
+    db.mq.push('queues/jobs', { n: 1 });
+    const peeked = db.mq.peek('queues/jobs', 10);
+    expect(peeked).toHaveLength(1);
+
+    // Should still be fetchable
+    const fetched = db.mq.fetch('queues/jobs', 1);
+    expect(fetched).toHaveLength(1);
+    expect(fetched[0].key).toBe(peeked[0].key);
+  });
+
+  test('visibility timeout reclaim via sweep', () => {
+    db.mq.push('queues/jobs', { n: 1 });
+    db.mq.fetch('queues/jobs', 1);
+
+    // Simulate expired inflight by directly updating
+    db.storage.db.run(`UPDATE nodes SET mq_inflight_until = 1 WHERE mq_status = 'inflight'`);
+
+    const result = db.mq.sweep();
+    expect(result.reclaimed).toBe(1);
+    expect(result.dlqd).toBe(0);
+
+    // Should be fetchable again
+    const msgs = db.mq.fetch('queues/jobs', 1);
+    expect(msgs).toHaveLength(1);
+  });
+
+  test('maxDeliveries exhausted → DLQ', () => {
+    const mqDb = new BodDB({ path: ':memory:', sweepInterval: 0, mq: { maxDeliveries: 2, visibilityTimeout: 1 } });
+    mqDb.mq.push('queues/jobs', { n: 1 });
+
+    // Fetch twice (exhaust deliveries)
+    for (let i = 0; i < 2; i++) {
+      mqDb.mq.fetch('queues/jobs', 1);
+      // Expire the inflight
+      mqDb.storage.db.run(`UPDATE nodes SET mq_inflight_until = 1 WHERE mq_status = 'inflight'`);
+    }
+
+    // Sweep should move to DLQ
+    const result = mqDb.mq.sweep();
+    expect(result.dlqd).toBe(1);
+    expect(result.reclaimed).toBe(0);
+
+    // Check DLQ
+    const dlqMsgs = mqDb.mq.dlq('queues/jobs');
+    expect(dlqMsgs).toHaveLength(1);
+    expect(dlqMsgs[0].data).toEqual({ n: 1 });
+
+    // Original queue should be empty
+    const remaining = mqDb.mq.peek('queues/jobs');
+    expect(remaining).toHaveLength(0);
+
+    mqDb.close();
+  });
+
+  test('purge removes all pending', () => {
+    db.mq.push('queues/jobs', { n: 1 });
+    db.mq.push('queues/jobs', { n: 2 });
+    db.mq.push('queues/jobs', { n: 3 });
+
+    const count = db.mq.purge('queues/jobs');
+    expect(count).toBe(3);
+
+    const remaining = db.mq.peek('queues/jobs');
+    expect(remaining).toHaveLength(0);
+  });
+
+  test('purge does not remove inflight messages', () => {
+    db.mq.push('queues/jobs', { n: 1 });
+    db.mq.push('queues/jobs', { n: 2 });
+    db.mq.fetch('queues/jobs', 1); // claim one
+
+    const count = db.mq.purge('queues/jobs');
+    expect(count).toBe(1); // only the pending one
+  });
+
+  test('idempotent push dedup', () => {
+    const k1 = db.mq.push('queues/jobs', { n: 1 }, { idempotencyKey: 'job-1' });
+    const k2 = db.mq.push('queues/jobs', { n: 2 }, { idempotencyKey: 'job-1' });
+    expect(k1).toBe(k2);
+
+    const msgs = db.mq.peek('queues/jobs');
+    expect(msgs).toHaveLength(1);
+    expect(msgs[0].data).toEqual({ n: 1 });
+  });
+
+  test('push returns key', () => {
+    const key = db.mq.push('queues/jobs', { n: 1 });
+    expect(typeof key).toBe('string');
+    expect(key.length).toBeGreaterThan(0);
+  });
+
+  test('separate queues are independent', () => {
+    db.mq.push('queues/email', { to: 'alice' });
+    db.mq.push('queues/sms', { to: 'bob' });
+
+    const emails = db.mq.fetch('queues/email', 10);
+    expect(emails).toHaveLength(1);
+    expect(emails[0].data).toEqual({ to: 'alice' });
+
+    const sms = db.mq.fetch('queues/sms', 10);
+    expect(sms).toHaveLength(1);
+    expect(sms[0].data).toEqual({ to: 'bob' });
+  });
+
+  test('MQ rows invisible to get/exists/delete but visible in getShallow', () => {
+    db.mq.push('queues/jobs', { n: 1 });
+    expect(db.get('queues/jobs')).toBeNull();
+    expect(db.storage.exists('queues/jobs')).toBe(false);
+    // getShallow is a browse operation — should see MQ rows
+    const shallow = db.getShallow('queues');
+    expect(shallow.length).toBeGreaterThan(0);
+  });
+
+  test('empty queue fetch returns empty array', () => {
+    const msgs = db.mq.fetch('queues/empty', 5);
+    expect(msgs).toHaveLength(0);
+  });
+
+  test('double ack is safe', () => {
+    db.mq.push('queues/jobs', { n: 1 });
+    const msgs = db.mq.fetch('queues/jobs', 1);
+    db.mq.ack('queues/jobs', msgs[0].key);
+    db.mq.ack('queues/jobs', msgs[0].key); // should not throw
+  });
+
+  test('nack on non-existent key is safe', () => {
+    db.mq.nack('queues/jobs', 'nonexistent'); // should not throw
+  });
+
+  test('purge does not delete DLQ rows', () => {
+    const mqDb = new BodDB({ path: ':memory:', sweepInterval: 0, mq: { maxDeliveries: 1, visibilityTimeout: 1 } });
+    mqDb.mq.push('queues/jobs', { n: 1 });
+    mqDb.mq.fetch('queues/jobs', 1);
+    mqDb.storage.db.run(`UPDATE nodes SET mq_inflight_until = 1 WHERE mq_status = 'inflight'`);
+    mqDb.mq.sweep(); // moves to DLQ
+
+    const dlqBefore = mqDb.mq.dlq('queues/jobs');
+    expect(dlqBefore).toHaveLength(1);
+
+    mqDb.mq.purge('queues/jobs'); // should not touch DLQ
+    const dlqAfter = mqDb.mq.dlq('queues/jobs');
+    expect(dlqAfter).toHaveLength(1);
+    mqDb.close();
+  });
+
+  test('peek shows status change after fetch', () => {
+    db.mq.push('queues/jobs', { n: 1 });
+
+    const before = db.mq.peek('queues/jobs');
+    expect(before[0].status).toBe('pending');
+
+    db.mq.fetch('queues/jobs', 1);
+
+    const after = db.mq.peek('queues/jobs');
+    expect(after[0].status).toBe('inflight');
+  });
+
+  test('fetch status is always inflight', () => {
+    db.mq.push('queues/jobs', { n: 1 });
+    const msgs = db.mq.fetch('queues/jobs', 1);
+    expect(msgs[0].status).toBe('inflight');
+  });
+
+  test('idempotent push does NOT emit on duplicate', () => {
+    let notifyCount = 0;
+    const mqDb = new BodDB({ path: ':memory:', sweepInterval: 0, mq: {} });
+    (mqDb.mq as any).options.notify = () => { notifyCount++; };
+
+    mqDb.mq.push('queues/jobs', { n: 1 }, { idempotencyKey: 'job-1' });
+    expect(notifyCount).toBe(1);
+
+    mqDb.mq.push('queues/jobs', { n: 2 }, { idempotencyKey: 'job-1' });
+    // Duplicate returns early before emit — correct behavior
+    expect(notifyCount).toBe(1);
+    mqDb.close();
+  });
+
+  test('normal db.delete does not delete MQ rows', () => {
+    db.mq.push('queues/jobs', { n: 1 });
+    db.delete('queues/jobs');
+
+    // MQ row should survive
+    const peeked = db.mq.peek('queues/jobs');
+    expect(peeked).toHaveLength(1);
+  });
+
+  test('normal db.set at queue path does not clobber MQ rows', () => {
+    db.mq.push('queues/jobs', { n: 1 });
+    db.set('queues/jobs/config', 'test');  // regular data at same prefix
+
+    // MQ row should survive
+    const peeked = db.mq.peek('queues/jobs');
+    expect(peeked).toHaveLength(1);
+    // Regular data should also exist
+    expect(db.get('queues/jobs/config')).toBe('test');
+  });
+
+  test('per-queue options override', () => {
+    const mqDb = new BodDB({
+      path: ':memory:', sweepInterval: 0,
+      mq: { visibilityTimeout: 10, maxDeliveries: 5, queues: { 'queues/critical': { maxDeliveries: 1 } } },
+    });
+
+    mqDb.mq.push('queues/critical', { n: 1 });
+    mqDb.mq.fetch('queues/critical', 1);
+    mqDb.storage.db.run(`UPDATE nodes SET mq_inflight_until = 1 WHERE mq_status = 'inflight'`);
+
+    const result = mqDb.mq.sweep();
+    // maxDeliveries=1, deliveryCount=1 after fetch → should DLQ
+    expect(result.dlqd).toBe(1);
+
+    mqDb.close();
+  });
+
+  test('DLQ path construction with nested queue', () => {
+    const mqDb = new BodDB({ path: ':memory:', sweepInterval: 0, mq: { maxDeliveries: 1 } });
+    mqDb.mq.push('queues/email/high', { n: 1 });
+    mqDb.mq.fetch('queues/email/high', 1);
+    mqDb.storage.db.run(`UPDATE nodes SET mq_inflight_until = 1 WHERE mq_status = 'inflight'`);
+    mqDb.mq.sweep();
+
+    // DLQ should be at queues/email/high/_dlq/<key>
+    const dlq = mqDb.mq.dlq('queues/email/high');
+    expect(dlq).toHaveLength(1);
+    expect(dlq[0].path).toContain('queues/email/high/_dlq/');
+
+    mqDb.close();
+  });
+
+  test('notify fires on push, ack, nack, purge, sweep', () => {
+    const events: string[][] = [];
+    const mqDb = new BodDB({ path: ':memory:', sweepInterval: 0, mq: { visibilityTimeout: 1, maxDeliveries: 1 } });
+    (mqDb.mq as any).options.notify = (paths: string[]) => { events.push(paths); };
+
+    mqDb.mq.push('q/a', { n: 1 });
+    expect(events.length).toBe(1); // push
+
+    mqDb.mq.push('q/a', { n: 2 });
+    expect(events.length).toBe(2); // push
+
+    const msgs = mqDb.mq.fetch('q/a', 2);
+    // fetch does NOT notify (status change only, not visible to subs)
+
+    mqDb.mq.nack('q/a', msgs[0].key);
+    expect(events.length).toBe(3); // nack
+
+    mqDb.mq.ack('q/a', msgs[1].key);
+    expect(events.length).toBe(4); // ack
+
+    mqDb.mq.purge('q/a');
+    expect(events.length).toBe(5); // purge
+
+    mqDb.close();
+  });
+
+  test('sweep integrated into BodDB.sweep()', () => {
+    db.mq.push('queues/jobs', { n: 1 });
+    db.mq.fetch('queues/jobs', 1);
+    db.storage.db.run(`UPDATE nodes SET mq_inflight_until = 1 WHERE mq_status = 'inflight'`);
+
+    db.sweep(); // should call mq.sweep() internally
+
+    const msgs = db.mq.fetch('queues/jobs', 1);
+    expect(msgs).toHaveLength(1);
+  });
+});

package/tests/push.test.ts

@@ -0,0 +1,55 @@
+import { describe, test, expect } from 'bun:test';
+import { BodDB } from '../src/server/BodDB.ts';
+import { generatePushId } from '../src/server/StorageEngine.ts';
+
+describe('Push & Append-Only', () => {
+  test('generatePushId produces time-sortable IDs', () => {
+    const ids: string[] = [];
+    for (let i = 0; i < 10; i++) {
+      ids.push(generatePushId());
+    }
+    // Should be in sorted order
+    const sorted = [...ids].sort();
+    expect(ids).toEqual(sorted);
+  });
+
+  test('generatePushId produces unique IDs', () => {
+    const ids = new Set<string>();
+    for (let i = 0; i < 100; i++) {
+      ids.add(generatePushId());
+    }
+    expect(ids.size).toBe(100);
+  });
+
+  test('db.push stores value as single JSON row', () => {
+    const db = new BodDB({ sweepInterval: 0 });
+    const key = db.push('messages', { text: 'hello', ts: 123 });
+    expect(typeof key).toBe('string');
+    expect(key.length).toBe(12); // 8 time + 4 random
+
+    const val = db.get(`messages/${key}`);
+    expect(val).toEqual({ text: 'hello', ts: 123 });
+    db.close();
+  });
+
+  test('push entries appear in queries', () => {
+    const db = new BodDB({ sweepInterval: 0 });
+    db.push('logs', { level: 'info', msg: 'start' });
+    db.push('logs', { level: 'error', msg: 'fail' });
+    db.push('logs', { level: 'info', msg: 'end' });
+
+    const all = db.query('logs').get();
+    expect(all.length).toBe(3);
+    db.close();
+  });
+
+  test('push triggers subscriptions', () => {
+    const db = new BodDB({ sweepInterval: 0 });
+    const events: string[] = [];
+    db.onChild('messages', (e) => events.push(e.type));
+
+    db.push('messages', { text: 'hello' });
+    expect(events).toEqual(['added']);
+    db.close();
+  });
+});

package/tests/query.test.ts

@@ -0,0 +1,60 @@
+import { describe, test, expect } from 'bun:test';
+import { BodDB } from '../src/server/BodDB.ts';
+
+describe('QueryEngine (via BodDB)', () => {
+  test('fluent query with where + order + limit', () => {
+    const db = new BodDB();
+    db.set('users/u1', { name: 'Charlie', role: 'admin' });
+    db.set('users/u2', { name: 'Alice', role: 'user' });
+    db.set('users/u3', { name: 'Bob', role: 'admin' });
+
+    const result = db.query('users')
+      .where('role', '==', 'admin')
+      .order('name')
+      .limit(1)
+      .get();
+
+    expect(result.length).toBe(1);
+    expect(result[0].name).toBe('Bob');
+    db.close();
+  });
+
+  test('query with desc ordering', () => {
+    const db = new BodDB();
+    db.set('posts/p1', { title: 'A', score: 10 });
+    db.set('posts/p2', { title: 'B', score: 50 });
+    db.set('posts/p3', { title: 'C', score: 30 });
+
+    const result = db.query('posts').order('score', 'desc').get();
+    expect(result.map(r => r.title)).toEqual(['B', 'C', 'A']);
+    db.close();
+  });
+
+  test('query with offset', () => {
+    const db = new BodDB();
+    db.set('items/a', { v: 1 });
+    db.set('items/b', { v: 2 });
+    db.set('items/c', { v: 3 });
+
+    const result = db.query('items').order('v').offset(1).limit(1).get();
+    expect(result.length).toBe(1);
+    expect(result[0].v).toBe(2);
+    db.close();
+  });
+
+  test('multiple filters', () => {
+    const db = new BodDB();
+    db.set('users/u1', { age: 25, role: 'admin' });
+    db.set('users/u2', { age: 30, role: 'admin' });
+    db.set('users/u3', { age: 35, role: 'user' });
+
+    const result = db.query('users')
+      .where('role', '==', 'admin')
+      .where('age', '>=', 30)
+      .get();
+
+    expect(result.length).toBe(1);
+    expect(result[0]._key).toBe('u2');
+    db.close();
+  });
+});