couchbase 4.2.11-rc.1 → 4.3.0

package/src/jstocbpp_transactions.hpp

@@ -47,7 +47,8 @@ struct js_to_cbpp_t<cbtxns::transactions_config> {
             cppObj.durability_level(durability_level.value());
         }
 
-        auto timeout = js_to_cbpp<std::optional<std::chrono::milliseconds>>(jsObj.Get("timeout"));
+        auto timeout = js_to_cbpp<std::optional<std::chrono::milliseconds>>(
+            jsObj.Get("timeout"));
         if (timeout.has_value()) {
             cppObj.timeout(timeout.value());
         }
@@ -81,6 +82,12 @@ struct js_to_cbpp_t<cbtxns::transactions_config> {
                 cleanup_client_attempts.value());
         }
 
+        auto keyspace = js_to_cbpp<std::optional<cbtxns::transaction_keyspace>>(
+            jsObj.Get("metadata_collection"));
+        if (keyspace.has_value()) {
+            cppObj.metadata_collection(keyspace.value());
+        }
+
         return cppObj;
     }
 };
@@ -99,7 +106,8 @@ struct js_to_cbpp_t<cbtxns::transaction_options> {
             cppObj.durability_level(durability_level.value());
         }
 
-        auto timeout = js_to_cbpp<std::optional<std::chrono::milliseconds>>(jsObj.Get("timeout"));
+        auto timeout = js_to_cbpp<std::optional<std::chrono::milliseconds>>(
+            jsObj.Get("timeout"));
         if (timeout.has_value()) {
             cppObj.timeout(timeout.value());
         }
@@ -197,6 +205,34 @@ struct js_to_cbpp_t<cbcoretxns::document_metadata> {
     }
 };
 
+template <>
+struct js_to_cbpp_t<cbtxns::transaction_keyspace> {
+    static inline cbtxns::transaction_keyspace from_js(Napi::Value jsVal)
+    {
+        auto jsObj = jsVal.ToObject();
+        auto bucket_name = js_to_cbpp<std::string>(jsObj.Get("bucket_name"));
+        auto scope_name =
+            js_to_cbpp<std::optional<std::string>>(jsObj.Get("scope_name"));
+        auto collection_name = js_to_cbpp<std::optional<std::string>>(
+            jsObj.Get("collection_name"));
+        if (scope_name.has_value() && collection_name.has_value()) {
+            return cbtxns::transaction_keyspace(bucket_name, scope_name.value(),
+                                                collection_name.value());
+        }
+        return cbtxns::transaction_keyspace(bucket_name);
+    }
+
+    static inline Napi::Value to_js(Napi::Env env,
+                                    const cbtxns::transaction_keyspace &res)
+    {
+        auto resObj = Napi::Object::New(env);
+        resObj.Set("bucket", cbpp_to_js(env, res.bucket));
+        resObj.Set("scope", cbpp_to_js(env, res.scope));
+        resObj.Set("collection", cbpp_to_js(env, res.collection));
+        return resObj;
+    }
+};
+
 template <>
 struct js_to_cbpp_t<cbcoretxns::transaction_get_result> {
     static inline cbcoretxns::transaction_get_result from_js(Napi::Value jsVal)
@@ -387,7 +423,8 @@ struct js_to_cbpp_t<cbcoretxns::op_exception> {
                                     const cbcoretxns::op_exception &err)
     {
         Napi::Error jsErr = Napi::Error::New(env, "transaction_exception");
-        jsErr.Set("ctxtype", Napi::String::New(env, "transaction_op_exception"));
+        jsErr.Set("ctxtype",
+                  Napi::String::New(env, "transaction_op_exception"));
         jsErr.Set("ctx", cbpp_to_js(env, err.ctx()));
         jsErr.Set("cause", cbpp_to_js(env, err.cause()));
         return jsErr.Value();

package/src/transactions.cpp

@@ -32,7 +32,18 @@ Transactions::Transactions(const Napi::CallbackInfo &info)
     auto cluster = Connection::Unwrap(clusterJsObj)->cluster();
 
     auto txnsConfig = jsToCbpp<cbtxns::transactions_config>(configJsObj);
-    _impl.reset(new cbcoretxns::transactions(cluster, txnsConfig));
+    std::future<
+        std::pair<std::error_code, std::shared_ptr<cbcoretxns::transactions>>>
+        future = cbcoretxns::transactions::create(cluster, txnsConfig);
+    std::pair<std::error_code, std::shared_ptr<cbcoretxns::transactions>>
+        result = future.get();
+    if (result.first.value()) {
+        Napi::Error err = Napi::Error::New(info.Env(), result.first.message());
+        err.Set("code", Napi::Number::New(info.Env(), result.first.value()));
+        throw err;
+    }
+    _impl.reset();
+    _impl = std::move(result.second);
 }
 
 Transactions::~Transactions()

package/tools/gen-bindings-json.py

@@ -69,7 +69,6 @@ fileList = [
     "couchbase/persist_to.hxx",
     "couchbase/replicate_to.hxx",
     "core/range_scan_options.hxx",
-    "core/scan_options.hxx",
     "core/range_scan_orchestrator_options.hxx",
     "core/query_context.hxx",
     "core/vector_query_combination.hxx",

package/deps/couchbase-cxx-client/core/scan_options.hxx

@@ -1,44 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- * Copyright 2022-Present Couchbase, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of the License at
- *
- *     https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under
- * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
- * ANY KIND, either express or implied. See the License for the specific language governing
- * permissions and limitations under the License.
- */
-
-#pragma once
-
-#include "range_scan_options.hxx"
-
-#include <couchbase/mutation_token.hxx>
-#include <couchbase/retry_strategy.hxx>
-
-#include <cinttypes>
-#include <memory>
-#include <optional>
-#include <system_error>
-#include <variant>
-#include <vector>
-
-namespace couchbase
-{
-class retry_strategy;
-namespace tracing
-{
-class request_span;
-} // namespace tracing
-} // namespace couchbase
-
-namespace couchbase::core
-{
-struct mutation_state {
-    std::vector<couchbase::mutation_token> tokens;
-};
-} // namespace couchbase::core