couchbase 4.2.11 → 4.3.1

package/src/jstocbpp_autogen.hpp

@@ -794,18 +794,37 @@ struct js_to_cbpp_t<
     from_js(Napi::Value jsVal)
     {
         auto jsObj = jsVal.ToObject();
+        auto auth_name = jsToCbpp<std::string>(jsObj.Get("auth_name"));
+        std::variant<
+            couchbase::core::management::eventing::function_url_no_auth,
+            couchbase::core::management::eventing::function_url_auth_basic,
+            couchbase::core::management::eventing::function_url_auth_digest,
+            couchbase::core::management::eventing::function_url_auth_bearer>
+            auth;
+        if (auth_name.compare("function_url_no_auth") == 0) {
+            auth = js_to_cbpp<
+                couchbase::core::management::eventing::function_url_no_auth>(
+                jsObj.Get("auth_value"));
+        } else if (auth_name.compare("function_url_auth_basic") == 0) {
+            auth = js_to_cbpp<
+                couchbase::core::management::eventing::function_url_auth_basic>(
+                jsObj.Get("auth_value"));
+        } else if (auth_name.compare("function_url_auth_digest") == 0) {
+            auth = js_to_cbpp<couchbase::core::management::eventing::
+                                  function_url_auth_digest>(
+                jsObj.Get("auth_value"));
+        } else {
+            auth = js_to_cbpp<couchbase::core::management::eventing::
+                                  function_url_auth_bearer>(
+                jsObj.Get("auth_value"));
+        }
         couchbase::core::management::eventing::function_url_binding cppObj;
         js_to_cbpp<std::string>(cppObj.alias, jsObj.Get("alias"));
         js_to_cbpp<std::string>(cppObj.hostname, jsObj.Get("hostname"));
         js_to_cbpp<bool>(cppObj.allow_cookies, jsObj.Get("allow_cookies"));
         js_to_cbpp<bool>(cppObj.validate_ssl_certificate,
                          jsObj.Get("validate_ssl_certificate"));
-        js_to_cbpp<std::variant<
-            couchbase::core::management::eventing::function_url_no_auth,
-            couchbase::core::management::eventing::function_url_auth_basic,
-            couchbase::core::management::eventing::function_url_auth_digest,
-            couchbase::core::management::eventing::function_url_auth_bearer>>(
-            cppObj.auth, jsObj.Get("auth"));
+        cppObj.auth = auth;
         return cppObj;
     }
     static inline Napi::Value
@@ -814,6 +833,25 @@ struct js_to_cbpp_t<
               &cppObj)
     {
         auto resObj = Napi::Object::New(env);
+        if (std::holds_alternative<
+                couchbase::core::management::eventing::function_url_no_auth>(
+                cppObj.auth)) {
+            resObj.Set("auth_name",
+                       cbpp_to_js<std::string>(env, "function_url_no_auth"));
+        } else if (std::holds_alternative<
+                       couchbase::core::management::eventing::
+                           function_url_auth_basic>(cppObj.auth)) {
+            resObj.Set("auth_name",
+                       cbpp_to_js<std::string>(env, "function_url_auth_basic"));
+        } else if (std::holds_alternative<
+                       couchbase::core::management::eventing::
+                           function_url_auth_digest>(cppObj.auth)) {
+            resObj.Set("auth_name", cbpp_to_js<std::string>(
+                                        env, "function_url_auth_digest"));
+        } else {
+            resObj.Set("auth_name", cbpp_to_js<std::string>(
+                                        env, "function_url_auth_bearer"));
+        }
         resObj.Set("alias", cbpp_to_js<std::string>(env, cppObj.alias));
         resObj.Set("hostname", cbpp_to_js<std::string>(env, cppObj.hostname));
         resObj.Set("allow_cookies",
@@ -821,7 +859,7 @@ struct js_to_cbpp_t<
         resObj.Set("validate_ssl_certificate",
                    cbpp_to_js<bool>(env, cppObj.validate_ssl_certificate));
         resObj.Set(
-            "auth",
+            "auth_value",
             cbpp_to_js<std::variant<
                 couchbase::core::management::eventing::function_url_no_auth,
                 couchbase::core::management::eventing::function_url_auth_basic,
@@ -889,6 +927,7 @@ struct js_to_cbpp_t<couchbase::core::management::eventing::function> {
             cppObj.constant_bindings, jsObj.Get("constant_bindings"));
         js_to_cbpp<couchbase::core::management::eventing::function_settings>(
             cppObj.settings, jsObj.Get("settings"));
+        // internal
         return cppObj;
     }
     static inline Napi::Value
@@ -937,6 +976,7 @@ struct js_to_cbpp_t<couchbase::core::management::eventing::function> {
             cbpp_to_js<
                 couchbase::core::management::eventing::function_settings>(
                 env, cppObj.settings));
+        // internal
         return resObj;
     }
 };
