bloom-filter-driver 1.0.0 → 1.0.1

package/README.md

@@ -1,25 +1,41 @@
 # Bloom Filter Driver (TypeScript / Node.js HTTP Client)
 
-**BloomFilterDriver** là thư viện client (SDK) nhỏ gọn được viết bằng TypeScript, đóng vai trò cầu nối giao tiếp giữa các ứng dụng Node.js/TypeScript (như `BloomFilterApplication`) và máy chủ xử lý dữ liệu Bloom Filter (`BloomFilterProcess`) thông qua giao thức HTTP REST.
+**BloomFilterDriver** is a lightweight client library (SDK) written in TypeScript, acting as a communication bridge between Node.js/TypeScript applications (such as `BloomFilterApplication`) and the Bloom Filter processing server (`BloomFilterProcess`) via the HTTP REST protocol.
 
-Thư viện được thiết kế độc lập, tuân thủ nguyên tắc kiến trúc sạch (Clean Architecture) với các lớp phân tách rõ ràng, hỗ trợ đầy đủ kiểu dữ liệu TypeScript (Type Safety), cơ chế kiểm tra tính hợp lệ dữ liệu (Validation) chặt chẽ và khả năng quản lý vòng đời request (Timeout & Cancellation) thông qua `AbortSignal`.
+The library is architected independently, adhering to Clean Architecture principles with clear layer separation. It provides full TypeScript type safety, robust data validation mechanisms, and request lifecycle management (Timeout & Cancellation) via `AbortSignal`.
 
 ---
 
-## 📦 Cài đặt
+## Prerequisites
 
-Bạn có thể cài đặt thư viện thông qua các công cụ quản lý gói thông dụng:
+Since **BloomFilterDriver** acts as an HTTP REST client SDK, you must ensure that the **BloomFilterProcess** server is running and ready to accept connections before making any API calls from your application.
+
+You can pull and run the official Docker image of the processing server from Docker Hub:
+
+```bash
+# Pull the latest image from Docker Hub
+docker pull hongphucle1010/bloom-filter-process:latest
+
+# Run the container on port 8080 (or your custom baseUrl port)
+docker run -d -p 8080:8080 --name bloom-filter-process hongphucle1010/bloom-filter-process:latest
+```
+
+---
+
+## Installation
+
+You can install the library using common package managers:
 
 ```bash
 npm install bloom-filter-driver
-# hoặc
+# or
 yarn add bloom-filter-driver
-# hoặc
+# or
 pnpm add bloom-filter-driver
 ```
 
-> **Lưu ý khi phát triển cục bộ (Local Development):**
-> Nếu bạn đang làm việc trực tiếp trong repository chứa mã nguồn của driver, hãy cài đặt các gói phụ thuộc và biên dịch mã nguồn trước khi sử dụng hoặc liên kết (link) tới ứng dụng:
+> **Note for Local Development:**
+> If you are working directly within the driver repository, make sure to install dependencies and build the source code before using or linking it to your application:
 > ```bash
 > npm install
 > npm run build
@@ -27,25 +43,25 @@ pnpm add bloom-filter-driver
 
 ---
 
-## 🚀 Khởi tạo & Cấu hình Driver
+## Initialization & Configuration
 
-Để sử dụng, bạn cần khởi tạo một đối tượng `BloomFilterDriver` với cấu hình `BloomDriverConfig`.
+To use the library, you need to instantiate a `BloomFilterDriver` object with a `BloomDriverConfig`.
 
 ```typescript
 import { BloomFilterDriver } from 'bloom-filter-driver';
 
 const driver = new BloomFilterDriver({
-  baseUrl: 'http://localhost:8080', // Địa chỉ gốc của máy chủ BloomFilterProcess
-  timeoutMs: 5000,                  // (Tùy chọn) Thời gian chờ tối đa cho mỗi request (mặc định: 5000ms)
-  // fetchImpl: customFetch         // (Tùy chọn) Hàm fetch tùy chỉnh (hữu ích khi viết mock/unit test)
+  baseUrl: 'http://localhost:8080', // Base URL of the BloomFilterProcess server
+  timeoutMs: 5000,                  // (Optional) Maximum waiting time per request (default: 5000ms)
+  // fetchImpl: customFetch         // (Optional) Custom fetch implementation (useful for mocking/unit testing)
 });
 ```
 
-### Quản lý vòng đời Request (Timeout & Cancellation)
+### Request Lifecycle Management (Timeout & Cancellation)
 
-Tất cả các phương thức API trong driver đều hỗ trợ tham số tùy chọn `options?: { signal?: AbortSignal }`. Điều này cho phép bạn:
-- Tự động hủy các request vượt quá thời gian `timeoutMs` đã cấu hình.
-- Chủ động hủy request từ bên ngoài thông qua `AbortController`.
+All API methods in the driver support an optional `options?: { signal?: AbortSignal }` parameter. This allows you to:
+- Automatically cancel requests that exceed the configured `timeoutMs`.
+- Manually cancel requests from the outside using an `AbortController`.
 
 ```typescript
 const controller = new AbortController();
