@onchaindb/sdk 0.4.5 → 2.0.0

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

@@ -1,80 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SelectionBuilder = void 0;
-class SelectionBuilder {
-    constructor() {
-        this.selections = {};
-    }
-    static new() {
-        return new SelectionBuilder();
-    }
-    // Static method to create selection that includes all fields
-    static all() {
-        return { "*": true }; // Empty selection map means select all fields
-    }
-    // Select specific fields
-    field(fieldName) {
-        this.selections[fieldName] = true; // true indicates field should be included
-        return this;
-    }
-    // Select multiple fields at once
-    fields(fieldNames) {
-        fieldNames.forEach(field => {
-            this.selections[field] = true;
-        });
-        return this;
-    }
-    // Select nested fields with a builder function
-    nested(fieldName, builderFn) {
-        const nestedBuilder = new SelectionBuilder();
-        builderFn(nestedBuilder);
-        this.selections[fieldName] = nestedBuilder.build();
-        return this;
-    }
-    // Exclude specific fields (useful when selecting most fields)
-    exclude(fieldName) {
-        this.selections[fieldName] = false; // false indicates field should be excluded
-        return this;
-    }
-    // Exclude multiple fields
-    excludeFields(fieldNames) {
-        fieldNames.forEach(field => {
-            this.selections[field] = false;
-        });
-        return this;
-    }
-    // Build and return the selection map
-    build() {
-        return { ...this.selections };
-    }
-    // Reset the builder
-    clear() {
-        this.selections = {};
-        return this;
-    }
-    // Check if any selections have been made
-    isEmpty() {
-        return Object.keys(this.selections).length === 0;
-    }
-    // Get current selection count
-    getSelectionCount() {
-        return Object.keys(this.selections).length;
-    }
-    // Check if a specific field is selected
-    hasField(fieldName) {
-        return fieldName in this.selections && this.selections[fieldName] === true;
-    }
-    // Check if a specific field is excluded
-    isFieldExcluded(fieldName) {
-        return fieldName in this.selections && this.selections[fieldName] === false;
-    }
-    // Get all selected field names
-    getSelectedFields() {
-        return Object.keys(this.selections).filter(field => this.selections[field] === true);
-    }
-    // Get all excluded field names
-    getExcludedFields() {
-        return Object.keys(this.selections).filter(field => this.selections[field] === false);
-    }
-}
-exports.SelectionBuilder = SelectionBuilder;

package/src/query-sdk/dist/adapters/HttpClientAdapter.d.ts

@@ -1,27 +0,0 @@
-import { HttpClient } from "../index";
-declare global {
-    interface Window {
-        any: any;
-    }
-}
-export declare class FetchHttpClient implements HttpClient {
-    private fetchFn;
-    constructor(fetchImplementation?: typeof fetch);
-    post(url: string, data: any, headers?: Record<string, string>): Promise<any>;
-}
-export declare class AxiosHttpClient implements HttpClient {
-    private axios;
-    constructor(axiosInstance: any);
-    post(url: string, data: any, headers?: Record<string, string>): Promise<any>;
-}
-export declare class NodeHttpClient implements HttpClient {
-    private timeout;
-    constructor(timeout?: number);
-    post(url: string, data: any, headers?: Record<string, string>): Promise<any>;
-}
-export declare function createHttpClient(options?: {
-    type?: 'fetch' | 'axios' | 'node';
-    fetchImplementation?: typeof fetch;
-    axiosInstance?: any;
-    timeout?: number;
-}): HttpClient;

package/src/query-sdk/dist/adapters/HttpClientAdapter.js

