couchbase 3.8.2 → 3.9.1

data/ext/couchbase/core/protocol/datatype.hxx

@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include <cstddef>
 #include <cstdint>
 
 namespace couchbase::core::protocol
@@ -28,6 +29,122 @@ enum class datatype : std::uint8_t {
   xattr = 0x04,
 };
 
+/*
+ * Free-standing bitwise operators for the datatype flag set.
+ *
+ * Combining two datatypes stays inside the enum domain and yields a datatype.
+ * Combining a datatype with a raw protocol byte yields std::byte (in either
+ * operand order), because the result may carry bits outside the named values
+ * and therefore should not pretend to be a well-formed datatype.
+ */
+
+constexpr auto
+operator|(datatype lhs, datatype rhs) noexcept -> datatype
+{
+  return static_cast<datatype>(static_cast<std::uint8_t>(lhs) | static_cast<std::uint8_t>(rhs));
+}
+
+constexpr auto
+operator&(datatype lhs, datatype rhs) noexcept -> datatype
+{
+  return static_cast<datatype>(static_cast<std::uint8_t>(lhs) & static_cast<std::uint8_t>(rhs));
+}
+
+constexpr auto
+operator^(datatype lhs, datatype rhs) noexcept -> datatype
+{
+  return static_cast<datatype>(static_cast<std::uint8_t>(lhs) ^ static_cast<std::uint8_t>(rhs));
+}
+
+constexpr auto
+operator|(datatype lhs, std::byte rhs) noexcept -> std::byte
+{
+  return static_cast<std::byte>(lhs) | rhs;
+}
+
+constexpr auto
+operator|(std::byte lhs, datatype rhs) noexcept -> std::byte
+{
+  return lhs | static_cast<std::byte>(rhs);
+}
+
+constexpr auto
+operator&(datatype lhs, std::byte rhs) noexcept -> std::byte
+{
+  return static_cast<std::byte>(lhs) & rhs;
+}
+
+constexpr auto
+operator&(std::byte lhs, datatype rhs) noexcept -> std::byte
+{
+  return lhs & static_cast<std::byte>(rhs);
+}
+
+constexpr auto
+operator^(datatype lhs, std::byte rhs) noexcept -> std::byte
+{
+  return static_cast<std::byte>(lhs) ^ rhs;
+}
+
+constexpr auto
+operator^(std::byte lhs, datatype rhs) noexcept -> std::byte
+{
+  return lhs ^ static_cast<std::byte>(rhs);
+}
+
+/*
+ * Type-safe flag presence test. Returns true when every bit of flag is set in
+ * value; using the composite flag itself as the right-hand side keeps the check
+ * correct even when flag carries more than one bit.
+ */
+
+constexpr auto
+has_flag(datatype value, datatype flag) noexcept -> bool
+{
+  const auto masked = value & flag;
+  return masked == flag;
+}
+
+constexpr auto
+has_flag(std::byte value, datatype flag) noexcept -> bool
+{
+  const auto masked = value & flag;
+  return masked == static_cast<std::byte>(flag);
+}
+
+/*
+ * In-place mutators that set or clear flag bits. The flag is always a named
+ * datatype, while the value being modified may live in the typed enum domain or
+ * as a raw protocol byte.
+ */
+
+constexpr void
+set_flag(datatype& value, datatype flag) noexcept
+{
+  value = value | flag;
+}
+
+constexpr void
+set_flag(std::byte& value, datatype flag) noexcept
+{
+  value = value | flag;
+}
+
+constexpr void
+clear_flag(datatype& value, datatype flag) noexcept
+{
+  // Complement the flag in the integer domain: the bitwise negation of a single
+  // flag is not itself a valid datatype, so it must never be cast back to the enum.
+  value =
+    static_cast<datatype>(static_cast<std::uint8_t>(value) & ~static_cast<std::uint8_t>(flag));
+}
+
+constexpr void
+clear_flag(std::byte& value, datatype flag) noexcept
+{
+  value &= ~static_cast<std::byte>(flag);
+}
+
 constexpr auto
 is_valid_datatype(std::uint8_t code) -> bool
 {
@@ -44,6 +161,6 @@ is_valid_datatype(std::uint8_t code) -> bool
 constexpr auto
 has_json_datatype(std::uint8_t code) -> bool
 {
-  return (code & static_cast<std::uint8_t>(datatype::json)) != 0;
+  return has_flag(static_cast<std::byte>(code), datatype::json);
 }
 } // namespace couchbase::core::protocol

