@onchaindb/sdk 0.4.5 → 2.0.0

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

@@ -2,320 +2,240 @@ import { NestedConditionBuilder, NestedFieldConditionBuilder } from '../NestedBu
 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);
+    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.toComposable()).toEqual({ user: { name: { is: 'John' } } });
+        });
+
+        test('should handle multi-level nesting', () => {
+            const condition = new NestedFieldConditionBuilder(['user', 'profile', 'bio']).contains('developer');
+            expect(condition.toComposable()).toEqual({ user: { profile: { bio: { includes: 'developer' } } } });
+        });
+    });
+
+    describe('Logical groups', () => {
+        test('should create AND groups', () => {
+            const andGroup = nestedBuilder.andGroup(builder => [
+                builder.field('name').equals('John'),
+                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 => [
+                builder.field('status').equals('active'),
+                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 => [
+                builder.field('deleted').isTrue()
+            ]);
+            expect(notGroup.type).toBe('not');
+            expect(notGroup.conditions).toHaveLength(1);
+        });
+
+        test('variadic and/or/not methods', () => {
+            const and = nestedBuilder.and(
+                nestedBuilder.field('a').equals(1),
+                nestedBuilder.field('b').equals(2)
+            );
+            expect(and.type).toBe('and');
+            expect(and.conditions).toHaveLength(2);
+        });
+    });
+
+    describe('Nested structure creation', () => {
+        test('should create nested callback structure', () => {
+            const nested = nestedBuilder.nested('profile', nested =>
+                nested.field('bio').equals('Developer')
+            );
+            expect(nested.type).toBe('condition');
+        });
     });
-  });
-
-  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');
+    let fieldBuilder: NestedFieldConditionBuilder;
+
+    beforeEach(() => {
+        fieldBuilder = new NestedFieldConditionBuilder(['user', 'profile', 'details']);
+    });
+
+    describe('Path construction', () => {
+        test('should construct correct field path', () => {
+            expect(fieldBuilder.equals('test').condition?.field).toBe('user.profile.details');
+        });
+
+        test('should work with single-level path', () => {
+            const singleLevel = new NestedFieldConditionBuilder(['name']);
+            expect(singleLevel.equals('John').toComposable()).toEqual({ name: { is: 'John' } });
+        });
+
+        test('should work with deep nesting', () => {
+            const deepNesting = new NestedFieldConditionBuilder(['a', 'b', 'c', 'd', 'e']);
+            expect(deepNesting.contains('value').toComposable()).toEqual({
+                a: { b: { c: { d: { e: { includes: 'value' } } } } }
+            });
+        });
+    });
+
+    describe('Basic operators', () => {
+        test('equals', () => {
+            expect(fieldBuilder.equals('value').toComposable()).toEqual({
+                user: { profile: { details: { is: 'value' } } }
+            });
+        });
+
+        test('notEquals', () => {
+            expect(fieldBuilder.notEquals('value').toComposable()).toEqual({
+                user: { profile: { details: { isNot: 'value' } } }
+            });
+        });
+
+        test('comparison operators', () => {
+            expect(fieldBuilder.greaterThan(10).condition?.operator).toBe('greaterThan');
+            expect(fieldBuilder.greaterThanOrEqual(10).condition?.operator).toBe('greaterThanOrEqual');
+            expect(fieldBuilder.lessThan(10).condition?.operator).toBe('lessThan');
+            expect(fieldBuilder.lessThanOrEqual(10).condition?.operator).toBe('lessThanOrEqual');
+        });
+    });
+
+    describe('String operators', () => {
+        test('string operations', () => {
+            expect(fieldBuilder.contains('test').condition?.operator).toBe('includes');
+            expect(fieldBuilder.startsWith('pre').condition?.operator).toBe('startsWith');
+            expect(fieldBuilder.endsWith('suf').condition?.operator).toBe('endsWith');
+            expect(fieldBuilder.regExpMatches('.*').condition?.operator).toBe('regExpMatches');
+            expect(fieldBuilder.includesCaseInsensitive('TEST').condition?.operator).toBe('includesCaseInsensitive');
+            expect(fieldBuilder.startsWithCaseInsensitive('PRE').condition?.operator).toBe('startsWithCaseInsensitive');
+            expect(fieldBuilder.endsWithCaseInsensitive('SUF').condition?.operator).toBe('endsWithCaseInsensitive');
+        });
+    });
+
+    describe('Array operators', () => {
+        test('in and notIn', () => {
+            const inCondition = fieldBuilder.in([1, 2, 3]);
+            expect(inCondition.condition?.operator).toBe('in');
+            expect(inCondition.condition?.value).toEqual([1, 2, 3]);
+
+            const notInCondition = fieldBuilder.notIn(['a', 'b']);
+            expect(notInCondition.condition?.operator).toBe('notIn');
+            expect(notInCondition.condition?.value).toEqual(['a', 'b']);
+        });
+    });
+
+    describe('Existence operators', () => {
+        test('exists and notExists', () => {
+            expect(fieldBuilder.exists().toComposable()).toEqual({
+                user: { profile: { details: { exists: true } } }
+            });
+            expect(fieldBuilder.notExists().toComposable()).toEqual({
+                user: { profile: { details: { exists: false } } }
+            });
+        });
+
+        test('isNull and isNotNull', () => {
+            expect(fieldBuilder.isNull().toComposable()).toEqual({
+                user: { profile: { details: { isNull: true } } }
+            });
+            expect(fieldBuilder.isNotNull().toComposable()).toEqual({
+                user: { profile: { details: { isNull: false } } }
+            });
+        });
+    });
+
+    describe('Numeric operators', () => {
+        test('between uses betweenOp with from/to', () => {
+            const betweenCondition = fieldBuilder.between(10, 20);
+            expect(betweenCondition.condition?.operator).toBe('betweenOp');
+            expect(betweenCondition.condition?.value).toEqual({ from: 10, to: 20 });
+        });
+    });
+
+    describe('Misc operators', () => {
+        test('b64, inCountry, inDataset, cidr', () => {
+            expect(fieldBuilder.b64('dGVzdA==').condition?.operator).toBe('b64');
+            expect(fieldBuilder.inCountry('US').condition?.operator).toBe('inCountry');
+            expect(fieldBuilder.inDataset('malware_ips').condition?.operator).toBe('inDataset');
+            expect(fieldBuilder.cidr('192.168.1.0/24').condition?.operator).toBe('CIDR');
+        });
+
+        test('IP operators', () => {
+            expect(fieldBuilder.isLocalIp().condition?.operator).toBe('isLocalIp');
+            expect(fieldBuilder.isExternalIp().condition?.operator).toBe('isExternalIp');
+        });
+    });
+
+    describe('Boolean convenience', () => {
+        test('isTrue and isFalse', () => {
+            expect(fieldBuilder.isTrue().toComposable()).toEqual({
+                user: { profile: { details: { is: true } } }
+            });
+            expect(fieldBuilder.isFalse().toComposable()).toEqual({
+                user: { profile: { details: { is: false } } }
+            });
+        });
+    });
+
+    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.condition?.field).toBe('level1.level2.level3.level4.level5.finalField');
+            expect(condition.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.condition?.field).toBe('user-profile.bio_text.data@field');
+        });
     });