@@ -963,6 +1003,7 @@ struct js_to_cbpp_t<couchbase::core::management::eventing::function_state> {
             cppObj.processing_status, jsObj.Get("processing_status"));
         js_to_cbpp<std::optional<bool>>(cppObj.redeploy_required,
                                         jsObj.Get("redeploy_required"));
+        // internal
         return cppObj;
     }
     static inline Napi::Value
@@ -990,6 +1031,7 @@ struct js_to_cbpp_t<couchbase::core::management::eventing::function_state> {
                        env, cppObj.processing_status));
         resObj.Set("redeploy_required", cbpp_to_js<std::optional<bool>>(
                                             env, cppObj.redeploy_required));
+        // internal
         return resObj;
     }
 };
@@ -2465,8 +2507,8 @@ struct js_to_cbpp_t<couchbase::core::operations::query_request> {
                                                jsObj.Get("client_context_id"));
         js_to_cbpp<std::optional<std::chrono::milliseconds>>(
             cppObj.timeout, jsObj.Get("timeout"));
-        js_to_cbpp<couchbase::query_profile>(cppObj.profile,
-                                             jsObj.Get("profile"));
+        js_to_cbpp<std::optional<couchbase::query_profile>>(
+            cppObj.profile, jsObj.Get("profile"));
         js_to_cbpp<
             std::map<std::string, couchbase::core::json_string, std::less<>>>(
             cppObj.raw, jsObj.Get("raw"));