data/ext/couchbase/core/protocol/frame_info_utils.cxx

@@ -39,7 +39,7 @@ add_durability_frame_info(std::vector<std::byte>& framing_extras,
     framing_extras.resize(extras_old_size + 1 + static_cast<std::size_t>(frame_size));
     framing_extras[extras_old_size + 0] = (frame_id << 4U) | frame_size;
     framing_extras[extras_old_size + 1] = static_cast<std::byte>(level);
-    std::uint16_t val = utils::byte_swap(*timeout);
+    std::uint16_t val = utils::host_to_network(*timeout);
     memcpy(framing_extras.data() + extras_old_size + 2, &val, sizeof(val));
   } else {
     const std::byte frame_size{ 1 /* 1 for level */ };

data/ext/couchbase/core/protocol/magic.hxx

@@ -22,6 +22,8 @@
 namespace couchbase::core::protocol
 {
 enum class magic : std::uint8_t {
+  /// Sentinel value for default-constructed/invalid packets (not a real wire value)
+  invalid = 0x00,
   /// Request packet from client to server
   client_request = 0x80,
   /// The alternative request packet containing frame extras
@@ -47,6 +49,8 @@ is_valid_magic(std::uint8_t code) -> bool
     case magic::server_request:
     case magic::server_response:
       return true;
+    case magic::invalid:
+      break;
   }
   return false;
 }

data/ext/couchbase/core/protocol/magic_fmt.hxx

@@ -52,6 +52,9 @@ struct fmt::formatter<couchbase::core::protocol::magic> {
       case couchbase::core::protocol::magic::server_response:
         name = "server_response (0x83)";
         break;
+      case couchbase::core::protocol::magic::invalid:
+        name = "invalid (0x00)";
+        break;
     }
     return format_to(ctx.out(), "{}", name);
   }

data/ext/couchbase/core/protocol/server_request.hxx

@@ -104,12 +104,14 @@ public:
 
     std::uint32_t field = 0;
     memcpy(&field, header_.data() + 8, sizeof(field));
-    body_size_ = utils::byte_swap(field);
+    body_size_ = utils::network_to_host(field);
     data_.resize(body_size_);
 
     memcpy(&opaque_, header_.data() + 12, sizeof(opaque_));
+    opaque_ = utils::network_to_host(opaque_);
 
     memcpy(&cas_, header_.data() + 16, sizeof(cas_));
+    cas_ = utils::network_to_host(cas_);
   }
 
   void parse_body()

data/ext/couchbase/core/protocol/status.cxx

@@ -65,6 +65,7 @@ map_status_code(protocol::client_opcode opcode, std::uint16_t status) -> std::er
     case key_value_status_code::invalid:
     case key_value_status_code::xattr_invalid:
     case key_value_status_code::subdoc_invalid_combo:
+    case key_value_status_code::subdoc_invalid_xattr_order:
     case key_value_status_code::subdoc_deleted_document_cannot_have_value:
       return errc::common::invalid_argument;
 
@@ -181,7 +182,6 @@ map_status_code(protocol::client_opcode opcode, std::uint16_t status) -> std::er
     case key_value_status_code::scope_size_limit_exceeded:
       return errc::common::quota_limited;
 
-    case key_value_status_code::subdoc_invalid_xattr_order:
     case key_value_status_code::not_my_vbucket:
     case key_value_status_code::auth_continue:
     case key_value_status_code::range_error:

