@onchaindb/sdk 0.4.5 → 1.0.0

package/src/query-sdk/tests/unit.test.ts

@@ -1,794 +0,0 @@
-// Comprehensive unit tests for TypeScript SDK
-import { 
-    FieldConditionBuilder, 
-    LogicalOperator, 
-    ConditionBuilder,
-    NestedConditionBuilder,
-    NestedFieldConditionBuilder,
-    QueryBuilder,
-    QueryResult,
-    createQueryResult
-} from '../index';
-
-// Test framework helpers
-interface TestCase {
-    name: string;
-    test: () => void;
-}
-
-class TestRunner {
-    private tests: TestCase[] = [];
-    private passed = 0;
-    private failed = 0;
-
-    add(name: string, test: () => void) {
-        this.tests.push({ name, test });
-    }
-
-    run() {
-        console.log(`🧪 Running ${this.tests.length} unit tests...\n`);
-        
-        for (const testCase of this.tests) {
-            try {
-                testCase.test();
-                console.log(`✅ ${testCase.name}`);
-                this.passed++;
-            } catch (error) {
-                console.error(`❌ ${testCase.name}: ${error instanceof Error ? error.message : error}`);
-                this.failed++;
-            }
-        }
-
-        console.log(`\n📊 Test Results: ${this.passed} passed, ${this.failed} failed`);
-        if (this.failed > 0) {
-            process.exit(1);
-        }
-    }
-}
-
-// Assertion helpers
-function assertEqual<T>(actual: T, expected: T, message?: string) {
-    const actualStr = JSON.stringify(actual, null, 2);
-    const expectedStr = JSON.stringify(expected, null, 2);
-    if (actualStr !== expectedStr) {
-        throw new Error(`${message || 'Values not equal'}\nExpected: ${expectedStr}\nActual: ${actualStr}`);
-    }
-}
-
-function assertTrue(condition: boolean, message?: string) {
-    if (!condition) {
-        throw new Error(message || 'Condition is false');
-    }
-}
-
-function assertFalse(condition: boolean, message?: string) {
-    if (condition) {
-        throw new Error(message || 'Condition is true');
-    }
-}
-
-function assertThrows(fn: () => void, message?: string) {
-    try {
-        fn();
-        throw new Error(message || 'Expected function to throw');
-    } catch (error) {
-        // Expected - function threw as required
-    }
-}
-
-// Initialize test runner
-const runner = new TestRunner();
-
-// ===== FIELD CONDITION BUILDER TESTS =====
-
-runner.add('FieldConditionBuilder - Basic operators', () => {
-    const builder = new FieldConditionBuilder('testField');
-    
-    assertEqual(builder.equals('value').operator, 'is');
-    assertEqual(builder.notEquals('value').operator, 'isNot');
-    assertEqual(builder.greaterThan(10).operator, 'greaterThan');
-    assertEqual(builder.lessThan(10).operator, 'lessThan');
-    assertEqual(builder.greaterThanOrEqual(10).operator, 'greaterThanOrEqual');
-    assertEqual(builder.lessThanOrEqual(10).operator, 'lessThanOrEqual');
-});
-
-runner.add('FieldConditionBuilder - String operators', () => {
-    const builder = new FieldConditionBuilder('text');
-    
-    assertEqual(builder.contains('sub').operator, 'includes');
-    assertEqual(builder.startsWith('pre').operator, 'startsWith');
-    assertEqual(builder.endsWith('suf').operator, 'endsWith');
-    assertEqual(builder.regExpMatches('.*test.*').operator, 'regExpMatches');
-    assertEqual(builder.includesCaseInsensitive('TEST').operator, 'includesCaseInsensitive');
-});
-
-runner.add('FieldConditionBuilder - Array operators', () => {
-    const builder = new FieldConditionBuilder('items');
-    
-    const inCondition = builder.in([1, 2, 3]);
-    assertEqual(inCondition.operator, 'in');
-    assertEqual(inCondition.value, [1, 2, 3]);
-    
-    const notInCondition = builder.notIn(['a', 'b']);
-    assertEqual(notInCondition.operator, 'notIn');
-    assertEqual(notInCondition.value, ['a', 'b']);
-});
-
-runner.add('FieldConditionBuilder - Null/existence operators', () => {
-    const builder = new FieldConditionBuilder('optional');
-    
-    assertEqual(builder.exists().value, true);
-    assertEqual(builder.notExists().value, false);
-    assertEqual(builder.isNull().value, true);
-    assertEqual(builder.isNotNull().value, false);
-});
-
-runner.add('FieldConditionBuilder - Numeric operators', () => {
-    const builder = new FieldConditionBuilder('score');
-    
-    const betweenCondition = builder.between(10, 20);
-    assertEqual(betweenCondition.operator, 'between');
-    assertEqual(betweenCondition.value, { min: 10, max: 20 });
-    
-    // Test additional real operators
-    const regexCondition = builder.regExpMatches('^test.*');
-    assertEqual(regexCondition.operator, 'regExpMatches');
-});
-
-runner.add('FieldConditionBuilder - String operators', () => {
-    const builder = new FieldConditionBuilder('text');
-    
-    assertEqual(builder.contains('test').operator, 'includes');
-    assertEqual(builder.startsWith('prefix').operator, 'startsWith');
-    assertEqual(builder.endsWith('suffix').operator, 'endsWith');
-    assertEqual(builder.regExpMatches('^test.*').operator, 'regExpMatches');
-    assertEqual(builder.includesCaseInsensitive('Test').operator, 'includesCaseInsensitive');
-    assertEqual(builder.startsWithCaseInsensitive('Test').operator, 'startsWithCaseInsensitive');
-    assertEqual(builder.endsWithCaseInsensitive('Test').operator, 'endsWithCaseInsensitive');
-});
-
-runner.add('FieldConditionBuilder - IP address operators', () => {
-    const builder = new FieldConditionBuilder('ipAddress');
-    
-    assertEqual(builder.isLocalIp().operator, 'isLocalIp');
-    assertEqual(builder.isExternalIp().operator, 'isExternalIp');
-    assertEqual(builder.inCountry('US').operator, 'inCountry');
-    assertEqual(builder.cidr('192.168.1.0/24').operator, 'CIDR');
-    assertEqual(builder.b64('dGVzdA==').operator, 'b64');
-    assertEqual(builder.inDataset('malware_ips').operator, 'inDataset');
-});
-
-runner.add('FieldConditionBuilder - Misc operators', () => {
-    const builder = new FieldConditionBuilder('data');
-    
-    const b64Condition = builder.b64('dGVzdA==');
-    assertEqual(b64Condition.operator, 'b64');
-    assertEqual(b64Condition.value, 'dGVzdA==');
-    
-    const countryCondition = builder.inCountry('US');
-    assertEqual(countryCondition.operator, 'inCountry');
-    assertEqual(countryCondition.value, 'US');
-    
-    const datasetCondition = builder.inDataset('malware_ips');
-    assertEqual(datasetCondition.operator, 'inDataset');
-    assertEqual(datasetCondition.value, 'malware_ips');
-    
-    const cidrCondition = builder.cidr('192.168.1.0/24');
-    assertEqual(cidrCondition.operator, 'CIDR');
-    assertEqual(cidrCondition.value, '192.168.1.0/24');
-});
-
-runner.add('FieldConditionBuilder - Boolean operators', () => {
-    const builder = new FieldConditionBuilder('isActive');
-    
-    const trueCondition = builder.isTrue();
-    assertEqual(trueCondition.operator, 'is');
-    assertEqual(trueCondition.value, true);
-    
-    const falseCondition = builder.isFalse();
-    assertEqual(falseCondition.operator, 'is');
-    assertEqual(falseCondition.value, false);
-});
-
-runner.add('FieldConditionBuilder - Number operators', () => {
-    const builder = new FieldConditionBuilder('amount');
-    
-    assertEqual(builder.greaterThan(100).operator, 'greaterThan');
-    assertEqual(builder.lessThan(500).operator, 'lessThan');
-    assertEqual(builder.greaterThanOrEqual(100).operator, 'greaterThanOrEqual');
-    assertEqual(builder.lessThanOrEqual(500).operator, 'lessThanOrEqual');
-    assertEqual(builder.between(100, 500).operator, 'betweenOp');
-});
-
-runner.add('FieldConditionBuilder - Base operators', () => {
-    const builder = new FieldConditionBuilder('value');
-    
-    assertEqual(builder.equals('test').operator, 'is');
-    assertEqual(builder.notEquals('test').operator, 'isNot');
-    assertEqual(builder.in(['a', 'b', 'c']).operator, 'in');
-    assertEqual(builder.notIn(['x', 'y', 'z']).operator, 'notIn');
-    assertEqual(builder.isNull().operator, 'isNull');
-    assertEqual(builder.isNotNull().operator, 'isNull');
-    assertEqual(builder.exists().operator, 'exists');
-    assertEqual(builder.notExists().operator, 'exists');
-    // Only test boolean convenience methods that use base operators
-    assertEqual(builder.isTrue().operator, 'is');
-    assertEqual(builder.isFalse().operator, 'is');
-});
-
-runner.add('FieldConditionBuilder - Boolean convenience methods', () => {
-    const builder = new FieldConditionBuilder('flag');
-    
-    const trueCondition = builder.isTrue();
-    assertEqual(trueCondition.operator, 'is');
-    assertEqual(trueCondition.value, true);
-    
-    const falseCondition = builder.isFalse();
-    assertEqual(falseCondition.operator, 'is');
-    assertEqual(falseCondition.value, false);
-});
-
-// ===== LOGICAL OPERATOR TESTS =====
-
-runner.add('LogicalOperator - Single condition', () => {
-    const condition = new FieldConditionBuilder('name').equals('John');
-    const logicalOp = LogicalOperator.Condition(condition);
-    
-    assertEqual(logicalOp.type, 'condition');
-    assertEqual(logicalOp.condition?.field, 'name');
-    assertEqual(logicalOp.condition?.operator, 'is');
-    assertEqual(logicalOp.condition?.value, 'John');
-});
-
-runner.add('LogicalOperator - AND operation', () => {
-    const condition1 = LogicalOperator.Condition(new FieldConditionBuilder('name').equals('John'));
-    const condition2 = LogicalOperator.Condition(new FieldConditionBuilder('age').greaterThan(25));
-    
-    const andOp = LogicalOperator.And([condition1, condition2]);
-    assertEqual(andOp.type, 'and');
-    assertEqual(andOp.conditions.length, 2);
-});
-
-runner.add('LogicalOperator - OR operation', () => {
-    const condition1 = LogicalOperator.Condition(new FieldConditionBuilder('status').equals('active'));
-    const condition2 = LogicalOperator.Condition(new FieldConditionBuilder('status').equals('pending'));
-    
-    const orOp = LogicalOperator.Or([condition1, condition2]);
-    assertEqual(orOp.type, 'or');
-    assertEqual(orOp.conditions.length, 2);
-});
-
-runner.add('LogicalOperator - NOT operation', () => {
-    const condition = LogicalOperator.Condition(new FieldConditionBuilder('deleted').isTrue());
-    const notOp = LogicalOperator.Not([condition]);
-    
-    assertEqual(notOp.type, 'not');
-    assertEqual(notOp.conditions.length, 1);
-});
-
-// ===== DOT NOTATION TESTS =====
-
-runner.add('createNestedQuery - Simple field', () => {
-    const result = createNestedQuery('name', 'is', 'John');
-    assertEqual(result, { name: { is: 'John' } });
-});
-
-runner.add('createNestedQuery - Nested field', () => {
-    const result = createNestedQuery('user.profile.name', 'is', 'John');
-    const expected = {
-        user: {
-            profile: {
-                name: {
-                    is: 'John'
-                }
-            }
-        }
-    };
-    assertEqual(result, expected);
-});
-
-runner.add('createNestedQuery - Deep nesting', () => {
-    const result = createNestedQuery('a.b.c.d.e', 'contains', 'test');
-    const expected = {
-        a: {
-            b: {
-                c: {
-                    d: {
-                        e: {
-                            contains: 'test'
-                        }
-                    }
-                }
-            }
-        }
-    };
-    assertEqual(result, expected);
-});
-
-runner.add('LogicalOperator.toComposable - Dot notation integration', () => {
-    const condition = new FieldConditionBuilder('user.profile.bio').equals('Developer');
-    const logicalOp = LogicalOperator.Condition(condition);
-    const composable = logicalOp.toComposable();
-    
-    const expected = {
-        user: {
-            profile: {
-                bio: {
-                    is: 'Developer'
-                }
-            }
-        }
-    };
-    assertEqual(composable, expected);
-});
-
-// ===== NESTED BUILDER TESTS =====
-
-runner.add('NestedConditionBuilder - Basic usage', () => {
-    const nestedBuilder = new NestedConditionBuilder('user');
-    const fieldBuilder = nestedBuilder.field('name');
-    
-    assertTrue(fieldBuilder instanceof NestedFieldConditionBuilder);
-});
-
-runner.add('NestedFieldConditionBuilder - Path construction', () => {
-    const nestedBuilder = new NestedConditionBuilder('user');
-    const condition = nestedBuilder.field('profile').field('bio').equals('Developer');
-    
-    assertEqual(condition.field, 'user.profile.bio');
-    assertEqual(condition.operator, 'is');
-    assertEqual(condition.value, 'Developer');
-});
-
-runner.add('NestedFieldConditionBuilder - All operators available', () => {
-    const nestedBuilder = new NestedConditionBuilder('user');
-    const fieldBuilder = nestedBuilder.field('data');
-    
-    // Test a few key operators to ensure they work
-    assertEqual(fieldBuilder.contains('test').operator, 'includes');
-    assertEqual(fieldBuilder.greaterThan(10).operator, 'greaterThan');
-    assertEqual(fieldBuilder.isNull().operator, 'isNull');
-    assertEqual(fieldBuilder.dateToday().operator, 'dateToday');
-});
-
-runner.add('NestedConditionBuilder - Logical groups', () => {
-    const nestedBuilder = new NestedConditionBuilder('user');
-    
-    const andGroup = nestedBuilder.andGroup(builder => [
-        LogicalOperator.Condition(builder.field('name').equals('John')),
-        LogicalOperator.Condition(builder.field('age').greaterThan(25))
-    ]);
-    
-    assertEqual(andGroup.type, 'and');
-    assertEqual(andGroup.conditions.length, 2);
-});
-
-// ===== CONDITION BUILDER TESTS =====
-
-runner.add('ConditionBuilder - Basic functionality', () => {
-    const builder = new ConditionBuilder();
-    
-    assertTrue(builder.isEmpty());
-    assertEqual(builder.getConditionCount(), 0);
-});
-
-runner.add('ConditionBuilder - Adding conditions', () => {
-    const builder = new ConditionBuilder();
-    const condition = LogicalOperator.Condition(new FieldConditionBuilder('name').equals('John'));
-    
-    builder.addCondition(condition);
-    assertEqual(builder.getConditionCount(), 1);
-    assertFalse(builder.isEmpty());
-});
-
-runner.add('ConditionBuilder - Logical groups', () => {
-    const builder = new ConditionBuilder();
-    
-    const andGroup = builder.andGroup(b => [
-        LogicalOperator.Condition(new FieldConditionBuilder('name').equals('John')),
-        LogicalOperator.Condition(new FieldConditionBuilder('age').greaterThan(25))
-    ]);
-    
-    assertEqual(andGroup.type, 'and');
-    assertEqual(andGroup.conditions.length, 2);
-});
-
-runner.add('ConditionBuilder - Nested conditions', () => {
-    const builder = new ConditionBuilder();
-    
-    const nestedCondition = builder.nested('user', nested => 
-        LogicalOperator.Condition(nested.field('name').equals('John'))
-    );
-    
-    assertEqual(nestedCondition.type, 'condition');
-});
-
-runner.add('ConditionBuilder - Clear functionality', () => {
-    const builder = new ConditionBuilder();
-    builder.addCondition(LogicalOperator.Condition(new FieldConditionBuilder('test').equals('value')));
-    
-    assertEqual(builder.getConditionCount(), 1);
-    builder.clear();
-    assertEqual(builder.getConditionCount(), 0);
-    assertTrue(builder.isEmpty());
-});
-
-// ===== QUERY BUILDER TESTS =====
-
-runner.add('QueryBuilder - Basic construction', () => {
-    const builder = new QueryBuilder();
-    assertFalse(builder.isValid()); // No conditions yet
-});
-
-runner.add('QueryBuilder - Method chaining', () => {
-    const mockClient = { 
-        async post() { return { data: { records: [], total: 0 } }; } 
-    };
-    
-    const builder = new QueryBuilder()
-        .withHttpClient(mockClient)
-        .withServerUrl('http://localhost:3000')
-        .collection('users')
-        .limit(10)
-        .offset(0);
-    
-    const rawQuery = builder.buildRawQuery();
-    assertEqual(rawQuery.limit, 10);
-    assertEqual(rawQuery.offset, 0);
-});
-
-runner.add('QueryBuilder - Where field conditions', () => {
-    const builder = new QueryBuilder();
-    const result = builder.whereField('name').equals('John');
-    
-    assertTrue(result === builder); // Returns self for chaining
-    assertTrue(builder.isValid()); // Now has conditions
-});
-
-runner.add('QueryBuilder - Complex find conditions', () => {
-    const builder = new QueryBuilder();
-    
-    builder.find(conditionBuilder => 
-        conditionBuilder.andGroup(b => [
-            LogicalOperator.Condition(new FieldConditionBuilder('name').equals('John')),
-            LogicalOperator.Condition(new FieldConditionBuilder('age').greaterThan(25))
-        ])
-    );
-    
-    assertTrue(builder.isValid());
-    const rawQuery = builder.buildRawQuery();
-    assertTrue(typeof rawQuery.find === 'object');
-});
-
-runner.add('QueryBuilder - Selection methods', () => {
-    const builder = new QueryBuilder();
-    
-    // Test selectFields
-    builder.selectFields(['name', 'email']);
-    assertTrue(builder.isValid());
-    
-    // Test selectAll
-    const builder2 = new QueryBuilder();
-    builder2.selectAll();
-    assertTrue(builder2.isValid());
-});
-
-runner.add('QueryBuilder - Clone functionality', () => {
-    const original = new QueryBuilder()
-        .collection('users')
-        .limit(10)
-        .whereField('name').equals('John');
-    
-    const cloned = original.clone();
-    
-    // Verify they're separate instances
-    assertTrue(cloned !== original);
-    
-    // Verify cloned data
-    assertEqual(cloned.buildRawQuery().limit, 10);
-});
-
-// ===== QUERY RESULT TESTS =====
-
-runner.add('QueryResult - Basic functionality', () => {
-    const data = [{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }];
-    const result = createQueryResult(data);
-    
-    assertEqual(result.len(), 2);
-    assertEqual(result.length(), 2);
-    assertFalse(result.isEmpty());
-    assertEqual(result.first()?.name, 'John');
-    assertEqual(result.last()?.name, 'Jane');
-    assertEqual(result.get(0)?.id, 1);
-});
-
-runner.add('QueryResult - Array input validation', () => {
-    // Test with single item
-    const single = createQueryResult({ id: 1, name: 'Test' } as any);
-    assertEqual(single.len(), 1);
-    
-    // Test with empty array
-    const empty = createQueryResult([]);
-    assertTrue(empty.isEmpty());
-    assertEqual(empty.len(), 0);
-});
-
-runner.add('QueryResult - Iteration methods', () => {
-    const data = [
-        { id: 1, name: 'John', active: true },
-        { id: 2, name: 'Jane', active: false },
-        { id: 3, name: 'Bob', active: true }
-    ];
-    const result = createQueryResult(data);
-    
-    // Test any/some
-    assertTrue(result.any(item => item.active));
-    assertTrue(result.any(item => item.name === 'Jane'));
-    
-    // Test all/every
-    assertFalse(result.all(item => item.active));
-    assertTrue(result.all(item => typeof item.id === 'number'));
-    
-    // Test find
-    const found = result.find(item => item.name === 'Jane');
-    assertEqual(found?.id, 2);
-    
-    // Test filter
-    const active = result.filter(item => item.active);
-    assertEqual(active.length, 2);
-    
-    // Test map
-    const names = result.map(item => item.name);
-    assertEqual(names, ['John', 'Jane', 'Bob']);
-});
-
-runner.add('QueryResult - Pluck methods', () => {
-    const data = [
-        { id: 1, name: 'John', score: 95.5 },
-        { id: 2, name: 'Jane', score: 87 },
-        { id: 3, name: 'Bob', score: null }
-    ];
-    const result = createQueryResult(data);
-    
-    // Test pluck
-    const names = result.pluck('name');
-    assertEqual(names, ['John', 'Jane', 'Bob']);
-    
-    // Test pluckStrings
-    const stringNames = result.pluckStrings('name');
-    assertEqual(stringNames, ['John', 'Jane', 'Bob']);
-    
-    // Test pluckNumbers
-    const scores = result.pluckNumbers('score');
-    assertEqual(scores, [95.5, 87, null]);
-});
-
-runner.add('QueryResult - Numeric summary', () => {
-    const data = [
-        { score: 85 },
-        { score: 92 },
-        { score: 78 },
-        { score: 95 }
-    ];
-    const result = createQueryResult(data);
-    
-    const summary = result.summarizeNumeric('score');
-    
-    assertTrue(summary !== null);
-    assertEqual(summary!.count, 4);
-    assertEqual(summary!.sum, 350);
-    assertEqual(summary!.mean, 87.5);
-    assertEqual(summary!.min, 78);
-    assertEqual(summary!.max, 95);
-    
-    // Test with no numeric data
-    const textData = [{ name: 'John' }, { name: 'Jane' }];
-    const textResult = createQueryResult(textData);
-    const textSummary = textResult.summarizeNumeric('name');
-    assertEqual(textSummary, null);
-});
-
-runner.add('QueryResult - Sorting', () => {
-    const data = [
-        { name: 'Charlie', age: 30 },
-        { name: 'Alice', age: 25 },
-        { name: 'Bob', age: 35 }
-    ];
-    const result = createQueryResult(data);
-    
-    // Test single field sort
-    const byName = result.sortBy('name');
-    assertEqual(byName[0].name, 'Alice');
-    assertEqual(byName[1].name, 'Bob');
-    assertEqual(byName[2].name, 'Charlie');
-    
-    // Test descending sort
-    const byAgeDesc = result.sortBy('age', false);
-    assertEqual(byAgeDesc[0].age, 35);
-    assertEqual(byAgeDesc[2].age, 25);
-    
-    // Test multi-field sort
-    const data2 = [
-        { dept: 'B', name: 'Charlie' },
-        { dept: 'A', name: 'Bob' },
-        { dept: 'A', name: 'Alice' }
-    ];
-    const result2 = createQueryResult(data2);
-    const sorted = result2.sortByMultiple([
-        { field: 'dept', ascending: true },
-        { field: 'name', ascending: true }
-    ]);
-    assertEqual(sorted[0].name, 'Alice');
-    assertEqual(sorted[1].name, 'Bob');
-    assertEqual(sorted[2].name, 'Charlie');
-});
-
-runner.add('QueryResult - Pagination and chunking', () => {
-    const data = Array.from({ length: 10 }, (_, i) => ({ id: i + 1 }));
-    const result = createQueryResult(data);
-    
-    // Test pagination
-    const page1 = result.paginate(1, 3);
-    assertEqual(page1.length, 3);
-    assertEqual(page1[0].id, 1);
-    
-    const page2 = result.paginate(2, 3);
-    assertEqual(page2[0].id, 4);
-    
-    // Test chunking
-    const chunks = result.chunk(3);
-    assertEqual(chunks.length, 4); // 10 items, chunks of 3 = 4 chunks
-    assertEqual(chunks[0].length, 3);
-    assertEqual(chunks[3].length, 1); // Last chunk has remainder
-});
-
-runner.add('QueryResult - Distinct and unique', () => {
-    const data = [
-        { category: 'A', value: 1 },
-        { category: 'B', value: 2 },
-        { category: 'A', value: 3 },
-        { category: 'C', value: 4 }
-    ];
-    const result = createQueryResult(data);
-    
-    const distinctByCategory = result.distinctBy('category');
-    assertEqual(distinctByCategory.length, 3);
-    
-    // Test unique (for primitive arrays)
-    const numbers = createQueryResult([1, 2, 2, 3, 3, 4]);
-    const uniqueNumbers = numbers.unique();
-    assertEqual(uniqueNumbers.length, 4);
-});
-
-runner.add('QueryResult - Statistical functions', () => {
-    const data = [
-        { category: 'A', active: true },
-        { category: 'B', active: false },
-        { category: 'A', active: true },
-        { category: 'C', active: true }
-    ];
-    const result = createQueryResult(data);
-    
-    // Test count with predicate
-    const activeCount = result.count(item => item.active);
-    assertEqual(activeCount, 3);
-    
-    // Test countBy
-    const categoryCounts = result.countBy('category');
-    assertEqual(categoryCounts['A'], 2);
-    assertEqual(categoryCounts['B'], 1);
-    assertEqual(categoryCounts['C'], 1);
-});
-
-runner.add('QueryResult - Joins', () => {
-    const users = createQueryResult([
-        { id: 1, name: 'John', deptId: 10 },
-        { id: 2, name: 'Jane', deptId: 20 }
-    ]);
-    
-    const departments = createQueryResult([
-        { id: 10, name: 'Engineering' },
-        { id: 20, name: 'Design' }
-    ]);
-    
-    // Test inner join
-    const innerJoined = users.innerJoin(departments, 'deptId', 'id');
-    assertEqual(innerJoined.length, 2);
-    assertEqual(innerJoined[0].name, 'Engineering'); // dept name
-    
-    // Test left join
-    const leftJoined = users.leftJoin(departments, 'deptId', 'id');
-    assertEqual(leftJoined.length, 2);
-});
-
-runner.add('QueryResult - Export functions', () => {
-    const data = [
-        { id: 1, name: 'John', active: true },
-        { id: 2, name: 'Jane', active: false }
-    ];
-    const result = createQueryResult(data);
-    
-    // Test CSV export
-    const csv = result.toCsv();
-    const lines = csv.split('\n');
-    assertEqual(lines.length, 3); // header + 2 rows
-    assertTrue(lines[0].includes('id'));
-    assertTrue(lines[0].includes('name'));
-    assertTrue(lines[0].includes('active'));
-    
-    // Test JSON export
-    const json = result.toJSON();
-    const parsed = JSON.parse(json);
-    assertEqual(parsed.length, 2);
-    assertEqual(parsed[0].name, 'John');
-    
-    // Test array conversion
-    const array = result.toArray();
-    assertEqual(array.length, 2);
-    assertTrue(Array.isArray(array));
-});
-
-runner.add('QueryResult - Nested field access', () => {
-    const data = [
-        { user: { profile: { name: 'John', age: 30 } } },
-        { user: { profile: { name: 'Jane', age: 25 } } }
-    ];
-    const result = createQueryResult(data);
-    
-    // Test nested pluck
-    const names = result.pluck('user.profile.name');
-    assertEqual(names, ['John', 'Jane']);
-    
-    // Test nested sort
-    const sorted = result.sortBy('user.profile.age');
-    assertEqual(sorted[0].user.profile.name, 'Jane');
-    assertEqual(sorted[1].user.profile.name, 'John');
-    
-    // Test nested groupBy
-    const grouped = result.groupBy('user.profile.name');
-    assertTrue('John' in grouped);
-    assertTrue('Jane' in grouped);
-});
-
-// ===== ERROR HANDLING AND EDGE CASES =====
-
-runner.add('Error handling - Invalid conditions', () => {
-    assertThrows(() => {
-        const builder = new ConditionBuilder();
-        builder.buildSingle(); // Should throw - no conditions
-    });
-});
-
-runner.add('Error handling - Missing required data', () => {
-    assertThrows(() => {
-        const logicalOp = new LogicalOperator('condition' as any, [], undefined);
-        logicalOp.toComposable(); // Should throw - no condition provided
-    });
-});
-
-runner.add('Edge cases - Empty and null data', () => {
-    const empty = createQueryResult([]);
-    
-    assertEqual(empty.len(), 0);
-    assertTrue(empty.isEmpty());
-    assertEqual(empty.first(), undefined);
-    assertEqual(empty.last(), undefined);
-    
-    const summary = empty.summarizeNumeric('nonexistent');
-    assertEqual(summary, null);
-});
-
-runner.add('Edge cases - Nested field access with missing data', () => {
-    const data = [
-        { user: { name: 'John' } }, // Missing profile.age
-        { user: { profile: { age: 25 } } } // Missing name
-    ];
-    const result = createQueryResult(data);
-    
-    const ages = result.pluck('user.profile.age');
-    assertEqual(ages[0], undefined);
-    assertEqual(ages[1], 25);
-});
-
-// Run all tests
-runner.run();