bunsane 0.3.1 → 0.3.2

package/tests/unit/cache/CacheManager.test.ts

@@ -3,7 +3,7 @@
  * Tests cache configuration and management
  */
 import { describe, test, expect, beforeEach, afterEach, mock } from 'bun:test';
-import { CacheManager } from '../../../core/cache/CacheManager';
+import { CacheManager, COMPONENT_TOMBSTONE } from '../../../core/cache/CacheManager';
 import { MemoryCache } from '../../../core/cache/MemoryCache';
 import { MultiLevelCache } from '../../../core/cache/MultiLevelCache';
 
@@ -210,6 +210,137 @@ describe('CacheManager', () => {
         });
     });
 
+    describe('component negative cache (tombstones)', () => {
+        beforeEach(async () => {
+            await cacheManager.initialize({
+                enabled: true,
+                provider: 'memory',
+                strategy: 'write-through',
+                defaultTTL: 3600000,
+                entity: { enabled: true, ttl: 3600000 },
+                component: {
+                    enabled: true,
+                    ttl: 1800000,
+                    negativeCacheEnabled: true,
+                    negativeCacheTtl: 60_000,
+                },
+                query: { enabled: false, ttl: 300000, maxSize: 10000 },
+            });
+        });
+
+        test('setComponentsWriteThrough writes tombstones for absent requested keys', async () => {
+            const requested = [
+                { entityId: 'e1', typeId: 't1' },
+                { entityId: 'e2', typeId: 't2' },
+            ];
+            await cacheManager.setComponentsWriteThrough([], requested);
+            const results = await cacheManager.getComponents(requested);
+            expect(results[0]).toBe(COMPONENT_TOMBSTONE);
+            expect(results[1]).toBe(COMPONENT_TOMBSTONE);
+        });
+
+        test('found rows are written, absent are tombstoned, single setMany', async () => {
+            const requested = [
+                { entityId: 'e1', typeId: 't1' },
+                { entityId: 'e2', typeId: 't2' },
+            ];
+            const found = [{
+                id: 'c1', entityId: 'e1', typeId: 't1',
+                data: { x: 1 }, createdAt: new Date(), updatedAt: new Date(), deletedAt: null,
+            }];
+            await cacheManager.setComponentsWriteThrough(found, requested);
+            const results = await cacheManager.getComponents(requested);
+            expect((results[0] as any)?.id).toBe('c1');
+            expect(results[1]).toBe(COMPONENT_TOMBSTONE);
+        });
+
+        test('invalidateComponent drops tombstone', async () => {
+            await cacheManager.setComponentsWriteThrough([], [{ entityId: 'e1', typeId: 't1' }]);
+            await cacheManager.invalidateComponent('e1', 't1');
+            const results = await cacheManager.getComponents([{ entityId: 'e1', typeId: 't1' }]);
+            expect(results[0]).toBeNull();
+        });
+
+        test('negativeCacheEnabled=false skips tombstone writes (backward compat)', async () => {
+            await cacheManager.initialize({
+                enabled: true,
+                provider: 'memory',
+                strategy: 'write-through',
+                defaultTTL: 3600000,
+                entity: { enabled: true, ttl: 3600000 },
+                component: { enabled: true, ttl: 1800000 },
+                query: { enabled: false, ttl: 300000, maxSize: 10000 },
+            });
+            await cacheManager.setComponentsWriteThrough([], [{ entityId: 'e1', typeId: 't1' }]);
+            const results = await cacheManager.getComponents([{ entityId: 'e1', typeId: 't1' }]);
+            expect(results[0]).toBeNull();
+        });
+
+        test('legacy 2-arg signature (components, ttl) still works', async () => {
+            const data = [{
+                id: 'c1', entityId: 'e1', typeId: 't1',
+                data: { x: 1 }, createdAt: new Date(), updatedAt: new Date(), deletedAt: null,
+            }];
+            await cacheManager.setComponentsWriteThrough(data, 3600_000);
+            const results = await cacheManager.getComponents([{ entityId: 'e1', typeId: 't1' }]);
+            expect((results[0] as any)?.id).toBe('c1');
+        });
+    });
+
+    describe('relation negative cache', () => {
+        beforeEach(async () => {
+            await cacheManager.initialize({
+                enabled: true,
+                provider: 'memory',
+                strategy: 'write-through',
+                defaultTTL: 3600000,
+                entity: { enabled: true, ttl: 3600000 },
+                component: { enabled: true, ttl: 1800000 },
+                relation: { negativeCacheEnabled: true, negativeCacheTtl: 60_000 },
+                query: { enabled: false, ttl: 300000, maxSize: 10000 },
+            });
+        });
+
+        test('setRelationsEmpty + getRelationsEmpty round trip', async () => {
+            const keys = [
+                { entityId: 'u1', relationField: 'orders', relatedType: 'Order', foreignKey: 'user_id' },
+                { entityId: 'u2', relationField: 'orders', relatedType: 'Order', foreignKey: 'user_id' },
+            ];
+            await cacheManager.setRelationsEmpty(keys);
+            const flags = await cacheManager.getRelationsEmpty(keys);
+            expect(flags).toEqual([true, true]);
+        });
+
+        test('getRelationsEmpty returns false for keys never tombstoned', async () => {
+            const flags = await cacheManager.getRelationsEmpty([
+                { entityId: 'u-fresh', relationField: 'orders', relatedType: 'Order', foreignKey: 'user_id' },
+            ]);
+            expect(flags).toEqual([false]);
+        });
+
+        test('invalidateRelation drops tombstone', async () => {
+            const key = { entityId: 'u1', relationField: 'orders', relatedType: 'Order', foreignKey: 'user_id' };
+            await cacheManager.setRelationsEmpty([key]);
+            await cacheManager.invalidateRelation(key.entityId, key.relationField, key.relatedType, key.foreignKey);
+            const flags = await cacheManager.getRelationsEmpty([key]);
+            expect(flags).toEqual([false]);
+        });
+
+        test('relation cache disabled returns all-false (no-op)', async () => {
+            await cacheManager.initialize({
+                enabled: true,
+                provider: 'memory',
+                strategy: 'write-through',
+                defaultTTL: 3600000,
+                relation: { negativeCacheEnabled: false },
+            });
+            const key = { entityId: 'u1', relationField: 'orders', relatedType: 'Order', foreignKey: 'user_id' };
+            await cacheManager.setRelationsEmpty([key]);
+            const flags = await cacheManager.getRelationsEmpty([key]);
+            expect(flags).toEqual([false]);
+        });
+    });
+
     describe('cache disabled', () => {
         beforeEach(async () => {
             await cacheManager.initialize({ enabled: false });

package/tests/unit/database/cancellable.test.ts

@@ -0,0 +1,81 @@
+/**
+ * Unit tests for `database/cancellable.ts` — the shared `runWithSignal`
+ * helper extracted from Entity.ts so every framework call-site uses the
+ * same abort-on-cancel pattern.
+ */
+import { describe, test, expect } from 'bun:test';
+import { runWithSignal } from '../../../database/cancellable';
+
+function makeFakeQuery<T>(opts: { delayMs?: number; value?: T; rejectWith?: Error }) {
+    let cancelFn: () => void = () => {};
+    const promise: any = new Promise<T>((resolve, reject) => {
+        const handle = setTimeout(() => {
+            if (opts.rejectWith) reject(opts.rejectWith);
+            else resolve(opts.value as T);
+        }, opts.delayMs ?? 1);
+        cancelFn = () => {
+            clearTimeout(handle);
+            promise.cancelled = true;
+            reject(Object.assign(new Error('Query cancelled'), { name: 'AbortError' }));
+        };
+    });
+    // Swallow unhandled rejection when the helper throws on pre-abort before
+    // awaiting `q`. Real Bun SQL Query objects don't surface this as an
+    // unhandled rejection because the runtime captures the cancel reason.
+    promise.catch(() => {});
+    promise.cancel = cancelFn;
+    promise.cancelled = false;
+    return promise;
+}
+
+describe('runWithSignal', () => {
+    test('resolves normally without signal', async () => {
+        const q = makeFakeQuery({ value: [1, 2, 3] });
+        const r = await runWithSignal<number[]>(q);
+        expect(r).toEqual([1, 2, 3]);
+    });
+
+    test('resolves normally when signal never fires', async () => {
+        const controller = new AbortController();
+        const q = makeFakeQuery({ value: 'done' });
+        const r = await runWithSignal<string>(q, controller.signal);
+        expect(r).toBe('done');
+    });
+
+    test('rejects immediately when signal is pre-aborted', async () => {
+        const controller = new AbortController();
+        controller.abort(new Error('pre-aborted'));
+        const q = makeFakeQuery({ delayMs: 5000 });
+        await expect(runWithSignal(q, controller.signal)).rejects.toBeDefined();
+        // Cancelling the underlying query is best-effort; verify cancel ran.
+        expect(q.cancelled).toBe(true);
+    });
+
+    test('cancels query mid-flight when signal aborts', async () => {
+        const controller = new AbortController();
+        const q = makeFakeQuery({ delayMs: 5000 });
+        queueMicrotask(() => controller.abort(new Error('mid-flight')));
+
+        await expect(runWithSignal(q, controller.signal)).rejects.toBeDefined();
+        expect(q.cancelled).toBe(true);
+    });
+
+    test('removes abort listener on success', async () => {
+        const controller = new AbortController();
+        let listenerCount = 0;
+        const origAdd = controller.signal.addEventListener.bind(controller.signal);
+        const origRemove = controller.signal.removeEventListener.bind(controller.signal);
+        controller.signal.addEventListener = ((...args: any[]) => {
+            listenerCount++;
+            return (origAdd as any)(...args);
+        }) as any;
+        controller.signal.removeEventListener = ((...args: any[]) => {
+            listenerCount--;
+            return (origRemove as any)(...args);
+        }) as any;
+
+        const q = makeFakeQuery({ value: 1 });
+        await runWithSignal(q, controller.signal);
+        expect(listenerCount).toBe(0);
+    });
+});

package/tests/unit/database/instrumentedDb.test.ts

@@ -0,0 +1,160 @@
+/**
+ * Unit tests for database/instrumentedDb.ts.
+ *
+ * Uses a fake `db` that returns a `cancel()`able promise-like to exercise
+ * the timing + abort path without a real Postgres backend.
+ */
+import { describe, test, expect, beforeEach } from 'bun:test';
+import {
+    timedUnsafe,
+    incrementDataLoaderCall,
+    getDbStats,
+    resetDbStats,
+    type PerRequestCounters,
+} from '../../../database/instrumentedDb';
+
+interface FakeQuery<T> extends Promise<T> {
+    cancel(): void;
+    cancelled: boolean;
+}
+
+function makeFakeDb(opts: { delayMs?: number; rejectWith?: Error; rows?: any[] } = {}) {
+    return {
+        unsafe(_sql: string, _params: any[]): FakeQuery<any[]> {
+            let cancelFn: () => void = () => {};
+            const promise: any = new Promise<any[]>((resolve, reject) => {
+                const handle = setTimeout(() => {
+                    if (opts.rejectWith) reject(opts.rejectWith);
+                    else resolve(opts.rows ?? []);
+                }, opts.delayMs ?? 1);
+                cancelFn = () => {
+                    clearTimeout(handle);
+                    promise.cancelled = true;
+                    reject(Object.assign(new Error('Query cancelled'), { name: 'AbortError' }));
+                };
+            });
+            // Swallow unhandled rejection on pre-abort cancel path.
+            promise.catch(() => {});
+            promise.cancel = cancelFn;
+            promise.cancelled = false;
+            return promise as FakeQuery<any[]>;
+        },
+    };
+}
+
+describe('timedUnsafe', () => {
+    beforeEach(() => resetDbStats());
+
+    test('records totalCount and totalMs on success', async () => {
+        const db = makeFakeDb({ rows: [{ id: 1 }], delayMs: 5 });
+        const result = await timedUnsafe(db as any, 'SELECT 1', []);
+        expect(result).toEqual([{ id: 1 }]);
+
+        const stats = getDbStats();
+        expect(stats.totalCount).toBe(1);
+        expect(stats.totalMs).toBeGreaterThanOrEqual(1);
+        expect(stats.maxMs).toBeGreaterThanOrEqual(1);
+        expect(stats.abortedCount).toBe(0);
+    });
+
+    test('increments dbQueryCount on perRequest counters', async () => {
+        const db = makeFakeDb();
+        const perReq: PerRequestCounters = { dbQueryCount: 0 };
+        await timedUnsafe(db as any, 'SELECT 1', [], undefined, perReq);
+        await timedUnsafe(db as any, 'SELECT 1', [], undefined, perReq);
+        expect(perReq.dbQueryCount).toBe(2);
+    });
+
+    test('aborted query rejects with AbortError and records abortedCount', async () => {
+        const db = makeFakeDb({ delayMs: 1000 });
+        const controller = new AbortController();
+        const promise = timedUnsafe(db as any, 'SELECT pg_sleep(10)', [], controller.signal);
+
+        queueMicrotask(() => controller.abort(new Error('test abort')));
+
+        await expect(promise).rejects.toBeDefined();
+
+        const stats = getDbStats();
+        expect(stats.totalCount).toBe(1);
+        expect(stats.abortedCount).toBe(1);
+    });
+
+    test('pre-aborted signal cancels before await', async () => {
+        const db = makeFakeDb({ delayMs: 1000 });
+        const controller = new AbortController();
+        controller.abort(new Error('pre-aborted'));
+
+        const promise = timedUnsafe(db as any, 'SELECT 1', [], controller.signal);
+        await expect(promise).rejects.toBeDefined();
+
+        const stats = getDbStats();
+        expect(stats.abortedCount).toBe(1);
+    });
+
+    test('slow query above threshold increments slowCount', async () => {
+        // Slow threshold defaults to 500ms; we cannot reasonably wait that long
+        // in a unit test, so we override via env at module load — fall back to
+        // asserting the slow path is reachable by passing a tiny synthetic
+        // delay larger than zero and checking that the slowCount path triggers
+        // only when over threshold. Direct assertion: with default threshold,
+        // a 5ms query should NOT mark slow.
+        const db = makeFakeDb({ delayMs: 5 });
+        await timedUnsafe(db as any, 'SELECT 1', []);
+        const stats = getDbStats();
+        expect(stats.slowCount).toBe(0);
+    });
+});
+
+describe('incrementDataLoaderCall', () => {
+    beforeEach(() => resetDbStats());
+
+    test('increments per-kind global stats', () => {
+        incrementDataLoaderCall('entity');
+        incrementDataLoaderCall('component');
+        incrementDataLoaderCall('component');
+        incrementDataLoaderCall('relation');
+
+        const stats = getDbStats();
+        expect(stats.dataLoaderCalls.entity).toBe(1);
+        expect(stats.dataLoaderCalls.component).toBe(2);
+        expect(stats.dataLoaderCalls.relation).toBe(1);
+    });
+
+    test('increments perRequest.dataLoaderCalls when supplied', () => {
+        const perReq = {
+            dbQueryCount: 0,
+            dataLoaderCalls: { entity: 0, component: 0, relation: 0 },
+        };
+        incrementDataLoaderCall('entity', perReq);
+        incrementDataLoaderCall('component', perReq);
+        incrementDataLoaderCall('component', perReq);
+        expect(perReq.dataLoaderCalls.entity).toBe(1);
+        expect(perReq.dataLoaderCalls.component).toBe(2);
+        expect(perReq.dataLoaderCalls.relation).toBe(0);
+    });
+});
+
+describe('getDbStats', () => {
+    beforeEach(() => resetDbStats());
+
+    test('reports avgMs as totalMs / totalCount', async () => {
+        const db = makeFakeDb({ delayMs: 4 });
+        await timedUnsafe(db as any, 'SELECT 1', []);
+        await timedUnsafe(db as any, 'SELECT 1', []);
+        const stats = getDbStats();
+        expect(stats.totalCount).toBe(2);
+        // avgMs is rounded to 2 decimals while totalMs is integer-rounded,
+        // so allow ±0.5ms tolerance against the unrounded computation.
+        expect(Math.abs(stats.avgMs - stats.totalMs / 2)).toBeLessThan(1);
+    });
+
+    test('returns zero state after reset', () => {
+        const stats = getDbStats();
+        expect(stats.totalCount).toBe(0);
+        expect(stats.totalMs).toBe(0);
+        expect(stats.maxMs).toBe(0);
+        expect(stats.slowCount).toBe(0);
+        expect(stats.abortedCount).toBe(0);
+        expect(stats.dataLoaderCalls).toEqual({ entity: 0, component: 0, relation: 0 });
+    });
+});