bunsane 0.1.4 → 0.2.0

package/tests/stress/scenarios/query-benchmarks.test.ts

@@ -0,0 +1,285 @@
+/**
+ * Stress Tests - Query Performance Benchmarks
+ *
+ * Tests query performance with configurable data volumes
+ * Default: 10,000 records (smoke test)
+ * Set STRESS_RECORD_COUNT env var for larger tests
+ */
+import { describe, test, beforeAll, afterAll, expect } from 'bun:test';
+import { DataSeeder } from '../DataSeeder';
+import { BenchmarkRunner } from '../BenchmarkRunner';
+import { StressTestReporter } from '../StressTestReporter';
+import { Query, FilterOp } from '../../../query/Query';
+import { StressUser, StressProfile } from '../fixtures/StressTestComponents';
+import { ensureComponentsRegistered } from '../../utils';
+
+// Configurable via environment variable
+const RECORD_COUNT = parseInt(process.env.STRESS_RECORD_COUNT || '10000', 10);
+const BATCH_SIZE = Math.min(5000, Math.floor(RECORD_COUNT / 10) || 1000);
+
+describe('Stress Tests - Query Performance', () => {
+    const seeder = new DataSeeder();
+    const benchmark = new BenchmarkRunner();
+    const reporter = new StressTestReporter();
+    let entityIds: string[] = [];
+    let setupTime = 0;
+
+    beforeAll(async () => {
+        const startSetup = performance.now();
+
+        // Ensure components are registered
+        await ensureComponentsRegistered(StressUser, StressProfile);
+
+        // Wait for index creation to settle (prevents deadlocks from concurrent index creation)
+        await new Promise(resolve => setTimeout(resolve, 3000));
+
+        console.log(`\n  Seeding ${RECORD_COUNT.toLocaleString()} records...`);
+
+        const result = await seeder.seed(
+            StressUser,
+            (i) => ({
+                name: `User ${i}`,
+                email: `user${i}@stress.test`,
+                age: 18 + (i % 62),
+                status: ['active', 'inactive', 'pending', 'banned'][i % 4],
+                score: Math.random() * 1000,
+                createdAt: new Date(Date.now() - Math.random() * 365 * 24 * 60 * 60 * 1000)
+            }),
+            {
+                totalEntities: RECORD_COUNT,
+                batchSize: BATCH_SIZE,
+                onProgress: (current, total, elapsed) => {
+                    if (current % (BATCH_SIZE * 2) === 0 || current === total) {
+                        const pct = ((current / total) * 100).toFixed(1);
+                        const rate = ((current / elapsed) * 1000).toFixed(0);
+                        console.log(`    Progress: ${pct}% (${rate} records/sec)`);
+                    }
+                }
+            }
+        );
+
+        entityIds = result.entityIds;
+        console.log(`  Seeded in ${(result.totalTime / 1000).toFixed(1)}s (${result.recordsPerSecond.toFixed(0)} records/sec)`);
+
+        // Add profile components to 50% of entities
+        if (RECORD_COUNT >= 1000) {
+            console.log('  Adding profile components to 50% of entities...');
+            await seeder.seedAdditionalComponent(
+                entityIds.slice(0, Math.floor(entityIds.length / 2)),
+                StressProfile,
+                (i) => ({
+                    bio: `This is bio ${i}`,
+                    avatarUrl: `https://example.com/avatar/${i}.png`,
+                    verified: i % 3 === 0
+                }),
+                BATCH_SIZE
+            );
+        }
+
+        console.log('  Running VACUUM ANALYZE...');
+        await seeder.optimize();
+
+        setupTime = performance.now() - startSetup;
+        console.log(`  Setup complete in ${(setupTime / 1000).toFixed(1)}s\n`);
+    });
+
+    afterAll(async () => {
+        // Print report
+        const recordCount = await seeder.getRecordCount();
+        const report = reporter.generateReport(benchmark.getResults(), {
+            recordCount,
+            environment: `PostgreSQL, Bun ${Bun.version}`,
+            duration: setupTime
+        });
+        console.log('\n' + report);
+
+        // Cleanup seeded data
+        console.log('\n  Cleaning up test data...');
+        await seeder.cleanup(entityIds, BATCH_SIZE);
+        console.log('  Cleanup complete.');
+    });
+
+    test('indexed equality filter (status = active)', async () => {
+        const result = await benchmark.runWithOutput(
+            'Filter: status = active',
+            () => new Query()
+                .with(StressUser, { filters: [{ field: 'status', operator: FilterOp.EQ, value: 'active' }] })
+                .take(100)
+                .exec(),
+            { targetP95: 50, iterations: 15 }
+        );
+        expect(result.passed).toBe(true);
+    });
+
+    test('indexed range filter (age 25-35)', async () => {
+        const result = await benchmark.runWithOutput(
+            'Filter: age 25-35',
+            () => new Query()
+                .with(StressUser, {
+                    filters: [
+                        { field: 'age', operator: FilterOp.GTE, value: 25 },
+                        { field: 'age', operator: FilterOp.LTE, value: 35 }
+                    ]
+                })
+                .take(100)
+                .exec(),
+            { targetP95: 75, iterations: 15 }
+        );
+        expect(result.passed).toBe(true);
+    });
+
+    test('count query', async () => {
+        const result = await benchmark.runWithOutput(
+            'COUNT all',
+            async () => [await new Query().with(StressUser).count()],
+            { targetP95: 100, iterations: 15 }
+        );
+        expect(result.passed).toBe(true);
+    });
+
+    test('pagination - shallow offset (1000)', async () => {
+        const result = await benchmark.runWithOutput(
+            'Offset 1000',
+            () => new Query()
+                .with(StressUser)
+                .sortBy(StressUser, 'name', 'ASC')
+                .take(100)
+                .offset(1000)
+                .exec(),
+            { targetP95: 75, iterations: 15 }
+        );
+        expect(result.passed).toBe(true);
+    });
+
+    test('pagination - deep offset (50% of records)', async () => {
+        const deepOffset = Math.floor(RECORD_COUNT / 2);
+        const result = await benchmark.runWithOutput(
+            `Offset ${deepOffset.toLocaleString()}`,
+            () => new Query()
+                .with(StressUser)
+                .sortBy(StressUser, 'name', 'ASC')
+                .take(100)
+                .offset(deepOffset)
+                .exec(),
+            { targetP95: 500, iterations: 10 }
+        );
+        // Deep pagination is expected to be slower, use a more lenient target
+        expect(result.timings.p95).toBeLessThan(2000);
+    });
+
+    test('cursor pagination - first page', async () => {
+        const result = await benchmark.runWithOutput(
+            'Cursor: first page',
+            () => new Query()
+                .with(StressUser)
+                .take(100)
+                .exec(),
+            { targetP95: 50, iterations: 15 }
+        );
+        expect(result.passed).toBe(true);
+    });
+
+    test('cursor pagination - from middle (using cursor)', async () => {
+        // First, get an entity ID from the middle of the dataset
+        const midpointResults = await new Query()
+            .with(StressUser)
+            .take(1)
+            .offset(Math.floor(RECORD_COUNT / 2))
+            .exec();
+
+        const cursorId = midpointResults[0]?.id;
+        expect(cursorId).toBeDefined();
+
+        const result = await benchmark.runWithOutput(
+            'Cursor: from middle (O(1))',
+            () => new Query()
+                .with(StressUser)
+                .cursor(cursorId!)
+                .take(100)
+                .exec(),
+            { targetP95: 50, iterations: 15 }
+        );
+        // Cursor pagination should be fast regardless of position
+        expect(result.passed).toBe(true);
+    });
+
+    test('cursor pagination - near end (using cursor)', async () => {
+        // Get an entity ID from near the end (90%)
+        const nearEndResults = await new Query()
+            .with(StressUser)
+            .take(1)
+            .offset(Math.floor(RECORD_COUNT * 0.9))
+            .exec();
+
+        const cursorId = nearEndResults[0]?.id;
+        expect(cursorId).toBeDefined();
+
+        const result = await benchmark.runWithOutput(
+            'Cursor: near end (O(1))',
+            () => new Query()
+                .with(StressUser)
+                .cursor(cursorId!)
+                .take(100)
+                .exec(),
+            { targetP95: 50, iterations: 15 }
+        );
+        // Cursor pagination should be fast regardless of position
+        expect(result.passed).toBe(true);
+    });
+
+    test('multi-component join (User + Profile)', async () => {
+        const result = await benchmark.runWithOutput(
+            'Join: User + Profile',
+            () => new Query()
+                .with(StressUser)
+                .with(StressProfile)
+                .take(100)
+                .exec(),
+            { targetP95: 150, iterations: 15 }
+        );
+        expect(result.passed).toBe(true);
+    });
+
+    test('combined filters and sort', async () => {
+        const result = await benchmark.runWithOutput(
+            'Filter + Sort + Limit',
+            () => new Query()
+                .with(StressUser, {
+                    filters: [
+                        { field: 'status', operator: FilterOp.EQ, value: 'active' },
+                        { field: 'age', operator: FilterOp.GTE, value: 21 }
+                    ]
+                })
+                .sortBy(StressUser, 'score', 'DESC')
+                .take(50)
+                .exec(),
+            { targetP95: 100, iterations: 15 }
+        );
+        expect(result.passed).toBe(true);
+    });
+
+    test('simple query without filters', async () => {
+        const result = await benchmark.runWithOutput(
+            'Simple: take 100',
+            () => new Query()
+                .with(StressUser)
+                .take(100)
+                .exec(),
+            { targetP95: 50, iterations: 15 }
+        );
+        expect(result.passed).toBe(true);
+    });
+
+    test('query with populate', async () => {
+        const result = await benchmark.runWithOutput(
+            'Populated: take 50',
+            () => new Query()
+                .with(StressUser)
+                .populate()
+                .take(50)
+                .exec(),
+            { targetP95: 100, iterations: 15 }
+        );
+        expect(result.passed).toBe(true);
+    });
+});

