@onchaindb/sdk 0.4.5 → 1.0.0

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

@@ -1,52 +0,0 @@
-export declare class QueryResult<T = any> {
-    data: T[];
-    constructor(data: T[]);
-    len(): number;
-    length(): number;
-    isEmpty(): boolean;
-    first(): T | undefined;
-    last(): T | undefined;
-    get(index: number): T | undefined;
-    any(predicate: (item: T) => boolean): boolean;
-    all(predicate: (item: T) => boolean): boolean;
-    find(predicate: (item: T) => boolean): T | undefined;
-    filter(predicate: (item: T) => boolean): T[];
-    map<U>(transform: (item: T) => U): U[];
-    forEach(callback: (item: T, index: number) => void): void;
-    reduce<U>(callback: (accumulator: U, item: T, index: number) => U, initialValue: U): U;
-    groupBy(field: string): Record<string, T[]>;
-    pluck(field: string): any[];
-    pluckStrings(field: string): (string | null)[];
-    pluckNumbers(field: string): (number | null)[];
-    summarizeNumeric(field: string): NumericSummary | null;
-    sortBy(field: string, ascending?: boolean): T[];
-    sortByMultiple(fields: Array<{
-        field: string;
-        ascending?: boolean;
-    }>): T[];
-    paginate(page: number, pageSize: number): T[];
-    chunk(size: number): T[][];
-    distinctBy(field: string): T[];
-    unique(): T[];
-    count(predicate?: (item: T) => boolean): number;
-    countBy(field: string): Record<string, number>;
-    private getNestedValue;
-    toArray(): T[];
-    toJSON(): string;
-    cast<U>(): QueryResult<U>;
-    innerJoin<U>(other: QueryResult<U>, thisKey: string, otherKey: string): Array<T & U>;
-    leftJoin<U>(other: QueryResult<U>, thisKey: string, otherKey: string): Array<T & Partial<U>>;
-    toCsv(delimiter?: string): string;
-    inspect(limit?: number): void;
-}
-export interface NumericSummary {
-    count: number;
-    sum: number;
-    mean: number;
-    median: number;
-    min: number;
-    max: number;
-    standardDeviation: number;
-    variance: number;
-}
-export declare function createQueryResult<T>(data: T[]): QueryResult<T>;

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

