@onchaindb/sdk 0.4.0 → 0.4.2

package/src/query-sdk/dist/operators.d.ts

@@ -0,0 +1,56 @@
+import { BetweenValue, DateRange, Val } from './index';
+export interface Condition {
+    field: string;
+    operator: string;
+    value: Val | BetweenValue | DateRange;
+}
+export declare function createNestedQuery(fieldPath: string, operator: string, value: Val | BetweenValue | DateRange): any;
+export declare enum LogicalOperatorType {
+    AND = "and",
+    OR = "or",
+    NOT = "not",
+    CONDITION = "condition"
+}
+export declare class LogicalOperator {
+    type: LogicalOperatorType;
+    conditions: LogicalOperator[];
+    condition?: Condition | undefined;
+    constructor(type: LogicalOperatorType, conditions?: LogicalOperator[], condition?: Condition | undefined);
+    static And(conditions: LogicalOperator[]): LogicalOperator;
+    static Or(conditions: LogicalOperator[]): LogicalOperator;
+    static Not(conditions: LogicalOperator[]): LogicalOperator;
+    static Condition(condition: Condition): LogicalOperator;
+    toComposable(): any;
+}
+export declare class FieldConditionBuilder {
+    private fieldName;
+    constructor(fieldName: string);
+    equals(value: Val): Condition;
+    notEquals(value: Val): Condition;
+    in(values: Val[]): Condition;
+    notIn(values: Val[]): Condition;
+    isNull(): Condition;
+    isNotNull(): Condition;
+    exists(): Condition;
+    notExists(): Condition;
+    startsWith(value: string): Condition;
+    endsWith(value: string): Condition;
+    contains(value: string): Condition;
+    regExpMatches(pattern: string): Condition;
+    includesCaseInsensitive(value: string): Condition;
+    startsWithCaseInsensitive(value: string): Condition;
+    endsWithCaseInsensitive(value: string): Condition;
+    greaterThan(value: Val): Condition;
+    lessThan(value: Val): Condition;
+    greaterThanOrEqual(value: Val): Condition;
+    lessThanOrEqual(value: Val): Condition;
+    isLocalIp(): Condition;
+    isExternalIp(): Condition;
+    b64(value: string): Condition;
+    inDataset(dataset: string): Condition;
+    inCountry(countryCode: string): Condition;
+    cidr(cidr: string): Condition;
+    between(min: Val, max: Val): Condition;
+    isTrue(): Condition;
+    isFalse(): Condition;
+}