data/ext/couchbase/core/protostellar/analytics_converter.hxx

@@ -0,0 +1,171 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2026. 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.
+ */
+
+#pragma once
+
+// Translates the core analytics request/response to and from the couchbase.analytics.v1 protobuf
+// messages, mirroring query_converter. Rows arrive across streamed AnalyticsQueryResponse messages
+// and are buffered into analytics_response::rows when no callback is provided, or delivered
+// incrementally to row_callback when present; the terminal message carries the metadata.
+//
+// Features with no couchbase2 equivalent are reported by can_encode() so the component can surface
+// feature_not_available rather than silently dropping them: the `raw` passthrough map and scoped
+// analytics.
+//
+// Scoped analytics is refused because the schema cannot express it, not merely because it is
+// unimplemented. AnalyticsQueryRequest at the pinned protostellar revision retired the field the
+// older schema used for this: field 8 is `reserved // bucket_name`, and field 9 was renamed from
+// `scope_name` to `analytics_scope_name` -- one analytics-scope identifier rather than the
+// bucket/scope pair the core request carries in bucket_name/scope_name/scope_qualifier. Collapsing
+// a two-part qualification into that single name would be a guess about which the gateway means, so
+// the request is refused instead. (Vendored copies in couchbase-jvm-clients and
+// couchbase-net-client still carry the older bucket_name=8/scope_name=9 shape, so a mapping cribbed
+// from them would target a schema this client does not speak.)
+
+#include "core/operations/document_analytics.hxx"
+#include "core/protostellar/json_payload.hxx"
+
+#include <couchbase/analytics_scan_consistency.hxx>
+
+#include <couchbase/analytics/v1/analytics.pb.h>
+
+#include <chrono>
+#include <cstddef>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace couchbase::core::protostellar::analytics
+{
+namespace v1 = ::couchbase::analytics::v1;
+
+[[nodiscard]] inline auto
+can_encode(const operations::analytics_request& request) -> bool
+{
+  return request.raw.empty() && !request.bucket_name.has_value() &&
+         !request.scope_name.has_value() && !request.scope_qualifier.has_value();
+}
+
+inline auto
+encode(const operations::analytics_request& request) -> v1::AnalyticsQueryRequest
+{
+  v1::AnalyticsQueryRequest proto;
+  proto.set_statement(request.statement);
+  proto.set_read_only(request.readonly);
+  proto.set_priority(request.priority);
+  if (request.client_context_id.has_value()) {
+    proto.set_client_context_id(*request.client_context_id);
+  }
+  if (request.scan_consistency.has_value()) {
+    switch (*request.scan_consistency) {
+      case analytics_scan_consistency::not_bounded:
+        proto.set_scan_consistency(
+          v1::AnalyticsQueryRequest_ScanConsistency_SCAN_CONSISTENCY_NOT_BOUNDED);
+        break;
+      case analytics_scan_consistency::request_plus:
+        proto.set_scan_consistency(
+          v1::AnalyticsQueryRequest_ScanConsistency_SCAN_CONSISTENCY_REQUEST_PLUS);
+        break;
+    }
+  }
+  for (const auto& parameter : request.positional_parameters) {
+    proto.add_positional_parameters(json_payload(parameter));
+  }
+  for (const auto& [name, value] : request.named_parameters) {
+    (*proto.mutable_named_parameters())[name] = json_payload(value);
+  }
+  return proto;
+}
+
+[[nodiscard]] inline auto
+to_nanoseconds(const google::protobuf::Duration& duration) -> std::chrono::nanoseconds
+{
+  return std::chrono::seconds{ duration.seconds() } + std::chrono::nanoseconds{ duration.nanos() };
+}
+
+// The gateway reports status as a lowercase string; map it onto the core enum.
+[[nodiscard]] inline auto
+status_from_string(const std::string& status) -> operations::analytics_response::analytics_status
+{
+  using s = operations::analytics_response::analytics_status;
+  if (status == "running") {
+    return s::running;
+  }
+  if (status == "success") {
+    return s::success;
+  }
+  if (status == "errors") {
+    return s::errors;
+  }
+  if (status == "completed") {
+    return s::completed;
+  }
+  if (status == "stopped") {
+    return s::stopped;
+  }
+  if (status == "timeout" || status == "timedout") {
+    return s::timedout;
+  }
+  if (status == "closed") {
+    return s::closed;
+  }
+  if (status == "fatal") {
+    return s::fatal;
+  }
+  if (status == "aborted") {
+    return s::aborted;
+  }
+  return s::unknown;
+}
+
+inline void
+decode_meta_data(const v1::AnalyticsQueryResponse_MetaData& proto,
+                 operations::analytics_response::analytics_meta_data& meta)
+{
+  meta.request_id = proto.request_id();
+  meta.client_context_id = proto.client_context_id();
+  meta.status = status_from_string(proto.status());
+  if (!proto.signature().empty()) {
+    meta.signature = proto.signature();
+  }
+  if (proto.has_metrics()) {
+    const auto& m = proto.metrics();
+    meta.metrics.elapsed_time = to_nanoseconds(m.elapsed_time());
+    meta.metrics.execution_time = to_nanoseconds(m.execution_time());
+    meta.metrics.result_count = m.result_count();
+    meta.metrics.result_size = m.result_size();
+    meta.metrics.error_count = m.error_count();
+    meta.metrics.processed_objects = m.processed_objects();
+    meta.metrics.warning_count = m.warning_count();
+  }
+  // Replaced rather than appended, matching query_converter: decode_meta_data runs once per
+  // MetaData message, and appending would accumulate duplicates without bound if a gateway ever
+  // sent more than one.
+  if (proto.warnings_size() > 0) {
+    std::vector<operations::analytics_response::analytics_problem> warnings;
+    warnings.reserve(static_cast<std::size_t>(proto.warnings_size()));
+    for (const auto& w : proto.warnings()) {
+      operations::analytics_response::analytics_problem problem;
+      problem.code = w.code();
+      problem.message = w.message();
+      warnings.push_back(std::move(problem));
+    }
+    meta.warnings = std::move(warnings);
+  }
+}
+
+} // namespace couchbase::core::protostellar::analytics