@@ -1,293 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryResult = void 0;
-exports.createQueryResult = createQueryResult;
-// Query result utilities class matching Rust SDK functionality
-class QueryResult {
-    constructor(data) {
-        this.data = Array.isArray(data) ? data : [data];
-    }
-    // ===== BASIC UTILITIES =====
-    len() {
-        return this.data.length;
-    }
-    length() {
-        return this.len();
-    }
-    isEmpty() {
-        return this.data.length === 0;
-    }
-    first() {
-        return this.data[0];
-    }
-    last() {
-        return this.data[this.data.length - 1];
-    }
-    get(index) {
-        return this.data[index];
-    }
-    // ===== ITERATION UTILITIES =====
-    any(predicate) {
-        return this.data.some(predicate);
-    }
-    all(predicate) {
-        return this.data.every(predicate);
-    }
-    find(predicate) {
-        return this.data.find(predicate);
-    }
-    filter(predicate) {
-        return this.data.filter(predicate);
-    }
-    map(transform) {
-        return this.data.map(transform);
-    }
-    forEach(callback) {
-        this.data.forEach(callback);
-    }
-    reduce(callback, initialValue) {
-        return this.data.reduce(callback, initialValue);
-    }
-    // ===== AGGREGATION UTILITIES =====
-    groupBy(field) {
-        const groups = {};
-        this.data.forEach(item => {
-            const key = this.getNestedValue(item, field);
-            const keyString = String(key ?? 'null');
-            if (!groups[keyString]) {
-                groups[keyString] = [];
-            }
-            groups[keyString].push(item);
-        });
-        return groups;
-    }
-    // Pluck values from a specific field across all records
-    pluck(field) {
-        return this.data.map(item => this.getNestedValue(item, field));
-    }
-    pluckStrings(field) {
-        return this.data.map(item => {
-            const value = this.getNestedValue(item, field);
-            return typeof value === 'string' ? value : (value != null ? String(value) : null);
-        });
-    }
-    pluckNumbers(field) {
-        return this.data.map(item => {
-            const value = this.getNestedValue(item, field);
-            if (typeof value === 'number' && !isNaN(value)) {
-                return value;
-            }
-            const parsed = Number(value);
-            return !isNaN(parsed) ? parsed : null;
-        });
-    }
-    // ===== NUMERIC SUMMARY =====
-    summarizeNumeric(field) {
-        const numbers = this.pluckNumbers(field).filter(n => n !== null);
-        if (numbers.length === 0) {
-            return null;
-        }
-        const sum = numbers.reduce((acc, n) => acc + n, 0);
-        const mean = sum / numbers.length;
-        const min = Math.min(...numbers);
-        const max = Math.max(...numbers);
-        // Calculate median
-        const sortedNumbers = [...numbers].sort((a, b) => a - b);
-        const mid = Math.floor(sortedNumbers.length / 2);
-        const median = sortedNumbers.length % 2 !== 0
-            ? sortedNumbers[mid]
-            : (sortedNumbers[mid - 1] + sortedNumbers[mid]) / 2;
-        // Calculate standard deviation
-        const variance = numbers.reduce((acc, n) => acc + Math.pow(n - mean, 2), 0) / numbers.length;
-        const standardDeviation = Math.sqrt(variance);
-        return {
-            count: numbers.length,
-            sum,
-            mean,
-            median,
-            min,
-            max,
-            standardDeviation,
-            variance
-        };
-    }
-    // ===== SORTING =====
-    sortBy(field, ascending = true) {
-        const sorted = [...this.data].sort((a, b) => {
-            const valueA = this.getNestedValue(a, field);
-            const valueB = this.getNestedValue(b, field);
-            // Handle null/undefined values
-            if (valueA == null && valueB == null)
-                return 0;
-            if (valueA == null)
-                return ascending ? -1 : 1;
-            if (valueB == null)
-                return ascending ? 1 : -1;
-            // Compare values
-            let comparison = 0;
-            if (valueA < valueB)
-                comparison = -1;
-            else if (valueA > valueB)
-                comparison = 1;
-            return ascending ? comparison : -comparison;
-        });
-        return sorted;
-    }
-    // Multiple field sorting
-    sortByMultiple(fields) {
-        const sorted = [...this.data].sort((a, b) => {
-            for (const { field, ascending = true } of fields) {
-                const valueA = this.getNestedValue(a, field);
-                const valueB = this.getNestedValue(b, field);
-                // Handle null/undefined values
-                if (valueA == null && valueB == null)
-                    continue;
-                if (valueA == null)
-                    return ascending ? -1 : 1;
-                if (valueB == null)
-                    return ascending ? 1 : -1;
-                // Compare values
-                let comparison = 0;
-                if (valueA < valueB)
-                    comparison = -1;
-                else if (valueA > valueB)
-                    comparison = 1;
-                if (comparison !== 0) {
-                    return ascending ? comparison : -comparison;
-                }
-            }
-            return 0;
-        });
-        return sorted;
-    }
-    // ===== PAGINATION =====
-    paginate(page, pageSize) {
-        const startIndex = (page - 1) * pageSize;
-        const endIndex = startIndex + pageSize;
-        return this.data.slice(startIndex, endIndex);
-    }
-    chunk(size) {
-        const chunks = [];
-        for (let i = 0; i < this.data.length; i += size) {
-            chunks.push(this.data.slice(i, i + size));
-        }
-        return chunks;
-    }
-    // ===== DISTINCT/UNIQUE =====
-    distinctBy(field) {
-        const seen = new Set();
-        return this.data.filter(item => {
-            const value = this.getNestedValue(item, field);
-            const key = String(value);
-            if (seen.has(key)) {
-                return false;
-            }
-            seen.add(key);
-            return true;
-        });
-    }
-    unique() {
-        return [...new Set(this.data)];
-    }
-    // ===== STATISTICAL FUNCTIONS =====
-    count(predicate) {
-        if (predicate) {
-            return this.data.filter(predicate).length;
-        }
-        return this.data.length;
-    }
-    countBy(field) {
-        const counts = {};
-        this.data.forEach(item => {
-            const key = String(this.getNestedValue(item, field) ?? 'null');
-            counts[key] = (counts[key] || 0) + 1;
-        });
-        return counts;
-    }
-    // ===== UTILITY METHODS =====
-    // Get nested field value using dot notation
-    getNestedValue(obj, path) {
-        return path.split('.').reduce((current, key) => {
-            return current && typeof current === 'object' ? current[key] : undefined;
-        }, obj);
-    }
-    // ===== TRANSFORMATION =====
-    toArray() {
-        return [...this.data];
-    }
-    toJSON() {
-        return JSON.stringify(this.data);
-    }
-    // Convert to QueryResult with different type
-    cast() {
-        return new QueryResult(this.data);
-    }
-    // ===== JOINING (similar to SQL joins) =====
-    innerJoin(other, thisKey, otherKey) {
-        const results = [];
-        this.data.forEach(thisItem => {
-            const thisValue = this.getNestedValue(thisItem, thisKey);
-            other.data.forEach(otherItem => {
-                const otherValue = this.getNestedValue(otherItem, otherKey);
-                if (thisValue === otherValue) {
-                    results.push({ ...thisItem, ...otherItem });
-                }
-            });
-        });
-        return results;
-    }
-    leftJoin(other, thisKey, otherKey) {
-        const results = [];
-        this.data.forEach(thisItem => {
-            const thisValue = this.getNestedValue(thisItem, thisKey);
-            const matches = other.data.filter(otherItem => this.getNestedValue(otherItem, otherKey) === thisValue);
-            if (matches.length > 0) {
-                matches.forEach(match => {
-                    results.push({ ...thisItem, ...match });
-                });
-            }
-            else {
-                results.push({ ...thisItem });
-            }
-        });
-        return results;
-    }
-    // ===== EXPORT/FORMATTING =====
-    toCsv(delimiter = ',') {
-        if (this.data.length === 0)
-            return '';
-        // Get all unique keys from all objects
-        const allKeys = new Set();
-        this.data.forEach(item => {
-            if (typeof item === 'object' && item !== null) {
-                Object.keys(item).forEach(key => allKeys.add(key));
-            }
-        });
-        const headers = Array.from(allKeys);
-        const csvRows = [headers.join(delimiter)];
-        this.data.forEach(item => {
-            const row = headers.map(header => {
-                const value = typeof item === 'object' && item !== null ? item[header] : '';
-                // Escape values that contain the delimiter
-                const stringValue = String(value ?? '');
-                return stringValue.includes(delimiter) ? `"${stringValue}"` : stringValue;
-            });
-            csvRows.push(row.join(delimiter));
-        });
-        return csvRows.join('\n');
-    }
-    // ===== DEBUGGING =====
-    inspect(limit) {
-        const itemsToShow = limit ? this.data.slice(0, limit) : this.data;
-        console.log('QueryResult:', {
-            count: this.data.length,
-            showing: itemsToShow.length,
-            data: itemsToShow
-        });
-    }
-}
-exports.QueryResult = QueryResult;
-// Utility function to create QueryResult
-function createQueryResult(data) {
-    return new QueryResult(data);
-}

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

@@ -1,20 +0,0 @@
-import { SelectionMap } from '../index';
-export declare class SelectionBuilder {
-    private selections;
-    constructor();
-    static new(): SelectionBuilder;
-    static all(): SelectionMap;
-    field(fieldName: string): SelectionBuilder;
-    fields(fieldNames: string[]): SelectionBuilder;
-    nested<T>(fieldName: string, builderFn: (nested: SelectionBuilder) => T): SelectionBuilder;
-    exclude(fieldName: string): SelectionBuilder;
-    excludeFields(fieldNames: string[]): SelectionBuilder;
-    build(): SelectionMap;
-    clear(): SelectionBuilder;
-    isEmpty(): boolean;
-    getSelectionCount(): number;
-    hasField(fieldName: string): boolean;
-    isFieldExcluded(fieldName: string): boolean;
-    getSelectedFields(): string[];
-    getExcludedFields(): string[];
-}

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';