bunsane 0.3.1 → 0.4.0

package/tests/stress/BenchmarkRunner.ts

@@ -1,203 +0,0 @@
-/**
- * Benchmark execution engine for stress testing
- * Runs queries with statistical analysis
- */
-import db from '../../database';
-
-export interface BenchmarkResult {
-    name: string;
-    iterations: number;
-    totalRecords: number;
-    timings: {
-        min: number;
-        max: number;
-        mean: number;
-        median: number;
-        p95: number;
-        p99: number;
-        stdDev: number;
-    };
-    rowsReturned: number;
-    queriesPerSecond: number;
-    memoryUsedMB: number;
-    passed: boolean;
-    target?: number;
-}
-
-export interface BenchmarkOptions {
-    iterations?: number;
-    warmupIterations?: number;
-    targetP95?: number;
-    collectMemory?: boolean;
-}
-
-export interface ConcurrentResult {
-    name: string;
-    concurrency: number;
-    totalQueries: number;
-    queriesPerSecond: number;
-    avgLatency: number;
-    errorRate: number;
-}
-
-export class BenchmarkRunner {
-    private results: BenchmarkResult[] = [];
-
-    async run(
-        name: string,
-        queryFn: () => Promise<any[]>,
-        options: BenchmarkOptions = {}
-    ): Promise<BenchmarkResult> {
-        const {
-            iterations = 20,
-            warmupIterations = 3,
-            targetP95,
-            collectMemory = true
-        } = options;
-
-        // Warmup phase
-        for (let i = 0; i < warmupIterations; i++) {
-            await queryFn();
-        }
-
-        // Force GC if available
-        if (typeof global.gc === 'function') {
-            global.gc();
-        }
-
-        const times: number[] = [];
-        let rowCount = 0;
-        const memBefore = process.memoryUsage().heapUsed;
-
-        // Benchmark phase
-        for (let i = 0; i < iterations; i++) {
-            const start = performance.now();
-            const results = await queryFn();
-            times.push(performance.now() - start);
-            rowCount = Array.isArray(results) ? results.length : 0;
-        }
-
-        const memAfter = process.memoryUsage().heapUsed;
-        const sortedTimes = [...times].sort((a, b) => a - b);
-
-        const timings = {
-            min: sortedTimes[0] ?? 0,
-            max: sortedTimes[sortedTimes.length - 1] ?? 0,
-            mean: times.reduce((a, b) => a + b, 0) / (times.length || 1),
-            median: sortedTimes[Math.floor(sortedTimes.length / 2)] ?? 0,
-            p95: sortedTimes[Math.floor(sortedTimes.length * 0.95)] ?? sortedTimes[sortedTimes.length - 1] ?? 0,
-            p99: sortedTimes[Math.floor(sortedTimes.length * 0.99)] ?? sortedTimes[sortedTimes.length - 1] ?? 0,
-            stdDev: this.calculateStdDev(times)
-        };
-
-        const result: BenchmarkResult = {
-            name,
-            iterations,
-            totalRecords: await this.getRecordCount(),
-            timings,
-            rowsReturned: rowCount,
-            queriesPerSecond: 1000 / (timings.mean || 1),
-            memoryUsedMB: collectMemory ? (memAfter - memBefore) / 1024 / 1024 : 0,
-            passed: targetP95 ? (timings.p95 ?? 0) <= targetP95 : true,
-            target: targetP95
-        };
-
-        this.results.push(result);
-        return result;
-    }
-
-    async runConcurrent(
-        name: string,
-        queryFn: () => Promise<any[]>,
-        concurrency: number,
-        duration: number = 10000
-    ): Promise<ConcurrentResult> {
-        const times: number[] = [];
-        let errors = 0;
-        const startTime = performance.now();
-
-        const worker = async () => {
-            while (performance.now() - startTime < duration) {
-                const queryStart = performance.now();
-                try {
-                    await queryFn();
-                    times.push(performance.now() - queryStart);
-                } catch {
-                    errors++;
-                }
-            }
-        };
-
-        await Promise.all(Array(concurrency).fill(null).map(() => worker()));
-
-        const totalTime = performance.now() - startTime;
-
-        return {
-            name,
-            concurrency,
-            totalQueries: times.length + errors,
-            queriesPerSecond: (times.length / totalTime) * 1000,
-            avgLatency: times.length > 0 ? times.reduce((a, b) => a + b, 0) / times.length : 0,
-            errorRate: (times.length + errors) > 0 ? errors / (times.length + errors) : 0
-        };
-    }
-
-    /**
-     * Run a benchmark and print detailed results
-     */
-    async runWithOutput(
-        name: string,
-        queryFn: () => Promise<any[]>,
-        options: BenchmarkOptions = {}
-    ): Promise<BenchmarkResult> {
-        console.log(`  Running: ${name}...`);
-        const result = await this.run(name, queryFn, options);
-
-        const status = result.passed ? '\x1b[32mPASS\x1b[0m' : '\x1b[31mFAIL\x1b[0m';
-        console.log(
-            `    ${status} p50=${result.timings.median.toFixed(1)}ms ` +
-            `p95=${result.timings.p95.toFixed(1)}ms ` +
-            `rows=${result.rowsReturned} ` +
-            `QPS=${result.queriesPerSecond.toFixed(0)}`
-        );
-
-        if (!result.passed && result.target) {
-            console.log(`    Target: p95 <= ${result.target}ms`);
-        }
-
-        return result;
-    }
-
-    private calculateStdDev(values: number[]): number {
-        if (values.length === 0) return 0;
-        const mean = values.reduce((a, b) => a + b) / values.length;
-        const squareDiffs = values.map(value => Math.pow(value - mean, 2));
-        return Math.sqrt(squareDiffs.reduce((a, b) => a + b) / values.length);
-    }
-
-    private async getRecordCount(): Promise<number> {
-        try {
-            const result = await db`SELECT COUNT(*) as count FROM entities WHERE deleted_at IS NULL`;
-            return parseInt(result[0].count);
-        } catch {
-            return 0;
-        }
-    }
-
-    getResults(): BenchmarkResult[] {
-        return [...this.results];
-    }
-
-    clearResults(): void {
-        this.results = [];
-    }
-
-    /**
-     * Get summary statistics
-     */
-    getSummary(): { passed: number; failed: number; total: number } {
-        const passed = this.results.filter(r => r.passed).length;
-        const failed = this.results.filter(r => !r.passed).length;
-        return { passed, failed, total: this.results.length };
-    }
-}

