couchbase 4.2.11 → 4.3.1

package/deps/couchbase-cxx-client/core/impl/query_error_context.cxx

@@ -38,8 +38,8 @@ query_error_context::to_json() const -> std::string
         { "retry_attempts", retry_attempts() },
         { "client_context_id", client_context_id_ },
         { "statement", statement_ },
-        { "method", statement_ },
-        { "path", statement_ },
+        { "method", method_ },
+        { "path", path_ },
         { "http_status", http_status_ },
         { "http_body", http_body_ },
         { "hostname", hostname_ },

package/deps/couchbase-cxx-client/core/impl/query_index_manager.cxx

@@ -30,6 +30,7 @@
 
 #include <asio/steady_timer.hpp>
 
+#include <algorithm>
 #include <utility>
 
 namespace couchbase

package/deps/couchbase-cxx-client/core/impl/scan_result.cxx

@@ -0,0 +1,174 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2024. 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
+ *
+ *       http://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.
+ */
+
+#include <couchbase/codec/encoded_value.hxx>
+#include <couchbase/error_codes.hxx>
+#include <couchbase/scan_result.hxx>
+#include <couchbase/scan_result_item.hxx>
+
+#include "core/range_scan_options.hxx"
+#include "core/scan_result.hxx"
+
+#include "internal_scan_result.hxx"
+
+#include <future>
+#include <memory>
+#include <optional>
+#include <system_error>
+#include <utility>
+
+namespace couchbase
+{
+namespace
+{
+auto
+to_scan_result_item(core::range_scan_item core_item) -> scan_result_item
+{
+    if (!core_item.body) {
+        return scan_result_item{ core_item.key };
+    }
+    return scan_result_item{
+        core_item.key,
+        core_item.body.value().cas,
+        couchbase::codec::encoded_value{ core_item.body.value().value, core_item.body.value().flags },
+        core_item.body.value().expiry_time(),
+    };
+}
+} // namespace
+
+internal_scan_result::internal_scan_result(core::scan_result core_result)
+  : core_result_{ std::move(core_result) }
+{
+}
+
+void
+internal_scan_result::next(scan_item_handler&& handler)
+{
+    return core_result_.next([handler = std::move(handler)](core::range_scan_item item, std::error_code ec) mutable {
+        if (ec == couchbase::errc::key_value::range_scan_completed) {
+            return handler({}, {});
+        }
+        if (ec) {
+            return handler(ec, {});
+        }
+        handler({}, to_scan_result_item(std::move(item)));
+    });
+}
+
+void
+internal_scan_result::cancel()
+{
+    return core_result_.cancel();
+}
+
+internal_scan_result::~internal_scan_result()
+{
+    cancel();
+}
+
+scan_result::scan_result(std::shared_ptr<couchbase::internal_scan_result> internal)
+  : internal_{ std::move(internal) }
+{
+}
+
+void
+scan_result::next(couchbase::scan_item_handler&& handler) const
+{
+    return internal_->next(std::move(handler));
+}
+
+auto
+scan_result::next() const -> std::future<std::pair<std::error_code, std::optional<scan_result_item>>>
+{
+    auto barrier = std::make_shared<std::promise<std::pair<std::error_code, std::optional<scan_result_item>>>>();
+    internal_->next([barrier](auto ec, auto item) mutable { barrier->set_value({ ec, item }); });
+    return barrier->get_future();
+}
+
+void
+scan_result::cancel()
+{
+    if (internal_) {
+        return internal_->cancel();
+    }
+}
+
+auto
+scan_result::begin() -> scan_result::iterator
+{
+    return scan_result::iterator(internal_);
+}
+
+auto
+scan_result::end() -> scan_result::iterator
+{
+    return scan_result::iterator({ errc::key_value::range_scan_completed, {} });
+}
+
+scan_result::iterator::iterator(std::shared_ptr<internal_scan_result> internal)
+  : internal_{ std::move(internal) }
+{
+    fetch_item();
+}
+
+scan_result::iterator::iterator(std::pair<std::error_code, scan_result_item> item)
+  : item_{ std::move(item) }
+{
+}
+
+void
+scan_result::iterator::fetch_item()
+{
+    auto barrier = std::make_shared<std::promise<std::pair<std::error_code, scan_result_item>>>();
+    internal_->next([barrier](std::error_code ec, std::optional<scan_result_item> item) mutable {
+        if (ec) {
+            return barrier->set_value({ ec, {} });
+        }
+        if (!item.has_value()) {
+            return barrier->set_value({ errc::key_value::range_scan_completed, {} });
+        }
+        barrier->set_value({ {}, item.value() });
+    });
+    auto f = barrier->get_future();
+    item_ = f.get();
+}
+
+auto
+scan_result::iterator::operator*() -> std::pair<std::error_code, scan_result_item>
+{
+    return item_;
+}
+
+auto
+scan_result::iterator::operator++() -> scan_result::iterator&
+{
+    fetch_item();
+    return *this;
+}
+
+auto
+scan_result::iterator::operator==(const couchbase::scan_result::iterator& other) const -> bool
+{
+    return item_ == other.item_;
+}
+
+auto
+scan_result::iterator::operator!=(const couchbase::scan_result::iterator& other) const -> bool
+{
+    return item_ != other.item_;
+}
+} // namespace couchbase

