bunsane 0.1.4 → 0.2.0

package/tests/stress/StressTestReporter.ts

@@ -0,0 +1,229 @@
+/**
+ * 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) + '...';
+    }
+}

package/tests/stress/cursor-perf-test.ts

@@ -0,0 +1,171 @@
+/**
+ * Quick cursor pagination performance test
+ * Run with: bun tests/stress/cursor-perf-test.ts
+ */
+
+// Load env first
+import { file } from 'bun';
+const envTestPath = new URL('../../.env.test', import.meta.url).pathname.replace(/^\/([A-Z]:)/, '$1');
+const envFile = file(envTestPath);
+if (await envFile.exists()) {
+    const envContent = await envFile.text();
+    for (const line of envContent.split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed && !trimmed.startsWith('#')) {
+            const [key, ...valueParts] = trimmed.split('=');
+            if (key) {
+                const value = valueParts.join('=');
+                process.env[key.trim()] = value.trim();
+            }
+        }
+    }
+}
+process.env.LOG_LEVEL = 'warn';
+
+import { Query } from '../../query/Query';
+import db from '../../database';
+import { PrepareDatabase, HasValidBaseTable } from '../../database/DatabaseHelper';
+import ApplicationLifecycle, { ApplicationPhase } from '../../core/ApplicationLifecycle';
+import EntityManager from '../../core/EntityManager';
+import { CacheManager } from '../../core/cache';
+import { StressUser } from './fixtures/StressTestComponents';
+import { ensureComponentsRegistered } from '../utils';
+
+async function init() {
+    // Verify database
+    await db`SELECT 1`;
+
+    // Ensure tables
+    if (!(await HasValidBaseTable())) {
+        await PrepareDatabase();
+    }
+
+    // Set app ready
+    ApplicationLifecycle.setPhase(ApplicationPhase.DATABASE_READY);
+    (EntityManager as any).dbReady = true;
+
+    // Init cache
+    await CacheManager.getInstance().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 }
+    });
+
+    // Ensure StressUser component is registered
+    await ensureComponentsRegistered(StressUser);
+}
+
+async function main() {
+    console.log('Initializing...');
+    await init();
+
+    // Get total count
+    const count = await new Query().with(StressUser).count();
+    console.log(`Total StressUser records: ${count}`);
+
+    if (count < 100) {
+        console.log('\nNot enough records for test.');
+        console.log('Run: STRESS_RECORD_COUNT=100000 bun test tests/stress --test-name-pattern "indexed"');
+        console.log('Then run this script again.');
+        process.exit(0);
+    }
+
+    const iterations = 10;
+
+    // Test 1: First page with offset 0
+    console.log('\n=== Offset-based pagination ===');
+    let times: number[] = [];
+    for (let i = 0; i < iterations; i++) {
+        const start = performance.now();
+        await new Query().with(StressUser).take(100).offset(0).exec();
+        times.push(performance.now() - start);
+    }
+    console.log(`Offset 0:       p50=${percentile(times, 50).toFixed(2)}ms, p95=${percentile(times, 95).toFixed(2)}ms`);
+
+    // Test 2: Offset at 50%
+    const midOffset = Math.floor(count / 2);
+    times = [];
+    for (let i = 0; i < iterations; i++) {
+        const start = performance.now();
+        await new Query().with(StressUser).take(100).offset(midOffset).exec();
+        times.push(performance.now() - start);
+    }
+    console.log(`Offset ${midOffset.toLocaleString().padStart(7)}:  p50=${percentile(times, 50).toFixed(2)}ms, p95=${percentile(times, 95).toFixed(2)}ms`);
+
+    // Test 3: Offset at 90%
+    const deepOffset = Math.floor(count * 0.9);
+    times = [];
+    for (let i = 0; i < iterations; i++) {
+        const start = performance.now();
+        await new Query().with(StressUser).take(100).offset(deepOffset).exec();
+        times.push(performance.now() - start);
+    }
+    console.log(`Offset ${deepOffset.toLocaleString().padStart(7)}:  p50=${percentile(times, 50).toFixed(2)}ms, p95=${percentile(times, 95).toFixed(2)}ms`);
+
+    // Get cursor IDs
+    const midResults = await new Query().with(StressUser).take(1).offset(midOffset).exec();
+    const midId = midResults[0]?.id;
+    const deepResults = await new Query().with(StressUser).take(1).offset(deepOffset).exec();
+    const deepId = deepResults[0]?.id;
+
+    if (!midId || !deepId) {
+        console.log('Could not get cursor IDs');
+        process.exit(1);
+    }
+
+    // Cursor tests
+    console.log('\n=== Cursor-based pagination ===');
+
+    // First page cursor (page 2)
+    const firstPage = await new Query().with(StressUser).take(100).exec();
+    const page1LastId = firstPage[firstPage.length - 1]?.id;
+
+    if (page1LastId) {
+        times = [];
+        for (let i = 0; i < iterations; i++) {
+            const start = performance.now();
+            await new Query().with(StressUser).cursor(page1LastId).take(100).exec();
+            times.push(performance.now() - start);
+        }
+        console.log(`Cursor page 2:  p50=${percentile(times, 50).toFixed(2)}ms, p95=${percentile(times, 95).toFixed(2)}ms`);
+    }
+
+    // Cursor from middle
+    times = [];
+    for (let i = 0; i < iterations; i++) {
+        const start = performance.now();
+        await new Query().with(StressUser).cursor(midId).take(100).exec();
+        times.push(performance.now() - start);
+    }
+    console.log(`Cursor @ 50%:   p50=${percentile(times, 50).toFixed(2)}ms, p95=${percentile(times, 95).toFixed(2)}ms`);
+
+    // Cursor from 90%
+    times = [];
+    for (let i = 0; i < iterations; i++) {
+        const start = performance.now();
+        await new Query().with(StressUser).cursor(deepId).take(100).exec();
+        times.push(performance.now() - start);
+    }
+    console.log(`Cursor @ 90%:   p50=${percentile(times, 50).toFixed(2)}ms, p95=${percentile(times, 95).toFixed(2)}ms`);
+
+    console.log('\n=== Summary ===');
+    console.log('Offset: O(offset) - gets slower as position increases');
+    console.log('Cursor: O(1) - consistent speed at any position');
+
+    process.exit(0);
+}
+
+function percentile(arr: number[], p: number): number {
+    const sorted = [...arr].sort((a, b) => a - b);
+    const idx = Math.ceil((p / 100) * sorted.length) - 1;
+    return sorted[Math.max(0, idx)] ?? 0;
+}
+
+main().catch(e => {
+    console.error(e);
+    process.exit(1);
+});

