bunsane 0.3.2 → 0.5.0

package/tests/integration/entity/Entity.saveTimeout.test.ts

@@ -1,110 +0,0 @@
-/**
- * Integration tests for Entity.save timeout and cancellation behavior.
- *
- * Regression coverage for the production incident where Entity.save's wall-
- * clock timeout rejected the outer Promise but left the underlying Bun SQL
- * transaction mid-flight. Under pgbouncer transaction-mode pooling this
- * leaked backend PostgreSQL sessions into `idle in transaction` state,
- * exhausting the pool.
- *
- * These tests prove the invariants the fix must uphold:
- *   1. An aborted save leaves no partial rows — Bun SQL's transaction callback
- *      throws, auto-ROLLBACK fires, backend connection is released.
- *   2. The connection pool stays healthy after repeated aborts — subsequent
- *      saves on fresh entities still succeed.
- *   3. A save with no abort still commits normally.
- *
- * The wall-clock DB_QUERY_TIMEOUT path is module-cached at import time so it
- * is not exercised here directly. Manual verification on a real Postgres +
- * pgbouncer stack (with query_wait_timeout short enough to fire) should
- * confirm pg_stat_activity shows no `idle in transaction` backends after
- * this test suite runs. See the handoff doc (2026-04-18) for the repro steps.
- */
-import { describe, test, expect, beforeAll } from 'bun:test';
-import { Entity } from '../../../core/Entity';
-import db from '../../../database';
-import { TestUser } from '../../fixtures/components';
-import { createTestContext, ensureComponentsRegistered } from '../../utils';
-
-describe('Entity.save timeout and cancellation', () => {
-    const ctx = createTestContext();
-
-    beforeAll(async () => {
-        await ensureComponentsRegistered(TestUser);
-    });
-
-    test('aborted doSave does not leave partial rows (transaction rolls back)', async () => {
-        const entity = ctx.tracker.create();
-        entity.add(TestUser, { name: 'aborted', email: 'a@example.com', age: 1 });
-
-        const controller = new AbortController();
-        // Abort immediately — the first in-flight query will be cancelled,
-        // the transaction callback throws, Bun SQL issues ROLLBACK.
-        queueMicrotask(() => controller.abort(new Error('simulated save timeout')));
-
-        const result = db.transaction(async (trx) => {
-            await entity.doSave(trx, controller.signal);
-        });
-
-        await expect(result).rejects.toBeDefined();
-
-        // Entity must NOT exist — rollback invariant.
-        const rows = await db`SELECT id FROM entities WHERE id = ${entity.id}`;
-        expect(rows.length).toBe(0);
-    });
-
-    test('connection pool stays healthy after multiple aborted saves', async () => {
-        // Repeatedly abort saves — if connections leaked, subsequent saves
-        // would eventually block on pool acquire.
-        for (let i = 0; i < 8; i++) {
-            const entity = Entity.Create();
-            entity.add(TestUser, { name: `aborted-${i}`, email: `a${i}@e.com`, age: i });
-
-            const controller = new AbortController();
-            queueMicrotask(() => controller.abort(new Error('simulated timeout')));
-
-            await db.transaction(async (trx) => {
-                await entity.doSave(trx, controller.signal);
-            }).catch(() => { /* expected */ });
-        }
-
-        // A fresh save must still succeed on the pool that serviced the aborts.
-        const healthy = ctx.tracker.create();
-        healthy.add(TestUser, { name: 'healthy', email: 'h@e.com', age: 99 });
-        await healthy.save();
-
-        expect(healthy._persisted).toBe(true);
-
-        const rows = await db`SELECT id FROM entities WHERE id = ${healthy.id}`;
-        expect(rows.length).toBe(1);
-    });
-
-    test('doSave without signal behaves normally (backwards compatible)', async () => {
-        const entity = ctx.tracker.create();
-        entity.add(TestUser, { name: 'no-signal', email: 'n@e.com', age: 5 });
-
-        await db.transaction(async (trx) => {
-            await entity.doSave(trx); // no signal passed
-        });
-
-        const rows = await db`SELECT id FROM entities WHERE id = ${entity.id}`;
-        expect(rows.length).toBe(1);
-    });
-
-    test('save() resolves even if post-commit cache work is slow (fire-and-forget)', async () => {
-        // Cache handler is queued via queueMicrotask; save() must resolve as
-        // soon as the DB transaction commits. We assert save resolves quickly
-        // even though handleCacheAfterSave is awaited separately.
-        const entity = ctx.tracker.create();
-        entity.add(TestUser, { name: 'fast', email: 'f@e.com', age: 10 });
-
-        const start = performance.now();
-        await entity.save();
-        const elapsed = performance.now() - start;
-
-        expect(entity._persisted).toBe(true);
-        // Generous bound — if cache were blocking save, timings under load
-        // could stretch past the budget. This just guards gross regressions.
-        expect(elapsed).toBeLessThan(5000);
-    });
-});

package/tests/integration/loaders/RequestLoaders.abort.test.ts