package/deps/couchbase-cxx-client/core/io/dns_client.cxx

@@ -285,6 +285,10 @@ dns_client::query_srv(const std::string& name,
                       const dns_config& config,
                       utils::movable_function<void(dns_srv_response&&)>&& handler)
 {
+    if (config.nameserver().empty()) {
+        return handler({ {} });
+    }
+
     std::error_code ec;
     auto address = asio::ip::make_address(config.nameserver(), ec);
     if (ec) {

package/deps/couchbase-cxx-client/core/io/dns_config.cxx

@@ -53,6 +53,7 @@ load_resolv_conf()
     fixed_info = (FIXED_INFO*)malloc(sizeof(FIXED_INFO));
     if (fixed_info == NULL) {
         CB_LOG_WARNING("Error allocating memory needed to call GetNetworkParams");
+        return {};
     }
     buf = sizeof(FIXED_INFO);
 
@@ -63,6 +64,7 @@ load_resolv_conf()
         fixed_info = (FIXED_INFO*)malloc(buf);
         if (fixed_info == NULL) {
             CB_LOG_WARNING("Error allocating memory needed to call GetNetworkParams");
+            return {};
         }
     }
 
@@ -86,10 +88,12 @@ load_resolv_conf()
         }
     } else {
         CB_LOG_WARNING("GetNetworkParams failed with error: {}", ret);
+        return {};
     }
 
-    if (fixed_info)
+    if (fixed_info) {
         free(fixed_info);
+    }
 
     if (dns_servers.size() > 0) {
         CB_LOG_DEBUG(
@@ -153,10 +157,17 @@ dns_config::system_config()
         std::error_code ec;
         asio::ip::make_address(nameserver, ec);
         if (ec) {
-            CB_LOG_DEBUG("Unable to parse \"{}\" as a network address, fall back to \"{}\"", nameserver, default_nameserver);
-            nameserver = default_nameserver;
+            std::string extra_info{};
+#ifndef _WIN32
+            extra_info = fmt::format(" in \"{}\"", default_resolv_conf_path);
+#endif
+            CB_LOG_WARNING("System DNS detection failed: unable to parse \"{}\" as a network address{}. DNS-SRV will not work "
+                           "unless nameserver is specified explicitly in the options.",
+                           nameserver,
+                           extra_info);
+        } else {
+            instance.nameserver_ = nameserver;
         }
-        instance.nameserver_ = nameserver;
     });
 
     return instance;

package/deps/couchbase-cxx-client/core/io/dns_config.hxx

@@ -40,7 +40,7 @@ class dns_config
     [[nodiscard]] std::chrono::milliseconds timeout() const;
 
   private:
-    std::string nameserver_{ default_nameserver };
+    std::string nameserver_{};
     std::uint16_t port_{ default_port };
     std::chrono::milliseconds timeout_{ timeout_defaults::dns_srv_timeout };
 };

package/deps/couchbase-cxx-client/core/io/mcbp_session.cxx

@@ -210,6 +210,7 @@ class mcbp_session_impl
         std::shared_ptr<mcbp_session_impl> session_;
         sasl::ClientContext sasl_;
         std::atomic_bool stopped_{ false };
+        std::string last_error_message_;
 
       public:
         ~bootstrap_handler()
@@ -234,6 +235,16 @@ class mcbp_session_impl
             return { "SCRAM-SHA512", "SCRAM-SHA256", "SCRAM-SHA1" };
         }
 
