@onchaindb/sdk 0.4.0 → 0.4.2

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

@@ -0,0 +1,321 @@
+import { NestedConditionBuilder, NestedFieldConditionBuilder } from '../NestedBuilders';
+import { LogicalOperator } from '../operators';
+
+describe('NestedConditionBuilder', () => {
+  let nestedBuilder: NestedConditionBuilder;
+
+  beforeEach(() => {
+    nestedBuilder = new NestedConditionBuilder('user');
+  });
+
+  describe('Basic nested building', () => {
+    test('should create nested field condition builder', () => {
+      const fieldBuilder = nestedBuilder.field('name');
+      expect(fieldBuilder).toBeInstanceOf(NestedFieldConditionBuilder);
+    });
+
+    test('should create condition with correct path', () => {
+      const condition = nestedBuilder.field('name').equals('John');
+      expect(condition.field).toBe('user.name');
+      expect(condition.operator).toBe('is');
+      expect(condition.value).toBe('John');
+    });
+
+    test('should handle multi-level nesting', () => {
+      const condition = new NestedFieldConditionBuilder(['user', 'profile', 'bio']).contains('developer');
+      expect(condition.field).toBe('user.profile.bio');
+      expect(condition.operator).toBe('includes');
+      expect(condition.value).toBe('developer');
+    });
+  });
+
+  describe('Logical groups', () => {
+    test('should create AND groups', () => {
+      const andGroup = nestedBuilder.andGroup(builder => [
+        LogicalOperator.Condition(builder.field('name').equals('John')),
+        LogicalOperator.Condition(builder.field('age').greaterThan(25))
+      ]);
+
+      expect(andGroup.type).toBe('and');
+      expect(andGroup.conditions).toHaveLength(2);
+    });
+
+    test('should create OR groups', () => {
+      const orGroup = nestedBuilder.orGroup(builder => [
+        LogicalOperator.Condition(builder.field('status').equals('active')),
+        LogicalOperator.Condition(builder.field('status').equals('pending'))
+      ]);
+
+      expect(orGroup.type).toBe('or');
+      expect(orGroup.conditions).toHaveLength(2);
+    });
+
+    test('should create NOT groups', () => {
+      const notGroup = nestedBuilder.notGroup(builder => [
+        LogicalOperator.Condition(builder.field('deleted').isTrue())
+      ]);
+
+      expect(notGroup.type).toBe('not');
+      expect(notGroup.conditions).toHaveLength(1);
+    });
+  });
+
+  describe('Nested structure creation', () => {
+    test('should create nested callback structure', () => {
+      const nested = nestedBuilder.nested('profile', nested => 
+        LogicalOperator.Condition(nested.field('bio').equals('Developer'))
+      );
+
+      expect(nested.type).toBe('condition');
+    });
+  });
+});
+
+describe('NestedFieldConditionBuilder', () => {
+  let fieldBuilder: NestedFieldConditionBuilder;
+
+  beforeEach(() => {
+    fieldBuilder = new NestedFieldConditionBuilder(['user', 'profile', 'details']);
+  });
+
+  describe('Path construction', () => {
+    test('should construct correct field path', () => {
+      const condition = fieldBuilder.equals('test');
+      expect(condition.field).toBe('user.profile.details');
+    });
+
+    test('should work with single-level path', () => {
+      const singleLevel = new NestedFieldConditionBuilder(['name']);
+      const condition = singleLevel.equals('John');
+      expect(condition.field).toBe('name');
+    });
+
+    test('should work with deep nesting', () => {
+      const deepNesting = new NestedFieldConditionBuilder(['a', 'b', 'c', 'd', 'e']);
+      const condition = deepNesting.contains('value');
+      expect(condition.field).toBe('a.b.c.d.e');
+    });
+  });
+
+  describe('Basic operators', () => {
+    test('equals should create correct condition', () => {
+      const condition = fieldBuilder.equals('value');
+      expect(condition.field).toBe('user.profile.details');
+      expect(condition.operator).toBe('is');
+      expect(condition.value).toBe('value');
+    });
+
+    test('notEquals should create correct condition', () => {
+      const condition = fieldBuilder.notEquals('value');
+      expect(condition.operator).toBe('isNot');
+      expect(condition.value).toBe('value');
+    });
+
+    test('comparison operators should work correctly', () => {
+      expect(fieldBuilder.greaterThan(10).operator).toBe('greaterThan');
+      expect(fieldBuilder.greaterThanOrEqual(10).operator).toBe('greaterThanOrEqual');
+      expect(fieldBuilder.lessThan(10).operator).toBe('lessThan');
+      expect(fieldBuilder.lessThanOrEqual(10).operator).toBe('lessThanOrEqual');
+    });
+  });
+
+  describe('String operators', () => {
+    test('string operations should work correctly', () => {
+      expect(fieldBuilder.contains('test').operator).toBe('includes');
+      expect(fieldBuilder.startsWith('pre').operator).toBe('startsWith');
+      expect(fieldBuilder.endsWith('suf').operator).toBe('endsWith');
+      expect(fieldBuilder.regExpMatches('.*').operator).toBe('regExpMatches');
+      expect(fieldBuilder.includesCaseInsensitive('TEST').operator).toBe('includesCaseInsensitive');
+    });
+
+    test('wildcard operators should work correctly', () => {
+      expect(fieldBuilder.wildcard('*.txt').operator).toBe('wildcard');
+      expect(fieldBuilder.glob('**/*.js').operator).toBe('glob');
+    });
+  });
+
+  describe('Array operators', () => {
+    test('list operations should work correctly', () => {
+      const inCondition = fieldBuilder.in([1, 2, 3]);
+      expect(inCondition.operator).toBe('in');
+      expect(inCondition.value).toEqual([1, 2, 3]);
+
+      const notInCondition = fieldBuilder.notIn(['a', 'b']);
+      expect(notInCondition.operator).toBe('notIn');
+      expect(notInCondition.value).toEqual(['a', 'b']);
+    });
+
+    test('base operators should work correctly', () => {
+      expect(fieldBuilder.equals('value').operator).toBe('is');
+      expect(fieldBuilder.notEquals('value').operator).toBe('isNot');
+      expect(fieldBuilder.isNull().operator).toBe('isNull');
+      expect(fieldBuilder.isNotNull().operator).toBe('isNull');
+    });
+  });
+
+  describe('Existence operators', () => {
+    test('existence checks should work correctly', () => {
+      expect(fieldBuilder.exists().operator).toBe('exists');
+      expect(fieldBuilder.exists().value).toBe(true);
+      
+      expect(fieldBuilder.notExists().operator).toBe('exists');
+      expect(fieldBuilder.notExists().value).toBe(false);
+    });
+
+    test('null checks should work correctly', () => {
+      expect(fieldBuilder.isNull().operator).toBe('isNull');
+      expect(fieldBuilder.isNull().value).toBe(true);
+      
+      expect(fieldBuilder.isNotNull().operator).toBe('isNull');
+      expect(fieldBuilder.isNotNull().value).toBe(false);
+    });
+
+    test('empty checks should work correctly', () => {
+      expect(fieldBuilder.isEmpty().operator).toBe('isEmpty');
+      expect(fieldBuilder.isEmpty().value).toBe(true);
+      
+      expect(fieldBuilder.isNotEmpty().operator).toBe('isEmpty');
+      expect(fieldBuilder.isNotEmpty().value).toBe(false);
+    });
+  });
+
+  describe('Numeric operators', () => {
+    test('number operations should work correctly', () => {
+      const betweenCondition = fieldBuilder.between(10, 20);
+      expect(betweenCondition.operator).toBe('betweenOp');
+      expect(betweenCondition.value).toEqual({ from: 10, to: 20 });
+
+      expect(fieldBuilder.greaterThan(100).operator).toBe('greaterThan');
+      expect(fieldBuilder.lessThan(500).operator).toBe('lessThan');
+      expect(fieldBuilder.greaterThanOrEqual(100).operator).toBe('greaterThanOrEqual');
+      expect(fieldBuilder.lessThanOrEqual(500).operator).toBe('lessThanOrEqual');
+    });
+  });
+
+  describe('Misc operators', () => {
+    test('misc operators should work correctly', () => {
+      expect(fieldBuilder.b64('dGVzdA==').operator).toBe('b64');
+      expect(fieldBuilder.inCountry('US').operator).toBe('inCountry');
+      expect(fieldBuilder.inDataset('malware_ips').operator).toBe('inDataset');
+      expect(fieldBuilder.cidr('192.168.1.0/24').operator).toBe('CIDR');
+    });
+  });
+
+  describe('Boolean operators', () => {
+    test('boolean checks should work correctly', () => {
+      const trueCondition = fieldBuilder.isTrue();
+      expect(trueCondition.operator).toBe('is');
+      expect(trueCondition.value).toBe(true);
+
+      const falseCondition = fieldBuilder.isFalse();
+      expect(falseCondition.operator).toBe('is');
+      expect(falseCondition.value).toBe(false);
+    });
+  });
+
+  describe('Type checking operators', () => {
+    test('type validation operators should work correctly', () => {
+      expect(fieldBuilder.isString().operator).toBe('isString');
+      expect(fieldBuilder.isNumber().operator).toBe('isNumber');
+      expect(fieldBuilder.isBoolean().operator).toBe('isBoolean');
+      expect(fieldBuilder.isArray().operator).toBe('isArray');
+      expect(fieldBuilder.isObject().operator).toBe('isObject');
+    });
+  });
+
+  describe('String operators', () => {
+    test('string operators should work correctly', () => {
+      expect(fieldBuilder.startsWith('prefix').operator).toBe('startsWith');
+      expect(fieldBuilder.endsWith('suffix').operator).toBe('endsWith');
+      expect(fieldBuilder.contains('substring').operator).toBe('includes');
+      expect(fieldBuilder.regExpMatches('^test.*').operator).toBe('regExpMatches');
+      expect(fieldBuilder.includesCaseInsensitive('Test').operator).toBe('includesCaseInsensitive');
+    });
+  });
+
+  describe('IP address operators', () => {
+    test('IP address operations should work correctly', () => {
+      expect(fieldBuilder.isLocalIp().operator).toBe('isLocalIp');
+      expect(fieldBuilder.isExternalIp().operator).toBe('isExternalIp');
+      expect(fieldBuilder.inCountry('US').operator).toBe('inCountry');
+      expect(fieldBuilder.cidr('192.168.1.0/24').operator).toBe('CIDR');
+      expect(fieldBuilder.b64('dGVzdA==').operator).toBe('b64');
+      expect(fieldBuilder.inDataset('malware_ips').operator).toBe('inDataset');
+    });
+  });
+
+  describe('Number operators', () => {
+    test('number operations should work correctly', () => {
+      expect(fieldBuilder.greaterThan(100).operator).toBe('greaterThan');
+      expect(fieldBuilder.lessThan(500).operator).toBe('lessThan');
+      expect(fieldBuilder.greaterThanOrEqual(100).operator).toBe('greaterThanOrEqual');
+      expect(fieldBuilder.lessThanOrEqual(500).operator).toBe('lessThanOrEqual');
+      expect(fieldBuilder.between(100, 500).operator).toBe('betweenOp');
+    });
+  });
+
+  describe('Complex scenarios', () => {
+    test('should work with very deep nesting', () => {
+      const deepPath = ['level1', 'level2', 'level3', 'level4', 'level5', 'finalField'];
+      const deepBuilder = new NestedFieldConditionBuilder(deepPath);
+      const condition = deepBuilder.equals('deep_value');
+      
+      expect(condition.field).toBe('level1.level2.level3.level4.level5.finalField');
+      expect(condition.value).toBe('deep_value');
+    });
+
+    test('should handle special characters in field names', () => {
+      const specialPath = ['user-profile', 'bio_text', 'data@field'];
+      const specialBuilder = new NestedFieldConditionBuilder(specialPath);
+      const condition = specialBuilder.contains('text');
+      
+      expect(condition.field).toBe('user-profile.bio_text.data@field');
+    });
+
+    test('should work with all operator types in nested context', () => {
+      const nestedBuilder = new NestedConditionBuilder('order');
+      const itemsBuilder = nestedBuilder.field('items');
+      
+      // Test that we can chain multiple field levels
+      const priceCondition = itemsBuilder.field('price').greaterThan(100);
+      expect(priceCondition.field).toBe('order.items.price');
+      
+      const categoryCondition = itemsBuilder.field('category').equals('electronics');
+      expect(categoryCondition.field).toBe('order.items.category');
+      
+      const stockCondition = itemsBuilder.field('stock').exists();
+      expect(stockCondition.field).toBe('order.items.stock');
+    });
+  });
+});
+
+describe('Integration with LogicalOperator', () => {
+  test('should work correctly with LogicalOperator.Condition', () => {
+    const nestedBuilder = new NestedConditionBuilder('user');
+    const condition = new NestedFieldConditionBuilder(['user', 'profile', 'name']).equals('John');
+    const logicalOp = LogicalOperator.Condition(condition);
+    
+    expect(logicalOp.type).toBe('condition');
+    expect(logicalOp.condition?.field).toBe('user.profile.name');
+  });
+
+  test('should work in complex logical structures', () => {
+    const nestedBuilder = new NestedConditionBuilder('user');
+    
+    const complexLogic = LogicalOperator.And([
+      LogicalOperator.Condition(new NestedFieldConditionBuilder(['user', 'profile', 'name']).equals('John')),
+      LogicalOperator.Or([
+        LogicalOperator.Condition(nestedBuilder.field('status').equals('active')),
+        LogicalOperator.Condition(nestedBuilder.field('status').equals('pending'))
+      ]),
+      LogicalOperator.Not([
+        LogicalOperator.Condition(new NestedFieldConditionBuilder(['user', 'flags', 'deleted']).isTrue())
+      ])
+    ]);
+
+    expect(complexLogic.type).toBe('and');
+    expect(complexLogic.conditions).toHaveLength(3);
+    expect(complexLogic.conditions[1].type).toBe('or');
+    expect(complexLogic.conditions[2].type).toBe('not');
+  });
+});

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

