bunsane 0.3.1 → 0.4.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/query/Query.complexAnalysis.test.ts

@@ -1,557 +0,0 @@
-/**
- * Complex Query Performance Analysis Tests
- * Analyzes query plans for performance issues
- */
-import { describe, test, expect, beforeAll, beforeEach, afterAll } from 'bun:test';
-import { Query, FilterOp } from '../../../query/Query';
-import { Entity } from '../../../core/Entity';
-import { TestUser, TestProduct, TestOrder } from '../../fixtures/components';
-import { ensureComponentsRegistered } from '../../utils';
-import { CacheManager } from '../../../core/cache';
-import EntityManager from '../../../core/EntityManager';
-import db from '../../../database';
-
-interface QueryPlanAnalysis {
-    plan: string;
-    hasSeqScan: boolean;
-    hasIndexScan: boolean;
-    hasNestedLoop: boolean;
-    hasHashJoin: boolean;
-    planningTimeMs: number;
-    executionTimeMs: number;
-    totalRows: number;
-    warnings: string[];
-}
-
-function analyzeQueryPlan(plan: string): QueryPlanAnalysis {
-    const warnings: string[] = [];
-
-    const hasSeqScan = /Seq Scan/i.test(plan);
-    const hasIndexScan = /Index Scan|Index Only Scan|Bitmap Index Scan/i.test(plan);
-    const hasNestedLoop = /Nested Loop/i.test(plan);
-    const hasHashJoin = /Hash Join/i.test(plan);
-
-    // Extract timing
-    const planningMatch = plan.match(/Planning Time:\s*([\d.]+)\s*ms/i);
-    const executionMatch = plan.match(/Execution Time:\s*([\d.]+)\s*ms/i);
-    const planningTimeMs = planningMatch ? parseFloat(planningMatch[1]!) : 0;
-    const executionTimeMs = executionMatch ? parseFloat(executionMatch[1]!) : 0;
-
-    // Extract row counts
-    const rowsMatch = plan.match(/rows=(\d+)/g);
-    const totalRows = rowsMatch
-        ? rowsMatch.reduce((sum, m) => sum + parseInt(m.replace('rows=', '')), 0)
-        : 0;
-
-    // Check for potential issues
-    if (hasSeqScan && !hasIndexScan) {
-        warnings.push('Sequential scan (expected for small tables)');
-    }
-
-    if (hasNestedLoop && totalRows > 1000) {
-        warnings.push('Nested loop with many rows');
-    }
-
-    return {
-        plan,
-        hasSeqScan,
-        hasIndexScan,
-        hasNestedLoop,
-        hasHashJoin,
-        planningTimeMs,
-        executionTimeMs,
-        totalRows,
-        warnings
-    };
-}
-
-describe('Complex Query Performance Analysis', () => {
-    // Configurable via PERF_ENTITY_COUNT env var (default: 50, max recommended: 50000)
-    const ENTITY_COUNT = parseInt(process.env.PERF_ENTITY_COUNT || '50', 10);
-    const BATCH_SIZE = 100; // Insert in batches for better performance
-    const createdEntityIds: string[] = [];
-
-    beforeAll(async () => {
-        await ensureComponentsRegistered(TestUser, TestProduct, TestOrder);
-
-        // Initialize cache
-        (EntityManager as any).dbReady = true;
-        const cacheManager = CacheManager.getInstance();
-        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 }
-        });
-
-        // Create test dataset (not using tracker so data persists)
-        console.log(`\n${'='.repeat(60)}`);
-        console.log(`Creating ${ENTITY_COUNT.toLocaleString()} test entities for performance analysis...`);
-        console.log(`(Set PERF_ENTITY_COUNT env var to change: 10000, 50000, etc.)`);
-        console.log(`${'='.repeat(60)}\n`);
-
-        const startTime = performance.now();
-        let lastProgressTime = startTime;
-
-        for (let i = 0; i < ENTITY_COUNT; i++) {
-            const entity = Entity.Create();
-            createdEntityIds.push(entity.id);
-
-            entity.add(TestUser, {
-                name: `PerfUser${i}`,
-                email: `perf${i}@example.com`,
-                age: 20 + (i % 50)
-            });
-
-            if (i % 2 === 0) {
-                entity.add(TestProduct, {
-                    sku: `PERF-SKU-${i}`,
-                    name: `Performance Product ${i}`,
-                    price: 10 + (i % 1000) * 5, // Vary prices
-                    inStock: i % 3 !== 0
-                });
-            }
-
-            if (i % 3 === 0) {
-                entity.add(TestOrder, {
-                    orderId: `ORD-${i}`,
-                    total: 100 + (i % 500) * 10,
-                    status: i % 2 === 0 ? 'completed' : 'pending'
-                });
-            }
-
-            await entity.save();
-
-            // Progress indicator for large datasets
-            if (ENTITY_COUNT >= 1000 && (i + 1) % 1000 === 0) {
-                const now = performance.now();
-                const elapsed = (now - startTime) / 1000;
-                const rate = (i + 1) / elapsed;
-                const remaining = (ENTITY_COUNT - i - 1) / rate;
-                console.log(`  Progress: ${i + 1}/${ENTITY_COUNT} (${((i + 1) / ENTITY_COUNT * 100).toFixed(1)}%) - ${rate.toFixed(0)} entities/sec - ETA: ${remaining.toFixed(1)}s`);
-            }
-        }
-
-        const totalTime = (performance.now() - startTime) / 1000;
-        console.log(`\nTest data created in ${totalTime.toFixed(2)}s (${(ENTITY_COUNT / totalTime).toFixed(0)} entities/sec)\n`);
-
-        // Run ANALYZE to update PostgreSQL statistics for better query planning
-        if (ENTITY_COUNT >= 1000) {
-            console.log('Running ANALYZE to update statistics...');
-            await db.unsafe(`ANALYZE entities`);
-            await db.unsafe(`ANALYZE components`);
-            await db.unsafe(`ANALYZE entity_components`);
-            console.log('Statistics updated.\n');
-        }
-    }, 600000); // 10 minute timeout for large datasets
-
-    afterAll(async () => {
-        // Bulk cleanup for performance
-        console.log(`\nCleaning up ${createdEntityIds.length.toLocaleString()} test entities...`);
-        const startTime = performance.now();
-
-        // Delete in batches
-        for (let i = 0; i < createdEntityIds.length; i += BATCH_SIZE) {
-            const batch = createdEntityIds.slice(i, i + BATCH_SIZE);
-            const placeholders = batch.map((_, idx) => `$${idx + 1}`).join(',');
-            try {
-                await db.unsafe(`DELETE FROM components WHERE entity_id IN (${placeholders})`, batch);
-                await db.unsafe(`DELETE FROM entities WHERE id IN (${placeholders})`, batch);
-            } catch { }
-        }
-
-        const duration = (performance.now() - startTime) / 1000;
-        console.log(`Cleanup completed in ${duration.toFixed(2)}s\n`);
-    }, 600000);
-
-    describe('Single Component Queries', () => {
-        test('simple query without filters', async () => {
-            const plan = await new Query()
-                .with(TestUser)
-                .explainAnalyze();
-
-            const analysis = analyzeQueryPlan(plan);
-
-            console.log('\n=== Simple Query (no filters) ===');
-            console.log(`Planning: ${analysis.planningTimeMs}ms, Execution: ${analysis.executionTimeMs}ms`);
-            console.log(`Seq Scan: ${analysis.hasSeqScan}, Index Scan: ${analysis.hasIndexScan}`);
-            if (analysis.warnings.length > 0) {
-                console.log('Warnings:', analysis.warnings);
-            }
-            console.log('---\n' + plan.substring(0, 500) + '...\n');
-
-            expect(analysis.executionTimeMs).toBeLessThan(1000); // Should be fast
-        });
-
-        test('query with equality filter', async () => {
-            const plan = await new Query()
-                .with(TestUser, {
-                    filters: [Query.filter('name', FilterOp.EQ, 'PerfUser25')]
-                })
-                .explainAnalyze();
-
-            const analysis = analyzeQueryPlan(plan);
-
-            console.log('\n=== Equality Filter Query ===');
-            console.log(`Planning: ${analysis.planningTimeMs}ms, Execution: ${analysis.executionTimeMs}ms`);
-            console.log(`Seq Scan: ${analysis.hasSeqScan}, Index Scan: ${analysis.hasIndexScan}`);
-            if (analysis.warnings.length > 0) {
-                console.log('Warnings:', analysis.warnings);
-            }
-
-            expect(analysis.executionTimeMs).toBeLessThan(500);
-        });
-
-        test('query with range filter', async () => {
-            const plan = await new Query()
-                .with(TestUser, {
-                    filters: [
-                        Query.filter('age', FilterOp.GTE, 30),
-                        Query.filter('age', FilterOp.LTE, 40)
-                    ]
-                })
-                .explainAnalyze();
-
-            const analysis = analyzeQueryPlan(plan);
-
-            console.log('\n=== Range Filter Query ===');
-            console.log(`Planning: ${analysis.planningTimeMs}ms, Execution: ${analysis.executionTimeMs}ms`);
-            console.log(`Seq Scan: ${analysis.hasSeqScan}, Index Scan: ${analysis.hasIndexScan}`);
-
-            expect(analysis.executionTimeMs).toBeLessThan(500);
-        });
-
-        test('query with LIKE filter', async () => {
-            const plan = await new Query()
-                .with(TestUser, {
-                    filters: [Query.filter('email', FilterOp.LIKE, 'perf%@example.com')]
-                })
-                .explainAnalyze();
-
-            const analysis = analyzeQueryPlan(plan);
-
-            console.log('\n=== LIKE Filter Query ===');
-            console.log(`Planning: ${analysis.planningTimeMs}ms, Execution: ${analysis.executionTimeMs}ms`);
-            // LIKE queries often use seq scan which is expected
-
-            expect(analysis.executionTimeMs).toBeLessThan(500);
-        });
-    });
-
-    describe('Multi-Component Queries', () => {
-        test('two component intersection', async () => {
-            const plan = await new Query()
-                .with(TestUser)
-                .with(TestProduct)
-                .explainAnalyze();
-
-            const analysis = analyzeQueryPlan(plan);
-
-            console.log('\n=== Two Component Query ===');
-            console.log(`Planning: ${analysis.planningTimeMs}ms, Execution: ${analysis.executionTimeMs}ms`);
-            console.log(`Join type - Nested Loop: ${analysis.hasNestedLoop}, Hash Join: ${analysis.hasHashJoin}`);
-            if (analysis.warnings.length > 0) {
-                console.log('Warnings:', analysis.warnings);
-            }
-
-            expect(analysis.executionTimeMs).toBeLessThan(1000);
-        });
-
-        test('three component intersection', async () => {
-            const plan = await new Query()
-                .with(TestUser)
-                .with(TestProduct)
-                .with(TestOrder)
-                .explainAnalyze();
-
-            const analysis = analyzeQueryPlan(plan);
-
-            console.log('\n=== Three Component Query ===');
-            console.log(`Planning: ${analysis.planningTimeMs}ms, Execution: ${analysis.executionTimeMs}ms`);
-            console.log(`Join type - Nested Loop: ${analysis.hasNestedLoop}, Hash Join: ${analysis.hasHashJoin}`);
-            if (analysis.warnings.length > 0) {
-                console.log('Warnings:', analysis.warnings);
-            }
-
-            expect(analysis.executionTimeMs).toBeLessThan(1000);
-        });
-
-        test('multi-component with filters on each', async () => {
-            const plan = await new Query()
-                .with(TestUser, {
-                    filters: [Query.filter('age', FilterOp.GT, 25)]
-                })
-                .with(TestProduct, {
-                    filters: [Query.filter('inStock', FilterOp.EQ, true)]
-                })
-                .explainAnalyze();
-
-            const analysis = analyzeQueryPlan(plan);
-
-            console.log('\n=== Multi-Component with Filters ===');
-            console.log(`Planning: ${analysis.planningTimeMs}ms, Execution: ${analysis.executionTimeMs}ms`);
-            if (analysis.warnings.length > 0) {
-                console.log('Warnings:', analysis.warnings);
-            }
-
-            expect(analysis.executionTimeMs).toBeLessThan(1000);
-        });
-    });
-
-    describe('Sorting and Pagination', () => {
-        test('sorted query', async () => {
-            const plan = await new Query()
-                .with(TestUser)
-                .sortBy(TestUser, 'age', 'DESC')
-                .explainAnalyze();
-
-            const analysis = analyzeQueryPlan(plan);
-
-            console.log('\n=== Sorted Query ===');
-            console.log(`Planning: ${analysis.planningTimeMs}ms, Execution: ${analysis.executionTimeMs}ms`);
-            console.log(`Has Sort operator: ${/Sort/i.test(plan)}`);
-
-            expect(analysis.executionTimeMs).toBeLessThan(500);
-        });
-
-        test('paginated query (OFFSET)', async () => {
-            const plan = await new Query()
-                .with(TestUser)
-                .take(10)
-                .offset(20)
-                .explainAnalyze();
-
-            const analysis = analyzeQueryPlan(plan);
-
-            console.log('\n=== Paginated Query (OFFSET) ===');
-            console.log(`Planning: ${analysis.planningTimeMs}ms, Execution: ${analysis.executionTimeMs}ms`);
-            console.log(`Has Limit: ${/Limit/i.test(plan)}`);
-
-            expect(analysis.executionTimeMs).toBeLessThan(500);
-        });
-
-        test('cursor-based pagination', async () => {
-            // First get an entity ID to use as cursor
-            const entities = await new Query()
-                .with(TestUser)
-                .take(15)
-                .exec();
-
-            if (entities.length >= 15) {
-                const cursorId = entities[14]!.id;
-
-                const plan = await new Query()
-                    .with(TestUser)
-                    .cursor(cursorId)
-                    .take(10)
-                    .explainAnalyze();
-
-                const analysis = analyzeQueryPlan(plan);
-
-                console.log('\n=== Cursor-Based Pagination ===');
-                console.log(`Planning: ${analysis.planningTimeMs}ms, Execution: ${analysis.executionTimeMs}ms`);
-
-                expect(analysis.executionTimeMs).toBeLessThan(500);
-            }
-        });
-
-        test('sorted and paginated', async () => {
-            const plan = await new Query()
-                .with(TestUser)
-                .sortBy(TestUser, 'name', 'ASC')
-                .take(10)
-                .offset(5)
-                .explainAnalyze();
-
-            const analysis = analyzeQueryPlan(plan);
-
-            console.log('\n=== Sorted + Paginated Query ===');
-            console.log(`Planning: ${analysis.planningTimeMs}ms, Execution: ${analysis.executionTimeMs}ms`);
-
-            expect(analysis.executionTimeMs).toBeLessThan(500);
-        });
-    });
-
-    describe('Aggregate Queries', () => {
-        test('count query', async () => {
-            const startTime = performance.now();
-            const count = await new Query()
-                .with(TestUser, {
-                    filters: [Query.filter('name', FilterOp.LIKE, 'PerfUser%')]
-                })
-                .count();
-            const duration = performance.now() - startTime;
-
-            console.log('\n=== Count Query ===');
-            console.log(`Count result: ${count}, Duration: ${duration.toFixed(2)}ms`);
-
-            expect(count).toBeGreaterThan(0);
-            expect(duration).toBeLessThan(500);
-        });
-
-        test('sum query', async () => {
-            const startTime = performance.now();
-            const sum = await new Query()
-                .with(TestProduct, {
-                    filters: [Query.filter('name', FilterOp.LIKE, 'Performance Product%')]
-                })
-                .sum(TestProduct, 'price');
-            const duration = performance.now() - startTime;
-
-            console.log('\n=== Sum Query ===');
-            console.log(`Sum result: ${sum}, Duration: ${duration.toFixed(2)}ms`);
-
-            expect(sum).toBeGreaterThan(0);
-            expect(duration).toBeLessThan(500);
-        });
-
-        test('average query', async () => {
-            const startTime = performance.now();
-            const avg = await new Query()
-                .with(TestUser, {
-                    filters: [Query.filter('name', FilterOp.LIKE, 'PerfUser%')]
-                })
-                .average(TestUser, 'age');
-            const duration = performance.now() - startTime;
-
-            console.log('\n=== Average Query ===');
-            console.log(`Average result: ${avg.toFixed(2)}, Duration: ${duration.toFixed(2)}ms`);
-
-            expect(avg).toBeGreaterThan(0);
-            expect(duration).toBeLessThan(500);
-        });
-    });
-
-    describe('Complex Combined Queries', () => {
-        test('full complexity query', async () => {
-            const plan = await new Query()
-                .with(TestUser, {
-                    filters: [
-                        Query.filter('age', FilterOp.GTE, 25),
-                        Query.filter('age', FilterOp.LTE, 45)
-                    ]
-                })
-                .with(TestProduct, {
-                    filters: [Query.filter('inStock', FilterOp.EQ, true)]
-                })
-                .sortBy(TestUser, 'age', 'DESC')
-                .take(20)
-                .explainAnalyze();
-
-            const analysis = analyzeQueryPlan(plan);
-
-            console.log('\n=== Full Complexity Query ===');
-            console.log(`Planning: ${analysis.planningTimeMs}ms, Execution: ${analysis.executionTimeMs}ms`);
-            console.log(`Seq Scan: ${analysis.hasSeqScan}, Index Scan: ${analysis.hasIndexScan}`);
-            console.log(`Nested Loop: ${analysis.hasNestedLoop}, Hash Join: ${analysis.hasHashJoin}`);
-            if (analysis.warnings.length > 0) {
-                console.log('Warnings:', analysis.warnings);
-            }
-            console.log('\nFull Plan:\n' + plan);
-
-            expect(analysis.executionTimeMs).toBeLessThan(1000);
-        });
-
-        test('without() exclusion query', async () => {
-            const plan = await new Query()
-                .with(TestUser)
-                .without(TestProduct)
-                .explainAnalyze();
-
-            const analysis = analyzeQueryPlan(plan);
-
-            console.log('\n=== Exclusion (without) Query ===');
-            console.log(`Planning: ${analysis.planningTimeMs}ms, Execution: ${analysis.executionTimeMs}ms`);
-            console.log(`Has NOT EXISTS or anti-join pattern: ${/NOT EXISTS|Anti/i.test(plan) || /NOT IN/i.test(plan)}`);
-
-            expect(analysis.executionTimeMs).toBeLessThan(1000);
-        });
-    });
-
-    describe('Performance Summary', () => {
-        test('generate performance report', async () => {
-            const results: Array<{ name: string; planningMs: number; executionMs: number; warnings: string[]; scanType: string }> = [];
-
-            const getScanType = (a: QueryPlanAnalysis) => {
-                if (a.hasIndexScan && !a.hasSeqScan) return 'Index';
-                if (a.hasSeqScan && !a.hasIndexScan) return 'Seq';
-                if (a.hasIndexScan && a.hasSeqScan) return 'Mixed';
-                return 'N/A';
-            };
-
-            // Simple query
-            let plan = await new Query().with(TestUser).explainAnalyze();
-            let analysis = analyzeQueryPlan(plan);
-            results.push({ name: 'Simple (1 component)', planningMs: analysis.planningTimeMs, executionMs: analysis.executionTimeMs, warnings: analysis.warnings, scanType: getScanType(analysis) });
-
-            // Filtered
-            plan = await new Query().with(TestUser, { filters: [Query.filter('age', FilterOp.GT, 30)] }).explainAnalyze();
-            analysis = analyzeQueryPlan(plan);
-            results.push({ name: 'Filtered (JSONB)', planningMs: analysis.planningTimeMs, executionMs: analysis.executionTimeMs, warnings: analysis.warnings, scanType: getScanType(analysis) });
-
-            // Multi-component
-            plan = await new Query().with(TestUser).with(TestProduct).explainAnalyze();
-            analysis = analyzeQueryPlan(plan);
-            results.push({ name: 'Multi-component (2)', planningMs: analysis.planningTimeMs, executionMs: analysis.executionTimeMs, warnings: analysis.warnings, scanType: getScanType(analysis) });
-
-            // Count
-            const countStart = performance.now();
-            const count = await new Query().with(TestUser).count();
-            const countMs = performance.now() - countStart;
-            results.push({ name: `Count (result: ${count})`, planningMs: 0, executionMs: countMs, warnings: [], scanType: 'N/A' });
-
-            // Sorted + paginated
-            plan = await new Query().with(TestUser).sortBy(TestUser, 'age').take(10).explainAnalyze();
-            analysis = analyzeQueryPlan(plan);
-            results.push({ name: 'Sorted + Paginated (10)', planningMs: analysis.planningTimeMs, executionMs: analysis.executionTimeMs, warnings: analysis.warnings, scanType: getScanType(analysis) });
-
-            // Offset pagination (worst case)
-            plan = await new Query().with(TestUser).take(10).offset(Math.floor(ENTITY_COUNT * 0.9)).explainAnalyze();
-            analysis = analyzeQueryPlan(plan);
-            results.push({ name: 'Offset pagination (90%)', planningMs: analysis.planningTimeMs, executionMs: analysis.executionTimeMs, warnings: analysis.warnings, scanType: getScanType(analysis) });
-
-            // Complex
-            plan = await new Query()
-                .with(TestUser, { filters: [Query.filter('age', FilterOp.GT, 25)] })
-                .with(TestProduct, { filters: [Query.filter('inStock', FilterOp.EQ, true)] })
-                .sortBy(TestUser, 'age', 'DESC')
-                .take(10)
-                .explainAnalyze();
-            analysis = analyzeQueryPlan(plan);
-            results.push({ name: 'Complex (multi+filter+sort)', planningMs: analysis.planningTimeMs, executionMs: analysis.executionTimeMs, warnings: analysis.warnings, scanType: getScanType(analysis) });
-
-            // Sum aggregate
-            const sumStart = performance.now();
-            const sum = await new Query()
-                .with(TestProduct, { filters: [Query.filter('name', FilterOp.LIKE, 'Performance%')] })
-                .sum(TestProduct, 'price');
-            const sumMs = performance.now() - sumStart;
-            results.push({ name: `Sum (result: ${sum})`, planningMs: 0, executionMs: sumMs, warnings: [], scanType: 'N/A' });
-
-            console.log('\n' + '='.repeat(80));
-            console.log(`PERFORMANCE SUMMARY REPORT - ${ENTITY_COUNT.toLocaleString()} entities`);
-            console.log('='.repeat(80));
-            console.log('\n| Query Type                          | Planning | Execution | Scan  |');
-            console.log('|-------------------------------------|----------|-----------|-------|');
-
-            let totalExecution = 0;
-            for (const r of results) {
-                totalExecution += r.executionMs;
-                const planStr = r.planningMs > 0 ? `${r.planningMs.toFixed(2)}ms` : '-';
-                const execStr = r.executionMs >= 1 ? `${r.executionMs.toFixed(1)}ms` : `${(r.executionMs * 1000).toFixed(0)}µs`;
-                console.log(`| ${r.name.padEnd(35)} | ${planStr.padStart(8)} | ${execStr.padStart(9)} | ${r.scanType.padStart(5)} |`);
-            }
-
-            console.log('|-------------------------------------|----------|-----------|-------|');
-            const totalStr = totalExecution >= 1 ? `${totalExecution.toFixed(1)}ms` : `${(totalExecution * 1000).toFixed(0)}µs`;
-            console.log(`| TOTAL                               |          | ${totalStr.padStart(9)} |       |`);
-            console.log('\n' + '='.repeat(80) + '\n');
-
-            // All queries should complete in reasonable time
-            expect(totalExecution).toBeLessThan(5000);
-        });
-    });
-});