+        std::string last_error_message() &&
+        {
+            return std::move(last_error_message_);
+        }
+
+        [[nodiscard]] const std::string& last_error_message() const&
+        {
+            return last_error_message_;
+        }
+
         explicit bootstrap_handler(std::shared_ptr<mcbp_session_impl> session)
           : session_(std::move(session))
           , sasl_([origin = session_->origin_]() { return origin.username(); },
@@ -322,21 +333,21 @@ class mcbp_session_impl
                         case key_value_status_code::rate_limited_max_connections:
                         case key_value_status_code::rate_limited_network_egress:
                         case key_value_status_code::rate_limited_network_ingress:
-                            CB_LOG_DEBUG(
-                              "{} unable to bootstrap MCBP session (bucket={}, opcode={}, status={}), the user has reached rate limit",
-                              session_->log_prefix_,
+                            last_error_message_ = fmt::format(
+                              "unable to bootstrap MCBP session (bucket={}, opcode={}, status={}), the user has reached rate limit",
                               session_->bucket_name_.value_or(""),
                               protocol::client_opcode(msg.header.opcode),
                               status);
+                            CB_LOG_DEBUG("{} {}", session_->log_prefix_, last_error_message_);
                             return complete(errc::common::rate_limited);
 
                         case key_value_status_code::scope_size_limit_exceeded:
-                            CB_LOG_DEBUG(
-                              "{} unable to bootstrap MCBP session (bucket={}, opcode={}, status={}), the user has reached quota limit",
-                              session_->log_prefix_,
+                            last_error_message_ = fmt::format(
+                              "unable to bootstrap MCBP session (bucket={}, opcode={}, status={}), the user has reached quota limit",
                               session_->bucket_name_.value_or(""),
                               protocol::client_opcode(msg.header.opcode),
                               status);
+                            CB_LOG_DEBUG("{} {}", session_->log_prefix_, last_error_message_);
                             return complete(errc::common::quota_limited);
 
                         default:
@@ -356,20 +367,18 @@ class mcbp_session_impl
                                     return auth_success();
                                 }
                             } else {
-                                CB_LOG_WARNING("{} unexpected message status during bootstrap: {} (opaque={})",
-                                               session_->log_prefix_,
-                                               resp.error_message(),
-                                               resp.opaque());
+                                last_error_message_ = fmt::format(
+                                  "unexpected message status during bootstrap: {} (opaque={})", resp.error_message(), resp.opaque());
+                                CB_LOG_WARNING("{} {}", session_->log_prefix_, last_error_message_);
                                 return complete(errc::network::handshake_failure);
                             }
                         } break;
                         case protocol::client_opcode::sasl_list_mechs: {
                             protocol::client_response<protocol::sasl_list_mechs_response_body> resp(std::move(msg));
                             if (resp.status() != key_value_status_code::success) {
-                                CB_LOG_WARNING("{} unexpected message status during bootstrap: {} (opaque={})",
-                                               session_->log_prefix_,
-                                               resp.error_message(),
-                                               resp.opaque());
+                                last_error_message_ = fmt::format(
+                                  "unexpected message status during bootstrap: {} (opaque={})", resp.error_message(), resp.opaque());
+                                CB_LOG_WARNING("{} {}", session_->log_prefix_, last_error_message_);
                                 return complete(errc::common::authentication_failure);
                             }
                         } break;
@@ -390,17 +399,17 @@ class mcbp_session_impl
                                     req.body().sasl_data(sasl_payload);
                                     session_->write_and_flush(req.data());
                                 } else {
-                                    CB_LOG_ERROR("{} unable to authenticate: (sasl_code={}, opaque={})",
-                                                 session_->log_prefix_,
-                                                 sasl_code,
-                                                 resp.opaque());
+                                    last_error_message_ =
+                                      fmt::format("unable to authenticate: (sasl_code={}, opaque={})", sasl_code, resp.opaque());
+                                    CB_LOG_ERROR("{} {}", session_->log_prefix_, last_error_message_);
                                     return complete(errc::common::authentication_failure);
                                 }
                             } else {
-                                CB_LOG_WARNING("{} unexpected message status during bootstrap: {} (opaque={})",
-                                               session_->log_prefix_,
-                                               resp.error_message(),
-                                               resp.opaque());
+                                last_error_message_ = fmt::format("{} unexpected message status during bootstrap: {} (opaque={})",
+                                                                  session_->log_prefix_,
+                                                                  resp.error_message(),
+                                                                  resp.opaque());
+                                CB_LOG_WARNING("{} {}", session_->log_prefix_, last_error_message_);
                                 return complete(errc::common::authentication_failure);
                             }
                         } break;
