@onchaindb/sdk 0.4.5 → 2.0.0

package/src/batch.ts

@@ -1,257 +0,0 @@
-import { OnChainDBClient } from './client';
-import { StoreRequest, StoreResponse, TransactionStatus } from './types';
-import { EventEmitter } from 'eventemitter3';
-
-/**
- * Batch operations for OnChainDB
- * 
- * Allows efficient batch insertion with transaction management
- * and progress tracking for large datasets.
- */
-export class BatchOperations extends EventEmitter {
-  constructor(private client: OnChainDBClient) {
-    super();
-  }
-
-  /**
-   * Batch store multiple records
-   * 
-   * @param requests - Array of store requests
-   * @param options - Batch options including payment configuration
-   * @returns Promise resolving to array of store responses
-   * 
-   * @example
-   * ```typescript
-   * const batch = new BatchOperations(db);
-   * 
-   * const results = await batch.store([
-   *   { data: { message: 'Tweet 1' }, collection: 'tweets' },
-   *   { data: { message: 'Tweet 2' }, collection: 'tweets' },
-   *   { data: { message: 'Tweet 3' }, collection: 'tweets' }
-   * ], {
-   *   concurrency: 5,
-   *   waitForConfirmation: true,
-   *   paymentOptions: {
-   *     userWallet: keplrWallet,
-   *     brokerAddress: 'celestia1xyz...'
-   *   }
-   * });
-   * ```
-   */
-  async store(
-    requests: StoreRequest[],
-    options: {
-      concurrency?: number;
-      waitForConfirmation?: boolean;
-      onProgress?: (completed: number, total: number) => void;
-      paymentOptions?: {
-        userWallet?: any;
-        brokerAddress?: string;
-      };
-    } = {}
-  ): Promise<StoreResponse[]> {
-    const {
-      concurrency = 10,
-      waitForConfirmation = false,
-      onProgress,
-      paymentOptions
-    } = options;
-
-    const results: StoreResponse[] = [];
-    const errors: Array<{ index: number; error: Error }> = [];
-    let completed = 0;
-
-    // Process requests in batches with concurrency limit
-    for (let i = 0; i < requests.length; i += concurrency) {
-      const batch = requests.slice(i, i + concurrency);
-      const batchPromises = batch.map(async (request, batchIndex) => {
-        const globalIndex = i + batchIndex;
-        try {
-          const result = await this.client.store(request, undefined, waitForConfirmation);
-          results[globalIndex] = result;
-          completed++;
-          onProgress?.(completed, requests.length);
-          this.emit('progress', { completed, total: requests.length, success: true });
-          return result;
-        } catch (error) {
-          errors.push({ index: globalIndex, error: error as Error });
-          completed++;
-          onProgress?.(completed, requests.length);
-          this.emit('progress', { completed, total: requests.length, success: false, error });
-          throw error;
-        }
-      });
-
-      // Wait for current batch to complete before starting next
-      await Promise.allSettled(batchPromises);
-    }
-
-    if (errors.length > 0) {
-      this.emit('batchComplete', { results, errors });
-      throw new Error(`Batch operation failed: ${errors.length}/${requests.length} requests failed`);
-    }
-
-    this.emit('batchComplete', { results, errors: [] });
-    return results;
-  }
-
-  /**
-   * Batch store with retry logic
-   * 
-   * @param requests - Store requests
-   * @param options - Batch options with retry configuration and payment support
-   * @returns Store responses
-   */
-  async storeWithRetry(
-    requests: StoreRequest[],
-    options: {
-      concurrency?: number;
-      waitForConfirmation?: boolean;
-      maxRetries?: number;
-      retryDelay?: number;
-      onProgress?: (completed: number, total: number) => void;
-      paymentOptions?: {
-        userWallet?: any;
-        brokerAddress?: string;
-      };
-    } = {}
-  ): Promise<StoreResponse[]> {
-    const {
-      maxRetries = 3,
-      retryDelay = 1000,
-      ...batchOptions
-    } = options;
-
-    let attempt = 0;
-    let lastError: Error;
-
-    while (attempt <= maxRetries) {
-      try {
-        return await this.store(requests, batchOptions);
-      } catch (error) {
-        lastError = error as Error;
-        attempt++;
-        
-        if (attempt <= maxRetries) {
-          this.emit('retryAttempt', { attempt, maxRetries, error });
-          await this.sleep(retryDelay * attempt); // Exponential backoff
-        }
-      }
-    }
-
-    throw lastError!;
-  }
-
-  /**
-   * Monitor multiple transactions for confirmation
-   * 
-   * @param transactionIds - Array of transaction IDs to monitor
-   * @param maxWaitTime - Maximum wait time per transaction
-   * @returns Promise resolving when all transactions are confirmed
-   */
-  async waitForBatchConfirmation(
-    transactionIds: string[],
-    maxWaitTime: number = 300000
-  ): Promise<TransactionStatus[]> {
-    const confirmationPromises = transactionIds.map(async (id, index) => {
-      try {
-        const result = await this.client.waitForConfirmation(id, maxWaitTime);
-        this.emit('transactionConfirmed', { id, index, result });
-        return {
-          id,
-          status: 'confirmed' as const,
-          block_height: result.block_height,
-          transaction_hash: result.transaction_hash,
-          celestia_height: result.celestia_height
-        };
-      } catch (error) {
-        this.emit('transactionFailed', { id, index, error });
-        return {
-          id,
-          status: 'failed' as const,
-          error: (error as Error).message
-        };
-      }
-    });
-
-    return Promise.all(confirmationPromises);
-  }
-
-  private sleep(ms: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, ms));
-  }
-}
-
-/**
- * Utility class for building bulk operations
- * 
- * @example
- * ```typescript
- * const builder = new BulkBuilder()
- *   .collection('tweets')
- *   .add({ message: 'Tweet 1', author: 'alice' })
- *   .add({ message: 'Tweet 2', author: 'bob' })
- *   .add({ message: 'Tweet 3', author: 'charlie' });
- * 
- * const results = await db.batch().store(builder.build());
- * ```
- */
-export class BulkBuilder {
-  private requests: StoreRequest[] = [];
-  private defaultCollection?: string;
-  private defaultApp?: string;
-
-  /**
-   * Set default collection for all subsequent operations
-   */
-  collection(name: string): this {
-    this.defaultCollection = name;
-    return this;
-  }
-
-  /**
-   * Set default app for all subsequent operations
-   */
-  app(name: string): this {
-    this.defaultApp = name;
-    return this;
-  }
-
-  /**
-   * Add a data record to the bulk operation
-   */
-  add(data: Record<string, any>, collection?: string, app?: string): this {
-    this.requests.push({data: [data], root: `${app}::${collection}`});
-    return this;
-  }
-
-  /**
-   * Add multiple data records
-   */
-  addMany(records: Record<string, any>[], collection?: string, app?: string): this {
-    records.forEach(data => this.add(data, collection, app));
-    return this;
-  }
-
-  /**
-   * Build the final array of store requests
-   */
-  build(): StoreRequest[] {
-    return [...this.requests];
-  }
-
-  /**
-   * Get the number of operations in the builder
-   */
-  count(): number {
-    return this.requests.length;
-  }
-
-  /**
-   * Clear all operations
-   */
-  clear(): this {
-    this.requests = [];
-    return this;
-  }
-}

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

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

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

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

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

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

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