package/tests/stress/fixtures/StressTestComponents.ts

@@ -0,0 +1,58 @@
+/**
+ * Stress test components with indexed fields for benchmarking
+ */
+import { BaseComponent } from '../../../core/components/BaseComponent';
+import { Component, CompData } from '../../../core/components/Decorators';
+import { IndexedField } from '../../../core/decorators/IndexedField';
+
+@Component
+export class StressUser extends BaseComponent {
+    @CompData({ indexed: true })
+    @IndexedField('btree')
+    name!: string;
+
+    @CompData({ indexed: true })
+    @IndexedField('btree')
+    email!: string;
+
+    @CompData()
+    @IndexedField('numeric')
+    age!: number;
+
+    @CompData()
+    @IndexedField('btree')
+    status!: string;
+
+    @CompData()
+    @IndexedField('numeric')
+    score!: number;
+
+    @CompData()
+    @IndexedField('btree', true)
+    createdAt!: Date;
+}
+
+@Component
+export class StressProfile extends BaseComponent {
+    @CompData()
+    bio!: string;
+
+    @CompData()
+    avatarUrl!: string;
+
+    @CompData()
+    @IndexedField('gin')
+    verified!: boolean;
+}
+
+@Component
+export class StressSettings extends BaseComponent {
+    @CompData()
+    theme!: string;
+
+    @CompData()
+    notifications!: boolean;
+
+    @CompData()
+    language!: string;
+}

package/tests/stress/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Stress testing module exports
+ */
+export { DataSeeder, type SeederOptions, type SeederResult } from './DataSeeder';
+export { BenchmarkRunner, type BenchmarkResult, type BenchmarkOptions, type ConcurrentResult } from './BenchmarkRunner';
+export { StressTestReporter, type ReportMetadata } from './StressTestReporter';
+export { StressUser, StressProfile, StressSettings } from './fixtures/StressTestComponents';