@onchaindb/sdk 0.4.0 → 0.4.2

package/src/.env

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

package/src/batch.d.ts

@@ -0,0 +1,121 @@
+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 declare class BatchOperations extends EventEmitter {
+    private client;
+    constructor(client: OnChainDBClient);
+    /**
+     * 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...'
+     *   }
+     * });
+     * ```
+     */
+    store(requests: StoreRequest[], options?: {
+        concurrency?: number;
+        waitForConfirmation?: boolean;
+        onProgress?: (completed: number, total: number) => void;
+        paymentOptions?: {
+            userWallet?: any;
+            brokerAddress?: string;
+        };
+    }): Promise<StoreResponse[]>;
+    /**
+     * Batch store with retry logic
+     *
+     * @param requests - Store requests
+     * @param options - Batch options with retry configuration and payment support
+     * @returns Store responses
+     */
+    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[]>;
+    /**
+     * 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
+     */
+    waitForBatchConfirmation(transactionIds: string[], maxWaitTime?: number): Promise<TransactionStatus[]>;
+    private sleep;
+}
+/**
+ * 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 declare class BulkBuilder {
+    private requests;
+    private defaultCollection?;
+    private defaultApp?;
+    /**
+     * Set default collection for all subsequent operations
+     */
+    collection(name: string): this;
+    /**
+     * Set default app for all subsequent operations
+     */
+    app(name: string): this;
+    /**
+     * Add a data record to the bulk operation
+     */
+    add(data: Record<string, any>, collection?: string, app?: string): this;
+    /**
+     * Add multiple data records
+     */
+    addMany(records: Record<string, any>[], collection?: string, app?: string): this;
+    /**
+     * Build the final array of store requests
+     */
+    build(): StoreRequest[];
+    /**
+     * Get the number of operations in the builder
+     */
+    count(): number;
+    /**
+     * Clear all operations
+     */
+    clear(): this;
+}

package/src/batch.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BulkBuilder = exports.BatchOperations = void 0;
+const eventemitter3_1 = require("eventemitter3");
+/**
+ * Batch operations for OnChainDB
+ *
+ * Allows efficient batch insertion with transaction management
+ * and progress tracking for large datasets.
+ */
+class BatchOperations extends eventemitter3_1.EventEmitter {
+    constructor(client) {
+        super();
+        this.client = client;
+    }
+    /**
+     * 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, options = {}) {
+        const { concurrency = 10, waitForConfirmation = false, onProgress, paymentOptions } = options;
+        const results = [];
+        const errors = [];
+        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, paymentOptions, 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 });
+                    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, options = {}) {
+        const { maxRetries = 3, retryDelay = 1000, ...batchOptions } = options;
+        let attempt = 0;
+        let lastError;
+        while (attempt <= maxRetries) {
+            try {
+                return await this.store(requests, batchOptions);
+            }
+            catch (error) {
+                lastError = 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, maxWaitTime = 300000) {
+        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',
+                    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',
+                    error: error.message
+                };
+            }
+        });
+        return Promise.all(confirmationPromises);
+    }
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+exports.BatchOperations = BatchOperations;
+/**
+ * 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());
+ * ```
+ */
+class BulkBuilder {
+    constructor() {
+        this.requests = [];
+    }
+    /**
+     * Set default collection for all subsequent operations
+     */
+    collection(name) {
+        this.defaultCollection = name;
+        return this;
+    }
+    /**
+     * Set default app for all subsequent operations
+     */
+    app(name) {
+        this.defaultApp = name;
+        return this;
+    }
+    /**
+     * Add a data record to the bulk operation
+     */
+    add(data, collection, app) {
+        this.requests.push({ data: [data], root: `${app}::${collection}` });
+        return this;
+    }
+    /**
+     * Add multiple data records
+     */
+    addMany(records, collection, app) {
+        records.forEach(data => this.add(data, collection, app));
+        return this;
+    }
+    /**
+     * Build the final array of store requests
+     */
+    build() {
+        return [...this.requests];
+    }
+    /**
+     * Get the number of operations in the builder
+     */
+    count() {
+        return this.requests.length;
+    }
+    /**
+     * Clear all operations
+     */
+    clear() {
+        this.requests = [];
+        return this;
+    }
+}
+exports.BulkBuilder = BulkBuilder;

package/src/batch.ts

@@ -0,0 +1,257 @@
+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;
+  }
+}