@onchaindb/sdk 0.4.5 → 2.0.0

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

@@ -1,327 +0,0 @@
-import { FieldConditionBuilder, LogicalOperator, createNestedQuery } from '../operators';
-
-describe('FieldConditionBuilder', () => {
-  let builder: FieldConditionBuilder;
-
-  beforeEach(() => {
-    builder = new FieldConditionBuilder('testField');
-  });
-
-  describe('Basic operators', () => {
-    test('equals creates correct condition', () => {
-      const condition = builder.equals('value');
-      expect(condition.field).toBe('testField');
-      expect(condition.operator).toBe('is');
-      expect(condition.value).toBe('value');
-    });
-
-    test('notEquals creates correct condition', () => {
-      const condition = builder.notEquals('value');
-      expect(condition.field).toBe('testField');
-      expect(condition.operator).toBe('isNot');
-      expect(condition.value).toBe('value');
-    });
-
-    test('greaterThan creates correct condition', () => {
-      const condition = builder.greaterThan(10);
-      expect(condition.operator).toBe('greaterThan');
-      expect(condition.value).toBe(10);
-    });
-
-    test('lessThan creates correct condition', () => {
-      const condition = builder.lessThan(10);
-      expect(condition.operator).toBe('lessThan');
-      expect(condition.value).toBe(10);
-    });
-  });
-
-  describe('String operators', () => {
-    test('contains creates correct condition', () => {
-      const condition = builder.contains('substring');
-      expect(condition.operator).toBe('includes');
-      expect(condition.value).toBe('substring');
-    });
-
-    test('startsWith creates correct condition', () => {
-      const condition = builder.startsWith('prefix');
-      expect(condition.operator).toBe('startsWith');
-      expect(condition.value).toBe('prefix');
-    });
-
-    test('endsWith creates correct condition', () => {
-      const condition = builder.endsWith('suffix');
-      expect(condition.operator).toBe('endsWith');
-      expect(condition.value).toBe('suffix');
-    });
-
-    test('regExpMatches creates correct condition', () => {
-      const pattern = '.*test.*';
-      const condition = builder.regExpMatches(pattern);
-      expect(condition.operator).toBe('regExpMatches');
-      expect(condition.value).toBe(pattern);
-    });
-  });
-
-  describe('Array operators', () => {
-    test('in creates correct condition', () => {
-      const values = [1, 2, 3];
-      const condition = builder.in(values);
-      expect(condition.operator).toBe('in');
-      expect(condition.value).toEqual(values);
-    });
-
-    test('notIn creates correct condition', () => {
-      const values = ['a', 'b', 'c'];
-      const condition = builder.notIn(values);
-      expect(condition.operator).toBe('notIn');
-      expect(condition.value).toEqual(values);
-    });
-
-    test('arrayLength creates correct condition', () => {
-      const condition = builder.arrayLength(5);
-      expect(condition.operator).toBe('arrayLength');
-      expect(condition.value).toBe(5);
-    });
-  });
-
-  describe('Null/existence operators', () => {
-    test('exists creates correct condition', () => {
-      const condition = builder.exists();
-      expect(condition.operator).toBe('exists');
-      expect(condition.value).toBe(true);
-    });
-
-    test('notExists creates correct condition', () => {
-      const condition = builder.notExists();
-      expect(condition.operator).toBe('exists');
-      expect(condition.value).toBe(false);
-    });
-
-    test('isNull creates correct condition', () => {
-      const condition = builder.isNull();
-      expect(condition.operator).toBe('isNull');
-      expect(condition.value).toBe(true);
-    });
-
-    test('isNotNull creates correct condition', () => {
-      const condition = builder.isNotNull();
-      expect(condition.operator).toBe('isNull');
-      expect(condition.value).toBe(false);
-    });
-  });
-
-  describe('Date operators', () => {
-    const testDate = new Date('2024-01-01');
-
-    test('dateEquals creates correct condition', () => {
-      const condition = builder.dateEquals(testDate);
-      expect(condition.operator).toBe('dateEquals');
-      expect(condition.value).toBe(testDate);
-    });
-
-    test('dateBefore creates correct condition', () => {
-      const condition = builder.dateBefore(testDate);
-      expect(condition.operator).toBe('dateBefore');
-      expect(condition.value).toBe(testDate);
-    });
-
-    test('dateAfter creates correct condition', () => {
-      const condition = builder.dateAfter(testDate);
-      expect(condition.operator).toBe('dateAfter');
-      expect(condition.value).toBe(testDate);
-    });
-
-    test('dateToday creates correct condition', () => {
-      const condition = builder.dateToday();
-      expect(condition.operator).toBe('dateToday');
-      expect(condition.value).toBe(true);
-    });
-  });
-
-  describe('Numeric operators', () => {
-    test('between creates correct condition', () => {
-      const condition = builder.between(10, 20);
-      expect(condition.operator).toBe('between');
-      expect(condition.value).toEqual({ min: 10, max: 20 });
-    });
-
-    test('notBetween creates correct condition', () => {
-      const condition = builder.notBetween(5, 15);
-      expect(condition.operator).toBe('notBetween');
-      expect(condition.value).toEqual({ min: 5, max: 15 });
-    });
-  });
-
-  describe('Type checking operators', () => {
-    test('isString creates correct condition', () => {
-      const condition = builder.isString();
-      expect(condition.operator).toBe('isString');
-      expect(condition.value).toBe(true);
-    });
-
-    test('isNumber creates correct condition', () => {
-      const condition = builder.isNumber();
-      expect(condition.operator).toBe('isNumber');
-      expect(condition.value).toBe(true);
-    });
-
-    test('isBoolean creates correct condition', () => {
-      const condition = builder.isBoolean();
-      expect(condition.operator).toBe('isBoolean');
-      expect(condition.value).toBe(true);
-    });
-  });
-
-  describe('IP address operators', () => {
-    test('ipEquals creates correct condition', () => {
-      const condition = builder.ipEquals('192.168.1.1');
-      expect(condition.operator).toBe('ipEquals');
-      expect(condition.value).toBe('192.168.1.1');
-    });
-
-    test('ipInRange creates correct condition', () => {
-      const condition = builder.ipInRange('192.168.1.0/24');
-      expect(condition.operator).toBe('ipInRange');
-      expect(condition.value).toBe('192.168.1.0/24');
-    });
-  });
-
-  describe('Geographical operators', () => {
-    test('geoWithinRadius creates correct condition', () => {
-      const condition = builder.geoWithinRadius(40.7128, -74.0060, 10);
-      expect(condition.operator).toBe('geoWithinRadius');
-      expect(condition.value).toEqual({
-        latitude: 40.7128,
-        longitude: -74.0060,
-        radiusKm: 10
-      });
-    });
-
-    test('geoWithinBounds creates correct condition', () => {
-      const northEast = { lat: 40.8, lng: -74.0 };
-      const southWest = { lat: 40.6, lng: -74.2 };
-      const condition = builder.geoWithinBounds(northEast, southWest);
-      expect(condition.operator).toBe('geoWithinBounds');
-      expect(condition.value).toEqual({ northEast, southWest });
-    });
-  });
-});
-
-describe('LogicalOperator', () => {
-  test('Condition creates correct logical operator', () => {
-    const condition = new FieldConditionBuilder('name').equals('John');
-    const logicalOp = LogicalOperator.Condition(condition);
-    
-    expect(logicalOp.type).toBe('condition');
-    expect(logicalOp.condition).toBe(condition);
-  });
-
-  test('And creates correct logical operator', () => {
-    const condition1 = LogicalOperator.Condition(new FieldConditionBuilder('name').equals('John'));
-    const condition2 = LogicalOperator.Condition(new FieldConditionBuilder('age').greaterThan(25));
-    
-    const andOp = LogicalOperator.And([condition1, condition2]);
-    expect(andOp.type).toBe('and');
-    expect(andOp.conditions).toHaveLength(2);
-  });
-
-  test('Or creates correct logical operator', () => {
-    const condition1 = LogicalOperator.Condition(new FieldConditionBuilder('status').equals('active'));
-    const condition2 = LogicalOperator.Condition(new FieldConditionBuilder('status').equals('pending'));
-    
-    const orOp = LogicalOperator.Or([condition1, condition2]);
-    expect(orOp.type).toBe('or');
-    expect(orOp.conditions).toHaveLength(2);
-  });
-
-  test('Not creates correct logical operator', () => {
-    const condition = LogicalOperator.Condition(new FieldConditionBuilder('deleted').isTrue());
-    const notOp = LogicalOperator.Not([condition]);
-    
-    expect(notOp.type).toBe('not');
-    expect(notOp.conditions).toHaveLength(1);
-  });
-});
-
-describe('Dot notation', () => {
-  test('createNestedQuery handles simple field', () => {
-    const result = createNestedQuery('name', 'is', 'John');
-    expect(result).toEqual({
-      name: { is: 'John' }
-    });
-  });
-
-  test('createNestedQuery handles nested field', () => {
-    const result = createNestedQuery('user.profile.name', 'is', 'John');
-    expect(result).toEqual({
-      user: {
-        profile: {
-          name: {
-            is: 'John'
-          }
-        }
-      }
-    });
-  });
-
-  test('createNestedQuery handles deep nesting', () => {
-    const result = createNestedQuery('a.b.c.d', 'contains', 'test');
-    expect(result).toEqual({
-      a: {
-        b: {
-          c: {
-            d: {
-              contains: 'test'
-            }
-          }
-        }
-      }
-    });
-  });
-
-  test('LogicalOperator.toComposable integrates with dot notation', () => {
-    const condition = new FieldConditionBuilder('user.profile.bio').equals('Developer');
-    const logicalOp = LogicalOperator.Condition(condition);
-    const composable = logicalOp.toComposable();
-    
-    expect(composable).toEqual({
-      user: {
-        profile: {
-          bio: {
-            is: 'Developer'
-          }
-        }
-      }
-    });
-  });
-
-  test('LogicalOperator.toComposable handles complex logical operations', () => {
-    const condition1 = new FieldConditionBuilder('user.name').equals('John');
-    const condition2 = new FieldConditionBuilder('user.age').greaterThan(25);
-    
-    const andOp = LogicalOperator.And([
-      LogicalOperator.Condition(condition1),
-      LogicalOperator.Condition(condition2)
-    ]);
-    
-    const composable = andOp.toComposable();
-    expect(composable).toEqual({
-      and: [
-        {
-          user: {
-            name: {
-              is: 'John'
-            }
-          }
-        },
-        {
-          user: {
-            age: {
-              greaterThan: 25
-            }
-          }
-        }
-      ]
-    });
-  });
-});