@onchaindb/sdk 0.4.5 → 1.0.0

package/src/index.ts

@@ -1,14 +1,9 @@
 // Main SDK exports
-export {OnChainDBClient} from './client';
-export {BatchOperations, BulkBuilder} from './batch';
+export { OnChainDBClient } from './client';
+export { QueryBuilder } from './query-sdk';
+export { DatabaseManager, createDatabaseManager } from './database';
 
-// Query builder exports from ./query-sdk
-export {QueryBuilder, SelectionBuilder, FieldConditionBuilder, LogicalOperator, ConditionBuilder, JoinBuilder, OnChainDB} from './query-sdk';
-
-// Database management exports
-export {DatabaseManager, createDatabaseManager} from './database';
-
-// Type exports
+// Core type exports
 export type {
     OnChainDBConfig,
     StoreRequest,
@@ -30,55 +25,58 @@ export type {
     PricingQuoteResponse,
     SimpleCollectionSchema,
     SimpleFieldDefinition,
+    SimpleCollectionSchemaWithSharding,
+    ShardingStrategy,
+    ShardKey,
     CreateCollectionResult,
     SyncCollectionResult,
+    UpdateCollectionRequest,
+    SetRetentionRequest,
+    ApiConfig,
+    SqlQueryRequest,
+    SqlQueryResponse,
+    SqlInsertRequest,
+    SqlCreateViewRequest,
+    ViewDataResponse,
+    ViewQueryRequest,
+    QueryParameter,
+    QueryDefinition,
+    CreateQueryRequest,
+    CreateQueryResponse,
+    QueryDataResponse,
+    RetentionConfig,
+    CollectionRetentionCost,
+    RetentionCostResponse,
+    CollectionResponse,
+    CreateApiCollectionRequest,
     BaseDocument,
-    ShardingStrategy,
-    ShardKey,
-    SimpleCollectionSchemaWithSharding
+    AppKeyPermission,
+    PayLimits,
+    CreateKeyRequest,
+    AppKeyInfo,
 } from './types';
 
-// Query type exports from ./query-sdk
-export type {
-    SelectionMap,
-    QueryRequest as RawQuery,
-    QueryResponse as OnChainQueryResponse,
-    QueryValue,
-    Val
-} from './query-sdk';
-
-// Re-export operator types from ./query-sdk
-export type {Condition} from './query-sdk';
+// Query type exports (useful for advanced typing)
+export type { QueryResponse as RawQueryResponse, SelectionMap, Val } from './query-sdk';
 
-// x402 payment types
+// x402 payment types (needed for payment callbacks)
 export type {
     X402Quote,
     X402PaymentRequirement,
     X402PaymentResult,
+    X402PaymentCallbackResult,
     ChainType,
-    PaymentMethod
+    PaymentMethod,
 } from './x402';
 
 // Database management type exports
 export type {
-    Collection,
-    CollectionSchema,
-    FieldDefinition,
-    FieldValidation,
-    Relationship,
     Index,
     IndexOptions,
-    IndexStatus,
-    IndexStatistics,
     PriceConfig,
-    CollectionMetadata,
-    DatabaseStats,
-    QueryPlan,
-    BatchOperation,
-    BatchResult,
     MaterializedView,
     ViewInfo,
-    ListViewsResponse
+    ListViewsResponse,
 } from './database';
 
 // Error exports
@@ -87,167 +85,16 @@ export {
     TransactionError,
     ValidationError,
     PaymentRequiredError,
-    PaymentVerificationError
+    PaymentVerificationError,
 } from './types';
 
-// Import types for factory function
-import {OnChainDBConfig} from './types';
-import {OnChainDBClient} from './client';
-
 // Convenience factory function
+import { OnChainDBConfig } from './types';
+import { OnChainDBClient } from './client';
+
 export function createClient(config: OnChainDBConfig): OnChainDBClient {
     return new OnChainDBClient(config);
 }
 
-// Re-export HTTP client utilities from ./query-sdk for advanced usage
-export {AxiosHttpClient, FetchHttpClient, NodeHttpClient, createHttpClient} from './query-sdk';
-
 // SDK version
 export const VERSION = '1.0.0';
-
-/**
- * OnChainDB TypeScript SDK
- *
- * A complete TypeScript SDK for OnChainDB - the decentralized database
- * built on Celestia blockchain.
- *
- * Features:
- * - ✅ Full type safety with TypeScript
- * - ✅ Automatic transaction management
- * - ✅ Real-time confirmation tracking
- * - ✅ Batch operations with progress tracking
- * - ✅ Built-in error handling and retries
- * - ✅ Event-driven architecture
- * - ✅ Query building and filtering
- * - ✅ Complete database management (collections, indexes, schemas)
- * - ✅ Performance monitoring and optimization
- * - ✅ Schema validation and migration
- *
- * @example Basic Usage
- * ```typescript
- * import { createClient } from '@onchaindb/sdk';
- *
- * const db = createClient({
- *   endpoint: 'http://localhost:9092',
- *   apiKey: 'your-api-key'
- * });
- *
- * // Store data
- * const result = await db.store({
- *   data: { message: 'Hello OnChainDB!', user: 'alice' },
- *   collection: 'messages'
- * });
- *
- * console.log('Stored with ID:', result.id);
- * console.log('Transaction:', result.transaction_hash);
- *
- * // Query data
- * const messages = await db.query({ 
- *   collection: 'messages',
- *   limit: 10 
- * });
- *
- * console.log(`Found ${messages.total} messages`);
- * ```
- *
- * @example Advanced Usage with Events
- * ```typescript
- * import { OnChainDBClient } from '@onchaindb/sdk';
- *
- * const db = new OnChainDBClient({
- *   endpoint: 'http://localhost:9092'
- * });
- *
- * // Listen for transaction events
- * db.on('transaction:pending', (tx) => {
- *   console.log('Transaction pending:', tx.id);
- * });
- *
- * db.on('transaction:confirmed', (tx) => {
- *   console.log('Transaction confirmed:', tx.id);
- * });
- *
- * // Store and wait for confirmation
- * const confirmed = await db.storeAndConfirm({
- *   data: { important: 'data that needs confirmation' },
- *   collection: 'critical'
- * });
- * ```
- *
- * @example Batch Operations
- * ```typescript
- * import { OnChainDBClient, BulkBuilder } from '@onchaindb/sdk';
- *
- * const db = new OnChainDBClient({ endpoint: 'http://localhost:9092' });
- * const batch = db.batch();
- *
- * // Build bulk operation
- * const builder = new BulkBuilder()
- *   .collection('tweets')
- *   .add({ message: 'Tweet 1', author: 'alice' })
- *   .add({ message: 'Tweet 2', author: 'bob' })
- *   .add({ message: 'Tweet 3', author: 'charlie' });
- *
- * // Execute with progress tracking
- * const results = await batch.store(builder.build(), {
- *   concurrency: 5,
- *   waitForConfirmation: true,
- *   onProgress: (completed, total) => {
- *     console.log(`Progress: ${completed}/${total}`);
- *   }
- * });
- * ```
- *
- * @example Database Management
- * ```typescript
- * import { createClient } from '@onchaindb/sdk';
- *
- * const client = createClient({
- *   endpoint: 'http://localhost:9092',
- *   apiKey: 'your-api-key'
- * });
- *
- * // Get database manager for an app
- * const db = client.database('app_12345');
- *
- * // Create collections with schemas
- * await db.createCollection('users', {
- *   fields: {
- *     id: { type: 'string', unique: true, required: true },
- *     name: { type: 'string', required: true },
- *     email: { type: 'string', unique: true, required: true },
- *     created_at: { type: 'date', default: () => new Date() }
- *   }
- * });
- *
- * // Create optimized indexes
- * await db.createIndex({
- *   name: 'users_email_index',
- *   collection: 'users',
- *   field_name: 'email',
- *   index_type: 'btree',
- *   options: { unique: true }
- * });
- *
- * // Monitor performance
- * const stats = await db.getDatabaseStats();
- * console.log(`Collections: ${stats.total_collections}, Indexes: ${stats.total_indexes}`);
- * ```
- *
- * @example Error Handling
- * ```typescript
- * import { OnChainDBError, TransactionError, ValidationError } from '@onchaindb/sdk';
- *
- * try {
- *   await db.store({ data: { test: 'data' } });
- * } catch (error) {
- *   if (error instanceof ValidationError) {
- *     console.log('Validation failed:', error.message);
- *   } else if (error instanceof TransactionError) {
- *     console.log('Transaction failed:', error.transactionId);
- *   } else if (error instanceof OnChainDBError) {
- *     console.log('OnChainDB error:', error.code);
- *   }
- * }
- * ```
- */

package/src/query-sdk/ConditionBuilder.ts

@@ -1,103 +1,51 @@
 import { LogicalOperator, FieldConditionBuilder } from './operators';
 import { NestedConditionBuilder } from './NestedBuilders';
 
-// Builder for creating complex conditions with logical operators
+// Builder for creating complex conditions with logical operators.
+// Received as the argument inside .find() and .on() callbacks.
 export class ConditionBuilder {
-  private conditions: LogicalOperator[] = [];
-  private currentOperator?: 'and' | 'or' | 'not';
+    constructor() {}
 
-  constructor() {}
-
-  static new(): ConditionBuilder {
-    return new ConditionBuilder();
-  }
-
-  // Create a field condition builder
-  field(fieldName: string): FieldConditionBuilder {
-    return new FieldConditionBuilder(fieldName);
-  }
-
-  // Create a nested field condition with fluent API (like Rust SDK)
-  nested(fieldName: string, builderFn: (builder: NestedConditionBuilder) => LogicalOperator): LogicalOperator {
-    const nestedBuilder = new NestedConditionBuilder(fieldName);
-    return builderFn(nestedBuilder);
-  }
-
-  // Add an AND operator context
-  and(): ConditionBuilder {
-    this.currentOperator = 'and';
-    return this;
-  }
-
-  // Add an OR operator context
-  or(): ConditionBuilder {
-    this.currentOperator = 'or';
-    return this;
-  }
-
-  // Add a NOT operator context
-  not(): ConditionBuilder {
-    this.currentOperator = 'not';
-    return this;
-  }
-
-  // Group conditions with AND logic
-  andGroup(builderFn: (builder: ConditionBuilder) => LogicalOperator[]): LogicalOperator {
-    const nestedBuilder = new ConditionBuilder();
-    const conditions = builderFn(nestedBuilder);
-    return LogicalOperator.And(conditions);
-  }
-
-  // Group conditions with OR logic
-  orGroup(builderFn: (builder: ConditionBuilder) => LogicalOperator[]): LogicalOperator {
-    const nestedBuilder = new ConditionBuilder();
-    const conditions = builderFn(nestedBuilder);
-    return LogicalOperator.Or(conditions);
-  }
+    static new(): ConditionBuilder {
+        return new ConditionBuilder();
+    }
 
-  // Group conditions with NOT logic
-  notGroup(builderFn: (builder: ConditionBuilder) => LogicalOperator[]): LogicalOperator {
-    const nestedBuilder = new ConditionBuilder();
-    const conditions = builderFn(nestedBuilder);
-    return LogicalOperator.Not(conditions);
-  }
+    // Create a field condition builder for a single field
+    field(fieldName: string): FieldConditionBuilder {
+        return new FieldConditionBuilder(fieldName);
+    }
 
-  // Add a condition to the current builder
-  addCondition(condition: LogicalOperator): ConditionBuilder {
-    this.conditions.push(condition);
-    return this;
-  }
+    // Create a nested field condition (dot-notation path)
+    nested(fieldName: string, builderFn: (builder: NestedConditionBuilder) => LogicalOperator): LogicalOperator {
+        const nestedBuilder = new NestedConditionBuilder(fieldName);
+        return builderFn(nestedBuilder);
+    }
 
-  // Build and return all conditions
-  build(): LogicalOperator[] {
-    return [...this.conditions];
-  }
+    // Combine conditions with AND — the default when no group is specified
+    and(...conditions: LogicalOperator[]): LogicalOperator {
+        return LogicalOperator.And(conditions);
+    }
 
-  // Build as a single logical operator (combines all conditions with AND by default)
-  buildSingle(): LogicalOperator {
-    if (this.conditions.length === 0) {
-      throw new Error('No conditions to build');
+    // Combine conditions with OR
+    or(...conditions: LogicalOperator[]): LogicalOperator {
+        return LogicalOperator.Or(conditions);
     }
-    if (this.conditions.length === 1) {
-      return this.conditions[0];
+
+    // Negate conditions with NOT
+    not(...conditions: LogicalOperator[]): LogicalOperator {
+        return LogicalOperator.Not(conditions);
     }
-    return LogicalOperator.And(this.conditions);
-  }
 
-  // Clear all conditions
-  clear(): ConditionBuilder {
-    this.conditions = [];
-    this.currentOperator = undefined;
-    return this;
-  }
+    // Callback-style group helpers (kept for compatibility)
+    andGroup(builderFn: (builder: ConditionBuilder) => LogicalOperator[]): LogicalOperator {
+        return LogicalOperator.And(builderFn(new ConditionBuilder()));
+    }
 
-  // Check if any conditions have been added
-  isEmpty(): boolean {
-    return this.conditions.length === 0;
-  }
+    orGroup(builderFn: (builder: ConditionBuilder) => LogicalOperator[]): LogicalOperator {
+        return LogicalOperator.Or(builderFn(new ConditionBuilder()));
+    }
 
-  // Get the number of conditions
-  getConditionCount(): number {
-    return this.conditions.length;
-  }
-}
+    notGroup(builderFn: (builder: ConditionBuilder) => LogicalOperator[]): LogicalOperator {
+        return LogicalOperator.Not(builderFn(new ConditionBuilder()));
+    }
+}