-  });
-
-  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');
-  });
-});
+    test('should have correct type and condition from NestedFieldConditionBuilder', () => {
+        const condition = new NestedFieldConditionBuilder(['user', 'profile', 'name']).equals('John');
+        expect(condition.type).toBe('condition');
+        expect(condition.condition?.field).toBe('user.profile.name');
+    });
+
+    test('should work in complex logical structures', () => {
+        const nestedBuilder = new NestedConditionBuilder('user');
+        const complexLogic = LogicalOperator.And([
+            new NestedFieldConditionBuilder(['user', 'profile', 'name']).equals('John'),
+            LogicalOperator.Or([
+                nestedBuilder.field('status').equals('active'),
+                nestedBuilder.field('status').equals('pending')
+            ]),
+            LogicalOperator.Not([
+                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

@@ -78,8 +78,8 @@ describe('QueryBuilder', () => {
         .collection('users')
         .find(builder =>
           LogicalOperator.And([
-            LogicalOperator.Condition(new FieldConditionBuilder('name').equals('John')),
-            LogicalOperator.Condition(new FieldConditionBuilder('age').greaterThan(25))
+            new FieldConditionBuilder('name').equals('John'),
+            new FieldConditionBuilder('age').greaterThan(25)
           ])
         )
         .buildRawQuery();
@@ -97,8 +97,8 @@ describe('QueryBuilder', () => {
         .collection('users')
         .find(builder =>
           LogicalOperator.Or([
-            LogicalOperator.Condition(new FieldConditionBuilder('role').equals('admin')),
-            LogicalOperator.Condition(new FieldConditionBuilder('role').equals('moderator'))
+            new FieldConditionBuilder('role').equals('admin'),
+            new FieldConditionBuilder('role').equals('moderator')
           ])
         )
         .buildRawQuery();
@@ -116,7 +116,7 @@ describe('QueryBuilder', () => {
         .collection('users')
         .find(builder =>
           LogicalOperator.Not([
-            LogicalOperator.Condition(new FieldConditionBuilder('status').equals('banned'))
+            new FieldConditionBuilder('status').equals('banned')
           ])
         )
         .buildRawQuery();