@onchaindb/sdk 0.4.5 → 1.0.0

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

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createHttpClient = exports.NodeHttpClient = exports.AxiosHttpClient = exports.FetchHttpClient = exports.createQueryResult = exports.QueryResult = exports.NestedFieldConditionBuilder = exports.NestedConditionBuilder = exports.LogicalOperator = exports.FieldConditionBuilder = exports.ConditionBuilder = exports.SelectionBuilder = exports.QueryBuilder = exports.OnChainDB = void 0;
-// Main SDK exports
-var OnChainDB_1 = require("./OnChainDB");
-Object.defineProperty(exports, "OnChainDB", { enumerable: true, get: function () { return OnChainDB_1.OnChainDB; } });
-var QueryBuilder_1 = require("./QueryBuilder");
-Object.defineProperty(exports, "QueryBuilder", { enumerable: true, get: function () { return QueryBuilder_1.QueryBuilder; } });
-var SelectionBuilder_1 = require("./SelectionBuilder");
-Object.defineProperty(exports, "SelectionBuilder", { enumerable: true, get: function () { return SelectionBuilder_1.SelectionBuilder; } });
-var ConditionBuilder_1 = require("./ConditionBuilder");
-Object.defineProperty(exports, "ConditionBuilder", { enumerable: true, get: function () { return ConditionBuilder_1.ConditionBuilder; } });
-var operators_1 = require("./operators");
-Object.defineProperty(exports, "FieldConditionBuilder", { enumerable: true, get: function () { return operators_1.FieldConditionBuilder; } });
-Object.defineProperty(exports, "LogicalOperator", { enumerable: true, get: function () { return operators_1.LogicalOperator; } });
-var NestedBuilders_1 = require("./NestedBuilders");
-Object.defineProperty(exports, "NestedConditionBuilder", { enumerable: true, get: function () { return NestedBuilders_1.NestedConditionBuilder; } });
-Object.defineProperty(exports, "NestedFieldConditionBuilder", { enumerable: true, get: function () { return NestedBuilders_1.NestedFieldConditionBuilder; } });
-var QueryResult_1 = require("./QueryResult");
-Object.defineProperty(exports, "QueryResult", { enumerable: true, get: function () { return QueryResult_1.QueryResult; } });
-Object.defineProperty(exports, "createQueryResult", { enumerable: true, get: function () { return QueryResult_1.createQueryResult; } });
-// HTTP Client adapters
-var HttpClientAdapter_1 = require("./adapters/HttpClientAdapter");
-Object.defineProperty(exports, "FetchHttpClient", { enumerable: true, get: function () { return HttpClientAdapter_1.FetchHttpClient; } });
-Object.defineProperty(exports, "AxiosHttpClient", { enumerable: true, get: function () { return HttpClientAdapter_1.AxiosHttpClient; } });
-Object.defineProperty(exports, "NodeHttpClient", { enumerable: true, get: function () { return HttpClientAdapter_1.NodeHttpClient; } });
-Object.defineProperty(exports, "createHttpClient", { enumerable: true, get: function () { return HttpClientAdapter_1.createHttpClient; } });

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

@@ -1,56 +0,0 @@
-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

@@ -1,289 +0,0 @@
-"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

@@ -1,15 +0,0 @@
-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

@@ -1,46 +0,0 @@
-"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/jest.config.js

@@ -1,25 +0,0 @@
-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']
-};

package/src/query-sdk/package.json

@@ -1,46 +0,0 @@
-{
-  "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"
-  ]
-}