@@ -409,6 +418,9 @@ class mcbp_session_impl
                             if (resp.status() == key_value_status_code::success) {
                                 return auth_success();
                             }
+                            last_error_message_ =
+                              fmt::format("unable to authenticate (opcode={}, status={}, opaque={})", opcode, resp.status(), resp.opaque());
+                            CB_LOG_ERROR("{} {}", session_->log_prefix_, last_error_message_);
                             return complete(errc::common::authentication_failure);
                         }
                         case protocol::client_opcode::get_error_map: {
@@ -416,11 +428,11 @@ class mcbp_session_impl
                             if (resp.status() == key_value_status_code::success) {
                                 session_->error_map_.emplace(resp.body().errmap());
                             } else {
-                                CB_LOG_WARNING("{} unexpected message status during bootstrap: {} (opaque={}, {:n})",
-                                               session_->log_prefix_,
-                                               resp.error_message(),
-                                               resp.opaque(),
-                                               spdlog::to_hex(resp.header()));
+                                last_error_message_ = fmt::format("unexpected message status during bootstrap: {} (opaque={}, {:n})",
+                                                                  resp.error_message(),
+                                                                  resp.opaque(),
+                                                                  spdlog::to_hex(resp.header()));
+                                CB_LOG_WARNING("{} {}", session_->log_prefix_, last_error_message_);
                                 return complete(errc::network::protocol_error);
                             }
                         } break;
@@ -430,25 +442,25 @@ class mcbp_session_impl
                                 CB_LOG_DEBUG("{} selected bucket: {}", session_->log_prefix_, session_->bucket_name_.value_or(""));
                                 session_->bucket_selected_ = true;
                             } else if (resp.status() == key_value_status_code::not_found) {
-                                CB_LOG_DEBUG(
-                                  "{} kv_engine node does not have configuration propagated yet (opcode={}, status={}, opaque={})",
-                                  session_->log_prefix_,
-                                  opcode,
-                                  resp.status(),
-                                  resp.opaque());
+                                last_error_message_ =
+                                  fmt::format("kv_engine node does not have configuration propagated yet (opcode={}, status={}, opaque={})",
+                                              opcode,
+                                              resp.status(),
+                                              resp.opaque());
+                                CB_LOG_DEBUG("{} {}", session_->log_prefix_, last_error_message_);
                                 return complete(errc::network::configuration_not_available);
                             } else if (resp.status() == key_value_status_code::no_access) {
-                                CB_LOG_DEBUG("{} unable to select bucket: {}, probably the bucket does not exist",
-                                             session_->log_prefix_,
-                                             session_->bucket_name_.value_or(""));
+                                last_error_message_ = fmt::format("unable to select bucket: {}, probably the bucket does not exist",
+                                                                  session_->bucket_name_.value_or(""));
+                                CB_LOG_DEBUG("{} {}", session_->log_prefix_, last_error_message_);
                                 session_->bucket_selected_ = false;
                                 return complete(errc::common::bucket_not_found);
                             } else {
-                                CB_LOG_WARNING("{} unexpected message status during bootstrap: {} (opaque={}, {:n})",
-                                               session_->log_prefix_,
-                                               resp.error_message(),
-                                               resp.opaque(),
-                                               spdlog::to_hex(resp.header()));
+                                last_error_message_ = fmt::format("unexpected message status during bootstrap: {} (opaque={}, {:n})",
+                                                                  resp.error_message(),
+                                                                  resp.opaque(),
+                                                                  spdlog::to_hex(resp.header()));
+                                CB_LOG_WARNING("{} {}", session_->log_prefix_, last_error_message_);
                                 return complete(errc::common::bucket_not_found);
                             }
                         } break;
