@onchaindb/sdk 0.4.0 → 0.4.2

package/src/query-sdk/operators.ts

@@ -0,0 +1,335 @@
+import { BetweenValue, DateRange, Val } from './index';
+
+// Condition represents a single field condition
+export interface Condition {
+    field: string;
+    operator: string;
+    value: Val | BetweenValue | DateRange;
+}
+
+// Helper function to convert dot notation paths to nested structures
+export function createNestedQuery(fieldPath: string, operator: string, value: Val | BetweenValue | DateRange): any {
+    if (!fieldPath.includes('.')) {
+        return {
+            [fieldPath]: {
+                [operator]: value
+            }
+        };
+    }
+
+    const pathParts = fieldPath.split('.');
+    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
+            };
+        }
+    }
+
+    return result;
+}
+
+// Logical operators for combining conditions
+export enum LogicalOperatorType {
+    AND = 'and',
+    OR = 'or',
+    NOT = 'not',
+    CONDITION = 'condition'
+}
+
+export class LogicalOperator {
+    constructor(
+        public type: LogicalOperatorType,
+        public conditions: LogicalOperator[] = [],
+        public condition?: Condition
+    ) {
+    }
+
+    static And(conditions: LogicalOperator[]): LogicalOperator {
+        return new LogicalOperator(LogicalOperatorType.AND, conditions);
+    }
+
+    static Or(conditions: LogicalOperator[]): LogicalOperator {
+        return new LogicalOperator(LogicalOperatorType.OR, conditions);
+    }
+
+    static Not(conditions: LogicalOperator[]): LogicalOperator {
+        return new LogicalOperator(LogicalOperatorType.NOT, conditions);
+    }
+
+    static Condition(condition: Condition): LogicalOperator {
+        return new LogicalOperator(LogicalOperatorType.CONDITION, [], condition);
+    }
+
+    // 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())
+                };
+            case LogicalOperatorType.OR:
+                return {
+                    [LogicalOperatorType.OR]: this.conditions.map(c => c.toComposable())
+                };
+            case LogicalOperatorType.NOT:
+                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}`);
+        }
+    }
+}
+
+// Field condition builder for creating individual field conditions
+// Only includes operators that actually exist in the Rust implementation
+export class FieldConditionBuilder {
+    constructor(private fieldName: string) {
+    }
+
+    // ===== BASE OPERATORS (BaseOperator) =====
+
+    equals(value: Val): Condition {
+        return {
+            field: this.fieldName,
+            operator: 'is',
+            value
+        };
+    }
+
+    notEquals(value: Val): Condition {
+        return {
+            field: this.fieldName,
+            operator: 'isNot',
+            value
+        };
+    }
+
+    in(values: Val[]): Condition {
+        return {
+            field: this.fieldName,
+            operator: 'in',
+            value: values as any
+        };
+    }
+
+    notIn(values: Val[]): Condition {
+        return {
+            field: this.fieldName,
+            operator: 'notIn',
+            value: values as any
+        };
+    }
+
+    isNull(): Condition {
+        return {
+            field: this.fieldName,
+            operator: 'isNull',
+            value: true
+        };
+    }
+
+    isNotNull(): Condition {
+        return {
+            field: this.fieldName,
+            operator: 'isNull',
+            value: false
+        };
+    }
+
+    exists(): Condition {
+        return {
+            field: this.fieldName,
+            operator: 'exists',
+            value: true
+        };
+    }
+
+    notExists(): Condition {
+        return {
+            field: this.fieldName,
+            operator: 'exists',
+            value: false
+        };
+    }
+
+    // ===== STRING OPERATORS (StringOperator) =====
+
+    startsWith(value: string): Condition {
+        return {
+            field: this.fieldName,
+            operator: 'startsWith',
+            value
+        };
+    }
+
+    endsWith(value: string): Condition {
+        return {
+            field: this.fieldName,
+            operator: 'endsWith',
+            value
+        };
+    }
+
+    contains(value: string): Condition {
+        return {
+            field: this.fieldName,
+            operator: 'includes',
+            value
+        };
+    }
+
+    regExpMatches(pattern: string): Condition {
+        return {
+            field: this.fieldName,
+            operator: 'regExpMatches',
+            value: pattern
+        };
+    }
+
+    includesCaseInsensitive(value: string): Condition {
+        return {
+            field: this.fieldName,
+            operator: 'includesCaseInsensitive',
+            value
+        };
+    }
+
+    startsWithCaseInsensitive(value: string): Condition {
+        return {
+            field: this.fieldName,
+            operator: 'startsWithCaseInsensitive',
+            value
+        };
+    }
+
+    endsWithCaseInsensitive(value: string): Condition {
+        return {
+            field: this.fieldName,
+            operator: 'endsWithCaseInsensitive',
+            value
+        };
+    }
+
+    // ===== NUMBER OPERATORS (NumberOperator) =====
+
+    greaterThan(value: Val): Condition {
+        return {
+            field: this.fieldName,
+            operator: 'greaterThan',
+            value
+        };
+    }
+
+    lessThan(value: Val): Condition {
+        return {
+            field: this.fieldName,
+            operator: 'lessThan',
+            value
+        };
+    }
+
+    greaterThanOrEqual(value: Val): Condition {
+        return {
+            field: this.fieldName,
+            operator: 'greaterThanOrEqual',
+            value
+        };
+    }
+
+    lessThanOrEqual(value: Val): Condition {
+        return {
+            field: this.fieldName,
+            operator: 'lessThanOrEqual',
+            value
+        };
+    }
+
+    // ===== IP OPERATORS (IpOperator) =====
+
+    isLocalIp(): Condition {
+        return {
+            field: this.fieldName,
+            operator: 'isLocalIp',
+            value: true
+        };
+    }
+
+    isExternalIp(): Condition {
+        return {
+            field: this.fieldName,
+            operator: 'isExternalIp',
+            value: true
+        };
+    }
+
+    // ===== MISC OPERATORS (MiscOperator) =====
+
+    b64(value: string): Condition {
+        return {
+            field: this.fieldName,
+            operator: 'b64',
+            value
+        };
+    }
+
+    inDataset(dataset: string): Condition {
+        return {
+            field: this.fieldName,
+            operator: 'inDataset',
+            value: dataset
+        };
+    }
+
+    inCountry(countryCode: string): Condition {
+        return {
+            field: this.fieldName,
+            operator: 'inCountry',
+            value: countryCode
+        };
+    }
+
+    cidr(cidr: string): Condition {
+        return {
+            field: this.fieldName,
+            operator: 'CIDR',
+            value: cidr
+        };
+    }
+
+    // ===== BETWEEN OPERATOR =====
+
+    between(min: Val, max: Val): Condition {
+        return {
+            field: this.fieldName,
+            operator: 'betweenOp',
+            value: { from: min, to: max } as any
+        };
+    }
+
+    // ===== CONVENIENCE METHODS =====
+
+    // Boolean checks (using base operators)
+    isTrue(): Condition {
+        return this.equals(true);
+    }
+
+    isFalse(): Condition {
+        return this.equals(false);
+    }
+}

package/src/query-sdk/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@scepter/typescript-sdk",
+  "version": "1.0.0",
+  "description": "TypeScript SDK for Scepter JSON query engine",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "build": "tsc",
+    "lint": "eslint src/**/*.ts",
+    "prepare": "npm run build"
+  },
+  "keywords": [
+    "query",
+    "json",
+    "database",
+    "typescript",
+    "sdk"
+  ],
+  "author": "Scepter Team",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^20.8.0",
+    "@typescript-eslint/eslint-plugin": "^6.7.0",
+    "@typescript-eslint/parser": "^6.7.0",
+    "eslint": "^8.50.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.4.4",
+    "typescript": "^5.2.0",
+    "yest": "^0.0.1"
+  },
+  "dependencies": {
+    "axios": "^1.5.0"
+  },
+  "peerDependencies": {
+    "axios": "^1.5.0"
+  },
+  "files": [
+    "dist/**/*",
+    "index.d.ts",
+    "README.md"
+  ]
+}

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

@@ -0,0 +1,84 @@
+import { FieldConditionBuilder, LogicalOperator } from '../index';
+
+describe('FieldConditionBuilder', () => {
+  test('should use correct operators for basic methods', () => {
+    const builder = new FieldConditionBuilder('name');
+
+    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');
+    });
+  });
+
+  test('should support advanced operators (string, IP, misc)', () => {
+    const stringBuilder = new FieldConditionBuilder('text');
+    const regexCondition = stringBuilder.regExpMatches('^test.*');
+    expect(regexCondition.operator).toBe('regExpMatches');
+
+    const caseInsensitiveCondition = stringBuilder.includesCaseInsensitive('Test');
+    expect(caseInsensitiveCondition.operator).toBe('includesCaseInsensitive');
+
+    const ipBuilder = new FieldConditionBuilder('ip_address');
+    const ipLocalCondition = ipBuilder.isLocalIp();
+    expect(ipLocalCondition.operator).toBe('isLocalIp');
+    
+    const ipExternalCondition = ipBuilder.isExternalIp();
+    expect(ipExternalCondition.operator).toBe('isExternalIp');
+
+    const b64Condition = ipBuilder.b64('dGVzdA==');
+    expect(b64Condition.operator).toBe('b64');
+    
+    const countryCondition = ipBuilder.inCountry('US');
+    expect(countryCondition.operator).toBe('inCountry');
+
+    const cidrCondition = ipBuilder.cidr('192.168.1.0/24');
+    expect(cidrCondition.operator).toBe('CIDR');
+
+    const datasetCondition = ipBuilder.inDataset('malware_ips');
+    expect(datasetCondition.operator).toBe('inDataset');
+
+    const betweenCondition = stringBuilder.between(5, 15);
+    expect(betweenCondition.operator).toBe('betweenOp');
+  });
+
+  test('should handle empty field names gracefully', () => {
+    expect(() => {
+      const condition = new FieldConditionBuilder('').equals('test');
+      LogicalOperator.Condition(condition).toComposable();
+    }).not.toThrow();
+  });
+});

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

@@ -0,0 +1,85 @@
+import { FieldConditionBuilder, LogicalOperator } from '../index';
+
+describe('LogicalOperator', () => {
+  test('should combine conditions with AND operator', () => {
+    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();
+
+    const expected = {
+      and: [
+        {
+          user: {
+            name: {
+              is: 'John'
+            }
+          }
+        },
+        {
+          user: {
+            age: {
+              greaterThan: 25
+            }
+          }
+        }
+      ]
+    };
+
+    expect(composable).toEqual(expected);
+  });
+
+  test('should combine conditions with OR operator', () => {
+    const condition1 = new FieldConditionBuilder('status').equals('active');
+    const condition2 = new FieldConditionBuilder('status').equals('pending');
+
+    const orOp = LogicalOperator.Or([
+      LogicalOperator.Condition(condition1),
+      LogicalOperator.Condition(condition2)
+    ]);
+
+    const composable = orOp.toComposable();
+
+    const expected = {
+      or: [
+        {
+          status: {
+            is: 'active'
+          }
+        },
+        {
+          status: {
+            is: 'pending'
+          }
+        }
+      ]
+    };
+
+    expect(composable).toEqual(expected);
+  });
+
+  test('should handle nested logical operations', () => {
+    const condition1 = new FieldConditionBuilder('name').equals('John');
+    const condition2 = new FieldConditionBuilder('age').greaterThan(25);
+    const condition3 = new FieldConditionBuilder('status').equals('active');
+
+    const nestedOp = LogicalOperator.Or([
+      LogicalOperator.And([
+        LogicalOperator.Condition(condition1),
+        LogicalOperator.Condition(condition2)
+      ]),
+      LogicalOperator.Condition(condition3)
+    ]);
+
+    const composable = nestedOp.toComposable();
+
+    expect(composable).toHaveProperty('or');
+    expect(composable.or).toHaveLength(2);
+    expect(composable.or[0]).toHaveProperty('and');
+  });
+});