package/tests/stress/DataSeeder.ts

@@ -1,190 +0,0 @@
-/**
- * Data seeder for stress testing
- * Performs optimized bulk inserts for maximum throughput
- */
-import db from '../../database';
-import { sql } from 'bun';
-import { ComponentRegistry } from '../../core/components';
-import { getMetadataStorage } from '../../core/metadata';
-import { uuidv7 } from '../../utils/uuid';
-import type { BaseComponent } from '../../core/components/BaseComponent';
-
-export interface SeederOptions {
-    totalEntities: number;
-    batchSize: number;
-    onProgress?: (current: number, total: number, elapsedMs: number) => void;
-}
-
-export interface SeederResult {
-    entityIds: string[];
-    totalTime: number;
-    recordsPerSecond: number;
-}
-
-type ComponentConstructor = new () => BaseComponent;
-
-export class DataSeeder {
-    /**
-     * Seeds the database with test entities and components
-     * Uses optimized bulk inserts for maximum throughput
-     */
-    async seed<T extends BaseComponent>(
-        componentClass: ComponentConstructor,
-        dataGenerator: (index: number) => Record<string, any>,
-        options: SeederOptions
-    ): Promise<SeederResult> {
-        const { totalEntities, batchSize, onProgress } = options;
-        const entityIds: string[] = [];
-        const startTime = performance.now();
-
-        // Ensure component is registered (just wait for readiness, don't trigger registration)
-        const componentName = componentClass.name;
-        await ComponentRegistry.getReadyPromise(componentName);
-
-        const storage = getMetadataStorage();
-        const typeId = storage.getComponentId(componentName);
-
-        for (let i = 0; i < totalEntities; i += batchSize) {
-            const currentBatch = Math.min(batchSize, totalEntities - i);
-            const now = new Date();
-
-            // Build batch data arrays
-            const entitiesToInsert: { id: string; created_at: Date; updated_at: Date }[] = [];
-            const componentsToInsert: { id: string; entity_id: string; type_id: string; name: string; data: any; created_at: Date; updated_at: Date }[] = [];
-            const entityComponentsToInsert: { entity_id: string; type_id: string; component_id: string; created_at: Date; updated_at: Date }[] = [];
-
-            // Generate batch data
-            for (let j = 0; j < currentBatch; j++) {
-                const entityId = uuidv7();
-                const componentId = uuidv7();
-                const data = dataGenerator(i + j);
-
-                entitiesToInsert.push({
-                    id: entityId,
-                    created_at: now,
-                    updated_at: now
-                });
-
-                componentsToInsert.push({
-                    id: componentId,
-                    entity_id: entityId,
-                    type_id: typeId,
-                    name: componentName,
-                    data: data,
-                    created_at: now,
-                    updated_at: now
-                });
-
-                entityComponentsToInsert.push({
-                    entity_id: entityId,
-                    type_id: typeId,
-                    component_id: componentId,
-                    created_at: now,
-                    updated_at: now
-                });
-
-                entityIds.push(entityId);
-            }
-
-            // Bulk insert entities using Bun's sql helper
-            await db`INSERT INTO entities ${sql(entitiesToInsert, 'id', 'created_at', 'updated_at')}`;
-
-            // Bulk insert components
-            await db`INSERT INTO components ${sql(componentsToInsert, 'id', 'entity_id', 'type_id', 'name', 'data', 'created_at', 'updated_at')}`;
-
-            // Bulk insert entity_components index
-            await db`INSERT INTO entity_components ${sql(entityComponentsToInsert, 'entity_id', 'type_id', 'component_id', 'created_at', 'updated_at')} ON CONFLICT (entity_id, type_id) DO NOTHING`;
-
-            if (onProgress) {
-                onProgress(i + currentBatch, totalEntities, performance.now() - startTime);
-            }
-        }
-
-        const totalTime = performance.now() - startTime;
-
-        return {
-            entityIds,
-            totalTime,
-            recordsPerSecond: (totalEntities / totalTime) * 1000
-        };
-    }
-
-    /**
-     * Seeds multiple components for existing entities
-     */
-    async seedAdditionalComponent<T extends BaseComponent>(
-        entityIds: string[],
-        componentClass: ComponentConstructor,
-        dataGenerator: (index: number, entityId: string) => Record<string, any>,
-        batchSize: number = 5000
-    ): Promise<void> {
-        const componentName = componentClass.name;
-        await ComponentRegistry.getReadyPromise(componentName);
-
-        const storage = getMetadataStorage();
-        const typeId = storage.getComponentId(componentName);
-
-        for (let i = 0; i < entityIds.length; i += batchSize) {
-            const batchEntityIds = entityIds.slice(i, i + batchSize);
-            const now = new Date();
-
-            const componentsToInsert: { id: string; entity_id: string; type_id: string; name: string; data: any; created_at: Date; updated_at: Date }[] = [];
-            const entityComponentsToInsert: { entity_id: string; type_id: string; component_id: string; created_at: Date; updated_at: Date }[] = [];
-
-            for (let j = 0; j < batchEntityIds.length; j++) {
-                const entityId = batchEntityIds[j]!;
-                const componentId = uuidv7();
-                const data = dataGenerator(i + j, entityId);
-
-                componentsToInsert.push({
-                    id: componentId,
-                    entity_id: entityId,
-                    type_id: typeId,
-                    name: componentName,
-                    data: data,
-                    created_at: now,
-                    updated_at: now
-                });
-
-                entityComponentsToInsert.push({
-                    entity_id: entityId,
-                    type_id: typeId,
-                    component_id: componentId,
-                    created_at: now,
-                    updated_at: now
-                });
-            }
-
-            await db`INSERT INTO components ${sql(componentsToInsert, 'id', 'entity_id', 'type_id', 'name', 'data', 'created_at', 'updated_at')}`;
-            await db`INSERT INTO entity_components ${sql(entityComponentsToInsert, 'entity_id', 'type_id', 'component_id', 'created_at', 'updated_at')} ON CONFLICT (entity_id, type_id) DO NOTHING`;
-        }
-    }
-
-    /**
-     * Cleans up seeded data
-     */
-    async cleanup(entityIds: string[], batchSize: number = 10000): Promise<void> {
-        for (let i = 0; i < entityIds.length; i += batchSize) {
-            const batch = entityIds.slice(i, i + batchSize);
-            // Use individual deletes for reliability
-            await db`DELETE FROM entities WHERE id IN ${sql(batch.map(id => [id]))}`;
-        }
-    }
-
-    /**
-     * Runs VACUUM ANALYZE for optimal query planning
-     */
-    async optimize(): Promise<void> {
-        await db.unsafe('VACUUM ANALYZE entities');
-        await db.unsafe('VACUUM ANALYZE components');
-        await db.unsafe('VACUUM ANALYZE entity_components');
-    }
-
-    /**
-     * Gets the current record count
-     */
-    async getRecordCount(): Promise<number> {
-        const result = await db`SELECT COUNT(*) as count FROM entities WHERE deleted_at IS NULL`;
-        return parseInt(result[0].count);
-    }
-}