@@ -467,15 +479,24 @@ class mcbp_session_impl
                             }
                             protocol::client_response<protocol::get_cluster_config_response_body> resp(std::move(msg), info);
                             if (resp.status() == key_value_status_code::success) {
+                                // MB-60405 fixes this for 7.6.2, but for earlier versions we need to protect against using a
+                                // config that has an empty vbucket map.  Ideally we don't timeout if we retry here, but a timeout
+                                // would be more acceptable than a crash and if we do timeout, we have a clear indication of the
+                                // problem (i.e. it is a server bug and we cannot use a config w/ an empty vbucket map).
+                                if (resp.body().config().vbmap && resp.body().config().vbmap->size() == 0) {
+                                    CB_LOG_WARNING("{} received a configuration with an empty vbucket map, retrying",
+                                                   session_->log_prefix_);
+                                    return complete(errc::network::configuration_not_available);
+                                }
                                 session_->update_configuration(resp.body().config());
                                 complete({});
                             } else if (resp.status() == key_value_status_code::not_found) {
-                                CB_LOG_DEBUG(
-                                  "{} kv_engine node does not have configuration propagated yet (opcode={}, status={}, opaque={})",
-                                  session_->log_prefix_,
-                                  opcode,
-                                  resp.status(),
-                                  resp.opaque());
+                                last_error_message_ =
+                                  fmt::format("kv_engine node does not have configuration propagated yet (opcode={}, status={}, opaque={})",
+                                              opcode,
+                                              resp.status(),
+                                              resp.opaque());
+                                CB_LOG_DEBUG("{} {}", session_->log_prefix_, last_error_message_);
                                 return complete(errc::network::configuration_not_available);
                             } else if (resp.status() == key_value_status_code::no_bucket && !session_->bucket_name_) {
                                 // bucket-less session, but the server wants bucket
@@ -486,16 +507,17 @@ class mcbp_session_impl
                                   session_->connection_endpoints_.remote_address, session_->connection_endpoints_.remote.port(), 0));
                                 complete({});
                             } else {
-                                CB_LOG_WARNING("{} unexpected message status during bootstrap: {} (opaque={}, {:n})",
-                                               session_->log_prefix_,
-                                               resp.error_message(),
-                                               resp.opaque(),
-                                               spdlog::to_hex(resp.header()));
+                                last_error_message_ = fmt::format("unexpected message status during bootstrap: {} (opaque={}, {:n})",
+                                                                  resp.error_message(),
+                                                                  resp.opaque(),
+                                                                  spdlog::to_hex(resp.header()));
+                                CB_LOG_WARNING("{} {}", session_->log_prefix_, last_error_message_);
                                 return complete(errc::network::protocol_error);
                             }
                         } break;
                         default:
-                            CB_LOG_WARNING("{} unexpected message during bootstrap: {}", session_->log_prefix_, opcode);
+                            last_error_message_ = fmt::format("unexpected message during bootstrap: {}", opcode);
+                            CB_LOG_WARNING("{} {}", session_->log_prefix_, last_error_message_);
                             return complete(errc::network::protocol_error);
                     }
                     break;