package/tests/unit/BatchLoader.test.ts

@@ -0,0 +1,82 @@
+/**
+ * Unit tests for BatchLoader TTL behavior
+ */
+import { describe, test, expect, beforeEach } from 'bun:test';
+import { BatchLoader } from '../../core/BatchLoader';
+
+describe('BatchLoader', () => {
+    beforeEach(() => {
+        BatchLoader.clearCache();
+    });
+
+    describe('getCacheStats()', () => {
+        test('returns zero stats when cache is empty', () => {
+            const stats = BatchLoader.getCacheStats();
+            expect(stats.size).toBe(0);
+            expect(stats.entries).toBe(0);
+            expect(stats.expired).toBe(0);
+        });
+    });
+
+    describe('clearCache()', () => {
+        test('clears all cached entries', () => {
+            // Access internal cache via any to set up test data
+            const cache = (BatchLoader as any).cache as Map<string, Map<string, any>>;
+            const innerMap = new Map();
+            innerMap.set('parent1', { ids: ['a', 'b'], expiresAt: Date.now() + 300000 });
+            cache.set('type1:value', innerMap);
+
+            expect(BatchLoader.getCacheStats().entries).toBe(1);
+
+            BatchLoader.clearCache();
+            expect(BatchLoader.getCacheStats().entries).toBe(0);
+        });
+    });
+
+    describe('TTL expiry', () => {
+        test('getCacheStats reports expired entries', () => {
+            const cache = (BatchLoader as any).cache as Map<string, Map<string, any>>;
+            const innerMap = new Map();
+            // One fresh entry
+            innerMap.set('parent1', { ids: ['a'], expiresAt: Date.now() + 300000 });
+            // One expired entry
+            innerMap.set('parent2', { ids: ['b'], expiresAt: Date.now() - 1000 });
+            cache.set('type1:value', innerMap);
+
+            const stats = BatchLoader.getCacheStats();
+            expect(stats.entries).toBe(2);
+            expect(stats.expired).toBe(1);
+        });
+
+        test('expired entries are counted correctly for multiple type keys', () => {
+            const cache = (BatchLoader as any).cache as Map<string, Map<string, any>>;
+
+            const map1 = new Map();
+            map1.set('p1', { ids: ['a'], expiresAt: Date.now() - 5000 });
+            map1.set('p2', { ids: ['b'], expiresAt: Date.now() + 300000 });
+            cache.set('type1:field', map1);
+
+            const map2 = new Map();
+            map2.set('p3', { ids: ['c'], expiresAt: Date.now() - 1000 });
+            cache.set('type2:field', map2);
+
+            const stats = BatchLoader.getCacheStats();
+            expect(stats.size).toBe(2);
+            expect(stats.entries).toBe(3);
+            expect(stats.expired).toBe(2);
+        });
+
+        test('all entries fresh means zero expired', () => {
+            const cache = (BatchLoader as any).cache as Map<string, Map<string, any>>;
+            const innerMap = new Map();
+            innerMap.set('p1', { ids: ['a'], expiresAt: Date.now() + 60000 });
+            innerMap.set('p2', { ids: ['b'], expiresAt: Date.now() + 60000 });
+            innerMap.set('p3', { ids: ['c'], expiresAt: Date.now() + 60000 });
+            cache.set('type:field', innerMap);
+
+            const stats = BatchLoader.getCacheStats();
+            expect(stats.entries).toBe(3);
+            expect(stats.expired).toBe(0);
+        });
+    });
+});