data/ext/couchbase/core/protostellar/bucket_admin_converter.hxx

@@ -0,0 +1,301 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2026. 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.
+ */
+
+#pragma once
+
+// Translates core bucket management settings to and from couchbase.admin.bucket.v1 (unary admin
+// RPCs). The proto enums have no `unknown` sentinel, so the core `unknown` values fall back to the
+// server default on encode. memcached buckets have no couchbase2 representation;
+// apply_create_only_settings() returns false for them so the component surfaces
+// feature_not_available.
+//
+// Every field the encode side writes is read back by decode_bucket(), because get-modify-update is
+// the ordinary way these settings are changed: a field that decodes to a default is sent back as a
+// default on the next update and silently resets the bucket.
+
+#include "core/management/bucket_settings.hxx"
+#include "core/operations/management/bucket_get_all.hxx"
+
+#include <couchbase/durability_level.hxx>
+
+#include <couchbase/admin/bucket/v1/bucket.pb.h>
+#include <couchbase/kv/v1/kv.pb.h>
+
+#include <cstdint>
+#include <limits>
+#include <optional>
+
+namespace couchbase::core::protostellar::bucket_admin
+{
+namespace v1 = ::couchbase::admin::bucket::v1;
+namespace mgmt = ::couchbase::core::management::cluster;
+
+[[nodiscard]] inline auto
+to_proto_durability(couchbase::durability_level level)
+  -> std::optional<::couchbase::kv::v1::DurabilityLevel>
+{
+  switch (level) {
+    case couchbase::durability_level::none:
+      return std::nullopt;
+    case couchbase::durability_level::majority:
+      return ::couchbase::kv::v1::DURABILITY_LEVEL_MAJORITY;
+    case couchbase::durability_level::majority_and_persist_to_active:
+      return ::couchbase::kv::v1::DURABILITY_LEVEL_MAJORITY_AND_PERSIST_TO_ACTIVE;
+    case couchbase::durability_level::persist_to_majority:
+      return ::couchbase::kv::v1::DURABILITY_LEVEL_PERSIST_TO_MAJORITY;
+  }
+  return std::nullopt;
+}
+
+// Populate the bucket-settings fields that are mutable on both Create and Update requests.
+template<typename Request>
+void
+apply_settings(const mgmt::bucket_settings& settings, Request& proto)
+{
+  proto.set_bucket_name(settings.name);
+  // ram_quota_mb == 0 means "unset" in the core settings (create defaults it to 100, update omits
+  // it); only send an explicit value so an unset quota does not overwrite the server-side value.
+  if (settings.ram_quota_mb != 0) {
+    proto.set_ram_quota_mb(settings.ram_quota_mb);
+  }
+
+  // Omitted when the caller expressed no opinion, so the server applies its own default. Sending an
+  // explicit zero instead would create a bucket with no replicas on their behalf.
+  if (settings.num_replicas.has_value()) {
+    proto.set_num_replicas(*settings.num_replicas);
+  }
+  if (settings.flush_enabled.has_value()) {
+    proto.set_flush_enabled(*settings.flush_enabled);
+  }
+  if (settings.max_expiry.has_value()) {
+    proto.set_max_expiry_secs(*settings.max_expiry);
+  }
+  if (settings.minimum_durability_level.has_value()) {
+    if (auto durability = to_proto_durability(*settings.minimum_durability_level);
+        durability.has_value()) {
+      proto.set_minimum_durability_level(*durability);
+    }
+  }
+  switch (settings.eviction_policy) {
+    case mgmt::bucket_eviction_policy::full:
+      proto.set_eviction_mode(v1::EVICTION_MODE_FULL);
+      break;
+    case mgmt::bucket_eviction_policy::value_only:
+      proto.set_eviction_mode(v1::EVICTION_MODE_VALUE_ONLY);
+      break;
+    case mgmt::bucket_eviction_policy::no_eviction:
+      proto.set_eviction_mode(v1::EVICTION_MODE_NONE);
+      break;
+    case mgmt::bucket_eviction_policy::not_recently_used:
+      proto.set_eviction_mode(v1::EVICTION_MODE_NOT_RECENTLY_USED);
+      break;
+    case mgmt::bucket_eviction_policy::unknown:
+      break; // leave server default
+  }
+  switch (settings.compression_mode) {
+    case mgmt::bucket_compression::off:
+      proto.set_compression_mode(v1::COMPRESSION_MODE_OFF);
+      break;
+    case mgmt::bucket_compression::active:
+      proto.set_compression_mode(v1::COMPRESSION_MODE_ACTIVE);
+      break;
+    case mgmt::bucket_compression::passive:
+      proto.set_compression_mode(v1::COMPRESSION_MODE_PASSIVE);
+      break;
+    case mgmt::bucket_compression::unknown:
+      break;
+  }
+  if (settings.history_retention_collection_default.has_value()) {
+    proto.set_history_retention_collection_default(*settings.history_retention_collection_default);
+  }
+  if (settings.history_retention_bytes.has_value()) {
+    proto.set_history_retention_bytes(*settings.history_retention_bytes);
+  }
+  if (settings.history_retention_duration.has_value()) {
+    proto.set_history_retention_duration_secs(*settings.history_retention_duration);
+  }
+}
+
+// Bucket type, replica indexes, storage backend, and conflict resolution are immutable after
+// creation, so they are only set on CreateBucketRequest. Returns false when the bucket type has no
+// couchbase2 representation (memcached).
+[[nodiscard]] inline auto
+apply_create_only_settings(const mgmt::bucket_settings& settings, v1::CreateBucketRequest& proto)
+  -> bool
+{
+  switch (settings.bucket_type) {
+    case mgmt::bucket_type::couchbase:
+      proto.set_bucket_type(v1::BUCKET_TYPE_COUCHBASE);
+      break;
+    case mgmt::bucket_type::unknown:
+      // Leave bucket_type unset so the gateway applies its server-side default rather than
+      // silently forcing a couchbase bucket.
+      break;
+    case mgmt::bucket_type::ephemeral:
+      proto.set_bucket_type(v1::BUCKET_TYPE_EPHEMERAL);
+      break;
+    case mgmt::bucket_type::memcached:
+      return false;
+  }
+  // A bucket must be created with a RAM quota. Core uses ram_quota_mb == 0 to mean "unset" (and
+  // apply_settings() omits it in that case), so mirror the classic create path and fall back to the
+  // historical 100 MiB default rather than sending a zero quota.
+  if (settings.ram_quota_mb == 0) {
+    proto.set_ram_quota_mb(100);
+  }
+  if (settings.replica_indexes.has_value()) {
+    proto.set_replica_indexes(*settings.replica_indexes);
+  }
+  switch (settings.storage_backend) {
+    case mgmt::bucket_storage_backend::couchstore:
+      proto.set_storage_backend(v1::STORAGE_BACKEND_COUCHSTORE);
+      break;
+    case mgmt::bucket_storage_backend::magma:
+      proto.set_storage_backend(v1::STORAGE_BACKEND_MAGMA);
+      break;
+    case mgmt::bucket_storage_backend::unknown:
+      break;
+  }
+  switch (settings.conflict_resolution_type) {
+    case mgmt::bucket_conflict_resolution::timestamp:
+      proto.set_conflict_resolution_type(v1::CONFLICT_RESOLUTION_TYPE_TIMESTAMP);
+      break;
+    case mgmt::bucket_conflict_resolution::sequence_number:
+      proto.set_conflict_resolution_type(v1::CONFLICT_RESOLUTION_TYPE_SEQUENCE_NUMBER);
+      break;
+    case mgmt::bucket_conflict_resolution::custom:
+      proto.set_conflict_resolution_type(v1::CONFLICT_RESOLUTION_TYPE_CUSTOM);
+      break;
+    case mgmt::bucket_conflict_resolution::unknown:
+      break;
+  }
+  return true;
+}
+
+// Decode one ListBucketsResponse bucket back into core settings.
+[[nodiscard]] inline auto
+decode_bucket(const v1::ListBucketsResponse_Bucket& proto) -> mgmt::bucket_settings
+{
+  mgmt::bucket_settings settings;
+  settings.name = proto.bucket_name();
+  settings.ram_quota_mb = proto.ram_quota_mb();
+  switch (proto.bucket_type()) {
+    case v1::BUCKET_TYPE_EPHEMERAL:
+      settings.bucket_type = mgmt::bucket_type::ephemeral;
+      break;
+    default:
+      settings.bucket_type = mgmt::bucket_type::couchbase;
+      break;
+  }
+  settings.num_replicas = proto.num_replicas();
+  settings.flush_enabled = proto.flush_enabled();
+  settings.replica_indexes = proto.replica_indexes();
+  settings.max_expiry = proto.max_expiry_secs();
+  switch (proto.eviction_mode()) {
+    case v1::EVICTION_MODE_FULL:
+      settings.eviction_policy = mgmt::bucket_eviction_policy::full;
+      break;
+    case v1::EVICTION_MODE_VALUE_ONLY:
+      settings.eviction_policy = mgmt::bucket_eviction_policy::value_only;
+      break;
+    case v1::EVICTION_MODE_NONE:
+      settings.eviction_policy = mgmt::bucket_eviction_policy::no_eviction;
+      break;
+    case v1::EVICTION_MODE_NOT_RECENTLY_USED:
+      settings.eviction_policy = mgmt::bucket_eviction_policy::not_recently_used;
+      break;
+    default:
+      break;
+  }
+  switch (proto.compression_mode()) {
+    case v1::COMPRESSION_MODE_OFF:
+      settings.compression_mode = mgmt::bucket_compression::off;
+      break;
+    case v1::COMPRESSION_MODE_ACTIVE:
+      settings.compression_mode = mgmt::bucket_compression::active;
+      break;
+    case v1::COMPRESSION_MODE_PASSIVE:
+      settings.compression_mode = mgmt::bucket_compression::passive;
+      break;
+    default:
+      break;
+  }
+  // storage_backend and minimum_durability_level are `optional` in the response, so the plain value
+  // getter cannot tell an explicit couchstore (enum 0) from a field the gateway did not send. Read
+  // through the presence bit: absent leaves the core `unknown` / empty optional, which is what the
+  // gateway means by omitting it.
+  if (proto.has_storage_backend()) {
+    switch (proto.storage_backend()) {
+      case v1::STORAGE_BACKEND_MAGMA:
+        settings.storage_backend = mgmt::bucket_storage_backend::magma;
+        break;
+      case v1::STORAGE_BACKEND_COUCHSTORE:
+        settings.storage_backend = mgmt::bucket_storage_backend::couchstore;
+        break;
+      default:
+        break;
+    }
+  }
+  if (proto.has_minimum_durability_level()) {
+    switch (proto.minimum_durability_level()) {
+      case ::couchbase::kv::v1::DURABILITY_LEVEL_MAJORITY:
+        settings.minimum_durability_level = couchbase::durability_level::majority;
+        break;
+      case ::couchbase::kv::v1::DURABILITY_LEVEL_MAJORITY_AND_PERSIST_TO_ACTIVE:
+        settings.minimum_durability_level =
+          couchbase::durability_level::majority_and_persist_to_active;
+        break;
+      case ::couchbase::kv::v1::DURABILITY_LEVEL_PERSIST_TO_MAJORITY:
+        settings.minimum_durability_level = couchbase::durability_level::persist_to_majority;
+        break;
+      default:
+        break;
+    }
+  }
+  // conflict_resolution_type carries no presence bit on this message, unlike the two above, so an
+  // unset field is indistinguishable from an explicit timestamp (enum 0) and is read as one.
+  switch (proto.conflict_resolution_type()) {
+    case v1::CONFLICT_RESOLUTION_TYPE_TIMESTAMP:
+      settings.conflict_resolution_type = mgmt::bucket_conflict_resolution::timestamp;
+      break;
+    case v1::CONFLICT_RESOLUTION_TYPE_SEQUENCE_NUMBER:
+      settings.conflict_resolution_type = mgmt::bucket_conflict_resolution::sequence_number;
+      break;
+    case v1::CONFLICT_RESOLUTION_TYPE_CUSTOM:
+      settings.conflict_resolution_type = mgmt::bucket_conflict_resolution::custom;
+      break;
+    default:
+      break;
+  }
+  if (proto.has_history_retention_collection_default()) {
+    settings.history_retention_collection_default = proto.history_retention_collection_default();
+  }
+  // The proto carries 64 bits and the core setting holds 32. Narrowing a larger value would report
+  // a retention size the bucket does not have, and the usual get-modify-update cycle would then
+  // send that smaller number back and shrink the setting. Leaving the optional empty is what the
+  // encode side omits, so the server keeps its own value.
+  if (proto.has_history_retention_bytes() &&
+      proto.history_retention_bytes() <= std::numeric_limits<std::uint32_t>::max()) {
+    settings.history_retention_bytes = static_cast<std::uint32_t>(proto.history_retention_bytes());
+  }
+  if (proto.has_history_retention_duration_secs()) {
+    settings.history_retention_duration = proto.history_retention_duration_secs();
+  }
+  return settings;
+}
+
+} // namespace couchbase::core::protostellar::bucket_admin