package/tests/stress/StressTestReporter.ts

@@ -1,229 +0,0 @@
-/**
- * Report generator for stress test results
- */
-import type { BenchmarkResult, ConcurrentResult } from './BenchmarkRunner';
-
-export interface ReportMetadata {
-    recordCount: number;
-    environment: string;
-    duration?: number;
-}
-
-export class StressTestReporter {
-    generateReport(
-        results: BenchmarkResult[],
-        metadata: ReportMetadata
-    ): string {
-        const lines: string[] = [];
-
-        lines.push('='.repeat(70));
-        lines.push('              BunSane Stress Test Report');
-        lines.push('='.repeat(70));
-        lines.push(`Date: ${new Date().toISOString()}`);
-        lines.push(`Records: ${metadata.recordCount.toLocaleString()}`);
-        lines.push(`Environment: ${metadata.environment}`);
-        if (metadata.duration) {
-            lines.push(`Duration: ${(metadata.duration / 1000).toFixed(1)}s`);
-        }
-        lines.push('');
-        lines.push('Query Performance:');
-        lines.push('-'.repeat(70));
-        lines.push(
-            this.padRight('Query', 35) +
-            this.padLeft('p50', 10) +
-            this.padLeft('p95', 10) +
-            this.padLeft('QPS', 8) +
-            this.padLeft('Status', 7)
-        );
-        lines.push('-'.repeat(70));
-
-        for (const result of results) {
-            const status = result.passed ? '\x1b[32mPASS\x1b[0m' : '\x1b[31mFAIL\x1b[0m';
-            lines.push(
-                this.padRight(this.truncate(result.name, 34), 35) +
-                this.padLeft(`${result.timings.median.toFixed(1)}ms`, 10) +
-                this.padLeft(`${result.timings.p95.toFixed(1)}ms`, 10) +
-                this.padLeft(`${result.queriesPerSecond.toFixed(0)}`, 8) +
-                this.padLeft(status, 7)
-            );
-        }
-
-        lines.push('-'.repeat(70));
-        lines.push('');
-
-        // Summary
-        const passed = results.filter(r => r.passed).length;
-        const failed = results.filter(r => !r.passed).length;
-
-        lines.push(`Summary: ${passed} passed, ${failed} failed`);
-
-        if (failed > 0) {
-            lines.push('');
-            lines.push('Failed benchmarks:');
-            for (const result of results.filter(r => !r.passed)) {
-                lines.push(
-                    `  - ${result.name}: p95=${result.timings.p95.toFixed(1)}ms ` +
-                    `(target: ${result.target}ms)`
-                );
-            }
-        }
-
-        // Recommendations based on results
-        const recommendations = this.generateRecommendations(results);
-        if (recommendations.length > 0) {
-            lines.push('');
-            lines.push('Recommendations:');
-            for (const rec of recommendations) {
-                lines.push(`  - ${rec}`);
-            }
-        }
-
-        return lines.join('\n');
-    }
-
-    generateConcurrentReport(
-        results: ConcurrentResult[],
-        metadata: ReportMetadata
-    ): string {
-        const lines: string[] = [];
-
-        lines.push('='.repeat(70));
-        lines.push('          BunSane Concurrent Load Test Report');
-        lines.push('='.repeat(70));
-        lines.push(`Date: ${new Date().toISOString()}`);
-        lines.push(`Records: ${metadata.recordCount.toLocaleString()}`);
-        lines.push(`Environment: ${metadata.environment}`);
-        lines.push('');
-        lines.push('Concurrent Performance:');
-        lines.push('-'.repeat(70));
-        lines.push(
-            this.padRight('Query', 25) +
-            this.padLeft('Concurrency', 12) +
-            this.padLeft('QPS', 10) +
-            this.padLeft('Avg Latency', 12) +
-            this.padLeft('Errors', 8)
-        );
-        lines.push('-'.repeat(70));
-
-        for (const result of results) {
-            lines.push(
-                this.padRight(this.truncate(result.name, 24), 25) +
-                this.padLeft(`${result.concurrency}`, 12) +
-                this.padLeft(`${result.queriesPerSecond.toFixed(0)}`, 10) +
-                this.padLeft(`${result.avgLatency.toFixed(1)}ms`, 12) +
-                this.padLeft(`${(result.errorRate * 100).toFixed(1)}%`, 8)
-            );
-        }
-
-        lines.push('-'.repeat(70));
-
-        return lines.join('\n');
-    }
-
-    generateMarkdownReport(
-        results: BenchmarkResult[],
-        metadata: ReportMetadata
-    ): string {
-        const lines: string[] = [];
-
-        lines.push('# BunSane Stress Test Report');
-        lines.push('');
-        lines.push(`**Date:** ${new Date().toISOString()}`);
-        lines.push(`**Records:** ${metadata.recordCount.toLocaleString()}`);
-        lines.push(`**Environment:** ${metadata.environment}`);
-        lines.push('');
-        lines.push('## Query Performance');
-        lines.push('');
-        lines.push('| Query | p50 | p95 | p99 | QPS | Status |');
-        lines.push('|-------|-----|-----|-----|-----|--------|');
-
-        for (const result of results) {
-            const status = result.passed ? 'PASS' : 'FAIL';
-            lines.push(
-                `| ${result.name} | ` +
-                `${result.timings.median.toFixed(1)}ms | ` +
-                `${result.timings.p95.toFixed(1)}ms | ` +
-                `${result.timings.p99.toFixed(1)}ms | ` +
-                `${result.queriesPerSecond.toFixed(0)} | ` +
-                `${status} |`
-            );
-        }
-
-        lines.push('');
-
-        // Summary
-        const passed = results.filter(r => r.passed).length;
-        const failed = results.filter(r => !r.passed).length;
-
-        lines.push('## Summary');
-        lines.push('');
-        lines.push(`- **Passed:** ${passed}`);
-        lines.push(`- **Failed:** ${failed}`);
-        lines.push(`- **Total:** ${results.length}`);
-
-        if (failed > 0) {
-            lines.push('');
-            lines.push('### Failed Benchmarks');
-            lines.push('');
-            for (const result of results.filter(r => !r.passed)) {
-                lines.push(
-                    `- **${result.name}**: p95=${result.timings.p95.toFixed(1)}ms ` +
-                    `(target: ${result.target}ms)`
-                );
-            }
-        }
-
-        return lines.join('\n');
-    }
-
-    private generateRecommendations(results: BenchmarkResult[]): string[] {
-        const recommendations: string[] = [];
-
-        // Check for slow non-indexed queries
-        const slowQueries = results.filter(r => r.timings.p95 > 500);
-        if (slowQueries.length > 0) {
-            recommendations.push(
-                `${slowQueries.length} queries have p95 > 500ms - consider adding indexes`
-            );
-        }
-
-        // Check for high memory usage
-        const highMemory = results.filter(r => r.memoryUsedMB > 100);
-        if (highMemory.length > 0) {
-            recommendations.push(
-                `${highMemory.length} queries use >100MB memory - consider pagination or streaming`
-            );
-        }
-
-        // Check for low QPS
-        const lowQps = results.filter(r => r.queriesPerSecond < 10);
-        if (lowQps.length > 0) {
-            recommendations.push(
-                `${lowQps.length} queries have QPS < 10 - investigate query plans with EXPLAIN ANALYZE`
-            );
-        }
-
-        // Check for high variance
-        const highVariance = results.filter(r => r.timings.stdDev > r.timings.mean * 0.5);
-        if (highVariance.length > 0) {
-            recommendations.push(
-                `${highVariance.length} queries show high variance - may indicate cache miss issues`
-            );
-        }
-
-        return recommendations;
-    }
-
-    private padRight(str: string, len: number): string {
-        return str.padEnd(len);
-    }
-
-    private padLeft(str: string, len: number): string {
-        return str.padStart(len);
-    }
-
-    private truncate(str: string, maxLen: number): string {
-        if (str.length <= maxLen) return str;
-        return str.slice(0, maxLen - 3) + '...';
-    }
-}