package/tests/unit/archetype/ArcheType.test.ts

@@ -0,0 +1,107 @@
+/**
+ * Unit tests for ArcheType system
+ * Tests archetype definition and basic functionality
+ */
+import { describe, test, expect, beforeAll } from 'bun:test';
+import { BaseArcheType, ArcheType, ArcheTypeField } from '../../../core/ArcheType';
+import { TestUser, TestProduct, TestOrder } from '../../fixtures/components';
+import { TestUserArchetype, TestUserWithOrdersArchetype } from '../../fixtures/archetypes/TestUserArchetype';
+import { ensureComponentsRegistered } from '../../utils';
+
+describe('ArcheType', () => {
+    beforeAll(async () => {
+        await ensureComponentsRegistered(TestUser, TestProduct, TestOrder);
+    });
+
+    describe('ArcheType definition', () => {
+        test('archetype class extends BaseArcheType', () => {
+            const archetype = new TestUserArchetype();
+            expect(archetype).toBeInstanceOf(BaseArcheType);
+        });
+
+        test('archetype has componentMap', () => {
+            const archetype = new TestUserArchetype();
+            expect(archetype.componentMap).toBeDefined();
+            expect(typeof archetype.componentMap).toBe('object');
+        });
+
+        test('componentMap contains declared fields', () => {
+            const archetype = new TestUserArchetype();
+            expect(archetype.componentMap.user).toBeDefined();
+        });
+
+        test('archetype with multiple components', () => {
+            const archetype = new TestUserWithOrdersArchetype();
+            expect(archetype.componentMap.user).toBeDefined();
+            expect(archetype.componentMap.order).toBeDefined();
+        });
+    });
+
+    describe('createEntity()', () => {
+        test('creates entity with id', () => {
+            const archetype = new TestUserArchetype();
+            const entity = archetype.createEntity();
+
+            expect(entity).toBeDefined();
+            expect(entity.id).toBeDefined();
+            expect(entity.id.length).toBeGreaterThan(0);
+        });
+
+        test('entity is dirty after creation', () => {
+            const archetype = new TestUserArchetype();
+            const entity = archetype.createEntity();
+
+            expect((entity as any)._dirty).toBe(true);
+        });
+
+        test('entity is not persisted after creation', () => {
+            const archetype = new TestUserArchetype();
+            const entity = archetype.createEntity();
+
+            expect(entity._persisted).toBe(false);
+        });
+    });
+
+    describe('getZodObjectSchema()', () => {
+        test('returns zod schema for archetype', () => {
+            const archetype = new TestUserArchetype();
+            const schema = archetype.getZodObjectSchema();
+
+            expect(schema).toBeDefined();
+        });
+    });
+
+    describe('getInputSchema()', () => {
+        test('returns input schema for archetype', () => {
+            const archetype = new TestUserArchetype();
+            const schema = archetype.getInputSchema();
+
+            expect(schema).toBeDefined();
+        });
+    });
+
+    describe('getComponentsToLoad()', () => {
+        test('returns non-empty components array', () => {
+            const archetype = new TestUserArchetype();
+            const components = (archetype as any).getComponentsToLoad();
+
+            expect(Array.isArray(components)).toBe(true);
+            expect(components.length).toBeGreaterThan(0);
+            expect(components).toContain(TestUser);
+        });
+    });
+
+    describe('withValidation()', () => {
+        test('returns a Zod schema with validations applied', () => {
+            const archetype = new TestUserArchetype();
+            const schema = archetype.withValidation({
+                user: { name: 'Valid', email: 'valid@test.com', age: 25 }
+            });
+
+            expect(schema).toBeDefined();
+            // Should return a Zod schema with a shape property
+            expect(schema.shape).toBeDefined();
+            expect(typeof schema.safeParse).toBe('function');
+        });
+    });
+});