@@ -2523,7 +2565,8 @@ struct js_to_cbpp_t<couchbase::core::operations::query_request> {
                    cbpp_to_js<std::optional<std::chrono::milliseconds>>(
                        env, cppObj.timeout));
         resObj.Set("profile",
-                   cbpp_to_js<couchbase::query_profile>(env, cppObj.profile));
+                   cbpp_to_js<std::optional<couchbase::query_profile>>(
+                       env, cppObj.profile));
         resObj.Set(
             "raw",
             cbpp_to_js<std::map<std::string, couchbase::core::json_string,
@@ -3916,6 +3959,10 @@ struct js_to_cbpp_t<couchbase::core::operations::search_request> {
                                                jsObj.Get("client_context_id"));
         js_to_cbpp<std::optional<std::chrono::milliseconds>>(
             cppObj.timeout, jsObj.Get("timeout"));
+        js_to_cbpp<std::optional<bool>>(cppObj.log_request,
+                                        jsObj.Get("log_request"));
+        js_to_cbpp<std::optional<bool>>(cppObj.log_response,
+                                        jsObj.Get("log_response"));
         js_to_cbpp<std::string>(cppObj.body_str, jsObj.Get("body_str"));
         // parent_span
         return cppObj;
@@ -3984,6 +4031,10 @@ struct js_to_cbpp_t<couchbase::core::operations::search_request> {
         resObj.Set("timeout",
                    cbpp_to_js<std::optional<std::chrono::milliseconds>>(
                        env, cppObj.timeout));
+        resObj.Set("log_request",
+                   cbpp_to_js<std::optional<bool>>(env, cppObj.log_request));
+        resObj.Set("log_response",
+                   cbpp_to_js<std::optional<bool>>(env, cppObj.log_response));
         resObj.Set("body_str", cbpp_to_js<std::string>(env, cppObj.body_str));
         // parent_span
         return resObj;
@@ -5146,6 +5197,10 @@ struct js_to_cbpp_t<
         couchbase::core::operations::management::eventing_pause_function_request
             cppObj;
         js_to_cbpp<std::string>(cppObj.name, jsObj.Get("name"));
+        js_to_cbpp<std::optional<std::string>>(cppObj.bucket_name,
+                                               jsObj.Get("bucket_name"));
+        js_to_cbpp<std::optional<std::string>>(cppObj.scope_name,
+                                               jsObj.Get("scope_name"));
         js_to_cbpp<std::optional<std::string>>(cppObj.client_context_id,
                                                jsObj.Get("client_context_id"));
         js_to_cbpp<std::optional<std::chrono::milliseconds>>(
@@ -5158,6 +5213,10 @@ struct js_to_cbpp_t<
     {
         auto resObj = Napi::Object::New(env);
         resObj.Set("name", cbpp_to_js<std::string>(env, cppObj.name));
+        resObj.Set("bucket_name", cbpp_to_js<std::optional<std::string>>(
+                                      env, cppObj.bucket_name));
+        resObj.Set("scope_name", cbpp_to_js<std::optional<std::string>>(
+                                     env, cppObj.scope_name));
         resObj.Set("client_context_id", cbpp_to_js<std::optional<std::string>>(
                                             env, cppObj.client_context_id));
         resObj.Set("timeout",
@@ -5355,6 +5414,10 @@ struct js_to_cbpp_t<
         couchbase::core::operations::management::
             eventing_resume_function_request cppObj;
         js_to_cbpp<std::string>(cppObj.name, jsObj.Get("name"));
+        js_to_cbpp<std::optional<std::string>>(cppObj.bucket_name,
+                                               jsObj.Get("bucket_name"));
+        js_to_cbpp<std::optional<std::string>>(cppObj.scope_name,
+                                               jsObj.Get("scope_name"));
         js_to_cbpp<std::optional<std::string>>(cppObj.client_context_id,
                                                jsObj.Get("client_context_id"));
         js_to_cbpp<std::optional<std::chrono::milliseconds>>(
@@ -5367,6 +5430,10 @@ struct js_to_cbpp_t<
     {
         auto resObj = Napi::Object::New(env);
         resObj.Set("name", cbpp_to_js<std::string>(env, cppObj.name));
+        resObj.Set("bucket_name", cbpp_to_js<std::optional<std::string>>(
+                                      env, cppObj.bucket_name));
+        resObj.Set("scope_name", cbpp_to_js<std::optional<std::string>>(
+                                     env, cppObj.scope_name));
         resObj.Set("client_context_id", cbpp_to_js<std::optional<std::string>>(
                                             env, cppObj.client_context_id));
         resObj.Set("timeout",
@@ -7338,6 +7405,10 @@ struct js_to_cbpp_t<
             eventing_upsert_function_request cppObj;
         js_to_cbpp<couchbase::core::management::eventing::function>(
             cppObj.function, jsObj.Get("function"));
+        js_to_cbpp<std::optional<std::string>>(cppObj.bucket_name,
+                                               jsObj.Get("bucket_name"));
+        js_to_cbpp<std::optional<std::string>>(cppObj.scope_name,
+                                               jsObj.Get("scope_name"));
         js_to_cbpp<std::optional<std::string>>(cppObj.client_context_id,
                                                jsObj.Get("client_context_id"));
         js_to_cbpp<std::optional<std::chrono::milliseconds>>(
@@ -7352,6 +7423,10 @@ struct js_to_cbpp_t<
         resObj.Set("function",
                    cbpp_to_js<couchbase::core::management::eventing::function>(
                        env, cppObj.function));
+        resObj.Set("bucket_name", cbpp_to_js<std::optional<std::string>>(
+                                      env, cppObj.bucket_name));
+        resObj.Set("scope_name", cbpp_to_js<std::optional<std::string>>(
+                                     env, cppObj.scope_name));
         resObj.Set("client_context_id", cbpp_to_js<std::optional<std::string>>(
                                             env, cppObj.client_context_id));
         resObj.Set("timeout",
@@ -7970,6 +8045,10 @@ struct js_to_cbpp_t<
         couchbase::core::operations::management::eventing_get_function_request
             cppObj;
         js_to_cbpp<std::string>(cppObj.name, jsObj.Get("name"));
+        js_to_cbpp<std::optional<std::string>>(cppObj.bucket_name,
+                                               jsObj.Get("bucket_name"));
+        js_to_cbpp<std::optional<std::string>>(cppObj.scope_name,
+                                               jsObj.Get("scope_name"));
         js_to_cbpp<std::optional<std::string>>(cppObj.client_context_id,
                                                jsObj.Get("client_context_id"));
         js_to_cbpp<std::optional<std::chrono::milliseconds>>(
@@ -7982,6 +8061,10 @@ struct js_to_cbpp_t<
     {
         auto resObj = Napi::Object::New(env);
         resObj.Set("name", cbpp_to_js<std::string>(env, cppObj.name));
+        resObj.Set("bucket_name", cbpp_to_js<std::optional<std::string>>(
+                                      env, cppObj.bucket_name));
+        resObj.Set("scope_name", cbpp_to_js<std::optional<std::string>>(
+                                     env, cppObj.scope_name));
         resObj.Set("client_context_id", cbpp_to_js<std::optional<std::string>>(
                                             env, cppObj.client_context_id));
         resObj.Set("timeout",
@@ -8322,6 +8405,10 @@ struct js_to_cbpp_t<
         auto jsObj = jsVal.ToObject();
         couchbase::core::operations::management::eventing_get_status_request
             cppObj;
+        js_to_cbpp<std::optional<std::string>>(cppObj.bucket_name,
+                                               jsObj.Get("bucket_name"));
+        js_to_cbpp<std::optional<std::string>>(cppObj.scope_name,
+                                               jsObj.Get("scope_name"));
         js_to_cbpp<std::optional<std::string>>(cppObj.client_context_id,
                                                jsObj.Get("client_context_id"));
         js_to_cbpp<std::optional<std::chrono::milliseconds>>(
@@ -8333,6 +8420,10 @@ struct js_to_cbpp_t<
                              eventing_get_status_request &cppObj)
     {
         auto resObj = Napi::Object::New(env);
+        resObj.Set("bucket_name", cbpp_to_js<std::optional<std::string>>(
+                                      env, cppObj.bucket_name));
+        resObj.Set("scope_name", cbpp_to_js<std::optional<std::string>>(
+                                     env, cppObj.scope_name));
         resObj.Set("client_context_id", cbpp_to_js<std::optional<std::string>>(
                                             env, cppObj.client_context_id));
         resObj.Set("timeout",
@@ -8391,6 +8482,10 @@ struct js_to_cbpp_t<couchbase::core::operations::management::
         auto jsObj = jsVal.ToObject();
         couchbase::core::operations::management::
             eventing_get_all_functions_request cppObj;
+        js_to_cbpp<std::optional<std::string>>(cppObj.bucket_name,
+                                               jsObj.Get("bucket_name"));
+        js_to_cbpp<std::optional<std::string>>(cppObj.scope_name,
+                                               jsObj.Get("scope_name"));
         js_to_cbpp<std::optional<std::string>>(cppObj.client_context_id,
                                                jsObj.Get("client_context_id"));
         js_to_cbpp<std::optional<std::chrono::milliseconds>>(
@@ -8402,6 +8497,10 @@ struct js_to_cbpp_t<couchbase::core::operations::management::
                              eventing_get_all_functions_request &cppObj)
     {
         auto resObj = Napi::Object::New(env);
+        resObj.Set("bucket_name", cbpp_to_js<std::optional<std::string>>(
+                                      env, cppObj.bucket_name));
+        resObj.Set("scope_name", cbpp_to_js<std::optional<std::string>>(
+                                     env, cppObj.scope_name));
         resObj.Set("client_context_id", cbpp_to_js<std::optional<std::string>>(
                                             env, cppObj.client_context_id));
         resObj.Set("timeout",
@@ -9227,6 +9326,10 @@ struct js_to_cbpp_t<
         couchbase::core::operations::management::eventing_drop_function_request
             cppObj;
         js_to_cbpp<std::string>(cppObj.name, jsObj.Get("name"));
+        js_to_cbpp<std::optional<std::string>>(cppObj.bucket_name,
+                                               jsObj.Get("bucket_name"));
+        js_to_cbpp<std::optional<std::string>>(cppObj.scope_name,
+                                               jsObj.Get("scope_name"));
         js_to_cbpp<std::optional<std::string>>(cppObj.client_context_id,
                                                jsObj.Get("client_context_id"));
         js_to_cbpp<std::optional<std::chrono::milliseconds>>(
@@ -9239,6 +9342,10 @@ struct js_to_cbpp_t<
     {
         auto resObj = Napi::Object::New(env);
         resObj.Set("name", cbpp_to_js<std::string>(env, cppObj.name));
+        resObj.Set("bucket_name", cbpp_to_js<std::optional<std::string>>(
+                                      env, cppObj.bucket_name));
+        resObj.Set("scope_name", cbpp_to_js<std::optional<std::string>>(
+                                     env, cppObj.scope_name));
         resObj.Set("client_context_id", cbpp_to_js<std::optional<std::string>>(
                                             env, cppObj.client_context_id));
         resObj.Set("timeout",
@@ -9450,6 +9557,10 @@ struct js_to_cbpp_t<
         couchbase::core::operations::management::
             eventing_deploy_function_request cppObj;
         js_to_cbpp<std::string>(cppObj.name, jsObj.Get("name"));
+        js_to_cbpp<std::optional<std::string>>(cppObj.bucket_name,
+                                               jsObj.Get("bucket_name"));
+        js_to_cbpp<std::optional<std::string>>(cppObj.scope_name,
+                                               jsObj.Get("scope_name"));
         js_to_cbpp<std::optional<std::string>>(cppObj.client_context_id,
                                                jsObj.Get("client_context_id"));
         js_to_cbpp<std::optional<std::chrono::milliseconds>>(
@@ -9462,6 +9573,10 @@ struct js_to_cbpp_t<
     {
         auto resObj = Napi::Object::New(env);
         resObj.Set("name", cbpp_to_js<std::string>(env, cppObj.name));
+        resObj.Set("bucket_name", cbpp_to_js<std::optional<std::string>>(
+                                      env, cppObj.bucket_name));
+        resObj.Set("scope_name", cbpp_to_js<std::optional<std::string>>(
+                                     env, cppObj.scope_name));
         resObj.Set("client_context_id", cbpp_to_js<std::optional<std::string>>(
                                             env, cppObj.client_context_id));
         resObj.Set("timeout",
@@ -10086,6 +10201,10 @@ struct js_to_cbpp_t<couchbase::core::operations::management::
         couchbase::core::operations::management::
             eventing_undeploy_function_request cppObj;
         js_to_cbpp<std::string>(cppObj.name, jsObj.Get("name"));
+        js_to_cbpp<std::optional<std::string>>(cppObj.bucket_name,
+                                               jsObj.Get("bucket_name"));
+        js_to_cbpp<std::optional<std::string>>(cppObj.scope_name,
+                                               jsObj.Get("scope_name"));
         js_to_cbpp<std::optional<std::string>>(cppObj.client_context_id,
                                                jsObj.Get("client_context_id"));
         js_to_cbpp<std::optional<std::chrono::milliseconds>>(
@@ -10098,6 +10217,10 @@ struct js_to_cbpp_t<couchbase::core::operations::management::
     {
         auto resObj = Napi::Object::New(env);
         resObj.Set("name", cbpp_to_js<std::string>(env, cppObj.name));
+        resObj.Set("bucket_name", cbpp_to_js<std::optional<std::string>>(
+                                      env, cppObj.bucket_name));
+        resObj.Set("scope_name", cbpp_to_js<std::optional<std::string>>(
+                                     env, cppObj.scope_name));
         resObj.Set("client_context_id", cbpp_to_js<std::optional<std::string>>(
                                             env, cppObj.client_context_id));
         resObj.Set("timeout",
@@ -10488,12 +10611,25 @@ struct js_to_cbpp_t<couchbase::core::range_scan_create_options> {
           const couchbase::core::range_scan_create_options &cppObj)
     {
         auto resObj = Napi::Object::New(env);
+        if (std::holds_alternative<couchbase::core::range_scan>(
+                cppObj.scan_type)) {
+            resObj.Set("scan_type_name",
+                       cbpp_to_js<std::string>(env, "range_scan"));
+        } else if (std::holds_alternative<couchbase::core::prefix_scan>(
+                       cppObj.scan_type)) {
+            resObj.Set("scan_type_name",
+                       cbpp_to_js<std::string>(env, "prefix_scan"));
+        } else if (std::holds_alternative<couchbase::core::sampling_scan>(
+                       cppObj.scan_type)) {
+            resObj.Set("scan_type_name",
+                       cbpp_to_js<std::string>(env, "sampling_scan"));
+        }
         resObj.Set("scope_name",
                    cbpp_to_js<std::string>(env, cppObj.scope_name));
         resObj.Set("collection_name",
                    cbpp_to_js<std::string>(env, cppObj.collection_name));
         resObj.Set(
-            "scan_type",
+            "scan_type_value",
             cbpp_to_js<std::variant<std::monostate, couchbase::core::range_scan,
                                     couchbase::core::prefix_scan,
                                     couchbase::core::sampling_scan>>(

package/src/jstocbpp_basic.hpp

@@ -8,6 +8,7 @@
 #include <core/cluster.hxx>
 #include <core/document_id.hxx>
 #include <core/json_string.hxx>
+#include <core/management/eventing_function.hxx>
 #include <core/query_context.hxx>
 
 namespace couchnode

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-js.js

@@ -10,8 +10,11 @@ const CustomDefinedTypes = [
 ]
 
 const handleJsVariant = {
-  names: ['couchbase::core::range_scan_create_options'],
-  fields: ['scan_type'],
+  names: [
+    'couchbase::core::range_scan_create_options',
+    'couchbase::core::management::eventing::function_url_binding',
+  ],
+  fields: ['scan_type', 'auth'],
 }
 
 function getTsType(type, typeDb) {
@@ -388,6 +391,8 @@ async function go() {
         ) {
           outJsAll.write(`  ${jsFieldName}_name: string`)
           outJsAll.write(`  ${jsFieldName}_value: ${jsFieldType}`)
+        } else if (jsFieldType === 'CppCas' && jsTypeName.endsWith('Request')) {
+          outJsAll.write(`  ${jsFieldName}: CppCasInput`)
         } else {
           outJsAll.write(`  ${jsFieldName}: ${jsFieldType}`)
         }
@@ -591,10 +596,13 @@ async function go() {
         `        auto ${field.name}_name = jsToCbpp<std::string>(jsObj.Get("${field.name}_name"));`
       )
       const ofTypes = field.type.of.filter((f) => !f.name.includes('monostate'))
+      const includeMonostate = field.type.of.find((f) =>
+        f.name.includes('monostate')
+      )
       outCppStructDefs.write(
-        `        std::variant<std::monostate, ${ofTypes
-          .map((x) => getCppType(x))
-          .join(', ')}> ${field.name};`
+        `        std::variant<${
+          includeMonostate ? 'std::monostate,' : ''
+        }${ofTypes.map((x) => getCppType(x)).join(', ')}> ${field.name};`
       )
       for (let i = 0; i < ofTypes.length; i++) {
         if (i == field.type.of.length - 1) {
@@ -639,14 +647,44 @@ async function go() {
     outCppStructDefs.write(`    to_js(Napi::Env env, const ${st.name} &cppObj)`)
     outCppStructDefs.write(`    {`)
     outCppStructDefs.write(`        auto resObj = Napi::Object::New(env);`)
+    variantFields.forEach((field) => {
+      const ofTypes = field.type.of.filter((f) => !f.name.includes('monostate'))
+      for (let i = 0; i < ofTypes.length; i++) {
+        const nameTokens = ofTypes[i].name.split('::')
+        if (i == field.type.of.length - 1) {
+          outCppStructDefs.write(`        else {`)
+        } else {
+          const ifStatement = i > 0 ? 'else if(' : 'if('
+          outCppStructDefs.write(
+            `        ${ifStatement} std::holds_alternative<${ofTypes[i].name}>(cppObj.${field.name})) {`
+          )
+        }
+        outCppStructDefs.write(
+          `            resObj.Set("${
+            field.name
+          }_name", cbpp_to_js<std::string>(env, "${
+            nameTokens[nameTokens.length - 1]
+          }"));`
+        )
+        outCppStructDefs.write(`        }`)
+      }
+      return
+    })
     st.fields.forEach((field) => {
       if (isIgnoredField(st, field.name)) {
         outCppStructDefs.write(`        // ${field.name}`)
         return
       }
+      let fieldName = field.name
+      if (
+        handleJsVariant.names.includes(st.name) &&
+        handleJsVariant.fields.includes(field.name)
+      ) {
+        fieldName = `${fieldName}_value`
+      }
       const fieldType = getCppType(field.type)
       outCppStructDefs.write(
-        `        resObj.Set("${field.name}", cbpp_to_js<${fieldType}>(env, cppObj.${field.name}));`
+        `        resObj.Set("${fieldName}", cbpp_to_js<${fieldType}>(env, cppObj.${field.name}));`
       )
     })
     outCppStructDefs.write(`        return resObj;`)

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-cache/asio/a1d8afc0fa0ccceae5729647623b3f7fd6859548/asio/asio/README

@@ -1,4 +0,0 @@
-asio version 1.28.1
-Released Sunday, 30 July 2023.
-
-See doc/index.html for API documentation and a tutorial.