@onchaindb/sdk 0.4.5 → 1.0.0

package/src/query-sdk/index.ts

@@ -47,7 +47,7 @@ export {SelectionBuilder} from './SelectionBuilder';
 export {ConditionBuilder} from './ConditionBuilder';
 export {FieldConditionBuilder, LogicalOperator, Condition} from './operators';
 export {NestedConditionBuilder, NestedFieldConditionBuilder} from './NestedBuilders';
-export {QueryResult, NumericSummary, createQueryResult} from './QueryResult';
+export {QueryResult, createQueryResult} from './QueryResult';
 
 // HTTP Client adapters
 export {

package/src/query-sdk/operators.ts

@@ -1,6 +1,6 @@
 import { BetweenValue, DateRange, Val } from './index';
 
-// Condition represents a single field condition
+// Condition represents a single field condition (internal)
 export interface Condition {
     field: string;
     operator: string;
@@ -18,22 +18,10 @@ export function createNestedQuery(fieldPath: string, operator: string, value: Va
     }
 
     const pathParts = fieldPath.split('.');
-    let result: any = {
-        [operator]: value
-    };
+    let result: any = { [operator]: value };
 
-    // Build nested structure from inside out
     for (let i = pathParts.length - 1; i >= 0; i--) {
-        const part = pathParts[i];
-        if (i === pathParts.length - 1) {
-            result = {
-                [part]: result
-            };
-        } else {
-            result = {
-                [part]: result
-            };
-        }
+        result = { [pathParts[i]]: result };
     }
 
     return result;
@@ -52,8 +40,7 @@ export class LogicalOperator {
         public type: LogicalOperatorType,
         public conditions: LogicalOperator[] = [],
         public condition?: Condition
-    ) {
-    }
+    ) {}
 
     static And(conditions: LogicalOperator[]): LogicalOperator {
         return new LogicalOperator(LogicalOperatorType.AND, conditions);
@@ -71,24 +58,32 @@ export class LogicalOperator {
         return new LogicalOperator(LogicalOperatorType.CONDITION, [], condition);
     }
 
+    // Chain: wrap this operator inside a new AND group with additional conditions
+    and(...conditions: LogicalOperator[]): LogicalOperator {
+        return LogicalOperator.And([this, ...conditions]);
+    }
+
+    // Chain: wrap this operator inside a new OR group with additional conditions
+    or(...conditions: LogicalOperator[]): LogicalOperator {
+        return LogicalOperator.Or([this, ...conditions]);
+    }
+
+    // Chain: wrap this operator inside a new NOT group with additional conditions
+    not(...conditions: LogicalOperator[]): LogicalOperator {
+        return LogicalOperator.Not([this, ...conditions]);
+    }
+
     // Convert to composable query structure for HTTP requests
     toComposable(): any {
         switch (this.type) {
             case LogicalOperatorType.AND:
-                return {
-                    [LogicalOperatorType.AND]: this.conditions.map(c => c.toComposable())
-                };
+                return { [LogicalOperatorType.AND]: this.conditions.map(c => c.toComposable()) };
             case LogicalOperatorType.OR:
-                return {
-                    [LogicalOperatorType.OR]: this.conditions.map(c => c.toComposable())
-                };
+                return { [LogicalOperatorType.OR]: this.conditions.map(c => c.toComposable()) };
             case LogicalOperatorType.NOT:
-                return {
-                    [LogicalOperatorType.NOT]: this.conditions.map(c => c.toComposable())
-                };
+                return { [LogicalOperatorType.NOT]: this.conditions.map(c => c.toComposable()) };
             case LogicalOperatorType.CONDITION:
                 if (!this.condition) throw new Error('Condition is required for CONDITION type');
-                // Use dot notation helper to create nested structures
                 return createNestedQuery(this.condition.field, this.condition.operator, this.condition.value);
             default:
                 throw new Error(`Unknown logical operator type: ${this.type}`);
@@ -96,240 +91,136 @@ export class LogicalOperator {
     }
 }
 
-// Field condition builder for creating individual field conditions
-// Only includes operators that actually exist in the Rust implementation
+// Field condition builder — all methods return LogicalOperator directly.
+// No need to wrap with LogicalOperator.Condition() at call sites.
 export class FieldConditionBuilder {
-    constructor(private fieldName: string) {
+    constructor(private fieldName: string) {}
+
+    private cond(operator: string, value: Val | BetweenValue | DateRange): LogicalOperator {
+        return LogicalOperator.Condition({ field: this.fieldName, operator, value });
     }
 
-    // ===== BASE OPERATORS (BaseOperator) =====
+    // ===== BASE OPERATORS =====
 
-    equals(value: Val): Condition {
-        return {
-            field: this.fieldName,
-            operator: 'is',
-            value
-        };
+    equals(value: Val): LogicalOperator {
+        return this.cond('is', value);
     }
 
-    notEquals(value: Val): Condition {
-        return {
-            field: this.fieldName,
-            operator: 'isNot',
-            value
-        };
+    notEquals(value: Val): LogicalOperator {
+        return this.cond('isNot', value);
     }
 
-    in(values: Val[]): Condition {
-        return {
-            field: this.fieldName,
-            operator: 'in',
-            value: values as any
-        };
+    in(values: Val[]): LogicalOperator {
+        return this.cond('in', values as any);
     }
 
-    notIn(values: Val[]): Condition {
-        return {
-            field: this.fieldName,
-            operator: 'notIn',
-            value: values as any
-        };
+    notIn(values: Val[]): LogicalOperator {
+        return this.cond('notIn', values as any);
     }
 
-    isNull(): Condition {
-        return {
-            field: this.fieldName,
-            operator: 'isNull',
-            value: true
-        };
+    isNull(): LogicalOperator {
+        return this.cond('isNull', true);
     }
 
-    isNotNull(): Condition {
-        return {
-            field: this.fieldName,
-            operator: 'isNull',
-            value: false
-        };
+    isNotNull(): LogicalOperator {
+        return this.cond('isNull', false);
     }
 
-    exists(): Condition {
-        return {
-            field: this.fieldName,
-            operator: 'exists',
-            value: true
-        };
+    exists(): LogicalOperator {
+        return this.cond('exists', true);
     }
 
-    notExists(): Condition {
-        return {
-            field: this.fieldName,
-            operator: 'exists',
-            value: false
-        };
+    notExists(): LogicalOperator {
+        return this.cond('exists', false);
     }
 
-    // ===== STRING OPERATORS (StringOperator) =====
+    // ===== STRING OPERATORS =====
 
-    startsWith(value: string): Condition {
-        return {
-            field: this.fieldName,
-            operator: 'startsWith',
-            value
-        };
+    startsWith(value: string): LogicalOperator {
+        return this.cond('startsWith', value);
     }
 
-    endsWith(value: string): Condition {
-        return {
-            field: this.fieldName,
-            operator: 'endsWith',
-            value
-        };
+    endsWith(value: string): LogicalOperator {
+        return this.cond('endsWith', value);
     }
 
-    contains(value: string): Condition {
-        return {
-            field: this.fieldName,
-            operator: 'includes',
-            value
-        };
+    contains(value: string): LogicalOperator {
+        return this.cond('includes', value);
     }
 
-    regExpMatches(pattern: string): Condition {
-        return {
-            field: this.fieldName,
-            operator: 'regExpMatches',
-            value: pattern
-        };
+    regExpMatches(pattern: string): LogicalOperator {
+        return this.cond('regExpMatches', pattern);
     }
 
-    includesCaseInsensitive(value: string): Condition {
-        return {
-            field: this.fieldName,
-            operator: 'includesCaseInsensitive',
-            value
-        };
+    includesCaseInsensitive(value: string): LogicalOperator {
+        return this.cond('includesCaseInsensitive', value);
     }
 
-    startsWithCaseInsensitive(value: string): Condition {
-        return {
-            field: this.fieldName,
-            operator: 'startsWithCaseInsensitive',
-            value
-        };
+    startsWithCaseInsensitive(value: string): LogicalOperator {
+        return this.cond('startsWithCaseInsensitive', value);
     }
 
-    endsWithCaseInsensitive(value: string): Condition {
-        return {
-            field: this.fieldName,
-            operator: 'endsWithCaseInsensitive',
-            value
-        };
+    endsWithCaseInsensitive(value: string): LogicalOperator {
+        return this.cond('endsWithCaseInsensitive', value);
     }
 
-    // ===== NUMBER OPERATORS (NumberOperator) =====
+    // ===== NUMBER OPERATORS =====
 
-    greaterThan(value: Val): Condition {
-        return {
-            field: this.fieldName,
-            operator: 'greaterThan',
-            value
-        };
+    greaterThan(value: Val): LogicalOperator {
+        return this.cond('greaterThan', value);
     }
 
-    lessThan(value: Val): Condition {
-        return {
-            field: this.fieldName,
-            operator: 'lessThan',
-            value
-        };
+    lessThan(value: Val): LogicalOperator {
+        return this.cond('lessThan', value);
     }
 
-    greaterThanOrEqual(value: Val): Condition {
-        return {
-            field: this.fieldName,
-            operator: 'greaterThanOrEqual',
-            value
-        };
+    greaterThanOrEqual(value: Val): LogicalOperator {
+        return this.cond('greaterThanOrEqual', value);
     }
 
-    lessThanOrEqual(value: Val): Condition {
-        return {
-            field: this.fieldName,
-            operator: 'lessThanOrEqual',
-            value
-        };
+    lessThanOrEqual(value: Val): LogicalOperator {
+        return this.cond('lessThanOrEqual', value);
     }
 
-    // ===== IP OPERATORS (IpOperator) =====
-
-    isLocalIp(): Condition {
-        return {
-            field: this.fieldName,
-            operator: 'isLocalIp',
-            value: true
-        };
+    between(min: Val, max: Val): LogicalOperator {
+        return this.cond('betweenOp', { from: min, to: max } as any);
     }
 
-    isExternalIp(): Condition {
-        return {
-            field: this.fieldName,
-            operator: 'isExternalIp',
-            value: true
-        };
-    }
+    // ===== IP OPERATORS =====
 
-    // ===== MISC OPERATORS (MiscOperator) =====
-
-    b64(value: string): Condition {
-        return {
-            field: this.fieldName,
-            operator: 'b64',
-            value
-        };
+    isLocalIp(): LogicalOperator {
+        return this.cond('isLocalIp', true);
     }
 
-    inDataset(dataset: string): Condition {
-        return {
-            field: this.fieldName,
-            operator: 'inDataset',
-            value: dataset
-        };
+    isExternalIp(): LogicalOperator {
+        return this.cond('isExternalIp', true);
     }
 
-    inCountry(countryCode: string): Condition {
-        return {
-            field: this.fieldName,
-            operator: 'inCountry',
-            value: countryCode
-        };
+    // ===== MISC OPERATORS =====
+
+    b64(value: string): LogicalOperator {
+        return this.cond('b64', value);
     }
 
-    cidr(cidr: string): Condition {
-        return {
-            field: this.fieldName,
-            operator: 'CIDR',
-            value: cidr
-        };
+    inDataset(dataset: string): LogicalOperator {
+        return this.cond('inDataset', dataset);
     }
 
-    // ===== BETWEEN OPERATOR =====
+    inCountry(countryCode: string): LogicalOperator {
+        return this.cond('inCountry', countryCode);
+    }
 
-    between(min: Val, max: Val): Condition {
-        return {
-            field: this.fieldName,
-            operator: 'betweenOp',
-            value: { from: min, to: max } as any
-        };
+    cidr(cidr: string): LogicalOperator {
+        return this.cond('CIDR', cidr);
     }
 
-    // ===== CONVENIENCE METHODS =====
+    // ===== CONVENIENCE =====
 
-    // Boolean checks (using base operators)
-    isTrue(): Condition {
+    isTrue(): LogicalOperator {
         return this.equals(true);
     }
 
-    isFalse(): Condition {
+    isFalse(): LogicalOperator {
         return this.equals(false);
     }
-}
+}

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

@@ -1,84 +1,83 @@
 import { FieldConditionBuilder, LogicalOperator } from '../index';
 
 describe('FieldConditionBuilder', () => {
-  test('should use correct operators for basic methods', () => {
-    const builder = new FieldConditionBuilder('name');
+    let builder: FieldConditionBuilder;
 
-    expect(builder.equals('John').operator).toBe('is');
-    expect(builder.contains('test').operator).toBe('includes');
-  });
-
-  test('should support dot notation in field paths', () => {
-    const condition = new FieldConditionBuilder('user.profile.bio').equals('Developer');
-    const logicalOp = LogicalOperator.Condition(condition);
-    const composable = logicalOp.toComposable();
-
-    const expected = {
-      user: {
-        profile: {
-          bio: {
-            is: 'Developer'
-          }
-        }
-      }
-    };
-
-    expect(composable).toEqual(expected);
-  });
-
-  test('should have all required operators available', () => {
-    const builder = new FieldConditionBuilder('test_field');
-
-    // Only test operators that actually exist in the Rust implementation
-    const operators = [
-      'equals', 'notEquals', 'greaterThan', 'lessThan', 'greaterThanOrEqual', 'lessThanOrEqual',
-      'contains', 'startsWith', 'endsWith', 'in', 'notIn', 'exists', 'notExists', 
-      'isNull', 'isNotNull', 'regExpMatches', 'includesCaseInsensitive', 
-      'startsWithCaseInsensitive', 'endsWithCaseInsensitive', 'between',
-      'isLocalIp', 'isExternalIp', 'b64', 'inDataset', 'inCountry', 'cidr',
-      'isTrue', 'isFalse'
-    ];
-
-    operators.forEach(op => {
-      expect(typeof (builder as any)[op]).toBe('function');
+    beforeEach(() => {
+        builder = new FieldConditionBuilder('field');
     });
-  });
 
-  test('should support advanced operators (string, IP, misc)', () => {
-    const stringBuilder = new FieldConditionBuilder('text');
-    const regexCondition = stringBuilder.regExpMatches('^test.*');
-    expect(regexCondition.operator).toBe('regExpMatches');
+    describe('Comparison operators', () => {
+        test('equals', () => expect(builder.equals('v').toComposable()).toEqual({ field: { is: 'v' } }));
+        test('notEquals', () => expect(builder.notEquals('v').toComposable()).toEqual({ field: { isNot: 'v' } }));
+        test('greaterThan', () => expect(builder.greaterThan(10).toComposable()).toEqual({ field: { greaterThan: 10 } }));
+        test('lessThan', () => expect(builder.lessThan(10).toComposable()).toEqual({ field: { lessThan: 10 } }));
+        test('greaterThanOrEqual', () => expect(builder.greaterThanOrEqual(10).toComposable()).toEqual({ field: { greaterThanOrEqual: 10 } }));
+        test('lessThanOrEqual', () => expect(builder.lessThanOrEqual(10).toComposable()).toEqual({ field: { lessThanOrEqual: 10 } }));
+        test('between', () => expect(builder.between(10, 20).toComposable()).toEqual({ field: { betweenOp: { from: 10, to: 20 } } }));
+    });
 
-    const caseInsensitiveCondition = stringBuilder.includesCaseInsensitive('Test');
-    expect(caseInsensitiveCondition.operator).toBe('includesCaseInsensitive');
+    describe('String operators', () => {
+        test('contains', () => expect(builder.contains('sub').toComposable()).toEqual({ field: { includes: 'sub' } }));
+        test('startsWith', () => expect(builder.startsWith('pre').toComposable()).toEqual({ field: { startsWith: 'pre' } }));
+        test('endsWith', () => expect(builder.endsWith('suf').toComposable()).toEqual({ field: { endsWith: 'suf' } }));
+        test('regExpMatches', () => expect(builder.regExpMatches('.*').toComposable()).toEqual({ field: { regExpMatches: '.*' } }));
+        test('includesCaseInsensitive', () => expect(builder.includesCaseInsensitive('T').toComposable()).toEqual({ field: { includesCaseInsensitive: 'T' } }));
+        test('startsWithCaseInsensitive', () => expect(builder.startsWithCaseInsensitive('P').toComposable()).toEqual({ field: { startsWithCaseInsensitive: 'P' } }));
+        test('endsWithCaseInsensitive', () => expect(builder.endsWithCaseInsensitive('S').toComposable()).toEqual({ field: { endsWithCaseInsensitive: 'S' } }));
+    });
 
-    const ipBuilder = new FieldConditionBuilder('ip_address');
-    const ipLocalCondition = ipBuilder.isLocalIp();
-    expect(ipLocalCondition.operator).toBe('isLocalIp');
-    
-    const ipExternalCondition = ipBuilder.isExternalIp();
-    expect(ipExternalCondition.operator).toBe('isExternalIp');
+    describe('Array operators', () => {
+        test('in', () => expect(builder.in([1, 2, 3]).toComposable()).toEqual({ field: { in: [1, 2, 3] } }));
+        test('notIn', () => expect(builder.notIn(['a', 'b']).toComposable()).toEqual({ field: { notIn: ['a', 'b'] } }));
+    });
 
-    const b64Condition = ipBuilder.b64('dGVzdA==');
-    expect(b64Condition.operator).toBe('b64');
-    
-    const countryCondition = ipBuilder.inCountry('US');
-    expect(countryCondition.operator).toBe('inCountry');
+    describe('Existence operators', () => {
+        test('exists', () => expect(builder.exists().toComposable()).toEqual({ field: { exists: true } }));
+        test('notExists', () => expect(builder.notExists().toComposable()).toEqual({ field: { exists: false } }));
+        test('isNull', () => expect(builder.isNull().toComposable()).toEqual({ field: { isNull: true } }));
+        test('isNotNull', () => expect(builder.isNotNull().toComposable()).toEqual({ field: { isNull: false } }));
+    });
 
-    const cidrCondition = ipBuilder.cidr('192.168.1.0/24');
-    expect(cidrCondition.operator).toBe('CIDR');
+    describe('Boolean convenience', () => {
+        test('isTrue', () => expect(builder.isTrue().toComposable()).toEqual({ field: { is: true } }));
+        test('isFalse', () => expect(builder.isFalse().toComposable()).toEqual({ field: { is: false } }));
+    });
 
-    const datasetCondition = ipBuilder.inDataset('malware_ips');
-    expect(datasetCondition.operator).toBe('inDataset');
+    describe('Network / security operators', () => {
+        test('isLocalIp', () => expect(builder.isLocalIp().toComposable()).toEqual({ field: { isLocalIp: true } }));
+        test('isExternalIp', () => expect(builder.isExternalIp().toComposable()).toEqual({ field: { isExternalIp: true } }));
+        test('b64', () => expect(builder.b64('dGVzdA==').toComposable()).toEqual({ field: { b64: 'dGVzdA==' } }));
+        test('inDataset', () => expect(builder.inDataset('malware_ips').toComposable()).toEqual({ field: { inDataset: 'malware_ips' } }));
+        test('inCountry', () => expect(builder.inCountry('US').toComposable()).toEqual({ field: { inCountry: 'US' } }));
+        test('cidr', () => expect(builder.cidr('192.168.1.0/24').toComposable()).toEqual({ field: { CIDR: '192.168.1.0/24' } }));
+    });
 
-    const betweenCondition = stringBuilder.between(5, 15);
-    expect(betweenCondition.operator).toBe('betweenOp');
-  });
+    describe('Dot-notation fields', () => {
+        test('handles nested path', () => {
+            expect(new FieldConditionBuilder('user.profile.bio').equals('Dev').toComposable()).toEqual({
+                user: { profile: { bio: { is: 'Dev' } } }
+            });
+        });
+
+        test('handles deeply nested path', () => {
+            expect(new FieldConditionBuilder('a.b.c.d').greaterThan(10).toComposable()).toEqual({
+                a: { b: { c: { d: { greaterThan: 10 } } } }
+            });
+        });
+    });
 
-  test('should handle empty field names gracefully', () => {
-    expect(() => {
-      const condition = new FieldConditionBuilder('').equals('test');
-      LogicalOperator.Condition(condition).toComposable();
-    }).not.toThrow();
-  });
-});
+    describe('Returns LogicalOperator', () => {
+        test('each method returns a LogicalOperator with correct condition', () => {
+            const lo = new FieldConditionBuilder('name').equals('John');
+            expect(lo.type).toBe('condition');
+            expect(lo.condition?.field).toBe('name');
+            expect(lo.condition?.operator).toBe('is');
+            expect(lo.condition?.value).toBe('John');
+        });
+
+        test('empty field name does not throw', () => {
+            expect(() => new FieldConditionBuilder('').equals('test').toComposable()).not.toThrow();
+        });
+    });
+});