@@ -1,170 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NodeHttpClient = exports.AxiosHttpClient = exports.FetchHttpClient = void 0;
-exports.createHttpClient = createHttpClient;
-// Adapter for fetch API (works in both browser and Node.js with node-fetch)
-class FetchHttpClient {
-    constructor(fetchImplementation) {
-        // Use provided fetch implementation or global fetch
-        this.fetchFn = fetchImplementation || (globalThis.fetch?.bind(globalThis));
-        if (!this.fetchFn) {
-            throw new Error('Fetch is not available. Please provide a fetch implementation or use in an environment that supports fetch.');
-        }
-    }
-    async post(url, data, headers = {}) {
-        try {
-            const response = await this.fetchFn(url, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    ...headers,
-                },
-                body: JSON.stringify(data),
-            });
-            if (!response.ok) {
-                const errorText = await response.text();
-                throw new Error(`HTTP ${response.status}: ${errorText}`);
-            }
-            const contentType = response.headers.get('content-type');
-            if (contentType && contentType.includes('application/json')) {
-                return await response.json();
-            }
-            else {
-                return await response.text();
-            }
-        }
-        catch (error) {
-            if (error instanceof Error) {
-                throw error;
-            }
-            throw new Error(`Request failed: ${error}`);
-        }
-    }
-}
-exports.FetchHttpClient = FetchHttpClient;
-// Adapter for axios (if user prefers axios)
-class AxiosHttpClient {
-    constructor(axiosInstance) {
-        if (!axiosInstance) {
-            throw new Error('Axios instance is required');
-        }
-        this.axios = axiosInstance;
-    }
-    async post(url, data, headers = {}) {
-        try {
-            const response = await this.axios.post(url, data, {
-                headers: {
-                    'Content-Type': 'application/json',
-                    ...headers,
-                },
-            });
-            return response.data;
-        }
-        catch (error) {
-            if (error.response) {
-                throw new Error(`HTTP ${error.response.status}: ${JSON.stringify(error.response.data)}`);
-            }
-            else if (error.request) {
-                throw new Error('No response received from server');
-            }
-            else {
-                throw new Error(`Request setup error: ${error.message}`);
-            }
-        }
-    }
-}
-exports.AxiosHttpClient = AxiosHttpClient;
-// Simple HTTP client using Node.js built-in modules (for Node.js environments)
-class NodeHttpClient {
-    constructor(timeout = 30000) {
-        this.timeout = timeout;
-    }
-    async post(url, data, headers = {}) {
-        return new Promise((resolve, reject) => {
-            const urlObj = new URL(url);
-            const isHttps = urlObj.protocol === 'https:';
-            // Dynamic import to avoid issues in browser environments
-            const httpModule = isHttps ? require('https') : require('http');
-            const postData = JSON.stringify(data);
-            const options = {
-                hostname: urlObj.hostname,
-                port: urlObj.port || (isHttps ? 443 : 80),
-                path: urlObj.pathname + urlObj.search,
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Content-Length': Buffer.byteLength(postData),
-                    ...headers,
-                },
-                timeout: this.timeout,
-            };
-            const req = httpModule.request(options, (res) => {
-                let responseData = '';
-                res.on('data', (chunk) => {
-                    responseData += chunk;
-                });
-                res.on('end', () => {
-                    try {
-                        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
-                            const contentType = res.headers['content-type'] || '';
-                            if (contentType.includes('application/json')) {
-                                resolve(JSON.parse(responseData));
-                            }
-                            else {
-                                resolve(responseData);
-                            }
-                        }
-                        else {
-                            reject(new Error(`HTTP ${res.statusCode}: ${responseData}`));
-                        }
-                    }
-                    catch (error) {
-                        reject(new Error(`Failed to parse response: ${error}`));
-                    }
-                });
-            });
-            req.on('error', (error) => {
-                reject(new Error(`Request failed: ${error.message}`));
-            });
-            req.on('timeout', () => {
-                req.destroy();
-                reject(new Error(`Request timed out after ${this.timeout}ms`));
-            });
-            req.write(postData);
-            req.end();
-        });
-    }
-}
-exports.NodeHttpClient = NodeHttpClient;
-// Factory function to create appropriate HTTP client based on environment
-function createHttpClient(options = {}) {
-    const { type, fetchImplementation, axiosInstance, timeout } = options;
-    // Auto-detect environment if type is not specified
-    if (!type) {
-        if (typeof globalThis !== 'undefined' && typeof globalThis.fetch === 'function') {
-            return new FetchHttpClient(fetchImplementation);
-        }
-        else { // @ts-ignore
-            if (typeof window !== 'undefined') {
-                throw new Error('Fetch is not available in this browser environment. Please provide a fetch implementation.');
-            }
-            else {
-                // Assume Node.js environment
-                return new NodeHttpClient(timeout);
-            }
-        }
-    }
-    switch (type) {
-        case 'fetch':
-            return new FetchHttpClient(fetchImplementation);
-        case 'axios':
-            if (!axiosInstance) {
-                throw new Error('Axios instance is required when using axios client');
-            }
-            return new AxiosHttpClient(axiosInstance);
-        case 'node':
-            return new NodeHttpClient(timeout);
-        default:
-            throw new Error(`Unknown HTTP client type: ${type}`);
-    }
-}

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

@@ -1,36 +0,0 @@
-export interface HttpClient {
-    post(url: string, data: any, headers?: Record<string, string>): Promise<any>;
-}
-export interface QueryValue {
-    find: any;
-    select: any;
-}
-export type QueryRequest = QueryValue & {
-    limit?: number;
-    offset?: number;
-    sort?: string[];
-};
-export interface QueryResponse<T = any> {
-    records: T[];
-    total?: number;
-    error?: string;
-}
-export type SelectionMap = Record<string, any>;
-export type FieldMap = Record<string, string>;
-export type Val = string | number | boolean | null | Val[] | Date | RegExp;
-export interface BetweenValue {
-    min: Val;
-    max: Val;
-}
-export interface DateRange {
-    start: Date | string | number;
-    end: Date | string | number;
-}
-export { OnChainDB } from './OnChainDB';
-export { QueryBuilder } 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';
-export { FetchHttpClient, AxiosHttpClient, NodeHttpClient, createHttpClient } from './adapters/HttpClientAdapter';

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;