bunsane 0.1.4 → 0.2.0

package/tests/bench/relations.bench.ts

@@ -1,270 +0,0 @@
-import { describe, test, beforeAll, beforeEach, expect } from "bun:test";
-import App from "core/App";
-import { BaseComponent, CompData, Component } from "core/Components";
-import { Entity } from "core/Entity";
-import { BatchLoader } from "core/BatchLoader";
-import db from "database";
-
-let app: App;
-
-beforeAll(async () => {
-    app = new App();
-    app.init();
-    await app.waitForAppReady();
-});
-
-beforeEach(async () => {
-    await db`TRUNCATE TABLE entities CASCADE;`;
-    Bun.sleep(1000);
-});
-
-@Component
-class AuthorComponent extends BaseComponent {
-    @CompData()
-    value: string = "";
-}
-
-@Component
-class TitleComponent extends BaseComponent {
-    @CompData()
-    value: string = "";
-}
-
-@Component
-class UserComponent extends BaseComponent {
-    @CompData()
-    name: string = "";
-}
-
-describe('Relations Benchmark - Performance Guarantees', () => {
-    /**
-     * PERFORMANCE GUARANTEE MATRIX
-     * ============================
-     * 
-     * Based on comprehensive benchmarking, BunSane provides the following
-     * measurable performance guarantees for relation loading:
-     * 
-     * SCALE GUARANTEES:
-     * - 1,000 posts + 100 users:  < 100ms (typical: ~50ms)
-     * - 5,000 posts + 500 users:  < 300ms (typical: ~100ms) 
-     * - 10,000 posts + 1,000 users: < 500ms (typical: ~120ms)
-     * 
-     * SCALABILITY GUARANTEES:
-     * - Linear scaling: Performance grows sub-linearly with dataset size
-     * - Batch efficiency: 10x data increase results in <3x time increase
-     * - Consistency: Standard deviation < 20% of average time
-     * 
-     * MEMORY GUARANTEES:
-     * - Memory overhead: < 50MB for loading 1,000 unique entities
-     * - No memory leaks: Efficient garbage collection
-     * - Batched loading: No memory proportional to total relations
-     * 
-     * QUERY EFFICIENCY GUARANTEES:
-     * - N+1 prevention: Constant query count regardless of relation count
-     * - Batch optimization: Single query for relation data + entity loading
-     * - Index utilization: Leverages PostgreSQL GIN indexes for JSON data
-     */
-    test('Guaranteed linear scalability for batched relations', async () => {
-        const scales = [
-            { users: 100, posts: 1000, maxTime: 100 },
-            { users: 500, posts: 5000, maxTime: 300 },
-            { users: 1000, posts: 10000, maxTime: 500 }
-        ];
-
-        const results = [];
-
-        for (const scale of scales) {
-            // Create users
-            const users: Entity[] = [];
-            for (let i = 0; i < scale.users; i++) {
-                const user = Entity.Create().add(UserComponent, { name: `User${i}` });
-                users.push(user);
-            }
-            await Promise.all(users.map(u => u.save()));
-
-            // Create posts with random authors
-            const batchSize = 1000;
-            const posts: Entity[] = [];
-            const batches = Math.ceil(scale.posts / batchSize);
-            
-            for (let batch = 0; batch < batches; batch++) {
-                const batchPosts: Entity[] = [];
-                const start = batch * batchSize;
-                const end = Math.min(start + batchSize, scale.posts);
-                
-                for (let i = start; i < end; i++) {
-                    const randomUser = users[Math.floor(Math.random() * users.length)]!;
-                    const post = Entity.Create()
-                        .add(TitleComponent, { value: `Post${i}` })
-                        .add(AuthorComponent, { value: randomUser.id });
-                    batchPosts.push(post);
-                }
-                await Promise.all(batchPosts.map(p => p.save()));
-                posts.push(...batchPosts);
-            }
-
-            // Benchmark batched loading with multiple runs for consistency
-            const runs = 3;
-            const times = [];
-            
-            for (let run = 0; run < runs; run++) {
-                const startTime = performance.now();
-                const loader = async (ids: string[]) => {
-                    return await Entity.LoadMultiple(ids);
-                };
-                
-                const result = await BatchLoader.loadRelatedEntitiesBatched(posts, AuthorComponent, loader);
-                const endTime = performance.now();
-                
-                const time = endTime - startTime;
-                times.push(time);
-                
-                // Validate result correctness
-                expect(result.size).toBe(scale.users);
-            }
-            
-            const avgTime = times.reduce((a, b) => a + b, 0) / times.length;
-            const maxTime = Math.max(...times);
-            const stdDev = Math.sqrt(times.reduce((sum, time) => sum + Math.pow(time - avgTime, 2), 0) / times.length);
-            
-            results.push({
-                scale,
-                avgTime,
-                maxTime,
-                stdDev,
-                times
-            });
-
-            console.log(`Scale ${scale.posts} posts, ${scale.users} users:`);
-            console.log(`  Average: ${avgTime.toFixed(2)}ms`);
-            console.log(`  Maximum: ${maxTime.toFixed(2)}ms`);
-            console.log(`  Std Dev: ${stdDev.toFixed(2)}ms`);
-            console.log(`  All runs: [${times.map(t => t.toFixed(2)).join(', ')}]ms`);
-
-            // PERFORMANCE GUARANTEE: Must complete within expected time
-            expect(maxTime).toBeLessThan(scale.maxTime);
-            
-            // CONSISTENCY GUARANTEE: Standard deviation should be low (< 20% of average)
-            expect(stdDev).toBeLessThan(avgTime * 0.2);
-            
-            await db`TRUNCATE TABLE entities CASCADE;`;
-        }
-
-        // SCALABILITY GUARANTEE: Performance should scale roughly linearly
-        for (let i = 1; i < results.length; i++) {
-            const prev = results[i - 1]!;
-            const curr = results[i]!;
-            const scaleRatio = curr.scale.posts / prev.scale.posts;
-            const timeRatio = curr.avgTime / prev.avgTime;
-            
-            console.log(`Scale ratio: ${scaleRatio.toFixed(2)}x, Time ratio: ${timeRatio.toFixed(2)}x`);
-            
-            // Time should not grow faster than 1.5x the scale ratio
-            expect(timeRatio).toBeLessThan(scaleRatio * 1.5);
-        }
-    });
-
-    test('N+1 prevention guarantee', async () => {
-        // Create test data
-        const users: Entity[] = [];
-        for (let i = 0; i < 50; i++) {
-            const user = Entity.Create().add(UserComponent, { name: `User${i}` });
-            users.push(user);
-        }
-        await Promise.all(users.map(u => u.save()));
-
-        const posts: Entity[] = [];
-        for (let i = 0; i < 500; i++) {
-            const randomUser = users[Math.floor(Math.random() * users.length)]!;
-            const post = Entity.Create()
-                .add(TitleComponent, { value: `Post${i}` })
-                .add(AuthorComponent, { value: randomUser.id });
-            posts.push(post);
-        }
-        await Promise.all(posts.map(p => p.save()));
-
-        // Count database queries during batched loading by monitoring logs
-        const loader = async (ids: string[]) => {
-            return await Entity.LoadMultiple(ids);
-        };
-
-        const startTime = performance.now();
-        const result = await BatchLoader.loadRelatedEntitiesBatched(posts, AuthorComponent, loader);
-        const endTime = performance.now();
-
-        const batchedTime = endTime - startTime;
-
-        console.log(`Batched loading: ${batchedTime.toFixed(2)}ms`);
-        console.log(`Loaded ${result.size} unique authors for ${posts.length} posts`);
-
-        // BATCHING EFFICIENCY GUARANTEE: Should efficiently batch queries
-        // The batched approach should complete quickly due to reduced query overhead
-        
-        // PERFORMANCE GUARANTEE: Should complete within reasonable time
-        expect(batchedTime).toBeLessThan(200);
-        
-        // PERFORMANCE GUARANTEE: Should complete within reasonable time
-        expect(batchedTime).toBeLessThan(200);
-        
-        // CORRECTNESS GUARANTEE: Should load all unique authors
-        expect(result.size).toBeGreaterThan(0);
-        expect(result.size).toBeLessThanOrEqual(users.length);
-    });
-
-    test('Memory efficiency guarantee', async () => {
-        const initialMemory = process.memoryUsage();
-        
-        // Create large dataset
-        const users: Entity[] = [];
-        for (let i = 0; i < 1000; i++) {
-            const user = Entity.Create().add(UserComponent, { name: `User${i}` });
-            users.push(user);
-        }
-        await Promise.all(users.map(u => u.save()));
-
-        const posts: Entity[] = [];
-        for (let i = 0; i < 10000; i++) {
-            const randomUser = users[Math.floor(Math.random() * users.length)]!;
-            const post = Entity.Create()
-                .add(TitleComponent, { value: `Post${i}` })
-                .add(AuthorComponent, { value: randomUser.id });
-            posts.push(post);
-        }
-        await Promise.all(posts.map(p => p.save()));
-
-        const beforeLoadMemory = process.memoryUsage();
-
-        // Perform batched loading
-        const loader = async (ids: string[]) => {
-            return await Entity.LoadMultiple(ids);
-        };
-
-        const result = await BatchLoader.loadRelatedEntitiesBatched(posts, AuthorComponent, loader);
-        
-        const afterLoadMemory = process.memoryUsage();
-
-        // Force garbage collection if available
-        if (global.gc) {
-            global.gc();
-        }
-        
-        const afterGCMemory = process.memoryUsage();
-
-        const loadMemoryIncrease = afterLoadMemory.heapUsed - beforeLoadMemory.heapUsed;
-        const finalMemoryIncrease = afterGCMemory.heapUsed - initialMemory.heapUsed;
-
-        console.log(`Initial memory: ${(initialMemory.heapUsed / 1024 / 1024).toFixed(2)} MB`);
-        console.log(`Before load: ${(beforeLoadMemory.heapUsed / 1024 / 1024).toFixed(2)} MB`);
-        console.log(`After load: ${(afterLoadMemory.heapUsed / 1024 / 1024).toFixed(2)} MB`);
-        console.log(`After GC: ${(afterGCMemory.heapUsed / 1024 / 1024).toFixed(2)} MB`);
-        console.log(`Load memory increase: ${(loadMemoryIncrease / 1024 / 1024).toFixed(2)} MB`);
-        console.log(`Final memory increase: ${(finalMemoryIncrease / 1024 / 1024).toFixed(2)} MB`);
-
-        // MEMORY EFFICIENCY GUARANTEE: Should not use excessive memory
-        // Loading 1000 unique entities should use less than 50MB additional memory
-        expect(loadMemoryIncrease).toBeLessThan(50 * 1024 * 1024); // 50MB
-
-        // CORRECTNESS GUARANTEE
-        expect(result.size).toBe(users.length);
-    });
-});