@@ -56,74 +72,74 @@ try {
     { signal: controller.signal }
   );
 } catch (error) {
-  // Xử lý khi request bị hủy hoặc lỗi
+  // Handle request cancellation or errors
 }
 
-// Khi muốn chủ động hủy request đang thực thi:
+// To manually cancel an ongoing request:
 controller.abort();
 ```
 
 ---
 
-## 🏗️ Kiến trúc & Thiết kế
+## Architecture & Design
 
-Driver được phân chia thành các module chuyên biệt nhằm đảm bảo tính dễ bảo trì và mở rộng:
+The driver is divided into specialized modules to ensure maintainability and scalability:
 
 ```
 ┌─────────────────────────────────────────────────────────┐
-│                   BloomFilterDriver                     │ (Lớp Facade tổng quan)
+│                   BloomFilterDriver                     │ (Main Facade Layer)
 └────────────┬───────────────────────────────┬────────────┘
              │                               │
              ▼                               ▼
 ┌─────────────────────────┐     ┌─────────────────────────┐
-│     BloomApiClient      │     │     RangeApiClient      │ (Lớp Client nghiệp vụ)
+│     BloomApiClient      │     │     RangeApiClient      │ (Business Client Layer)
 └────────────┬────────────┘     └────────────┬────────────┘
              │                               │
              └───────────────┬───────────────┘
                              │
                              ▼
 ┌─────────────────────────────────────────────────────────┐
-│                       HttpClient                        │ (Lớp xử lý HTTP & Timeout)
+│                       HttpClient                        │ (HTTP & Timeout Handling)
 └────────────────────────────┬────────────────────────────┘
                              │
                              ▼
 ┌─────────────────────────────────────────────────────────┐
