feat: async functions

CMakeLists.txt

@@ -270,6 +270,7 @@ endif()
 add_library(${PROJECT_NAME} SHARED
     ${CMAKE_JS_SRC}
     src/binding/addon.cc
+    src/binding/async_workers.cc
     src/binding/collection.cc
     src/binding/config.cc
     src/binding/doc.cc

jest.config.json

@@ -1,7 +1,13 @@
 {
-  "preset": "ts-jest",
   "testEnvironment": "node",
   "testMatch": [
-    "<rootDir>/tests/*.test.ts"
-  ]
+    "<rootDir>/tests/*.test.ts",
+    "<rootDir>/tests/**/*.test.ts"
+  ],
+  "modulePathIgnorePatterns": [
+    "<rootDir>/build/"
+  ],
+  "transform": {
+    "^.+\\.ts$": ["ts-jest", { "diagnostics": { "ignoreCodes": [151002] } }]
+  }
 }

src/binding/async_workers.cc

@@ -0,0 +1,94 @@
+#include "async_workers.h"
+#include "doc.h"
+#include "types.h"
+
+
+namespace binding {
+
+
+DeleteByFilterWorker::DeleteByFilterWorker(Napi::Env env,
+                                           zvec::Collection::Ptr collection,
+                                           std::string filter,
+                                           Napi::Promise::Deferred deferred)
+    : Napi::AsyncWorker(env),
+      collection_(collection),
+      filter_(std::move(filter)),
+      deferred_(deferred) {}
+
+void DeleteByFilterWorker::Execute() {
+  status_ = collection_->DeleteByFilter(filter_);
+}
+
+void DeleteByFilterWorker::OnOK() {
+  Napi::Env env = Env();
+  deferred_.Resolve(CreateStatusObject(env, status_));
+}
+
+void DeleteByFilterWorker::OnError(const Napi::Error &error) {
+  deferred_.Reject(error.Value());
+}
+
+
+QueryWorker::QueryWorker(Napi::Env env, zvec::Collection::Ptr collection,
+                         zvec::CollectionSchema::Ptr schema,
+                         zvec::VectorQuery query,
+                         Napi::Promise::Deferred deferred)
+    : Napi::AsyncWorker(env),
+      collection_(collection),
+      schema_(schema),
+      query_(std::move(query)),
+      deferred_(deferred) {}
+
+void QueryWorker::Execute() {
+  auto res = collection_->Query(query_);
+  if (res) {
+    results_ = std::move(res.value());
+  } else {
+    status_ = res.error();
+  }
+}
+
+void QueryWorker::OnOK() {
+  Napi::Env env = Env();
+  if (status_.ok()) {
+    Napi::Array array = Napi::Array::New(env);
+    for (size_t i = 0; i < results_.size(); i++) {
+      array.Set(i, CreateDoc(env, schema_, results_[i]));
+    }
+    deferred_.Resolve(array);
+  } else {
+    RejectIfNotOk(env, status_, deferred_);
+  }
+}
+
+void QueryWorker::OnError(const Napi::Error &error) {
+  deferred_.Reject(error.Value());
+}
+
+
+OptimizeWorker::OptimizeWorker(Napi::Env env, zvec::Collection::Ptr collection,
+                               zvec::OptimizeOptions options,
+                               Napi::Promise::Deferred deferred)
+    : Napi::AsyncWorker(env),
+      collection_(collection),
+      options_(options),
+      deferred_(deferred) {}
+
+void OptimizeWorker::Execute() {
+  status_ = collection_->Optimize(options_);
+}
+
+void OptimizeWorker::OnOK() {
+  Napi::Env env = Env();
+  if (status_.ok()) {
+    deferred_.Resolve(env.Undefined());
+  } else {
+    RejectIfNotOk(env, status_, deferred_);
+  }
+}
+void OptimizeWorker::OnError(const Napi::Error &error) {
+  deferred_.Reject(error.Value());
+}
+
+
+}  // namespace binding

src/binding/async_workers.h

@@ -0,0 +1,68 @@
+#pragma once
+
+
+#include <napi.h>
+#include <string>
+#include "zvec/db/collection.h"
+#include "zvec/db/status.h"
+
+
+namespace binding {
+
+
+class DeleteByFilterWorker : public Napi::AsyncWorker {
+ public:
+  DeleteByFilterWorker(Napi::Env env, zvec::Collection::Ptr collection,
+                       std::string filter, Napi::Promise::Deferred deferred);
+
+  void Execute() override;
+  void OnOK() override;
+  void OnError(const Napi::Error &error) override;
+
+ private:
+  zvec::Collection::Ptr collection_;
+  std::string filter_;
+  zvec::Status status_;
+  Napi::Promise::Deferred deferred_;
+};
+
+
+class QueryWorker : public Napi::AsyncWorker {
+ public:
+  QueryWorker(Napi::Env env, zvec::Collection::Ptr collection,
+              zvec::CollectionSchema::Ptr schema, zvec::VectorQuery query,
+              Napi::Promise::Deferred deferred);
+
+  void Execute() override;
+  void OnOK() override;
+  void OnError(const Napi::Error &error) override;
+
+ private:
+  zvec::Collection::Ptr collection_;
+  zvec::CollectionSchema::Ptr schema_;
+  zvec::VectorQuery query_;
+  Napi::Promise::Deferred deferred_;
+  zvec::Status status_;
+  zvec::DocPtrList results_;
+};
+
+
+class OptimizeWorker : public Napi::AsyncWorker {
+ public:
+  OptimizeWorker(Napi::Env env, zvec::Collection::Ptr collection,
+                 zvec::OptimizeOptions options,
+                 Napi::Promise::Deferred deferred);
+
+  void Execute() override;
+  void OnOK() override;
+  void OnError(const Napi::Error &error) override;
+
+ private:
+  zvec::Collection::Ptr collection_;
+  zvec::OptimizeOptions options_;
+  zvec::Status status_;
+  Napi::Promise::Deferred deferred_;
+};
+
+
+}  // namespace binding