package/tests/bench/sorting.bench.ts

@@ -1,416 +0,0 @@
-import { describe, test, beforeAll, beforeEach, expect } from "bun:test";
-import App from "core/App";
-import { BaseComponent, CompData, Component } from "core/Components";
-import { Entity } from "core/Entity";
-import Query from "core/Query";
-import db from "database";
-import ComponentRegistry from "core/ComponentRegistry";
-
-let app: App;
-
-beforeAll(async () => {
-    app = new App();
-    app.init();
-    await app.waitForAppReady();
-});
-
-beforeEach(async () => {
-    await db`TRUNCATE TABLE entities CASCADE;`;
-    await Bun.sleep(1000);
-});
-
-@Component
-class UserComponent extends BaseComponent {
-    @CompData()
-    name: string = "";
-
-    @CompData()
-    age: number = 0;
-
-    @CompData()
-    score: number = 0;
-
-    @CompData()
-    createdAt: string = "";
-}
-
-@Component
-class PostComponent extends BaseComponent {
-    @CompData()
-    title: string = "";
-
-    @CompData()
-    content: string = "";
-
-    @CompData()
-    likes: number = 0;
-
-    @CompData()
-    publishedAt: string = "";
-}
-
-describe('Sorting Benchmark - Performance Guarantees', () => {
-    /**
-     * SORTING PERFORMANCE GUARANTEE MATRIX
-     * ====================================
-     *
-     * Based on comprehensive benchmarking, BunSane provides the following
-     * measurable performance guarantees for sorting operations:
-     *
-     * SCALE GUARANTEES:
-     * - 1,000 entities:  < 50ms (typical: ~20ms)
-     * - 5,000 entities:  < 150ms (typical: ~60ms)
-     * - 10,000 entities: < 300ms (typical: ~100ms)
-     * - 50,000 entities: < 800ms (typical: ~300ms)
-     *
-     * SCALABILITY GUARANTEES:
-     * - Linear scaling: Performance grows sub-linearly with dataset size
-     * - Sort efficiency: 10x data increase results in <4x time increase
-     * - Consistency: Standard deviation < 15% of average time
-     *
-     * MEMORY GUARANTEES:
-     * - Memory overhead: < 30MB for sorting 10,000 entities
-     * - No memory leaks: Efficient garbage collection
-     * - Streaming processing: Memory usage doesn't scale linearly with data size
-     *
-     * QUERY EFFICIENCY GUARANTEES:
-     * - Single query: Sorting operations use single optimized SQL query
-     * - Index utilization: Leverages PostgreSQL JSONB GIN indexes
-     * - No N+1: Sorting doesn't trigger additional queries
-     */
-    test('Guaranteed linear scalability for sorting operations', async () => {
-        await db`TRUNCATE TABLE entities CASCADE;`;
-        const scales = [
-            { entities: 1000, maxTime: 50 },
-            { entities: 5000, maxTime: 150 },
-            { entities: 10000, maxTime: 300 },
-            { entities: 50000, maxTime: 800 }
-        ];
-
-        const results = [];
-
-        for (const scale of scales) {
-            // Create test entities with varied data for realistic sorting
-            const entities: Entity[] = [];
-            const batchSize = 1000;
-            const batches = Math.ceil(scale.entities / batchSize);
-
-            for (let batch = 0; batch < batches; batch++) {
-                const batchEntities: Entity[] = [];
-                const start = batch * batchSize;
-                const end = Math.min(start + batchSize, scale.entities);
-
-                for (let i = start; i < end; i++) {
-                    const user = Entity.Create().add(UserComponent, {
-                        name: `User${i}`,
-                        age: Math.floor(Math.random() * 80) + 18, // 18-98 years old
-                        score: Math.floor(Math.random() * 1000), // 0-999 score
-                        createdAt: new Date(Date.now() - Math.random() * 365 * 24 * 60 * 60 * 1000).toISOString()
-                    });
-                    batchEntities.push(user);
-                }
-                await Promise.all(batchEntities.map(e => e.save()));
-                entities.push(...batchEntities);
-            }
-
-            // Benchmark different sorting scenarios
-            const sortScenarios = [
-                { name: 'Single property ASC', query: () => new Query().with(UserComponent).sortBy(UserComponent, "age", "ASC") },
-                { name: 'Single property DESC', query: () => new Query().with(UserComponent).sortBy(UserComponent, "score", "DESC") },
-                { name: 'Multiple properties', query: () => new Query().with(UserComponent).orderBy([
-                    { component: "UserComponent", property: "age", direction: "DESC" },
-                    { component: "UserComponent", property: "name", direction: "ASC" }
-                ])},
-                { name: 'With nulls first', query: () => new Query().with(UserComponent).sortBy(UserComponent, "score", "ASC", true) }
-            ];
-
-            const scenarioResults = [];
-
-            for (const scenario of sortScenarios) {
-                // Multiple runs for better consistency statistics
-                const runs = 5;
-                const times = [];
-
-                for (let run = 0; run < runs; run++) {
-                    // Add small delay between runs to reduce caching effects
-                    if (run > 0) {
-                        await new Promise(resolve => setTimeout(resolve, 10));
-                    }
-
-                    const startTime = performance.now();
-
-                    const result = await scenario.query().exec();
-
-                    const endTime = performance.now();
-                    const time = endTime - startTime;
-                    times.push(time);
-
-                    // Validate result correctness (only for first run to save time)
-                    if (run === 0) {
-                        expect(result.length).toBe(scale.entities);
-                        if (scenario.name === 'Single property ASC') {
-                            // Verify sorting order for first scenario
-                            const ages = await Promise.all(result.map(async (e) => {
-                                const comp = await e.get(UserComponent);
-                                return comp?.age || 0;
-                            }));
-                            for (let i = 1; i < ages.length; i++) {
-                                expect(ages[i]).toBeGreaterThanOrEqual(ages[i - 1]!);
-                            }
-                        }
-                    }
-                }
-
-                const avgTime = times.reduce((a, b) => a + b, 0) / times.length;
-                const maxTime = Math.max(...times);
-                const stdDev = Math.sqrt(times.reduce((sum, time) => sum + Math.pow(time - avgTime, 2), 0) / times.length);
-
-                // Use median for more robust consistency check
-                const sortedTimes = [...times].sort((a, b) => a - b);
-                const medianTime = sortedTimes[Math.floor(sortedTimes.length / 2)]!;
-
-                scenarioResults.push({
-                    scenario: scenario.name,
-                    avgTime,
-                    maxTime,
-                    stdDev,
-                    medianTime,
-                    times
-                });
-
-                console.log(`${scenario.name} - Scale ${scale.entities} entities:`);
-                console.log(`  Average: ${avgTime.toFixed(2)}ms`);
-                console.log(`  Median: ${medianTime.toFixed(2)}ms`);
-                console.log(`  Maximum: ${maxTime.toFixed(2)}ms`);
-                console.log(`  Std Dev: ${stdDev.toFixed(2)}ms`);
-                console.log(`  All runs: [${times.map(t => t.toFixed(2)).join(', ')}]ms`);
-
-                // PERFORMANCE GUARANTEE: Must complete within expected time
-                expect(maxTime).toBeLessThan(scale.maxTime);
-
-                // CONSISTENCY GUARANTEE: Use median-based check for robustness
-                // Allow up to 50% variance from median for database operations
-                const maxVariance = medianTime * 0.50;
-                expect(stdDev).toBeLessThan(maxVariance);
-            }
-
-            results.push({
-                scale,
-                scenarios: scenarioResults
-            });
-
-            await db`TRUNCATE TABLE entities CASCADE;`;
-        }
-
-        // SCALABILITY GUARANTEE: Performance should scale roughly linearly
-        for (let i = 1; i < results.length; i++) {
-            const prev = results[i - 1]!;
-            const curr = results[i]!;
-
-            for (const scenario of curr.scenarios) {
-                const prevScenario = prev.scenarios.find(s => s.scenario === scenario.scenario);
-                if (prevScenario) {
-                    const scaleRatio = curr.scale.entities / prev.scale.entities;
-                    const timeRatio = scenario.avgTime / prevScenario.avgTime;
-
-                    console.log(`${scenario.scenario} - Scale ratio: ${scaleRatio.toFixed(2)}x, Time ratio: ${timeRatio.toFixed(2)}x`);
-
-                    // Time should not grow faster than 4x the scale ratio for sorting operations
-                    expect(timeRatio).toBeLessThan(scaleRatio * 4);
-                }
-            }
-        }
-    }, 60000);
-
-    test('Memory efficiency guarantee for sorting', async () => {
-        await db`TRUNCATE TABLE entities CASCADE;`;
-        const initialMemory = process.memoryUsage();
-
-        // Create large dataset
-        const entities: Entity[] = [];
-        for (let i = 0; i < 10000; i++) {
-            const user = Entity.Create().add(UserComponent, {
-                name: `User${i}`,
-                age: Math.floor(Math.random() * 80) + 18,
-                score: Math.floor(Math.random() * 1000),
-                createdAt: new Date(Date.now() - Math.random() * 365 * 24 * 60 * 60 * 1000).toISOString()
-            });
-            entities.push(user);
-        }
-        await Promise.all(entities.map(e => e.save()));
-
-        const beforeSortMemory = process.memoryUsage();
-
-        // Perform sorting operation
-        const startTime = performance.now();
-        const sortedEntities = await new Query()
-            .with(UserComponent)
-            .sortBy(UserComponent, "score", "DESC")
-            .exec();
-        const endTime = performance.now();
-
-        const afterSortMemory = process.memoryUsage();
-
-        // Force garbage collection if available
-        if (global.gc) {
-            global.gc();
-        }
-
-        const afterGCMemory = process.memoryUsage();
-
-        const sortMemoryIncrease = afterSortMemory.heapUsed - beforeSortMemory.heapUsed;
-        const finalMemoryIncrease = afterGCMemory.heapUsed - initialMemory.heapUsed;
-        const sortTime = endTime - startTime;
-
-        console.log(`Initial memory: ${(initialMemory.heapUsed / 1024 / 1024).toFixed(2)} MB`);
-        console.log(`Before sort: ${(beforeSortMemory.heapUsed / 1024 / 1024).toFixed(2)} MB`);
-        console.log(`After sort: ${(afterSortMemory.heapUsed / 1024 / 1024).toFixed(2)} MB`);
-        console.log(`After GC: ${(afterGCMemory.heapUsed / 1024 / 1024).toFixed(2)} MB`);
-        console.log(`Sort memory increase: ${(sortMemoryIncrease / 1024 / 1024).toFixed(2)} MB`);
-        console.log(`Final memory increase: ${(finalMemoryIncrease / 1024 / 1024).toFixed(2)} MB`);
-        console.log(`Sort time: ${sortTime.toFixed(2)}ms`);
-
-        // MEMORY EFFICIENCY GUARANTEE: Sorting should not use excessive memory
-        // Sorting 10,000 entities should use less than 30MB additional memory
-        expect(sortMemoryIncrease).toBeLessThan(30 * 1024 * 1024); // 30MB
-
-        // PERFORMANCE GUARANTEE: Should complete within reasonable time
-        expect(sortTime).toBeLessThan(300); // 300ms
-
-        // CORRECTNESS GUARANTEE: Should return all entities
-        expect(sortedEntities.length).toBe(10000);
-
-        // Verify sorting order
-        const scores = await Promise.all(sortedEntities.map(async (e) => {
-            const comp = await e.get(UserComponent);
-            return comp?.score || 0;
-        }));
-        for (let i = 1; i < scores.length; i++) {
-            expect(scores[i]).toBeLessThanOrEqual(scores[i - 1]!);
-        }
-    });
-
-    test('Query efficiency guarantee for sorting', async () => {
-        await db`TRUNCATE TABLE entities CASCADE;`;
-        // Create test data
-        const entities: Entity[] = [];
-        for (let i = 0; i < 5000; i++) {
-            const user = Entity.Create().add(UserComponent, {
-                name: `User${i}`,
-                age: Math.floor(Math.random() * 80) + 18,
-                score: Math.floor(Math.random() * 1000),
-                createdAt: new Date(Date.now() - Math.random() * 365 * 24 * 60 * 60 * 1000).toISOString()
-            });
-            entities.push(user);
-        }
-        await Promise.all(entities.map(e => e.save()));
-
-        // Test different sorting scenarios
-        const scenarios = [
-            { name: 'Simple sort', query: new Query().with(UserComponent).sortBy(UserComponent, "age", "ASC") },
-            { name: 'Complex sort', query: new Query().with(UserComponent).orderBy([
-                { component: "UserComponent", property: "score", direction: "DESC" },
-                { component: "UserComponent", property: "name", direction: "ASC" }
-            ])},
-            { name: 'Sort with filter', query: new Query()
-                .with(UserComponent, Query.filters(Query.filter("age", ">", 30)))
-                .sortBy(UserComponent, "score", "DESC") },
-            { name: 'Sort with pagination', query: new Query()
-                .with(UserComponent)
-                .sortBy(UserComponent, "age", "DESC")
-                .take(100)
-                .offset(100) }
-        ];
-
-        for (const scenario of scenarios) {
-            const startTime = performance.now();
-            const result = await scenario.query.exec();
-            const endTime = performance.now();
-
-            const queryTime = endTime - startTime;
-
-            console.log(`${scenario.name}:`);
-            console.log(`  Time: ${queryTime.toFixed(2)}ms`);
-            console.log(`  Results: ${result.length}`);
-
-            // PERFORMANCE GUARANTEE: Should complete within reasonable time
-            expect(queryTime).toBeLessThan(200);
-
-            // CORRECTNESS GUARANTEE: Should return expected number of results
-            if (scenario.name === 'Sort with pagination') {
-                expect(result.length).toBeLessThanOrEqual(100);
-            } else if (scenario.name === 'Sort with filter') {
-                expect(result.length).toBeLessThan(5000);
-            } else {
-                expect(result.length).toBe(5000);
-            }
-        }
-    });
-
-    test('Sorting correctness guarantee', async () => {
-        await db`TRUNCATE TABLE entities CASCADE;`;
-        // Create predictable test data
-        const entities: Entity[] = [];
-        const testData = [
-            { name: "Alice", age: 25, score: 100, createdAt: "2023-01-01T00:00:00Z" },
-            { name: "Bob", age: 30, score: 95, createdAt: "2023-01-02T00:00:00Z" },
-            { name: "Charlie", age: 20, score: 110, createdAt: "2023-01-03T00:00:00Z" },
-            { name: "Diana", age: 35, score: 85, createdAt: "2023-01-04T00:00:00Z" },
-            { name: "Eve", age: 28, score: 105, createdAt: "2023-01-05T00:00:00Z" }
-        ];
-
-        for (const data of testData) {
-            const user = Entity.Create().add(UserComponent, data);
-            entities.push(user);
-        }
-        await Promise.all(entities.map(e => e.save()));
-
-        // Test ascending sort by age
-        const ageAscResult = await new Query()
-            .with(UserComponent)
-            .sortBy(UserComponent, "age", "ASC")
-            .exec();
-
-        const ageAscValues = await Promise.all(ageAscResult.map(async (e) => {
-            const comp = await e.get(UserComponent);
-            return comp?.age || 0;
-        }));
-        expect(ageAscValues).toEqual([20, 25, 28, 30, 35]);
-
-        // Test descending sort by score
-        const scoreDescResult = await new Query()
-            .with(UserComponent)
-            .sortBy(UserComponent, "score", "DESC")
-            .exec();
-
-        const scoreDescValues = await Promise.all(scoreDescResult.map(async (e) => {
-            const comp = await e.get(UserComponent);
-            return comp?.score || 0;
-        }));
-        expect(scoreDescValues).toEqual([110, 105, 100, 95, 85]);
-
-        // Test multi-property sort (age DESC, then name ASC)
-        const multiSortResult = await new Query()
-            .with(UserComponent)
-            .orderBy([
-                { component: "UserComponent", property: "age", direction: "DESC" },
-                { component: "UserComponent", property: "name", direction: "ASC" }
-            ])
-            .exec();
-
-        const multiSortValues = await Promise.all(multiSortResult.map(async (e) => {
-            const comp = await e.get(UserComponent);
-            return {
-                age: comp?.age || 0,
-                name: comp?.name || ""
-            };
-        }));
-
-        // Should be sorted by age DESC: 35, 30, 28, 25, 20
-        expect(multiSortValues[0]).toEqual({ age: 35, name: "Diana" });
-        expect(multiSortValues[1]).toEqual({ age: 30, name: "Bob" });
-        expect(multiSortValues[2]).toEqual({ age: 28, name: "Eve" });
-        expect(multiSortValues[3]).toEqual({ age: 25, name: "Alice" });
-        expect(multiSortValues[4]).toEqual({ age: 20, name: "Charlie" });
-    });
-});