-│                     DriverValidator                     │ (Lớp kiểm tra dữ liệu)
+│                     DriverValidator                     │ (Input Validation Layer)
 └─────────────────────────────────────────────────────────┘
 ```
 
-- **`BloomFilterDriver`**: Lớp giao diện chính (Facade) tổng hợp toàn bộ các phương thức thao tác với Bloom Filter và RangeLH.
-- **`BloomApiClient`**: Quản lý các endpoint liên quan đến cấu trúc Bloom Filter (`/bloom/*`).
-- **`RangeApiClient`**: Quản lý các endpoint liên quan đến cấu trúc phân cấp/chỉ mục dải RangeLH (`/rangelh/*`).
-- **`HttpClient`**: Đóng gói hàm `fetch`, xử lý nối chuỗi URL, thiết lập HTTP headers, quản lý `AbortController` và chuẩn hóa lỗi HTTP.
-- **`DriverValidator`**: Kiểm tra tính hợp lệ của dữ liệu đầu vào (tên bộ lọc, dải giá trị, xác suất, tham số cấu hình) trước khi gửi request tới máy chủ.
+- **`BloomFilterDriver`**: The main Facade layer aggregating all methods for interacting with Bloom Filters and RangeLH.
+- **`BloomApiClient`**: Manages endpoints related to Bloom Filter structures (`/bloom/*`).
+- **`RangeApiClient`**: Manages endpoints related to RangeLH hierarchical index structures (`/rangelh/*`).
+- **`HttpClient`**: Encapsulates `fetch`, handles URL construction, sets HTTP headers, manages `AbortController`, and standardizes HTTP errors.
+- **`DriverValidator`**: Validates input data (filter names, ranges, probabilities, configuration parameters) before sending requests to the server.
 
 ---
 
-## 📚 Tài liệu API Tham khảo (API Reference)
+## 📚 API Reference
 
 ---
 
 ### 1. Bloom Filter API (`BloomApiClient`)
 
-Các API chuyên biệt dành cho bộ lọc Bloom thông thường (Standard Bloom Filter) và bộ lọc Bloom có đếm (Counting Bloom Filter).
+Specialized APIs for Standard Bloom Filters and Counting Bloom Filters.
 
 #### `createBloom(payload: BloomCreatePayload, options?: DriverRequestOptions): Promise<void>`
-Khởi tạo và cấu hình một bộ lọc Bloom mới trên máy chủ trước khi sử dụng.
+Initializes and configures a new Bloom filter on the server before use.
 
 ```typescript
 await driver.createBloom({
-  bfName: 'users-bf',              // Tên định danh của bộ lọc
-  expectedValues: 100000,          // Số lượng phần tử dự kiến thêm vào
-  bloomType: 'standard',           // 'standard' | 'counting' (mặc định: 'standard')
-  falsePositiveProbability: 0.01,  // (Tùy chọn) Xác suất dương tính giả mong muốn (ví dụ: 1%)
-  counterBits: 4                   // (Tùy chọn) Số bit cho mỗi bộ đếm (chỉ dùng khi bloomType là 'counting', từ 1-8)
+  bfName: 'users-bf',              // Identifier of the bloom filter
+  expectedValues: 100000,          // Expected number of elements to be added
+  bloomType: 'standard',           // 'standard' | 'counting' (default: 'standard')
+  falsePositiveProbability: 0.01,  // (Optional) Desired false positive probability (e.g., 1%)
+  counterBits: 4                   // (Optional) Number of bits per counter (only used when bloomType is 'counting', from 1-8)
 });
 ```
-> *Lưu ý:* Thư viện cung cấp hàm alias `configureBloom` tương đương với `createBloom` nhằm mục đích tương thích ngược. Khuyến nghị sử dụng `createBloom` cho các dự án mới.
+> *Note:* The library provides an alias function `configureBloom` equivalent to `createBloom` for backward compatibility. Using `createBloom` is recommended for new projects.
 
 #### `add(payload: BloomDataPayload, options?: DriverRequestOptions): Promise<void>`
-Thêm một phần tử (chuỗi dữ liệu) vào bộ lọc Bloom.
+Adds an element (string data) to the Bloom filter.
 
 ```typescript
 await driver.add({
@@ -133,7 +149,7 @@ await driver.add({
 ```
 
 #### `mightContain(payload: BloomDataPayload, options?: DriverRequestOptions): Promise<boolean>`
-Kiểm tra xem một phần tử **có thể** tồn tại trong bộ lọc Bloom hay không.
+Checks whether an element **might** exist in the Bloom filter.
 
 ```typescript
 const isPresent = await driver.mightContain({
@@ -142,14 +158,14 @@ const isPresent = await driver.mightContain({
 });
 
 if (isPresent) {
-  console.log('Phần tử CÓ THỂ tồn tại (có rủi ro dương tính giả theo xác suất đã cấu hình).');
+  console.log('Element MIGHT exist (subject to the configured false positive probability).');
 } else {
-  console.log('Phần tử CHẮC CHẮN KHÔNG tồn tại trong bộ lọc.');
+  console.log('Element DEFINITELY DOES NOT exist in the filter.');
 }
 ```
 
 #### `remove(payload: BloomDataPayload, options?: DriverRequestOptions): Promise<void>`
-Xóa một phần tử khỏi bộ lọc Bloom. (Yêu cầu bộ lọc phải được khởi tạo với `bloomType: 'counting'`).
+Removes an element from the Bloom filter. (Requires the filter to be initialized with `bloomType: 'counting'`).
 
 ```typescript
 await driver.remove({
@@ -159,45 +175,45 @@ await driver.remove({
 ```
 
 #### `benchLoadSequentialKeys(payload: BloomBenchSequentialPayload, options?: DriverRequestOptions): Promise<void>`
-API hỗ trợ nạp dữ liệu giả lập hàng loạt (bulk insert) trực tiếp trên máy chủ với hiệu năng cao (chỉ tốn 1 lần gọi HTTP và 1 lần lưu trữ/persist). Thường dùng cho mục đích benchmark hoặc khởi tạo dữ liệu mẫu.
+API supporting high-performance bulk insertion of simulated sequential keys directly on the server (requiring only 1 HTTP call and 1 persistence operation). Typically used for benchmarking or generating sample data.
 
 ```typescript
 await driver.benchLoadSequentialKeys({
   bfName: 'users-bf',
-  from: 1,         // (Tùy chọn) Chỉ số bắt đầu (mặc định: 1)
-  to: 100000,      // Chỉ số kết thúc
-  keyWidth: 10     // (Tùy chọn) Độ rộng chuỗi số được đệm zero (zero-padding, mặc định: 10)
+  from: 1,         // (Optional) Starting index (default: 1)
+  to: 100000,      // Ending index
+  keyWidth: 10     // (Optional) Width of zero-padded numeric string (default: 10)
 });
-// Máy chủ sẽ tự động nạp các key dạng: "k-0000000001", "k-0000000002", ..., "k-0000100000"
+// The server will automatically load keys such as: "k-0000000001", "k-0000000002", ..., "k-0000100000"
 ```
 
 ---
 
 ### 2. RangeLH API (`RangeApiClient`)
 
-RangeLH (Range Linear Hashing) là cấu trúc chỉ mục nâng cao phân bổ theo `key`, hỗ trợ tối ưu hóa các truy vấn điểm (point query), truy vấn khoảng (range query) và tổng hợp dữ liệu (aggregation).
+RangeLH (Range Linear Hashing) is an advanced key-distributed index structure supporting optimized point queries, range queries, and aggregations.
 
 #### `createRange(payload: RangeCreatePayload, options?: DriverRequestOptions): Promise<void>`
-Khởi tạo cấu trúc chỉ mục RangeLH với các tham số tinh chỉnh chuyên sâu.
+Initializes the RangeLH index structure with advanced tuning parameters.
 
 ```typescript
 await driver.createRange({
   bfName: 'orders-range',
   config: {
-    masterInitNumBucket: 2,     // Số lượng bucket khởi tạo ban đầu cho Master Index
-    masterSplitPolicy: 0.5,     // Tỷ lệ/Chính sách tách bucket (split policy)
-    expectedNItems: 1000000,    // Tổng số lượng phần tử dự kiến
-    fpProbBloomRF: 0.01,        // Xác suất dương tính giả cho các Bloom Filter con
-    deltaBloomRF: 10,           // Tham số dải delta cho bộ lọc
-    keyLength: 20,              // Độ dài cố định của chuỗi key (từ 1-64)
-    maxBytesString: 8,          // Số byte tối đa cho phần chuỗi giá trị (từ 1-8)
-    floatScale: 100             // Tỷ lệ nhân (scale) cho dữ liệu số thực
+    masterInitNumBucket: 2,     // Initial number of buckets for Master Index
+    masterSplitPolicy: 0.5,     // Bucket split policy/ratio
+    expectedNItems: 1000000,    // Total expected number of elements
+    fpProbBloomRF: 0.01,        // False positive probability for child Bloom Filters
+    deltaBloomRF: 10,           // Delta range parameter for the filter
+    keyLength: 20,              // Fixed length of the key string (from 1-64)
+    maxBytesString: 8,          // Maximum bytes for the string value portion (from 1-8)
+    floatScale: 100             // Scaling factor for floating-point data
   }
 });
 ```
 
-#### `addRange(payload: RangePayload, options?: Driver: RequestOptions): Promise<void>`
-Thêm một cặp định danh/khóa (key) đơn lẻ vào chỉ mục RangeLH.
+#### `addRange(payload: RangePayload, options?: DriverRequestOptions): Promise<void>`
+Adds a single key/identifier pair to the RangeLH index.
 
 ```typescript
 await driver.addRange({
@@ -207,7 +223,7 @@ await driver.addRange({
 ```
 
 #### `addRangeBulk(payload: RangeBulkAddPayload, options?: DriverRequestOptions): Promise<void>`
-Thêm nhiều khóa cùng lúc (bulk insert) vào chỉ mục RangeLH, giúp tiết kiệm băng thông và giảm thiểu độ trễ mạng.
+Adds multiple keys simultaneously (bulk insert) to the RangeLH index, conserving bandwidth and minimizing network latency.
 
 ```typescript
 await driver.addRangeBulk({
@@ -221,7 +237,7 @@ await driver.addRangeBulk({
 ```
 
 #### `removeRange(payload: RangePayload, options?: DriverRequestOptions): Promise<void>`
-Xóa một khóa khỏi chỉ mục RangeLH.
+Removes a key from the RangeLH index.
 
 ```typescript
 await driver.removeRange({
@@ -231,18 +247,18 @@ await driver.removeRange({
 ```
 
 #### `pointQuery(payload: PointQueryPayload, options?: DriverRequestOptions): Promise<string[]>`
-Truy vấn điểm để lấy ra danh sách các khóa khớp chính xác.
+Performs a point query to retrieve a list of exactly matching keys.
 
 ```typescript
 const results = await driver.pointQuery({
   bfName: 'orders-range',
   key: '2026-05-17T12:00:00Z'
 });
-// results: string[] (Danh sách các giá trị/khóa tìm thấy)
+// results: string[] (List of matching keys/values found)
 ```
 
 #### `rangeQuery(payload: RangeQueryPayload, options?: DriverRequestOptions): Promise<string[]>`
-Truy vấn khoảng để lấy ra danh sách các khóa nằm trong dải từ `from` đến `to`.
+Performs a range query to retrieve a list of keys falling within the range from `from` to `to`.
 
 ```typescript
 const results = await driver.rangeQuery({
@@ -250,27 +266,27 @@ const results = await driver.rangeQuery({
   from: '2026-05-01T00:00:00Z',
   to: '2026-05-31T23:59:59Z'
 });
-// results: string[] (Danh sách các khóa thuộc khoảng thời gian/dải truy vấn)
+// results: string[] (List of keys within the specified query range/timeframe)
 ```
 
 #### `aggregate(payload: RangeAggregatePayload, options?: DriverRequestOptions): Promise<number>`
-Thực hiện truy vấn tổng hợp (aggregation) dữ liệu trên một dải khóa cụ thể.
+Performs data aggregation over a specific key range.
 
 ```typescript
 const totalOrders = await driver.aggregate({
   bfName: 'orders-range',
   from: '2026-05-01T00:00:00Z',
   to: '2026-05-31T23:59:59Z',
-  op: 'count' // Các phép toán hỗ trợ: 'sum' | 'avg' | 'min' | 'max' | 'count'
+  op: 'count' // Supported operations: 'sum' | 'avg' | 'min' | 'max' | 'count'
 });
-console.log(`Tổng số đơn hàng trong tháng 5: ${totalOrders}`);
+console.log(`Total orders in May: ${totalOrders}`);
 ```
 
 ---
 
-## ⚠️ Xử lý lỗi (Error Handling)
+## ⚠️ Error Handling
 
-Tất cả các lỗi phát sinh từ driver (bao gồm lỗi kiểm tra dữ liệu đầu vào, lỗi mạng, lỗi timeout hoặc lỗi nghiệp vụ từ phía máy chủ) đều được ném ra dưới dạng đối tượng `BloomDriverError`.
+All errors originating from the driver (including input validation errors, network errors, timeouts, or server-side business errors) are thrown as `BloomDriverError` objects.
 
 ```typescript
 import { BloomFilterDriver, BloomDriverError } from 'bloom-filter-driver';
@@ -279,20 +295,20 @@ const driver = new BloomFilterDriver({ baseUrl: 'http://localhost:8080' });
 
 async function execute() {
   try {
-    // Thử gửi dữ liệu không hợp lệ (chuỗi rỗng)
+    // Attempt to send invalid data (empty string)
     await driver.add({ bfName: 'users-bf', data: '' });
   } catch (error) {
     if (error instanceof BloomDriverError) {
-      console.error('[BloomDriverError] Thông báo lỗi:', error.message);
+      console.error('[BloomDriverError] Error message:', error.message);
       
       if (error.status) {
-        console.error('Mã trạng thái HTTP:', error.status);
+        console.error('HTTP status code:', error.status);
       }
       if (error.responseBody) {
-        console.error('Nội dung phản hồi từ máy chủ:', error.responseBody);
+        console.error('Server response body:', error.responseBody);
       }
     } else {
-      console.error('[Lỗi không xác định]:', error);
+      console.error('[Unknown error]:', error);
     }
   }
 }
@@ -300,22 +316,22 @@ async function execute() {
 
 ---
 
-## 🛠️ Build & Publish (Dành cho nhà phát triển)
+## 🛠️ Build & Publish (For Developers)
 
-Các lệnh thao tác chính khi tham gia phát triển gói thư viện `bloom-filter-driver`:
+Main commands for developing the `bloom-filter-driver` package:
 
-- **Kiểm tra lỗi cú pháp và định dạng (Lint & Format):**
+- **Linting & Formatting:**
   ```bash
   npm run lint
   ```
 
-- **Biên dịch mã nguồn TypeScript sang JavaScript (thư mục `dist`):**
+- **Compile TypeScript source code to JavaScript (`dist` directory):**
   ```bash
   npm run build
   ```
 
-- **Đóng gói và phát hành lên NPM registry:**
+- **Package and publish to NPM registry:**
   ```bash
   npm publish
   ```
-  *(Lưu ý: Script `prepublishOnly` trong `package.json` sẽ tự động kích hoạt tiến trình `build` trước khi publish để đảm bảo mã nguồn phát hành luôn mới nhất).*
+  *(Note: The `prepublishOnly` script in `package.json` automatically triggers the `build` process before publishing to ensure the published code is always up to date).*

package/dist/DriverValidator.d.ts

@@ -11,6 +11,8 @@ export declare class DriverValidator {
     parseNumericValue(body: string): number;
     positiveNumberInZeroOne(value: number, fieldName: string): number;
     keysArray(values: string[]): string[];
+    uint64Key(value: number, fieldName: string): number;
+    uint64KeysArray(values: number[]): number[];
     rangeConfig(config: RangeConfigPayload): RangeConfigPayload;
     integerInRange(value: number, fieldName: string, min: number, max: number): number;
 }

package/dist/DriverValidator.js

@@ -74,6 +74,18 @@ class DriverValidator {
         }
         return values.map((value, index) => this.nonEmpty(value, `keys[${index}]`));
     }
+    uint64Key(value, fieldName) {
+        if (typeof value !== 'number' || !Number.isInteger(value) || value < 0) {
+            throw new errors_1.BloomDriverError(`"${fieldName}" must be a non-negative integer`);
+        }
+        return value;
+    }
+    uint64KeysArray(values) {
+        if (!Array.isArray(values) || values.length === 0) {
+            throw new errors_1.BloomDriverError('"keys" must be a non-empty array');
+        }
+        return values.map((value, index) => this.uint64Key(value, `keys[${index}]`));
+    }
     rangeConfig(config) {
         return {
             masterInitNumBucket: this.positiveInt(config.masterInitNumBucket, 'masterInitNumBucket'),

package/dist/RangeApiClient.js

@@ -23,43 +23,51 @@ class RangeApiClient {
         }, options);
     }
     async addRange(payload, options) {
-        await this.http.post('/rangelh/add', {
+        const requestBody = {
             bfName: this.validator.bfName(payload.bfName),
-            key: this.validator.nonEmpty(payload.key, 'key')
-        }, options);
+            key: this.validator.uint64Key(payload.key, 'key')
+        };
+        if (payload.data !== undefined) {
+            requestBody.data = this.validator.nonEmpty(payload.data, 'data');
+        }
+        await this.http.post('/rangelh/add', requestBody, options);
     }
     async addRangeBulk(payload, options) {
-        await this.http.post('/rangelh/add-bulk', {
+        const requestBody = {
             bfName: this.validator.bfName(payload.bfName),
-            keys: this.validator.keysArray(payload.keys)
-        }, options);
+            keys: this.validator.uint64KeysArray(payload.keys)
+        };
+        if (payload.data !== undefined) {
+            requestBody.data = this.validator.keysArray(payload.data);
+        }
+        await this.http.post('/rangelh/add-bulk', requestBody, options);
     }
     async removeRange(payload, options) {
         await this.http.post('/rangelh/remove', {
             bfName: this.validator.bfName(payload.bfName),
-            key: this.validator.nonEmpty(payload.key, 'key')
+            key: this.validator.uint64Key(payload.key, 'key')
         }, options);
     }
     async pointQuery(payload, options) {
         const response = await this.http.get('/rangelh/point-query', {
             bfName: this.validator.bfName(payload.bfName),
-            key: this.validator.nonEmpty(payload.key, 'key')
+            key: this.validator.uint64Key(payload.key, 'key').toString()
         }, options);
         return this.validator.parseStringList(response);
     }
     async rangeQuery(payload, options) {
         const response = await this.http.get('/rangelh/range-query', {
             bfName: this.validator.bfName(payload.bfName),
-            from: this.validator.nonEmpty(payload.from, 'from'),
-            to: this.validator.nonEmpty(payload.to, 'to')
+            from: this.validator.uint64Key(payload.from, 'from').toString(),
+            to: this.validator.uint64Key(payload.to, 'to').toString()
         }, options);
         return this.validator.parseStringList(response);
     }
     async aggregate(payload, options) {
         const response = await this.http.get('/rangelh/aggregate', {
             bfName: this.validator.bfName(payload.bfName),
-            from: this.validator.nonEmpty(payload.from, 'from'),
-            to: this.validator.nonEmpty(payload.to, 'to'),
+            from: this.validator.uint64Key(payload.from, 'from').toString(),
+            to: this.validator.uint64Key(payload.to, 'to').toString(),
             op: this.validator.aggregateOp(payload.op)
         }, options);
         return this.validator.parseNumericValue(response);

package/dist/types.d.ts

@@ -27,7 +27,8 @@ export interface BloomBenchSequentialPayload {
 }
 export interface RangePayload {
     bfName: string;
-    key: string;
+    key: number;
+    data?: string;
 }
 export interface RangeConfigPayload {
     masterInitNumBucket: number;
@@ -45,22 +46,23 @@ export interface RangeCreatePayload {
 }
 export interface RangeBulkAddPayload {
     bfName: string;
-    keys: string[];
+    keys: number[];
+    data?: string[];
 }
 export interface PointQueryPayload {
     bfName: string;
-    key: string;
+    key: number;
 }
 export interface RangeQueryPayload {
     bfName: string;
-    from: string;
-    to: string;
+    from: number;
+    to: number;
 }
 export type RangeAggregateOp = 'sum' | 'avg' | 'min' | 'max' | 'count';
 export interface RangeAggregatePayload {
     bfName: string;
-    from: string;
-    to: string;
+    from: number;
+    to: number;
     op: RangeAggregateOp;
 }
 export interface DriverRequestOptions {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bloom-filter-driver",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "HTTP driver for BloomFilterProcess",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",