@onchaindb/sdk 0.4.0 → 0.4.2

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

@@ -0,0 +1,608 @@
+// Integration tests for TypeScript SDK - Complete workflows
+import { 
+    QueryBuilder, 
+    ConditionBuilder,
+    NestedConditionBuilder,
+    LogicalOperator,
+    FieldConditionBuilder,
+    QueryResult,
+    createQueryResult 
+} from '../index';
+
+// Mock HTTP client that simulates real API responses
+class MockHttpClient {
+    private responses: Record<string, any> = {
+        '/list': {
+            records: [
+                {
+                    id: 1,
+                    name: 'John Doe',
+                    email: 'john@example.com',
+                    age: 30,
+                    department: 'Engineering',
+                    user: {
+                        profile: {
+                            bio: 'Senior Developer',
+                            settings: {
+                                theme: 'dark',
+                                notifications: true
+                            }
+                        },
+                        metadata: {
+                            lastLogin: '2024-01-15T10:30:00Z',
+                            ipAddress: '192.168.1.100'
+                        }
+                    },
+                    scores: [95, 87, 92],
+                    active: true,
+                    location: { lat: 40.7128, lng: -74.0060 }
+                },
+                {
+                    id: 2,
+                    name: 'Jane Smith',
+                    email: 'jane@example.com',
+                    age: 28,
+                    department: 'Design',
+                    user: {
+                        profile: {
+                            bio: 'UI/UX Designer',
+                            settings: {
+                                theme: 'light',
+                                notifications: false
+                            }
+                        },
+                        metadata: {
+                            lastLogin: '2024-01-14T16:45:00Z',
+                            ipAddress: '10.0.0.50'
+                        }
+                    },
+                    scores: [88, 94, 90],
+                    active: true,
+                    location: { lat: 34.0522, lng: -118.2437 }
+                },
+                {
+                    id: 3,
+                    name: 'Bob Johnson',
+                    email: 'bob@example.com',
+                    age: 35,
+                    department: 'Engineering',
+                    user: {
+                        profile: {
+                            bio: 'DevOps Engineer',
+                            settings: {
+                                theme: 'dark',
+                                notifications: true
+                            }
+                        },
+                        metadata: {
+                            lastLogin: '2024-01-13T09:15:00Z',
+                            ipAddress: '192.168.1.101'
+                        }
+                    },
+                    scores: [92, 85, 97],
+                    active: false,
+                    location: { lat: 41.8781, lng: -87.6298 }
+                }
+            ],
+            total: 3,
+            page: 1,
+            limit: 10
+        }
+    };
+
+    async post(url: string, data: any, headers?: Record<string, string>) {
+        // Simulate network delay
+        await new Promise(resolve => setTimeout(resolve, 10));
+        
+        const response = this.responses[url.split('http://localhost:3000')[1] || url];
+        return { data: response };
+    }
+}
+
+// Test framework
+interface IntegrationTest {
+    name: string;
+    test: () => Promise<void>;
+}
+
+class IntegrationTestRunner {
+    private tests: IntegrationTest[] = [];
+    private passed = 0;
+    private failed = 0;
+
+    add(name: string, test: () => Promise<void>) {
+        this.tests.push({ name, test });
+    }
+
+    async run() {
+        console.log(`🧪 Running ${this.tests.length} integration tests...\n`);
+        
+        for (const testCase of this.tests) {
+            try {
+                await 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📊 Integration Test Results: ${this.passed} passed, ${this.failed} failed`);
+        if (this.failed > 0) {
+            process.exit(1);
+        }
+    }
+}
+
+// Helper functions
+function assertEqual<T>(actual: T, expected: T, message?: string) {
+    const actualStr = JSON.stringify(actual);
+    const expectedStr = JSON.stringify(expected);
+    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');
+    }
+}
+
+// Initialize test runner
+const runner = new IntegrationTestRunner();
+
+// ===== COMPLETE WORKFLOW TESTS =====
+
+runner.add('Complete Query Workflow - Simple field query', async () => {
+    const client = new MockHttpClient();
+    const queryBuilder = new QueryBuilder(client, 'http://localhost:3000', 'testApp');
+    
+    const response = await queryBuilder
+        .collection('users')
+        .whereField('name').equals('John Doe')
+        .limit(10)
+        .selectFields(['id', 'name', 'email'])
+        .execute();
+    
+    assertTrue(response.records.length > 0);
+    assertEqual(response.records[0].name, 'John Doe');
+});
+
+runner.add('Complete Query Workflow - Nested field query with dot notation', async () => {
+    const client = new MockHttpClient();
+    const queryBuilder = new QueryBuilder(client, 'http://localhost:3000', 'testApp');
+    
+    const response = await queryBuilder
+        .collection('users')
+        .whereField('user.profile.bio').contains('Developer')
+        .execute();
+    
+    assertTrue(response.records.length >= 1);
+    
+    // Verify the raw query structure includes nested fields
+    const rawQuery = queryBuilder.buildRawQuery();
+    assertTrue(typeof rawQuery.find === 'object');
+});
+
+runner.add('Complete Query Workflow - Complex logical conditions', async () => {
+    const client = new MockHttpClient();
+    const queryBuilder = new QueryBuilder(client, 'http://localhost:3000', 'testApp');
+    
+    const response = await queryBuilder
+        .collection('users')
+        .find(builder => 
+            builder.andGroup(() => [
+                LogicalOperator.Condition(new FieldConditionBuilder('age').greaterThan(25)),
+                LogicalOperator.Condition(new FieldConditionBuilder('department').equals('Engineering'))
+            ])
+        )
+        .limit(5)
+        .execute();
+    
+    assertTrue(response.records.length > 0);
+    assertEqual(response.limit, 5);
+});
+
+runner.add('Complete Query Workflow - Nested builder with ORM-like syntax', async () => {
+    const client = new MockHttpClient();
+    const queryBuilder = new QueryBuilder(client, 'http://localhost:3000', 'testApp');
+    
+    const response = await queryBuilder
+        .collection('users')
+        .find(builder =>
+            builder.nested('user', nested =>
+                nested.andGroup(() => [
+                    LogicalOperator.Condition(nested.field('profile').field('bio').contains('Engineer')),
+                    LogicalOperator.Condition(nested.field('metadata').field('ipAddress').startsWith('192.168'))
+                ])
+            )
+        )
+        .execute();
+    
+    assertTrue(response.records.length >= 0);
+    
+    // Verify the query structure
+    const rawQuery = queryBuilder.buildRawQuery();
+    assertTrue(typeof rawQuery.find === 'object');
+});
+
+runner.add('Complete Query Workflow - Advanced operators', async () => {
+    const client = new MockHttpClient();
+    const queryBuilder = new QueryBuilder(client, 'http://localhost:3000', 'testApp');
+    
+    const response = await queryBuilder
+        .collection('users')
+        .whereField('age').between(25, 40)
+        .limit(10)
+        .execute();
+    
+    assertTrue(response.records.length > 0);
+    
+    // Test with date operators
+    const dateQuery = new QueryBuilder(client, 'http://localhost:3000', 'testApp')
+        .collection('users')
+        .whereField('user.metadata.lastLogin').dateAfter('2024-01-01')
+        .execute();
+    
+    const dateResponse = await dateQuery;
+    assertTrue(dateResponse.records.length >= 0);
+});
+
+runner.add('Complete Query Workflow - IP and geographical queries', async () => {
+    const client = new MockHttpClient();
+    
+    // Test IP range query
+    const ipQuery = new QueryBuilder(client, 'http://localhost:3000', 'testApp')
+        .collection('users')
+        .whereField('user.metadata.ipAddress').ipInRange('192.168.1.0/24')
+        .execute();
+    
+    const ipResponse = await ipQuery;
+    assertTrue(ipResponse.records.length >= 0);
+    
+    // Test geographical query
+    const geoQuery = new QueryBuilder(client, 'http://localhost:3000', 'testApp')
+        .collection('users')
+        .whereField('location').geoWithinRadius(40.7128, -74.0060, 100)
+        .execute();
+    
+    const geoResponse = await geoQuery;
+    assertTrue(geoResponse.records.length >= 0);
+});
+
+runner.add('Complete Query Workflow - Array and type checking operators', async () => {
+    const client = new MockHttpClient();
+    
+    // Test array operators
+    const arrayQuery = new QueryBuilder(client, 'http://localhost:3000', 'testApp')
+        .collection('users')
+        .whereField('scores').arrayLength(3)
+        .execute();
+    
+    const arrayResponse = await arrayQuery;
+    assertTrue(arrayResponse.records.length >= 0);
+    
+    // Test type checking
+    const typeQuery = new QueryBuilder(client, 'http://localhost:3000', 'testApp')
+        .collection('users')
+        .whereField('active').isBoolean()
+        .execute();
+    
+    const typeResponse = await typeQuery;
+    assertTrue(typeResponse.records.length >= 0);
+});
+
+// ===== QUERY RESULT PROCESSING WORKFLOWS =====
+
+runner.add('QueryResult Processing Workflow - Complete data analysis', async () => {
+    const client = new MockHttpClient();
+    const queryBuilder = new QueryBuilder(client, 'http://localhost:3000', 'testApp');
+    
+    const response = await queryBuilder
+        .collection('users')
+        .selectAll()
+        .execute();
+    
+    const result = createQueryResult(response.records);
+    
+    // Basic analysis
+    assertTrue(result.len() > 0);
+    assertTrue(!result.isEmpty());
+    
+    // Pluck and analyze ages
+    const ages = result.pluckNumbers('age');
+    const ageSummary = result.summarizeNumeric('age');
+    
+    assertTrue(ageSummary !== null);
+    assertTrue(ageSummary.mean > 0);
+    assertTrue(ageSummary.min <= ageSummary.max);
+    
+    // Group by department
+    const byDepartment = result.groupBy('department');
+    assertTrue('Engineering' in byDepartment);
+    assertTrue('Design' in byDepartment);
+    
+    // Sort by age
+    const sortedByAge = result.sortBy('age');
+    assertTrue(sortedByAge.length === result.len());
+    
+    // Filter active users
+    const activeUsers = result.filter(user => user.active);
+    assertTrue(activeUsers.length >= 0);
+});
+
+runner.add('QueryResult Processing Workflow - Nested field analysis', async () => {
+    const client = new MockHttpClient();
+    const queryBuilder = new QueryBuilder(client, 'http://localhost:3000', 'testApp');
+    
+    const response = await queryBuilder
+        .collection('users')
+        .selectAll()
+        .execute();
+    
+    const result = createQueryResult(response.records);
+    
+    // Analyze nested profile data
+    const themes = result.pluck('user.profile.settings.theme');
+    const themeGroups = result.groupBy('user.profile.settings.theme');
+    
+    assertTrue(themes.length > 0);
+    assertTrue('dark' in themeGroups || 'light' in themeGroups);
+    
+    // Sort by nested field
+    const sortedByBio = result.sortBy('user.profile.bio');
+    assertTrue(sortedByBio.length === result.len());
+    
+    // Count by nested boolean
+    const notificationCounts = result.countBy('user.profile.settings.notifications');
+    assertTrue('true' in notificationCounts || 'false' in notificationCounts);
+});
+
+runner.add('QueryResult Processing Workflow - Advanced aggregations', async () => {
+    const client = new MockHttpClient();
+    const queryBuilder = new QueryBuilder(client, 'http://localhost:3000', 'testApp');
+    
+    const response = await queryBuilder
+        .collection('users')
+        .selectAll()
+        .execute();
+    
+    const result = createQueryResult(response.records);
+    
+    // Multi-field sorting
+    const sortedMultiple = result.sortByMultiple([
+        { field: 'department', ascending: true },
+        { field: 'age', ascending: false }
+    ]);
+    assertTrue(sortedMultiple.length === result.len());
+    
+    // Pagination
+    const page1 = result.paginate(1, 2);
+    const page2 = result.paginate(2, 2);
+    assertTrue(page1.length <= 2);
+    assertTrue(page2.length >= 0);
+    
+    // Chunking
+    const chunks = result.chunk(2);
+    assertTrue(chunks.length >= 1);
+    
+    // Distinct values
+    const distinctDepts = result.distinctBy('department');
+    assertTrue(distinctDepts.length <= result.len());
+});
+
+runner.add('QueryResult Processing Workflow - Data export and joins', async () => {
+    const client = new MockHttpClient();
+    const queryBuilder = new QueryBuilder(client, 'http://localhost:3000', 'testApp');
+    
+    const response = await queryBuilder
+        .collection('users')
+        .selectAll()
+        .execute();
+    
+    const users = createQueryResult(response.records);
+    
+    // Create mock departments for join
+    const departments = createQueryResult([
+        { name: 'Engineering', budget: 100000 },
+        { name: 'Design', budget: 75000 }
+    ]);
+    
+    // Test join operations
+    const joinedData = users.innerJoin(departments, 'department', 'name');
+    assertTrue(joinedData.length >= 0);
+    
+    // Test CSV export
+    const csv = users.toCsv();
+    const lines = csv.split('\n');
+    assertTrue(lines.length > 1); // At least header + 1 row
+    assertTrue(lines[0].includes('id'));
+    assertTrue(lines[0].includes('name'));
+    
+    // Test JSON export
+    const json = users.toJSON();
+    const parsed = JSON.parse(json);
+    assertTrue(Array.isArray(parsed));
+    assertTrue(parsed.length > 0);
+});
+
+// ===== ERROR HANDLING AND EDGE CASE WORKFLOWS =====
+
+runner.add('Error Handling Workflow - Missing HTTP client', async () => {
+    const queryBuilder = new QueryBuilder(); // No HTTP client
+    
+    try {
+        await queryBuilder
+            .collection('users')
+            .whereField('name').equals('John')
+            .execute();
+        
+        throw new Error('Should have thrown error for missing HTTP client');
+    } catch (error) {
+        assertTrue(error instanceof Error);
+        assertTrue(error.message.includes('HTTP client'));
+    }
+});
+
+runner.add('Error Handling Workflow - Missing server URL', async () => {
+    const client = new MockHttpClient();
+    const queryBuilder = new QueryBuilder(client); // No server URL
+    
+    try {
+        await queryBuilder
+            .collection('users')
+            .whereField('name').equals('John')
+            .execute();
+        
+        throw new Error('Should have thrown error for missing server URL');
+    } catch (error) {
+        assertTrue(error instanceof Error);
+        assertTrue(error.message.includes('Server URL'));
+    }
+});
+
+runner.add('Edge Case Workflow - Empty result processing', async () => {
+    // Simulate empty response
+    class EmptyMockClient {
+        async post() {
+            return {
+                data: {
+                    records: [],
+                    total: 0,
+                    page: 1,
+                    limit: 10
+                }
+            };
+        }
+    }
+    
+    const client = new EmptyMockClient();
+    const queryBuilder = new QueryBuilder(client, 'http://localhost:3000', 'testApp');
+    
+    const response = await queryBuilder
+        .collection('users')
+        .whereField('nonexistent').equals('value')
+        .execute();
+    
+    assertEqual(response.records.length, 0);
+    
+    const result = createQueryResult(response.records);
+    assertTrue(result.isEmpty());
+    assertEqual(result.first(), undefined);
+    assertEqual(result.summarizeNumeric('age'), null);
+});
+
+runner.add('Edge Case Workflow - Complex nested queries with missing fields', async () => {
+    const client = new MockHttpClient();
+    const queryBuilder = new QueryBuilder(client, 'http://localhost:3000', 'testApp');
+    
+    // Query with deeply nested field that might not exist
+    const response = await queryBuilder
+        .collection('users')
+        .find(builder =>
+            builder.nested('user', nested =>
+                nested.field('profile').field('settings').field('advanced').field('feature').equals('enabled')
+            )
+        )
+        .execute();
+    
+    // Should not throw error even if nested field doesn't exist
+    assertTrue(response.records.length >= 0);
+    
+    const result = createQueryResult(response.records);
+    
+    // Test accessing missing nested fields
+    const missingValues = result.pluck('user.profile.settings.advanced.feature');
+    assertTrue(Array.isArray(missingValues));
+});
+
+runner.add('Performance Workflow - Large dataset simulation', async () => {
+    // Create a mock client that returns larger dataset
+    class LargeDataMockClient {
+        async post() {
+            const records = Array.from({ length: 100 }, (_, i) => ({
+                id: i + 1,
+                name: `User ${i + 1}`,
+                age: Math.floor(Math.random() * 50) + 20,
+                department: ['Engineering', 'Design', 'Marketing'][i % 3],
+                user: {
+                    profile: {
+                        bio: `Bio for user ${i + 1}`,
+                        settings: {
+                            theme: ['dark', 'light'][i % 2],
+                            notifications: i % 2 === 0
+                        }
+                    }
+                },
+                scores: [
+                    Math.floor(Math.random() * 100),
+                    Math.floor(Math.random() * 100),
+                    Math.floor(Math.random() * 100)
+                ],
+                active: i % 3 !== 0
+            }));
+            
+            return {
+                data: {
+                    records,
+                    total: 1000,
+                    page: 1,
+                    limit: 100
+                }
+            };
+        }
+    }
+    
+    const client = new LargeDataMockClient();
+    const queryBuilder = new QueryBuilder(client, 'http://localhost:3000', 'testApp');
+    
+    const startTime = Date.now();
+    
+    const response = await queryBuilder
+        .collection('users')
+        .find(builder =>
+            builder.andGroup(() => [
+                LogicalOperator.Condition(new FieldConditionBuilder('age').between(25, 45)),
+                LogicalOperator.Condition(new FieldConditionBuilder('active').isTrue())
+            ])
+        )
+        .limit(50)
+        .execute();
+    
+    const queryTime = Date.now() - startTime;
+    
+    const result = createQueryResult(response.records);
+    
+    const processingStartTime = Date.now();
+    
+    // Perform various operations on the large dataset
+    const summary = result.summarizeNumeric('age');
+    const grouped = result.groupBy('department');
+    const sorted = result.sortByMultiple([
+        { field: 'department', ascending: true },
+        { field: 'age', ascending: false }
+    ]);
+    const filtered = result.filter(user => user.active);
+    const csv = result.toCsv();
+    
+    const processingTime = Date.now() - processingStartTime;
+    
+    console.log(`   Query time: ${queryTime}ms, Processing time: ${processingTime}ms`);
+    
+    // Verify results
+    assertTrue(response.records.length > 0);
+    assertTrue(summary !== null);
+    assertTrue(Object.keys(grouped).length > 0);
+    assertTrue(sorted.length > 0);
+    assertTrue(filtered.length >= 0);
+    assertTrue(csv.length > 0);
+    
+    // Performance should be reasonable (adjust thresholds as needed)
+    assertTrue(queryTime < 1000, 'Query should complete in reasonable time');
+    assertTrue(processingTime < 1000, 'Processing should complete in reasonable time');
+});
+
+// Run all integration tests
+runner.run();