@omendb/omendb 0.0.19 → 0.0.21

package/index.d.ts

@@ -21,7 +21,8 @@ export declare class VectorDatabase {
   /**
    * Batch search with parallel execution (async).
    *
-   * Runs searches in parallel using rayon, returns Promise.
+   * Runs searches in parallel using rayon on a blocking thread pool,
+   * keeping the Node.js event loop free.
    */
   searchBatch(queries: Array<Array<number> | Float32Array>, k: number, ef?: number | undefined | null): Promise<Array<Array<SearchResult>>>
   /** Get a vector by ID. */
@@ -44,16 +45,16 @@ export declare class VectorDatabase {
    * @example
    * ```javascript
    * // Delete by equality
-   * db.deleteWhere({ status: "archived" });
+   * db.deleteByFilter({ status: "archived" });
    *
    * // Delete with comparison
-   * db.deleteWhere({ score: { $lt: 0.5 } });
+   * db.deleteByFilter({ score: { $lt: 0.5 } });
    *
    * // Complex filter
-   * db.deleteWhere({ $and: [{ type: "draft" }, { age: { $gt: 30 } }] });
+   * db.deleteByFilter({ $and: [{ type: "draft" }, { age: { $gt: 30 } }] });
    * ```
    */
-  deleteWhere(filter: Record<string, unknown>): number
+  deleteByFilter(filter: Record<string, unknown>): number
   /**
    * Count vectors, optionally filtered by metadata.
    *
@@ -185,12 +186,12 @@ export declare class VectorDatabase {
    * @param ids - Array of vector IDs to retrieve
    * @returns Array of results in same order as input, null for missing IDs
    */
-  getMany(ids: Array<string>): Array<GetResult | undefined | null>
+  getBatch(ids: Array<string>): Array<GetResult | undefined | null>
 }
 
 export interface GetResult {
   id: string
-  vector: Array<number>
+  vector: Float32Array
   metadata: Record<string, unknown>
 }
 
@@ -306,8 +307,8 @@ export interface TextSearchResult {
 
 export interface VectorItem {
   id: string
-  /** Vector data as array of numbers */
-  vector: Array<number>
+  /** Vector data as Float32Array */
+  vector: Float32Array
   /** Optional metadata */
   metadata?: Record<string, unknown> | undefined
   /** Optional document text (stored in metadata.document) */
@@ -316,7 +317,7 @@ export interface VectorItem {
 
 export interface VectorItemWithText {
   id: string
-  vector: Array<number>
+  vector: Float32Array
   text: string
   metadata?: Record<string, unknown> | undefined
 }

package/index.js

@@ -101,7 +101,158 @@ if (!nativeBinding) {
 	throw new Error(`Failed to load native binding`);
 }
 
-const { VectorDatabase, open } = nativeBinding;
+// Convert array to Float32Array if needed
+function toFloat32Array(arr) {
+	if (arr instanceof Float32Array) {
+		return arr;
+	}
+	return new Float32Array(arr);
+}
+
+// Convert VectorItem to use Float32Array
+function convertVectorItem(item) {
+	return {
+		...item,
+		vector: toFloat32Array(item.vector),
+	};
+}
+
+// Wrap VectorDatabase to handle array conversion
+const NativeVectorDatabase = nativeBinding.VectorDatabase;
+
+class VectorDatabase {
+	constructor(nativeDb) {
+		this._native = nativeDb;
+	}
+
+	set(items) {
+		return this._native.set(items.map(convertVectorItem));
+	}
+
+	search(query, k, ef, filter, maxDistance) {
+		return this._native.search(query, k, ef, filter, maxDistance);
+	}
+
+	searchBatch(queries, k, ef) {
+		return this._native.searchBatch(queries, k, ef);
+	}
+
+	get(id) {
+		return this._native.get(id);
+	}
+
+	delete(ids) {
+		return this._native.delete(ids);
+	}
+
+	deleteByFilter(filter) {
+		return this._native.deleteByFilter(filter);
+	}
+
+	count(filter) {
+		return this._native.count(filter);
+	}
+
+	update(id, vector, metadata) {
+		return this._native.update(id, vector, metadata);
+	}
+
+	get length() {
+		return this._native.length;
+	}
+
+	get dimensions() {
+		return this._native.dimensions;
+	}
+
+	isEmpty() {
+		return this._native.isEmpty();
+	}
+
+	stats() {
+		return this._native.stats();
+	}
+
+	get efSearch() {
+		return this._native.efSearch;
+	}
+
+	set efSearch(value) {
+		this._native.efSearch = value;
+	}
+
+	collection(name) {
+		return new VectorDatabase(this._native.collection(name));
+	}
+
+	collections() {
+		return this._native.collections();
+	}
+
+	deleteCollection(name) {
+		return this._native.deleteCollection(name);
+	}
+
+	enableTextSearch() {
+		return this._native.enableTextSearch();
+	}
+
+	get hasTextSearch() {
+		return this._native.hasTextSearch;
+	}
+
+	setWithText(items) {
+		return this._native.setWithText(items.map(convertVectorItem));
+	}
+
+	textSearch(query, k) {
+		return this._native.textSearch(query, k);
+	}
+
+	hybridSearch(queryVector, queryText, k, filter, alpha, rrfK, subscores) {
+		return this._native.hybridSearch(
+			queryVector,
+			queryText,
+			k,
+			filter,
+			alpha,
+			rrfK,
+			subscores,
+		);
+	}
+
+	flush() {
+		return this._native.flush();
+	}
+
+	optimize() {
+		return this._native.optimize();
+	}
+
+	mergeFrom(other) {
+		return this._native.mergeFrom(other._native);
+	}
+
+	ids() {
+		return this._native.ids();
+	}
+
+	items() {
+		return this._native.items();
+	}
+
+	exists(id) {
+		return this._native.exists(id);
+	}
+
+	getBatch(ids) {
+		return this._native.getBatch(ids);
+	}
+}
+
+function open(path, options) {
+	return new VectorDatabase(nativeBinding.open(path, options));
+}
 
 module.exports.VectorDatabase = VectorDatabase;
 module.exports.open = open;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omendb/omendb",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "description": "Fast embedded vector database with HNSW + ACORN-1 filtered search",
   "main": "index.js",
   "types": "index.d.ts",
@@ -50,10 +50,10 @@
     "omendb.node"
   ],
   "optionalDependencies": {
-    "@omendb/omendb-darwin-x64": "0.0.19",
-    "@omendb/omendb-darwin-arm64": "0.0.19",
-    "@omendb/omendb-linux-x64-gnu": "0.0.19",
-    "@omendb/omendb-linux-arm64-gnu": "0.0.19",
-    "@omendb/omendb-win32-x64-msvc": "0.0.19"
+    "@omendb/omendb-darwin-x64": "0.0.21",
+    "@omendb/omendb-darwin-arm64": "0.0.21",
+    "@omendb/omendb-linux-x64-gnu": "0.0.21",
+    "@omendb/omendb-linux-arm64-gnu": "0.0.21",
+    "@omendb/omendb-win32-x64-msvc": "0.0.21"
   }
 }