@@ -1,82 +0,0 @@
-/**
- * Integration tests for `createRequestLoaders` AbortSignal threading.
- *
- * The GraphQL request plugin (core/RequestContext.ts) wires the request's
- * AbortSignal into each DataLoader's `db.unsafe()` call via timedUnsafe.
- * On abort the in-flight query is cancelled, releasing the backend
- * connection back to pgbouncer.
- */
-import { describe, test, expect, beforeAll, beforeEach } from 'bun:test';
-import db from '../../../database';
-import { Entity } from '../../../core/Entity';
-import { createRequestLoaders } from '../../../core/RequestLoaders';
-import { ComponentRegistry } from '../../../core/components';
-import { TestUser } from '../../fixtures/components';
-import { createTestContext, ensureComponentsRegistered } from '../../utils';
-
-describe('RequestLoaders AbortSignal', () => {
-    const ctx = createTestContext();
-    let seededEntity: Entity;
-    let testUserTypeId: string;
-
-    beforeAll(async () => {
-        await ensureComponentsRegistered(TestUser);
-        testUserTypeId = ComponentRegistry.getComponentId('TestUser')!;
-        expect(testUserTypeId).toBeTruthy();
-    });
-
-    beforeEach(async () => {
-        // Fresh seed per test — createTestContext's afterEach cleans tracked
-        // entities, so seeds set up once would disappear after the first
-        // test in the suite runs.
-        seededEntity = ctx.tracker.create();
-        seededEntity.add(TestUser, { name: 'loader-seed', email: 'l@e.com', age: 1 });
-        await seededEntity.save();
-        await Entity.drainPendingSideEffects();
-    });
-
-    test('entityById loader rejects when pre-aborted', async () => {
-        const controller = new AbortController();
-        controller.abort(new Error('pre-aborted'));
-
-        const loaders = createRequestLoaders(db, undefined, controller.signal);
-        await expect(loaders.entityById.load(seededEntity.id)).rejects.toBeDefined();
-    });
-
-    test('componentsByEntityType loader rejects when pre-aborted', async () => {
-        const controller = new AbortController();
-        controller.abort(new Error('pre-aborted'));
-
-        const loaders = createRequestLoaders(db, undefined, controller.signal);
-        await expect(
-            loaders.componentsByEntityType.load({
-                entityId: seededEntity.id,
-                typeId: testUserTypeId,
-            }),
-        ).rejects.toBeDefined();
-    });
-
-    test('loaders without signal still work (backwards compatible)', async () => {
-        const loaders = createRequestLoaders(db);
-        const ent = await loaders.entityById.load(seededEntity.id);
-        expect(ent?.id).toBe(seededEntity.id);
-    });
-
-    test('perRequest counters track DataLoader invocations', async () => {
-        const perRequest = {
-            dbQueryCount: 0,
-            dataLoaderCalls: { entity: 0, component: 0, relation: 0 },
-        };
-        const loaders = createRequestLoaders(db, undefined, undefined, perRequest);
-
-        await loaders.entityById.load(seededEntity.id);
-        await loaders.componentsByEntityType.load({
-            entityId: seededEntity.id,
-            typeId: testUserTypeId,
-        });
-
-        expect(perRequest.dataLoaderCalls.entity).toBeGreaterThanOrEqual(1);
-        expect(perRequest.dataLoaderCalls.component).toBeGreaterThanOrEqual(1);
-        expect(perRequest.dbQueryCount).toBeGreaterThan(0);
-    });
-});

package/tests/integration/query/Query.abort.test.ts

@@ -1,66 +0,0 @@
-/**
- * Integration tests for Query.exec / Query.count AbortSignal propagation.
- *
- * The framework wall-clock timeout (core/app/requestRouter.ts) aborts a
- * controller on 30s. The plugin in core/RequestContext.ts threads the
- * request's AbortSignal into Query.exec via `{ signal }` options. These
- * tests prove the abort actually cancels the underlying Bun SQL query
- * (releasing the pgbouncer-backed connection) rather than just rejecting
- * the outer promise.
- */
-import { describe, test, expect, beforeAll } from 'bun:test';
-import { Query } from '../../../query/Query';
-import { TestUser } from '../../fixtures/components';
-import { createTestContext, ensureComponentsRegistered } from '../../utils';
-
-describe('Query AbortSignal propagation', () => {
-    const ctx = createTestContext();
-
-    beforeAll(async () => {
-        await ensureComponentsRegistered(TestUser);
-
-        // Seed a small dataset so queries actually hit the DB.
-        for (let i = 0; i < 5; i++) {
-            const e = ctx.tracker.create();
-            e.add(TestUser, { name: `abort-seed-${i}`, email: `a${i}@e.com`, age: i });
-            await e.save();
-        }
-    });
-
-    test('exec() with pre-aborted signal rejects without running query', async () => {
-        const controller = new AbortController();
-        controller.abort(new Error('pre-aborted'));
-
-        const promise = new Query().with(TestUser).exec({ signal: controller.signal });
-        await expect(promise).rejects.toBeDefined();
-    });
-
-    test('exec() rejects when signal aborts mid-flight', async () => {
-        const controller = new AbortController();
-        queueMicrotask(() => controller.abort(new Error('mid-flight')));
-
-        const promise = new Query().with(TestUser).exec({ signal: controller.signal });
-        await expect(promise).rejects.toBeDefined();
-    });
-
-    test('exec() without signal still works (backwards compatible)', async () => {
-        const rows = await new Query().with(TestUser).take(5).exec();
-        expect(Array.isArray(rows)).toBe(true);
-    });
-
-    test('count() respects signal abort', async () => {
-        const controller = new AbortController();
-        controller.abort(new Error('pre-aborted'));
-
-        const promise = new Query().with(TestUser).count({ signal: controller.signal });
-        await expect(promise).rejects.toBeDefined();
-    });
-
-    test('perRequest counters increment when supplied', async () => {
-        const perRequest = { dbQueryCount: 0 };
-        await new Query().with(TestUser).take(5).exec({ perRequest });
-        // Exec performs at least one DB query (count guard / select). Real
-        // count depends on prepared-cache state; assert non-zero only.
-        expect(perRequest.dbQueryCount).toBeGreaterThan(0);
-    });
-});