@@ -1,144 +0,0 @@
-"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/QueryBuilder.d.ts

@@ -1,70 +0,0 @@
-import { QueryRequest, QueryResponse, Val } from '../index';
-import { LogicalOperator } from './operators';
-import { SelectionBuilder } from './SelectionBuilder';
-import { ConditionBuilder } from './ConditionBuilder';
-import { FieldMap, HttpClient } from "./index";
-export declare class QueryBuilder {
-    private findConditions?;
-    private selections?;
-    private fieldMap?;
-    private limitValue?;
-    private offsetValue?;
-    private sortBy?;
-    private sortDirection?;
-    private httpClient?;
-    private serverUrl?;
-    private collectionName;
-    private app;
-    constructor(httpClient?: HttpClient, serverUrl?: string, app?: string);
-    static new(httpClient?: HttpClient, serverUrl?: string, app?: string): QueryBuilder;
-    withHttpClient(httpClient: HttpClient): QueryBuilder;
-    withServerUrl(serverUrl: string): QueryBuilder;
-    find(builderFn: (builder: ConditionBuilder) => LogicalOperator): QueryBuilder;
-    collection(s: string): QueryBuilder;
-    whereField(fieldName: string): WhereClause;
-    select(builderFn: (builder: SelectionBuilder) => SelectionBuilder): QueryBuilder;
-    selectFields(fields: string[]): QueryBuilder;
-    selectAll(): QueryBuilder;
-    withFieldMap(fieldMap: FieldMap): QueryBuilder;
-    limit(limit: number): QueryBuilder;
-    offset(offset: number): QueryBuilder;
-    orderBy(fields: string): QueryBuilder;
-    execute<T extends Record<string, any>>(): Promise<QueryResponse<T>>;
-    isValid(): boolean;
-    buildRawQuery(): QueryRequest;
-    clone(): QueryBuilder;
-    private buildQueryValue;
-}
-export declare class WhereClause {
-    private queryBuilder;
-    private fieldName;
-    constructor(queryBuilder: QueryBuilder, fieldName: string);
-    equals(value: Val): QueryBuilder;
-    notEquals(value: Val): QueryBuilder;
-    greaterThan(value: Val): QueryBuilder;
-    greaterThanOrEqual(value: Val): QueryBuilder;
-    lessThan(value: Val): QueryBuilder;
-    lessThanOrEqual(value: Val): QueryBuilder;
-    contains(value: string): QueryBuilder;
-    startsWith(value: string): QueryBuilder;
-    endsWith(value: string): QueryBuilder;
-    in(values: Val[]): QueryBuilder;
-    notIn(values: Val[]): QueryBuilder;
-    exists(): QueryBuilder;
-    notExists(): QueryBuilder;
-    isNull(): QueryBuilder;
-    isNotNull(): QueryBuilder;
-    regExpMatches(pattern: string): QueryBuilder;
-    includesCaseInsensitive(value: string): QueryBuilder;
-    startsWithCaseInsensitive(value: string): QueryBuilder;
-    endsWithCaseInsensitive(value: string): QueryBuilder;
-    isLocalIp(): QueryBuilder;
-    isExternalIp(): QueryBuilder;
-    b64(value: string): QueryBuilder;
-    inDataset(dataset: string): QueryBuilder;
-    inCountry(countryCode: string): QueryBuilder;
-    cidr(cidr: string): QueryBuilder;
-    between(min: any, max: any): QueryBuilder;
-    isTrue(): QueryBuilder;
-    isFalse(): QueryBuilder;
-}