@onchaindb/sdk 0.4.0 → 0.4.2

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

@@ -0,0 +1,794 @@
+// 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();