@@ -0,0 +1,348 @@
+import { QueryBuilder, FieldConditionBuilder, LogicalOperator } from '../index';
+import { MockHttpClient, createMockResponse } from './setup';
+
+describe('QueryBuilder', () => {
+  let mockClient: MockHttpClient;
+  let queryBuilder: QueryBuilder;
+  
+  const serverUrl = 'http://localhost:3000';
+  const app = 'testApp';
+
+  beforeEach(() => {
+    mockClient = new MockHttpClient();
+    queryBuilder = new QueryBuilder(mockClient, serverUrl, app);
+  });
+
+  afterEach(() => {
+    mockClient.clear();
+  });
+
+  describe('Basic query building', () => {
+    test('should create query builder with HTTP client', () => {
+      expect(queryBuilder).toBeInstanceOf(QueryBuilder);
+    });
+
+    test('should build valid raw query', () => {
+      const rawQuery = queryBuilder
+        .collection('users')
+        .whereField('name')
+        .equals('John')
+        .buildRawQuery();
+
+      expect(rawQuery).toMatchObject({
+        find: {
+          name: { is: 'John' }
+        }
+      });
+    });
+
+    test('should validate query correctly', () => {
+      expect(queryBuilder.isValid()).toBe(false);
+      
+      queryBuilder.whereField('name').equals('John');
+      expect(queryBuilder.isValid()).toBe(true);
+    });
+  });
+
+  describe('Method chaining', () => {
+    test('should support fluent API', () => {
+      const result = queryBuilder
+        .collection('users')
+        .whereField('name').equals('John')
+        .limit(10)
+        .offset(0);
+      
+      expect(result).toBe(queryBuilder);
+    });
+
+    test('should build complex query with chaining', () => {
+      const rawQuery = queryBuilder
+        .collection('users')
+        .whereField('active').equals(true)
+        .whereField('age').greaterThan(18)
+        .selectFields(['id', 'name', 'email'])
+        .limit(50)
+        .offset(100)
+        .orderBy('name')
+        .buildRawQuery();
+
+      expect(rawQuery.limit).toBe(50);
+      expect(rawQuery.offset).toBe(100);
+      expect(rawQuery.sortBy).toBe('name');
+    });
+  });
+
+  describe('Complex find conditions', () => {
+    test('should build AND conditions', () => {
+      const rawQuery = queryBuilder
+        .collection('users')
+        .find(builder =>
+          LogicalOperator.And([
+            LogicalOperator.Condition(new FieldConditionBuilder('name').equals('John')),
+            LogicalOperator.Condition(new FieldConditionBuilder('age').greaterThan(25))
+          ])
+        )
+        .buildRawQuery();
+
+      expect(rawQuery.find).toEqual({
+        and: [
+          { name: { is: 'John' } },
+          { age: { greaterThan: 25 } }
+        ]
+      });
+    });
+
+    test('should build OR conditions', () => {
+      const rawQuery = queryBuilder
+        .collection('users')
+        .find(builder =>
+          LogicalOperator.Or([
+            LogicalOperator.Condition(new FieldConditionBuilder('role').equals('admin')),
+            LogicalOperator.Condition(new FieldConditionBuilder('role').equals('moderator'))
+          ])
+        )
+        .buildRawQuery();
+
+      expect(rawQuery.find).toEqual({
+        or: [
+          { role: { is: 'admin' } },
+          { role: { is: 'moderator' } }
+        ]
+      });
+    });
+
+    test('should build NOT conditions', () => {
+      const rawQuery = queryBuilder
+        .collection('users')
+        .find(builder =>
+          LogicalOperator.Not([
+            LogicalOperator.Condition(new FieldConditionBuilder('status').equals('banned'))
+          ])
+        )
+        .buildRawQuery();
+
+      expect(rawQuery.find).toEqual({
+        not: [
+          { status: { is: 'banned' } }
+        ]
+      });
+    });
+  });
+
+  describe('Selection methods', () => {
+    test('should select specific fields', () => {
+      queryBuilder.selectFields(['id', 'name', 'email']);
+      expect(queryBuilder.isValid()).toBe(true);
+    });
+
+    test('should select all fields', () => {
+      queryBuilder.selectAll();
+      expect(queryBuilder.isValid()).toBe(true);
+    });
+  });
+
+  describe('Query execution', () => {
+    test('should execute query successfully', async () => {
+      const mockData = [
+        { id: 1, name: 'John', email: 'john@example.com' },
+        { id: 2, name: 'Jane', email: 'jane@example.com' }
+      ];
+      
+      mockClient.setResponse('/list', createMockResponse(mockData));
+
+      const response = await queryBuilder
+        .collection('users')
+        .whereField('active')
+        .equals(true)
+        .execute();
+
+      expect(response.records).toEqual(mockData);
+      expect(response.total).toBe(2);
+    });
+
+    test('should throw error when HTTP client is missing', async () => {
+      const builderWithoutClient = new QueryBuilder();
+      
+      await expect(
+        builderWithoutClient
+          .collection('users')
+          .whereField('name')
+          .equals('John')
+          .execute()
+      ).rejects.toThrow('HTTP client is required');
+    });
+
+    test('should throw error when server URL is missing', async () => {
+      const builderWithoutUrl = new QueryBuilder(mockClient);
+      
+      await expect(
+        builderWithoutUrl
+          .collection('users')
+          .whereField('name')
+          .equals('John')
+          .execute()
+      ).rejects.toThrow('Server URL is required');
+    });
+  });
+
+  describe('Query cloning', () => {
+    test('should clone query builder', () => {
+      const original = queryBuilder
+        .collection('users')
+        .whereField('name').equals('John')
+        .limit(10);
+
+      const cloned = original.clone();
+      
+      expect(cloned).not.toBe(original);
+      expect(cloned.buildRawQuery().limit).toBe(10);
+    });
+
+    test('should create independent clones', () => {
+      const original = queryBuilder
+        .collection('users')
+        .whereField('name').equals('John');
+
+      const cloned = original.clone();
+      cloned.whereField('age').greaterThan(25);
+
+      const originalQuery = original.buildRawQuery();
+      const clonedQuery = cloned.buildRawQuery();
+
+      // Original should not be affected by clone modifications
+      expect(originalQuery).not.toEqual(clonedQuery);
+    });
+  });
+
+  describe('WhereClause', () => {
+    test('should build conditions via WhereClause', () => {
+      const rawQuery = queryBuilder
+        .collection('users')
+        .whereField('age')
+        .between(18, 65)
+        .buildRawQuery();
+
+      expect(rawQuery.find).toEqual({
+        age: { betweenOp: { from: 18, to: 65 } }
+      });
+    });
+
+    test('should support all operators in WhereClause', () => {
+      // Test a sampling of operators
+      const tests = [
+        { method: 'contains', value: 'test', expected: { includes: 'test' } },
+        { method: 'startsWith', value: 'pre', expected: { startsWith: 'pre' } },
+        { method: 'endsWith', value: 'suf', expected: { endsWith: 'suf' } },
+        { method: 'in', value: [1, 2, 3], expected: { in: [1, 2, 3] } },
+        { method: 'exists', value: undefined, expected: { exists: true } },
+        { method: 'isNull', value: undefined, expected: { isNull: true } }
+      ];
+
+      tests.forEach(({ method, value, expected }) => {
+        const builder = new QueryBuilder(mockClient, serverUrl, app)
+          .collection('test');
+        
+        const whereClause = builder.whereField('field');
+        
+        if (value !== undefined) {
+          (whereClause as any)[method](value);
+        } else {
+          (whereClause as any)[method]();
+        }
+
+        const rawQuery = builder.buildRawQuery();
+        expect(rawQuery.find).toEqual({
+          field: expected
+        });
+      });
+    });
+  });
+
+  describe('Nested field queries', () => {
+    test('should handle dot notation in whereField', () => {
+      const rawQuery = queryBuilder
+        .collection('users')
+        .whereField('user.profile.name')
+        .equals('John')
+        .buildRawQuery();
+
+      expect(rawQuery.find).toEqual({
+        user: {
+          profile: {
+            name: {
+              is: 'John'
+            }
+          }
+        }
+      });
+    });
+
+    test('should handle deeply nested fields', () => {
+      const rawQuery = queryBuilder
+        .collection('data')
+        .whereField('a.b.c.d.e')
+        .contains('value')
+        .buildRawQuery();
+
+      expect(rawQuery.find).toEqual({
+        a: {
+          b: {
+            c: {
+              d: {
+                e: {
+                  includes: 'value'
+                }
+              }
+            }
+          }
+        }
+      });
+    });
+  });
+
+  describe('HTTP client integration', () => {
+    test('should use correct endpoint and request format', async () => {
+      const mockData = [{ id: 1, name: 'Test' }];
+      mockClient.setResponse('/list', createMockResponse(mockData));
+
+      // Spy on the HTTP client to verify the request
+      const postSpy = jest.spyOn(mockClient, 'post');
+
+      await queryBuilder
+        .collection('users')
+        .whereField('name')
+        .equals('Test')
+        .limit(10)
+        .execute();
+
+      expect(postSpy).toHaveBeenCalledWith(
+        `${serverUrl}/list`,
+        expect.objectContaining({
+          find: { name: { is: 'Test' } },
+          limit: 10,
+          root: `${app}::users`
+        }),
+        { 'Content-Type': 'application/json' }
+      );
+    });
+
+    test('should handle HTTP errors gracefully', async () => {
+      // Mock HTTP client that throws an error
+      const errorClient = {
+        async post() {
+          throw new Error('Network error');
+        }
+      };
+
+      const errorBuilder = new QueryBuilder(errorClient, serverUrl, app);
+
+      await expect(
+        errorBuilder
+          .collection('users')
+          .whereField('name')
+          .equals('Test')
+          .execute()
+      ).rejects.toThrow('Query execution failed: Network error');
+    });
+  });
+});