@onchaindb/sdk 0.4.0 → 0.4.2

package/src/query-sdk/SelectionBuilder.ts

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

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

@@ -0,0 +1,249 @@
+import {HttpClient} from "../index";
+
+declare global {
+    interface Window {
+        any: any;
+    }
+}
+
+// Adapter for fetch API (works in both browser and Node.js with node-fetch)
+export class FetchHttpClient implements HttpClient {
+    private fetchFn: typeof fetch;
+
+    constructor(fetchImplementation?: typeof fetch) {
+        // 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: string, data: any, headers: Record<string, string> = {}): Promise<any> {
+        try {
+            const response = await this.fetchFn(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...headers,
+                },
+                body: JSON.stringify(data),
+            });
+
+            // x402: Handle 402 Payment Required specially (not an error)
+            if (response.status === 402) {
+                const paymentData = await response.json();
+                return {
+                    status: 402,
+                    data: paymentData,
+                    headers: Object.fromEntries(response.headers.entries())
+                };
+            }
+
+            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')) {
+                const jsonData = await response.json();
+                return {
+                    status: response.status,
+                    data: jsonData,
+                    headers: Object.fromEntries(response.headers.entries())
+                };
+            } else {
+                return {
+                    status: response.status,
+                    data: await response.text(),
+                    headers: Object.fromEntries(response.headers.entries())
+                };
+            }
+        } catch (error) {
+            if (error instanceof Error) {
+                throw error;
+            }
+            throw new Error(`Request failed: ${error}`);
+        }
+    }
+}
+
+// Adapter for axios (if user prefers axios)
+export class AxiosHttpClient implements HttpClient {
+    private axios: any;
+
+    constructor(axiosInstance: any) {
+        if (!axiosInstance) {
+            throw new Error('Axios instance is required');
+        }
+        this.axios = axiosInstance;
+    }
+
+    async post(url: string, data: any, headers: Record<string, string> = {}): Promise<any> {
+        try {
+            const response = await this.axios.post(url, data, {
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...headers,
+                },
+                validateStatus: (status: number) => status < 500  // Don't throw on 402
+            });
+
+            // Return consistent format with status and headers
+            return {
+                status: response.status,
+                data: response.data,
+                headers: response.headers || {}
+            };
+        } catch (error: any) {
+            // x402: Check if this is a 402 Payment Required error
+            if (error.response && error.response.status === 402) {
+                return {
+                    status: 402,
+                    data: error.response.data,
+                    headers: error.response.headers || {}
+                };
+            }
+
+            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}`);
+            }
+        }
+    }
+}
+
+// Simple HTTP client using Node.js built-in modules (for Node.js environments)
+export class NodeHttpClient implements HttpClient {
+    private timeout: number;
+
+    constructor(timeout: number = 30000) {
+        this.timeout = timeout;
+    }
+
+    async post(url: string, data: any, headers: Record<string, string> = {}): Promise<any> {
+        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: any) => {
+                let responseData = '';
+
+                res.on('data', (chunk: any) => {
+                    responseData += chunk;
+                });
+
+                res.on('end', () => {
+                    try {
+                        const contentType = res.headers['content-type'] || '';
+                        let parsedData;
+
+                        if (contentType.includes('application/json')) {
+                            parsedData = JSON.parse(responseData);
+                        } else {
+                            parsedData = responseData;
+                        }
+
+                        // x402: Handle 402 specially (not an error)
+                        if (res.statusCode === 402) {
+                            resolve({
+                                status: 402,
+                                data: parsedData,
+                                headers: res.headers
+                            });
+                            return;
+                        }
+
+                        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+                            resolve({
+                                status: res.statusCode,
+                                data: parsedData,
+                                headers: res.headers
+                            });
+                        } else {
+                            reject(new Error(`HTTP ${res.statusCode}: ${responseData}`));
+                        }
+                    } catch (error) {
+                        reject(new Error(`Failed to parse response: ${error}`));
+                    }
+                });
+            });
+
+            req.on('error', (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();
+        });
+    }
+}
+
+// Factory function to create appropriate HTTP client based on environment
+export function createHttpClient(
+    options: {
+        type?: 'fetch' | 'axios' | 'node';
+        fetchImplementation?: typeof fetch;
+        axiosInstance?: any;
+        timeout?: number;
+    } = {}
+): HttpClient {
+    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/ConditionBuilder.d.ts

@@ -0,0 +1,22 @@
+import { LogicalOperator, FieldConditionBuilder } from './operators';
+import { NestedConditionBuilder } from './NestedBuilders';
+export declare class ConditionBuilder {
+    private conditions;
+    private currentOperator?;
+    constructor();
+    static new(): ConditionBuilder;
+    field(fieldName: string): FieldConditionBuilder;
+    nested(fieldName: string, builderFn: (builder: NestedConditionBuilder) => LogicalOperator): LogicalOperator;
+    and(): ConditionBuilder;
+    or(): ConditionBuilder;
+    not(): ConditionBuilder;
+    andGroup(builderFn: (builder: ConditionBuilder) => LogicalOperator[]): LogicalOperator;
+    orGroup(builderFn: (builder: ConditionBuilder) => LogicalOperator[]): LogicalOperator;
+    notGroup(builderFn: (builder: ConditionBuilder) => LogicalOperator[]): LogicalOperator;
+    addCondition(condition: LogicalOperator): ConditionBuilder;
+    build(): LogicalOperator[];
+    buildSingle(): LogicalOperator;
+    clear(): ConditionBuilder;
+    isEmpty(): boolean;
+    getConditionCount(): number;
+}

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

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConditionBuilder = void 0;
+const operators_1 = require("./operators");
+const NestedBuilders_1 = require("./NestedBuilders");
+// Builder for creating complex conditions with logical operators
+class ConditionBuilder {
+    constructor() {
+        this.conditions = [];
+    }
+    static new() {
+        return new ConditionBuilder();
+    }
+    // Create a field condition builder
+    field(fieldName) {
+        return new operators_1.FieldConditionBuilder(fieldName);
+    }
+    // Create a nested field condition with fluent API (like Rust SDK)
+    nested(fieldName, builderFn) {
+        const nestedBuilder = new NestedBuilders_1.NestedConditionBuilder(fieldName);
+        return builderFn(nestedBuilder);
+    }
+    // Add an AND operator context
+    and() {
+        this.currentOperator = 'and';
+        return this;
+    }
+    // Add an OR operator context
+    or() {
+        this.currentOperator = 'or';
+        return this;
+    }
+    // Add a NOT operator context
+    not() {
+        this.currentOperator = 'not';
+        return this;
+    }
+    // Group conditions with AND logic
+    andGroup(builderFn) {
+        const nestedBuilder = new ConditionBuilder();
+        const conditions = builderFn(nestedBuilder);
+        return operators_1.LogicalOperator.And(conditions);
+    }
+    // Group conditions with OR logic
+    orGroup(builderFn) {
+        const nestedBuilder = new ConditionBuilder();
+        const conditions = builderFn(nestedBuilder);
+        return operators_1.LogicalOperator.Or(conditions);
+    }
+    // Group conditions with NOT logic
+    notGroup(builderFn) {
+        const nestedBuilder = new ConditionBuilder();
+        const conditions = builderFn(nestedBuilder);
+        return operators_1.LogicalOperator.Not(conditions);
+    }
+    // Add a condition to the current builder
+    addCondition(condition) {
+        this.conditions.push(condition);
+        return this;
+    }
+    // Build and return all conditions
+    build() {
+        return [...this.conditions];
+    }
+    // Build as a single logical operator (combines all conditions with AND by default)
+    buildSingle() {
+        if (this.conditions.length === 0) {
+            throw new Error('No conditions to build');
+        }
+        if (this.conditions.length === 1) {
+            return this.conditions[0];
+        }
+        return operators_1.LogicalOperator.And(this.conditions);
+    }
+    // Clear all conditions
+    clear() {
+        this.conditions = [];
+        this.currentOperator = undefined;
+        return this;
+    }
+    // Check if any conditions have been added
+    isEmpty() {
+        return this.conditions.length === 0;
+    }
+    // Get the number of conditions
+    getConditionCount() {
+        return this.conditions.length;
+    }
+}
+exports.ConditionBuilder = ConditionBuilder;

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

@@ -0,0 +1 @@
+export { FieldConditionBuilder } from './operators';

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldConditionBuilder = void 0;
+// Re-export from operators for convenience
+var operators_1 = require("./operators");
+Object.defineProperty(exports, "FieldConditionBuilder", { enumerable: true, get: function () { return operators_1.FieldConditionBuilder; } });

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

@@ -0,0 +1,43 @@
+import { LogicalOperator, Condition } from './operators';
+export declare class NestedConditionBuilder {
+    private path;
+    constructor(rootField: string);
+    field(fieldName: string): NestedFieldConditionBuilder;
+    nested(fieldName: string, builderFn: (builder: NestedConditionBuilder) => LogicalOperator): LogicalOperator;
+    andGroup(builderFn: (builder: NestedConditionBuilder) => LogicalOperator[]): LogicalOperator;
+    orGroup(builderFn: (builder: NestedConditionBuilder) => LogicalOperator[]): LogicalOperator;
+    notGroup(builderFn: (builder: NestedConditionBuilder) => LogicalOperator[]): LogicalOperator;
+}
+export declare class NestedFieldConditionBuilder {
+    private fieldPath;
+    constructor(fieldPath: string[]);
+    private createCondition;
+    equals(value: any): Condition;
+    notEquals(value: any): Condition;
+    in(values: any[]): Condition;
+    notIn(values: any[]): 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: any): Condition;
+    lessThan(value: any): Condition;
+    greaterThanOrEqual(value: any): Condition;
+    lessThanOrEqual(value: any): Condition;
+    isLocalIp(): Condition;
+    isExternalIp(): Condition;
+    b64(value: string): Condition;
+    inDataset(dataset: string): Condition;
+    inCountry(countryCode: string): Condition;
+    cidr(cidr: string): Condition;
+    between(min: any, max: any): Condition;
+    isTrue(): Condition;
+    isFalse(): Condition;
+}

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

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestedFieldConditionBuilder = exports.NestedConditionBuilder = void 0;
+const operators_1 = require("./operators");
+// Builder for creating nested field conditions with ORM-like syntax
+class NestedConditionBuilder {
+    constructor(rootField) {
+        this.path = [rootField];
+    }
+    // Add another level to the path and create field conditions
+    field(fieldName) {
+        const newPath = [...this.path, fieldName];
+        return new NestedFieldConditionBuilder(newPath);
+    }
+    // Create nested structure with callback
+    nested(fieldName, builderFn) {
+        const nestedPath = [...this.path, fieldName];
+        const nestedBuilder = new NestedConditionBuilder('');
+        nestedBuilder.path = nestedPath;
+        return builderFn(nestedBuilder);
+    }
+    // Create logical groups
+    andGroup(builderFn) {
+        const conditions = builderFn(this);
+        return operators_1.LogicalOperator.And(conditions);
+    }
+    orGroup(builderFn) {
+        const conditions = builderFn(this);
+        return operators_1.LogicalOperator.Or(conditions);
+    }
+    notGroup(builderFn) {
+        const conditions = builderFn(this);
+        return operators_1.LogicalOperator.Not(conditions);
+    }
+}
+exports.NestedConditionBuilder = NestedConditionBuilder;
+// Builder for field conditions within nested structures
+// Only includes operators that actually exist in the Rust implementation
+class NestedFieldConditionBuilder {
+    constructor(fieldPath) {
+        this.fieldPath = fieldPath;
+    }
+    createCondition(operator, value) {
+        const path = this.fieldPath.join('.');
+        return {
+            field: path,
+            operator,
+            value
+        };
+    }
+    // ===== BASE OPERATORS (BaseOperator) =====
+    equals(value) {
+        return this.createCondition('is', value);
+    }
+    notEquals(value) {
+        return this.createCondition('isNot', value);
+    }
+    in(values) {
+        return this.createCondition('in', values);
+    }
+    notIn(values) {
+        return this.createCondition('notIn', values);
+    }
+    isNull() {
+        return this.createCondition('isNull', true);
+    }
+    isNotNull() {
+        return this.createCondition('isNull', false);
+    }
+    exists() {
+        return this.createCondition('exists', true);
+    }
+    notExists() {
+        return this.createCondition('exists', false);
+    }
+    // ===== STRING OPERATORS (StringOperator) =====
+    startsWith(value) {
+        return this.createCondition('startsWith', value);
+    }
+    endsWith(value) {
+        return this.createCondition('endsWith', value);
+    }
+    contains(value) {
+        return this.createCondition('includes', value);
+    }
+    regExpMatches(pattern) {
+        return this.createCondition('regExpMatches', pattern);
+    }
+    includesCaseInsensitive(value) {
+        return this.createCondition('includesCaseInsensitive', value);
+    }
+    startsWithCaseInsensitive(value) {
+        return this.createCondition('startsWithCaseInsensitive', value);
+    }
+    endsWithCaseInsensitive(value) {
+        return this.createCondition('endsWithCaseInsensitive', value);
+    }
+    // ===== NUMBER OPERATORS (NumberOperator) =====
+    greaterThan(value) {
+        return this.createCondition('greaterThan', value);
+    }
+    lessThan(value) {
+        return this.createCondition('lessThan', value);
+    }
+    greaterThanOrEqual(value) {
+        return this.createCondition('greaterThanOrEqual', value);
+    }
+    lessThanOrEqual(value) {
+        return this.createCondition('lessThanOrEqual', value);
+    }
+    // ===== IP OPERATORS (IpOperator) =====
+    isLocalIp() {
+        return this.createCondition('isLocalIp', true);
+    }
+    isExternalIp() {
+        return this.createCondition('isExternalIp', true);
+    }
+    // ===== MISC OPERATORS (MiscOperator) =====
+    b64(value) {
+        return this.createCondition('b64', value);
+    }
+    inDataset(dataset) {
+        return this.createCondition('inDataset', dataset);
+    }
+    inCountry(countryCode) {
+        return this.createCondition('inCountry', countryCode);
+    }
+    cidr(cidr) {
+        return this.createCondition('CIDR', cidr);
+    }
+    // ===== BETWEEN OPERATOR =====
+    between(min, max) {
+        return this.createCondition('betweenOp', { from: min, to: max });
+    }
+    // ===== CONVENIENCE METHODS =====
+    // Boolean checks (using base operators)
+    isTrue() {
+        return this.equals(true);
+    }
+    isFalse() {
+        return this.equals(false);
+    }
+}
+exports.NestedFieldConditionBuilder = NestedFieldConditionBuilder;

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

@@ -0,0 +1,19 @@
+import { QueryBuilder } from './QueryBuilder';
+import { SelectionBuilder } from './SelectionBuilder';
+import { FieldMap, HttpClient, QueryResponse } from "./index";
+export declare class OnChainDB {
+    private static httpClient?;
+    private static serverUrl?;
+    static configure(httpClient: HttpClient, serverUrl: string): void;
+    static getHttpClient(): HttpClient | undefined;
+    static getServerUrl(): string | undefined;
+    static query(): QueryBuilder;
+    static queryWith(httpClient: HttpClient, serverUrl: string): QueryBuilder;
+    static select(builderFn: (builder: SelectionBuilder) => SelectionBuilder): QueryBuilder;
+    static rawQuery(queryJson: string, httpClient?: HttpClient, serverUrl?: string, fieldMap?: FieldMap): Promise<QueryResponse>;
+    static queryFromJson(queryObject: any, httpClient?: HttpClient, serverUrl?: string): Promise<QueryResponse>;
+    static healthCheck(httpClient?: HttpClient, serverUrl?: string): Promise<boolean>;
+    static serverInfo(httpClient?: HttpClient, serverUrl?: string): Promise<any>;
+    static reset(): void;
+    static isConfigured(): boolean;
+}