package/src/query-sdk/dist/operators.js

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldConditionBuilder = exports.LogicalOperator = exports.LogicalOperatorType = void 0;
+exports.createNestedQuery = createNestedQuery;
+// Helper function to convert dot notation paths to nested structures
+function createNestedQuery(fieldPath, operator, value) {
+    if (!fieldPath.includes('.')) {
+        return {
+            [fieldPath]: {
+                [operator]: value
+            }
+        };
+    }
+    const pathParts = fieldPath.split('.');
+    let result = {
+        [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
+var LogicalOperatorType;
+(function (LogicalOperatorType) {
+    LogicalOperatorType["AND"] = "and";
+    LogicalOperatorType["OR"] = "or";
+    LogicalOperatorType["NOT"] = "not";
+    LogicalOperatorType["CONDITION"] = "condition";
+})(LogicalOperatorType || (exports.LogicalOperatorType = LogicalOperatorType = {}));
+class LogicalOperator {
+    constructor(type, conditions = [], condition) {
+        this.type = type;
+        this.conditions = conditions;
+        this.condition = condition;
+    }
+    static And(conditions) {
+        return new LogicalOperator(LogicalOperatorType.AND, conditions);
+    }
+    static Or(conditions) {
+        return new LogicalOperator(LogicalOperatorType.OR, conditions);
+    }
+    static Not(conditions) {
+        return new LogicalOperator(LogicalOperatorType.NOT, conditions);
+    }
+    static Condition(condition) {
+        return new LogicalOperator(LogicalOperatorType.CONDITION, [], condition);
+    }
+    // Convert to composable query structure for HTTP requests
+    toComposable() {
+        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}`);
+        }
+    }
+}
+exports.LogicalOperator = LogicalOperator;
+// Field condition builder for creating individual field conditions
+// Only includes operators that actually exist in the Rust implementation
+class FieldConditionBuilder {
+    constructor(fieldName) {
+        this.fieldName = fieldName;
+    }
+    // ===== BASE OPERATORS (BaseOperator) =====
+    equals(value) {
+        return {
+            field: this.fieldName,
+            operator: 'is',
+            value
+        };
+    }
+    notEquals(value) {
+        return {
+            field: this.fieldName,
+            operator: 'isNot',
+            value
+        };
+    }
+    in(values) {
+        return {
+            field: this.fieldName,
+            operator: 'in',
+            value: values
+        };
+    }
+    notIn(values) {
+        return {
+            field: this.fieldName,
+            operator: 'notIn',
+            value: values
+        };
+    }
+    isNull() {
+        return {
+            field: this.fieldName,
+            operator: 'isNull',
+            value: true
+        };
+    }
+    isNotNull() {
+        return {
+            field: this.fieldName,
+            operator: 'isNull',
+            value: false
+        };
+    }
+    exists() {
+        return {
+            field: this.fieldName,
+            operator: 'exists',
+            value: true
+        };
+    }
+    notExists() {
+        return {
+            field: this.fieldName,
+            operator: 'exists',
+            value: false
+        };
+    }
+    // ===== STRING OPERATORS (StringOperator) =====
+    startsWith(value) {
+        return {
+            field: this.fieldName,
+            operator: 'startsWith',
+            value
+        };
+    }
+    endsWith(value) {
+        return {
+            field: this.fieldName,
+            operator: 'endsWith',
+            value
+        };
+    }
+    contains(value) {
+        return {
+            field: this.fieldName,
+            operator: 'includes',
+            value
+        };
+    }
+    regExpMatches(pattern) {
+        return {
+            field: this.fieldName,
+            operator: 'regExpMatches',
+            value: pattern
+        };
+    }
+    includesCaseInsensitive(value) {
+        return {
+            field: this.fieldName,
+            operator: 'includesCaseInsensitive',
+            value
+        };
+    }
+    startsWithCaseInsensitive(value) {
+        return {
+            field: this.fieldName,
+            operator: 'startsWithCaseInsensitive',
+            value
+        };
+    }
+    endsWithCaseInsensitive(value) {
+        return {
+            field: this.fieldName,
+            operator: 'endsWithCaseInsensitive',
+            value
+        };
+    }
+    // ===== NUMBER OPERATORS (NumberOperator) =====
+    greaterThan(value) {
+        return {
+            field: this.fieldName,
+            operator: 'greaterThan',
+            value
+        };
+    }
+    lessThan(value) {
+        return {
+            field: this.fieldName,
+            operator: 'lessThan',
+            value
+        };
+    }
+    greaterThanOrEqual(value) {
+        return {
+            field: this.fieldName,
+            operator: 'greaterThanOrEqual',
+            value
+        };
+    }
+    lessThanOrEqual(value) {
+        return {
+            field: this.fieldName,
+            operator: 'lessThanOrEqual',
+            value
+        };
+    }
+    // ===== IP OPERATORS (IpOperator) =====
+    isLocalIp() {
+        return {
+            field: this.fieldName,
+            operator: 'isLocalIp',
+            value: true
+        };
+    }
+    isExternalIp() {
+        return {
+            field: this.fieldName,
+            operator: 'isExternalIp',
+            value: true
+        };
+    }
+    // ===== MISC OPERATORS (MiscOperator) =====
+    b64(value) {
+        return {
+            field: this.fieldName,
+            operator: 'b64',
+            value
+        };
+    }
+    inDataset(dataset) {
+        return {
+            field: this.fieldName,
+            operator: 'inDataset',
+            value: dataset
+        };
+    }
+    inCountry(countryCode) {
+        return {
+            field: this.fieldName,
+            operator: 'inCountry',
+            value: countryCode
+        };
+    }
+    cidr(cidr) {
+        return {
+            field: this.fieldName,
+            operator: 'CIDR',
+            value: cidr
+        };
+    }
+    // ===== BETWEEN OPERATOR =====
+    between(min, max) {
+        return {
+            field: this.fieldName,
+            operator: 'betweenOp',
+            value: { from: min, to: max }
+        };
+    }
+    // ===== CONVENIENCE METHODS =====
+    // Boolean checks (using base operators)
+    isTrue() {
+        return this.equals(true);
+    }
+    isFalse() {
+        return this.equals(false);
+    }
+}
+exports.FieldConditionBuilder = FieldConditionBuilder;

package/src/query-sdk/dist/tests/setup.d.ts

@@ -0,0 +1,15 @@
+import 'jest';
+export declare const createMockResponse: (data: any) => {
+    data: {
+        records: any[];
+        total: number;
+        page: number;
+        limit: number;
+    };
+};
+export declare class MockHttpClient {
+    private responses;
+    setResponse(url: string, response: any): void;
+    post(url: string, data: any, headers?: Record<string, string>): Promise<any>;
+    clear(): void;
+}

package/src/query-sdk/dist/tests/setup.js

@@ -0,0 +1,46 @@
+"use strict";
+// Jest setup file for global test configuration
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockHttpClient = exports.createMockResponse = void 0;
+// Extend Jest matchers if needed
+require("jest");
+// Global test timeout
+jest.setTimeout(30000);
+// Mock console methods for cleaner test output
+const originalConsoleError = console.error;
+const originalConsoleWarn = console.warn;
+beforeAll(() => {
+    console.error = jest.fn();
+    console.warn = jest.fn();
+});
+afterAll(() => {
+    console.error = originalConsoleError;
+    console.warn = originalConsoleWarn;
+});
+// Helper function to create mock HTTP responses
+const createMockResponse = (data) => ({
+    data: {
+        records: Array.isArray(data) ? data : [data],
+        total: Array.isArray(data) ? data.length : 1,
+        page: 1,
+        limit: 10
+    }
+});
+exports.createMockResponse = createMockResponse;
+// Mock HTTP client for tests
+class MockHttpClient {
+    constructor() {
+        this.responses = new Map();
+    }
+    setResponse(url, response) {
+        this.responses.set(url, response);
+    }
+    async post(url, data, headers) {
+        const response = this.responses.get(url) || (0, exports.createMockResponse)([]);
+        return Promise.resolve(response);
+    }
+    clear() {
+        this.responses.clear();
+    }
+}
+exports.MockHttpClient = MockHttpClient;

package/src/query-sdk/index.ts

@@ -0,0 +1,59 @@
+// HTTP Client Interface for dependency injection
+export interface HttpClient {
+    post(url: string, data: any, headers?: Record<string, string>): Promise<any>;
+}
+
+// Query types matching Rust SDK structure
+export interface QueryValue {
+    find: any;
+    select: any;
+    include_history?: boolean;
+}
+
+export type QueryRequest = QueryValue & {
+    limit?: number;
+    offset?: number;
+    sort?: string[];
+}
+
+export interface QueryResponse<T = any> {
+    records: T[];
+    total?: number;
+    error?: string;
+}
+
+// Selection types
+export type SelectionMap = Record<string, any>;
+export type FieldMap = Record<string, string>;
+
+// Operator values - expanded to match Rust SDK
+export type Val = string | number | boolean | null | Val[] | Date | RegExp;
+
+// Extended operator types to match Rust SDK
+export interface BetweenValue {
+    min: Val;
+    max: Val;
+}
+
+export interface DateRange {
+    start: Date | string | number;
+    end: Date | string | number;
+}
+
+// Main SDK exports
+export {OnChainDB} from './OnChainDB';
+export {QueryBuilder, JoinBuilder, ServerJoinConfig, GroupByQueryBuilder} from './QueryBuilder';
+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';
+
+// HTTP Client adapters
+export {
+    FetchHttpClient,
+    AxiosHttpClient,
+    NodeHttpClient,
+    createHttpClient
+} from './adapters/HttpClientAdapter';
+

package/src/query-sdk/jest.config.js

@@ -0,0 +1,25 @@
+module.exports = {
+    preset: 'ts-jest',
+    testEnvironment: 'node',
+    roots: ['<rootDir>/tests'],
+    testMatch: [
+        '**/__tests__/**/*.ts',
+        '**/?(*.)+(spec|test).ts'
+    ],
+    transform: {
+        '^.+\\.ts$': 'ts-jest',
+    },
+    collectCoverageFrom: [
+        '**/*.ts',
+        '!**/*.d.ts',
+        '!**/node_modules/**',
+        '!**/tests/**',
+    ],
+    coverageDirectory: 'coverage',
+    coverageReporters: [
+        'text',
+        'lcov',
+        'html'
+    ],
+    setupFilesAfterEnv: ['<rootDir>/tests/setup.ts']
+};