@onchaindb/sdk 0.4.5 → 2.0.0

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

@@ -2,11 +2,9 @@ import { createQueryResult, QueryResult } from '../QueryResult';
 
 describe('QueryResult', () => {
   const testData = [
-    { id: 1, name: 'Alice', age: 30, department: 'Engineering', salary: 75000, active: true },
-    { id: 2, name: 'Bob', age: 25, department: 'Design', salary: 65000, active: true },
-    { id: 3, name: 'Carol', age: 35, department: 'Engineering', salary: 85000, active: false },
-    { id: 4, name: 'David', age: 28, department: 'Marketing', salary: 55000, active: true },
-    { id: 5, name: 'Eve', age: 32, department: 'Engineering', salary: 95000, active: true }
+    { id: 1, name: 'Alice', age: 30 },
+    { id: 2, name: 'Bob', age: 25 },
+    { id: 3, name: 'Carol', age: 35 },
   ];
 
   let result: QueryResult<any>;
@@ -15,450 +13,58 @@ describe('QueryResult', () => {
     result = createQueryResult(testData);
   });
 
-  describe('Basic operations', () => {
-    test('should return correct length', () => {
-      expect(result.len()).toBe(5);
-      expect(result.length()).toBe(5);
-    });
-
-    test('should identify empty results', () => {
-      const emptyResult = createQueryResult([]);
-      expect(emptyResult.isEmpty()).toBe(true);
-      expect(result.isEmpty()).toBe(false);
-    });
-
-    test('should return first and last items', () => {
-      expect(result.first()?.name).toBe('Alice');
-      expect(result.last()?.name).toBe('Eve');
-    });
-
-    test('should get item by index', () => {
-      expect(result.get(0)?.name).toBe('Alice');
-      expect(result.get(2)?.name).toBe('Carol');
-      expect(result.get(10)).toBeUndefined();
-    });
-
-    test('should handle single item input', () => {
-      const singleResult = createQueryResult({ id: 1, name: 'Test' } as any);
-      expect(singleResult.len()).toBe(1);
-      expect(singleResult.first()?.name).toBe('Test');
-    });
-  });
-
-  describe('Iteration methods', () => {
-    test('any should work correctly', () => {
-      expect(result.any(item => item.age > 30)).toBe(true);
-      expect(result.any(item => item.age > 100)).toBe(false);
-    });
-
-    test('all should work correctly', () => {
-      expect(result.all(item => item.id > 0)).toBe(true);
-      expect(result.all(item => item.active)).toBe(false);
-    });
-
-    test('find should return correct item', () => {
-      const found = result.find(item => item.name === 'Carol');
-      expect(found?.id).toBe(3);
-      expect(result.find(item => item.name === 'Unknown')).toBeUndefined();
-    });
-
-    test('filter should return correct items', () => {
-      const activeUsers = result.filter(item => item.active);
-      expect(activeUsers).toHaveLength(4);
-      
-      const engineers = result.filter(item => item.department === 'Engineering');
-      expect(engineers).toHaveLength(3);
-    });
-
-    test('map should transform items correctly', () => {
-      const names = result.map(item => item.name);
-      expect(names).toEqual(['Alice', 'Bob', 'Carol', 'David', 'Eve']);
-      
-      const ages = result.map(item => item.age);
-      expect(ages).toEqual([30, 25, 35, 28, 32]);
-    });
-
-    test('forEach should iterate over all items', () => {
-      const mockCallback = jest.fn();
-      result.forEach(mockCallback);
-      expect(mockCallback).toHaveBeenCalledTimes(5);
-    });
-
-    test('reduce should accumulate correctly', () => {
-      const totalAge = result.reduce((sum, item) => sum + item.age, 0);
-      expect(totalAge).toBe(150);
-      
-      const nameList = result.reduce((names, item) => names + item.name + ',', '');
-      expect(nameList).toBe('Alice,Bob,Carol,David,Eve,');
-    });
-  });
-
-  describe('Data extraction', () => {
-    test('pluck should extract field values', () => {
-      const names = result.pluck('name');
-      expect(names).toEqual(['Alice', 'Bob', 'Carol', 'David', 'Eve']);
-      
-      const ages = result.pluck('age');
-      expect(ages).toEqual([30, 25, 35, 28, 32]);
-    });
-
-    test('pluckStrings should extract and convert to strings', () => {
-      const ageStrings = result.pluckStrings('age');
-      expect(ageStrings).toEqual(['30', '25', '35', '28', '32']);
-      
-      const names = result.pluckStrings('name');
-      expect(names).toEqual(['Alice', 'Bob', 'Carol', 'David', 'Eve']);
-    });
-
-    test('pluckNumbers should extract and convert to numbers', () => {
-      const ages = result.pluckNumbers('age');
-      expect(ages).toEqual([30, 25, 35, 28, 32]);
-      
-      const salaries = result.pluckNumbers('salary');
-      expect(salaries).toEqual([75000, 65000, 85000, 55000, 95000]);
-    });
-
-    test('pluckNumbers should handle non-numeric values', () => {
-      const testDataWithNulls = [
-        { id: 1, score: 85 },
-        { id: 2, score: null },
-        { id: 3, score: '90' },
-        { id: 4, score: 'invalid' }
-      ];
-      
-      const resultWithNulls = createQueryResult(testDataWithNulls);
-      const scores = resultWithNulls.pluckNumbers('score');
-      expect(scores).toEqual([85, null, 90, null]);
-    });
-  });
-
-  describe('Numeric summary', () => {
-    test('should calculate numeric summary correctly', () => {
-      const ageSummary = result.summarizeNumeric('age');
-      
-      expect(ageSummary).not.toBeNull();
-      expect(ageSummary!.count).toBe(5);
-      expect(ageSummary!.sum).toBe(150);
-      expect(ageSummary!.mean).toBe(30);
-      expect(ageSummary!.min).toBe(25);
-      expect(ageSummary!.max).toBe(35);
-    });
-
-    test('should calculate median correctly', () => {
-      const ageSummary = result.summarizeNumeric('age');
-      expect(ageSummary!.median).toBe(30); // [25, 28, 30, 32, 35]
-    });
-
-    test('should calculate standard deviation correctly', () => {
-      const ageSummary = result.summarizeNumeric('age');
-      expect(ageSummary!.standardDeviation).toBeCloseTo(3.74, 2);
-    });
-
-    test('should return null for non-numeric fields', () => {
-      const nameSummary = result.summarizeNumeric('name');
-      expect(nameSummary).toBeNull();
-    });
-
-    test('should handle empty data', () => {
-      const emptyResult = createQueryResult([]);
-      const summary = emptyResult.summarizeNumeric('age');
-      expect(summary).toBeNull();
-    });
+  test('len() and length() return correct count', () => {
+    expect(result.len()).toBe(3);
+    expect(result.length()).toBe(3);
   });
 
-  describe('Grouping and aggregation', () => {
-    test('groupBy should group items correctly', () => {
-      const byDepartment = result.groupBy('department');
-      
-      expect(byDepartment['Engineering']).toHaveLength(3);
-      expect(byDepartment['Design']).toHaveLength(1);
-      expect(byDepartment['Marketing']).toHaveLength(1);
-    });
-
-    test('countBy should count values correctly', () => {
-      const departmentCounts = result.countBy('department');
-      
-      expect(departmentCounts['Engineering']).toBe(3);
-      expect(departmentCounts['Design']).toBe(1);
-      expect(departmentCounts['Marketing']).toBe(1);
-    });
-
-    test('count with predicate should work correctly', () => {
-      const activeCount = result.count(item => item.active);
-      expect(activeCount).toBe(4);
-      
-      const engineerCount = result.count(item => item.department === 'Engineering');
-      expect(engineerCount).toBe(3);
-    });
-
-    test('count without predicate should return total count', () => {
-      expect(result.count()).toBe(5);
-    });
+  test('isEmpty() works correctly', () => {
+    expect(createQueryResult([]).isEmpty()).toBe(true);
+    expect(result.isEmpty()).toBe(false);
   });
 
-  describe('Sorting', () => {
-    test('sortBy should sort correctly', () => {
-      const sortedByAge = result.sortBy('age');
-      const ages = sortedByAge.map(item => item.age);
-      expect(ages).toEqual([25, 28, 30, 32, 35]);
-      
-      const sortedByName = result.sortBy('name');
-      const names = sortedByName.map(item => item.name);
-      expect(names).toEqual(['Alice', 'Bob', 'Carol', 'David', 'Eve']);
-    });
-
-    test('sortBy should handle descending order', () => {
-      const sortedByAgeDesc = result.sortBy('age', false);
-      const ages = sortedByAgeDesc.map(item => item.age);
-      expect(ages).toEqual([35, 32, 30, 28, 25]);
-    });
-
-    test('sortByMultiple should handle multiple sort fields', () => {
-      const sorted = result.sortByMultiple([
-        { field: 'department', ascending: true },
-        { field: 'salary', ascending: false }
-      ]);
-      
-      // Should sort by department first, then by salary descending
-      expect(sorted[0].department).toBe('Design');
-      expect(sorted[1].department).toBe('Engineering');
-      expect(sorted[1].salary).toBe(95000); // Highest paid engineer first
-    });
-
-    test('sortBy should handle null values', () => {
-      const dataWithNulls = [
-        { id: 1, score: 10 },
-        { id: 2, score: null },
-        { id: 3, score: 5 }
-      ];
-      
-      const resultWithNulls = createQueryResult(dataWithNulls);
-      const sorted = resultWithNulls.sortBy('score');
-      
-      // Null values should sort first in ascending order
-      expect(sorted[0].score).toBeNull();
-      expect(sorted[1].score).toBe(5);
-      expect(sorted[2].score).toBe(10);
-    });
+  test('first() and last() return correct items', () => {
+    expect(result.first()?.name).toBe('Alice');
+    expect(result.last()?.name).toBe('Carol');
   });
 
-  describe('Pagination and chunking', () => {
-    test('paginate should return correct page', () => {
-      const page1 = result.paginate(1, 2);
-      expect(page1).toHaveLength(2);
-      expect(page1[0].name).toBe('Alice');
-      expect(page1[1].name).toBe('Bob');
-      
-      const page2 = result.paginate(2, 2);
-      expect(page2).toHaveLength(2);
-      expect(page2[0].name).toBe('Carol');
-      expect(page2[1].name).toBe('David');
-      
-      const page3 = result.paginate(3, 2);
-      expect(page3).toHaveLength(1);
-      expect(page3[0].name).toBe('Eve');
-    });
-
-    test('chunk should split data into chunks', () => {
-      const chunks = result.chunk(2);
-      expect(chunks).toHaveLength(3);
-      expect(chunks[0]).toHaveLength(2);
-      expect(chunks[1]).toHaveLength(2);
-      expect(chunks[2]).toHaveLength(1);
-      
-      expect(chunks[0][0].name).toBe('Alice');
-      expect(chunks[2][0].name).toBe('Eve');
-    });
+  test('first() and last() return undefined on empty result', () => {
+    const empty = createQueryResult([]);
+    expect(empty.first()).toBeUndefined();
+    expect(empty.last()).toBeUndefined();
   });
 
-  describe('Distinct and unique', () => {
-    test('distinctBy should return unique values', () => {
-      const uniqueDepartments = result.distinctBy('department');
-      const departments = uniqueDepartments.map(item => item.department);
-      expect(departments).toEqual(['Engineering', 'Design', 'Marketing']);
-    });
-
-    test('unique should remove duplicates', () => {
-      const duplicateData = [1, 2, 2, 3, 3, 3, 4];
-      const duplicateResult = createQueryResult(duplicateData);
-      const unique = duplicateResult.unique();
-      expect(unique).toEqual([1, 2, 3, 4]);
-    });
+  test('get(index) returns correct item or undefined', () => {
+    expect(result.get(0)?.name).toBe('Alice');
+    expect(result.get(2)?.name).toBe('Carol');
+    expect(result.get(99)).toBeUndefined();
   });
 
-  describe('Joining', () => {
-    const departments = createQueryResult([
-      { id: 'Engineering', budget: 100000, manager: 'John' },
-      { id: 'Design', budget: 75000, manager: 'Jane' },
-      { id: 'Marketing', budget: 50000, manager: 'Mike' }
-    ]);
-
-    test('innerJoin should join matching records', () => {
-      const joined = result.innerJoin(departments, 'department', 'id');
-      
-      expect(joined).toHaveLength(5);
-      expect(joined[0].budget).toBe(100000); // Alice from Engineering
-      expect(joined[1].budget).toBe(75000);  // Bob from Design
-    });
-
-    test('leftJoin should include all left records', () => {
-      const leftJoined = result.leftJoin(departments, 'department', 'id');
-      
-      expect(leftJoined).toHaveLength(5);
-      // All original records should be present
-      expect(leftJoined.map(r => r.name)).toEqual(['Alice', 'Bob', 'Carol', 'David', 'Eve']);
-    });
+  test('toArray() returns a copy of the data', () => {
+    const arr = result.toArray();
+    expect(Array.isArray(arr)).toBe(true);
+    expect(arr).toHaveLength(3);
+    expect(arr[0]).toEqual(testData[0]);
+    // Ensure it's a copy, not the same reference
+    arr.push({ id: 99, name: 'Extra', age: 0 });
+    expect(result.len()).toBe(3);
   });
 
-  describe('Export functions', () => {
-    test('toArray should return array copy', () => {
-      const array = result.toArray();
-      expect(Array.isArray(array)).toBe(true);
-      expect(array).toHaveLength(5);
-      expect(array[0]).toEqual(testData[0]);
-    });
-
-    test('toJSON should return JSON string', () => {
-      const json = result.toJSON();
-      const parsed = JSON.parse(json);
-      expect(parsed).toEqual(testData);
-    });
-
-    test('toCsv should generate CSV format', () => {
-      const csv = result.toCsv();
-      const lines = csv.split('\n');
-      
-      expect(lines.length).toBe(6); // Header + 5 data rows
-      expect(lines[0]).toContain('id,name,age,department,salary,active');
-      expect(lines[1]).toContain('1,Alice,30,Engineering,75000,true');
-    });
-
-    test('toCsv should handle custom delimiter', () => {
-      const tsv = result.toCsv('\t');
-      expect(tsv).toContain('\t');
-      expect(tsv.split('\n')[0]).toContain('id\tname\tage');
-    });
-
-    test('toCsv should escape values with delimiters', () => {
-      const dataWithCommas = [
-        { name: 'Smith, John', description: 'A person, who works' }
-      ];
-      const resultWithCommas = createQueryResult(dataWithCommas);
-      const csv = resultWithCommas.toCsv();
-      
-      expect(csv).toContain('"Smith, John"');
-      expect(csv).toContain('"A person, who works"');
-    });
+  test('toJSON() returns valid JSON string of the data', () => {
+    const json = result.toJSON();
+    expect(JSON.parse(json)).toEqual(testData);
   });
 
-  describe('Nested field access', () => {
-    const nestedData = [
-      {
-        id: 1,
-        user: {
-          profile: {
-            name: 'Alice',
-            age: 30
-          },
-          settings: {
-            theme: 'dark'
-          }
-        }
-      },
-      {
-        id: 2,
-        user: {
-          profile: {
-            name: 'Bob',
-            age: 25
-          },
-          settings: {
-            theme: 'light'
-          }
-        }
-      }
-    ];
-
-    test('should handle nested field plucking', () => {
-      const nestedResult = createQueryResult(nestedData);
-      
-      const names = nestedResult.pluck('user.profile.name');
-      expect(names).toEqual(['Alice', 'Bob']);
-      
-      const ages = nestedResult.pluck('user.profile.age');
-      expect(ages).toEqual([30, 25]);
-    });
-
-    test('should handle nested field sorting', () => {
-      const nestedResult = createQueryResult(nestedData);
-      const sorted = nestedResult.sortBy('user.profile.age');
-      
-      expect(sorted[0].user.profile.name).toBe('Bob');
-      expect(sorted[1].user.profile.name).toBe('Alice');
-    });
-
-    test('should handle nested field grouping', () => {
-      const nestedResult = createQueryResult(nestedData);
-      const grouped = nestedResult.groupBy('user.settings.theme');
-      
-      expect(grouped['dark']).toHaveLength(1);
-      expect(grouped['light']).toHaveLength(1);
-    });
-
-    test('should handle missing nested fields gracefully', () => {
-      const dataWithMissing = [
-        { id: 1, user: { profile: { name: 'Alice' } } },
-        { id: 2, user: { name: 'Bob' } }, // Missing profile
-        { id: 3 } // Missing user entirely
-      ];
-      
-      const resultWithMissing = createQueryResult(dataWithMissing);
-      const names = resultWithMissing.pluck('user.profile.name');
-      
-      expect(names).toEqual(['Alice', undefined, undefined]);
-    });
+  test('cast() returns a new QueryResult with the same data', () => {
+    const casted = result.cast<{ id: number; name: string }>();
+    expect(casted).toBeInstanceOf(QueryResult);
+    expect(casted.len()).toBe(3);
+    expect(casted.first()?.name).toBe('Alice');
   });
 
-  describe('Type casting and transformation', () => {
-    test('cast should change type', () => {
-      const casted = result.cast<{ id: number; name: string }>();
-      expect(casted).toBeInstanceOf(QueryResult);
-      expect(casted.len()).toBe(5);
-    });
-  });
-
-  describe('Debugging and inspection', () => {
-    test('inspect should not throw error', () => {
-      // Mock console.log to prevent output during tests
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      
-      result.inspect();
-      expect(consoleSpy).toHaveBeenCalled();
-      
-      result.inspect(2); // Limited output
-      expect(consoleSpy).toHaveBeenCalledTimes(2);
-      
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('Edge cases', () => {
-    test('should handle empty arrays gracefully', () => {
-      const emptyResult = createQueryResult([]);
-      
-      expect(emptyResult.len()).toBe(0);
-      expect(emptyResult.isEmpty()).toBe(true);
-      expect(emptyResult.first()).toBeUndefined();
-      expect(emptyResult.summarizeNumeric('age')).toBeNull();
-      expect(emptyResult.groupBy('department')).toEqual({});
-    });
-
-    test('should handle invalid field names', () => {
-      const invalidSummary = result.summarizeNumeric('nonexistent');
-      expect(invalidSummary).toBeNull();
-      
-      const invalidPluck = result.pluck('nonexistent');
-      expect(invalidPluck.every(val => val === undefined)).toBe(true);
-    });
+  test('constructor wraps a single non-array item in an array', () => {
+    const single = createQueryResult({ id: 1, name: 'Test' } as any);
+    expect(single.len()).toBe(1);
+    expect((single.first() as any)?.name).toBe('Test');
   });
-});
+});