@@ -796,6 +818,20 @@ class mcbp_session_impl
 
     void ping(std::shared_ptr<diag::ping_reporter> handler, std::optional<std::chrono::milliseconds> timeout)
     {
+        if (!bootstrapped_) {
+            handler->report({
+              service_type::key_value,
+              id_,
+              std::chrono::microseconds(0),
+              remote_address(),
+              local_address(),
+              diag::ping_state::error,
+              bucket_name_,
+              last_bootstrap_error_message_.has_value() ? last_bootstrap_error_message_.value()
+                                                        : "Bootstrap incomplete, cannot perform ping.",
+            });
+            return;
+        }
         protocol::client_request<protocol::mcbp_noop_request_body> req;
         req.opaque(next_opaque());
         write_and_subscribe(req.opaque(),
@@ -871,6 +907,9 @@ class mcbp_session_impl
             return;
         }
         bootstrapped_ = false;
+        if (bootstrap_handler_) {
+            last_bootstrap_error_message_ = std::move(bootstrap_handler_)->last_error_message();
+        }
         bootstrap_handler_ = nullptr;
         state_ = diag::endpoint_state::connecting;
         if (stream_->is_open()) {
@@ -1226,6 +1265,14 @@ class mcbp_session_impl
             return;
         }
         std::scoped_lock lock(config_mutex_);
+        // MB-60405 fixes this for 7.6.2, but for earlier versions we need to protect against using a
+        // config that has an empty vbucket map.  We should be okay to ignore at this point b/c we should
+        // already have a config w/ a non-empty vbucket map (bootstrap will not complete successfully
+        // unless we have a config w/ a non-empty vbucket map).
+        if (config.vbmap && config.vbmap->size() == 0) {
+            CB_LOG_DEBUG("{} received a configuration with an empty vbucket map, ignoring", log_prefix_);
+            return;
+        }
         if (config_) {
             if (config_->vbmap && config.vbmap && config_->vbmap->size() != config.vbmap->size()) {
                 CB_LOG_DEBUG("{} received a configuration with a different number of vbuckets, ignoring", log_prefix_);
@@ -1644,6 +1691,7 @@ class mcbp_session_impl
     std::optional<std::string> bucket_name_;
     mcbp_parser parser_;
     std::shared_ptr<bootstrap_handler> bootstrap_handler_{ nullptr };
+    std::optional<std::string> last_bootstrap_error_message_;
     std::shared_ptr<message_handler> handler_{ nullptr };
     utils::movable_function<void(std::error_code, const topology::configuration&)> bootstrap_callback_{};
     std::mutex command_handlers_mutex_{};

package/deps/couchbase-cxx-client/core/management/eventing_function.hxx

@@ -44,6 +44,7 @@ enum class function_language_compatibility {
     version_6_0_0,
     version_6_5_0,
     version_6_6_2,
+    version_7_2_0,
 };
 
 enum class function_log_level {
@@ -184,5 +185,10 @@ struct function {
     std::vector<function_url_binding> url_bindings{};
     std::vector<function_constant_binding> constant_bindings{};
     function_settings settings{};
+
+    struct {
+        std::optional<std::string> bucket_name{};
+        std::optional<std::string> scope_name{};
+    } internal{};
 };
 } // namespace couchbase::core::management::eventing

package/deps/couchbase-cxx-client/core/management/eventing_function_json.hxx

@@ -175,6 +175,9 @@ struct traits<couchbase::core::management::eventing::function> {
                 } else if (language_compatibility_string == "6.6.2") {
                     result.settings.language_compatibility =
                       couchbase::core::management::eventing::function_language_compatibility::version_6_6_2;
+                } else if (language_compatibility_string == "7.2.0") {
+                    result.settings.language_compatibility =
+                      couchbase::core::management::eventing::function_language_compatibility::version_7_2_0;
                 }
             }
 
@@ -206,6 +209,11 @@ struct traits<couchbase::core::management::eventing::function> {
             }
         }
 
+        if (const auto* function_scope = v.find("function_scope"); function_scope != nullptr && function_scope->is_object()) {
+            result.internal.bucket_name = function_scope->template optional<std::string>("bucket");
+            result.internal.scope_name = function_scope->template optional<std::string>("scope");
+        }
+
         return result;
     }
 };

package/deps/couchbase-cxx-client/core/management/eventing_status.hxx

@@ -74,6 +74,11 @@ struct function_state {
     function_deployment_status deployment_status;
     function_processing_status processing_status;
     std::optional<bool> redeploy_required{};
+
+    struct {
+        std::optional<std::string> bucket_name{};
+        std::optional<std::string> scope_name{};
+    } internal{};
 };
 
 struct status {

package/deps/couchbase-cxx-client/core/management/eventing_status_json.hxx

@@ -67,6 +67,11 @@ struct traits<couchbase::core::management::eventing::status> {
                     function.status = couchbase::core::management::eventing::function_status::pausing;
                 }
 
+                if (const auto* function_scope = app.find("function_scope"); function_scope != nullptr && function_scope->is_object()) {
+                    function.internal.bucket_name = function_scope->template optional<std::string>("bucket");
+                    function.internal.scope_name = function_scope->template optional<std::string>("scope");
+                }
+
                 result.functions.emplace_back(function);
             }
         }

package/deps/couchbase-cxx-client/core/mcbp/operation_queue.cxx

@@ -25,6 +25,7 @@
 
 #include <fmt/core.h>
 
+#include <algorithm>
 #include <memory>
 
 namespace couchbase::core::mcbp

package/deps/couchbase-cxx-client/core/meta/features.hxx

@@ -126,3 +126,14 @@
  * Transaction's transaction_operation_failed has a public getter for its final_error
  */
 #define COUCHBASE_CXX_CLIENT_TRANSACTIONS_CAN_FETCH_TO_RAISE 1
+
+/**
+ * Hooks in the transactions core are asynchronous (they have a callback parameter)
+ */
+#define COUCHBASE_CXX_CLIENT_TRANSACTIONS_CORE_ASYNC_HOOKS
+
+/**
+ * Range scan is accessible from the public API
+ * couchbase::collection::scan()
+ */
+#define COUCHBASE_CXX_CLIENT_HAS_PUBLIC_RANGE_SCAN 1