couchbase 3.5.1 → 3.5.2

data/ext/couchbase/core/crud_component.cxx

@@ -46,70 +46,72 @@ namespace couchbase::core
 static std::pair<std::vector<std::byte>, std::error_code>
 serialize_range_scan_create_options(const range_scan_create_options& options)
 {
-    tao::json::value body{};
-    if (options.ids_only) {
-        body["key_only"] = true;
+  tao::json::value body{};
+  if (options.ids_only) {
+    body["key_only"] = true;
+  }
+
+  if (options.collection_id != 0) {
+    body["collection"] = fmt::format("{:x}", options.collection_id);
+  }
+
+  if (std::holds_alternative<range_scan>(options.scan_type) ||
+      std::holds_alternative<prefix_scan>(options.scan_type)) {
+    const auto& range = (std::holds_alternative<range_scan>(options.scan_type))
+                          ? std::get<range_scan>(options.scan_type)
+                          : std::get<prefix_scan>(options.scan_type).to_range_scan();
+
+    const auto& from = range.from.value_or(scan_term{ "" });
+    const auto& to = range.to.value_or(scan_term{ "\xf4\x8f\xfb\xfb" });
+
+    body["range"] = {
+      { from.exclusive ? "excl_start" : "start", base64::encode(from.term) },
+      { to.exclusive ? "excl_end" : "end", base64::encode(to.term) },
+    };
+  } else if (std::holds_alternative<sampling_scan>(options.scan_type)) {
+    const auto& sampling = std::get<sampling_scan>(options.scan_type);
+
+    // The limit in sampling scan is required to be greater than 0
+    if (sampling.limit <= 0) {
+      return { {}, errc::common::invalid_argument };
     }
 
-    if (options.collection_id != 0) {
-        body["collection"] = fmt::format("{:x}", options.collection_id);
-    }
-
-    if (std::holds_alternative<range_scan>(options.scan_type) || std::holds_alternative<prefix_scan>(options.scan_type)) {
-        const auto& range = (std::holds_alternative<range_scan>(options.scan_type))
-                              ? std::get<range_scan>(options.scan_type)
-                              : std::get<prefix_scan>(options.scan_type).to_range_scan();
-
-        const auto& from = range.from.value_or(scan_term{ "" });
-        const auto& to = range.to.value_or(scan_term{ "\xf4\x8f\xfb\xfb" });
-
-        body["range"] = {
-            { from.exclusive ? "excl_start" : "start", base64::encode(from.term) },
-            { to.exclusive ? "excl_end" : "end", base64::encode(to.term) },
-        };
-    } else if (std::holds_alternative<sampling_scan>(options.scan_type)) {
-        const auto& sampling = std::get<sampling_scan>(options.scan_type);
-
-        // The limit in sampling scan is required to be greater than 0
-        if (sampling.limit <= 0) {
-            return { {}, errc::common::invalid_argument };
-        }
-
-        std::uint64_t seed{};
-        if (sampling.seed.has_value()) {
-            seed = sampling.seed.value();
-        } else {
-            // Generate random uint64 as seed
-            std::random_device rd;
-            std::mt19937_64 gen(rd());
-            std::uniform_int_distribution<std::uint64_t> dis;
-            seed = dis(gen);
-        }
-
-        body["sampling"] = {
-            { "samples", sampling.limit },
-            { "seed", seed },
-        };
+    std::uint64_t seed{};
+    if (sampling.seed.has_value()) {
+      seed = sampling.seed.value();
     } else {
-        return { {}, errc::common::invalid_argument };
+      // Generate random uint64 as seed
+      std::random_device rd;
+      std::mt19937_64 gen(rd());
+      std::uniform_int_distribution<std::uint64_t> dis;
+      seed = dis(gen);
     }
 
-    if (options.snapshot_requirements) {
-        const auto& snapshot = options.snapshot_requirements.value();
-        tao::json::value requirements = {
-            { "vb_uuid", std::to_string(snapshot.vbucket_uuid) },
-            { "seqno", snapshot.sequence_number },
-            { "timeout_ms",
-              (options.timeout == std::chrono::milliseconds::zero()) ? timeout_defaults::key_value_scan_timeout.count()
-                                                                     : options.timeout.count() },
-        };
-        if (snapshot.sequence_number_exists) {
-            requirements["seqno_exists"] = true;
-        }
-        body["snapshot_requirements"] = requirements;
+    body["sampling"] = {
+      { "samples", sampling.limit },
+      { "seed", seed },
+    };
+  } else {
+    return { {}, errc::common::invalid_argument };
+  }
+
+  if (options.snapshot_requirements) {
+    const auto& snapshot = options.snapshot_requirements.value();
+    tao::json::value requirements = {
+      { "vb_uuid", std::to_string(snapshot.vbucket_uuid) },
+      { "seqno", snapshot.sequence_number },
+      { "timeout_ms",
+        (options.timeout == std::chrono::milliseconds::zero())
+          ? timeout_defaults::key_value_scan_timeout.count()
+          : options.timeout.count() },
+    };
+    if (snapshot.sequence_number_exists) {
+      requirements["seqno_exists"] = true;
     }
+    body["snapshot_requirements"] = requirements;
+  }
 
-    return { utils::json::generate_binary(body), {} };
+  return { utils::json::generate_binary(body), {} };
 }
 
 auto
@@ -117,21 +119,23 @@ parse_range_scan_keys(gsl::span<std::byte> data,
                       std::shared_ptr<mcbp::queue_request> request,
                       range_scan_item_callback&& item_callback) -> std::error_code
 {
-    do {
-        if (data.empty() || request->is_cancelled()) {
-            return {};
-        }
-        auto [key_length, remaining] = utils::decode_unsigned_leb128<std::size_t>(data, core::utils::leb_128_no_throw{});
-        if (remaining.size() < key_length) {
-            return errc::network::protocol_error;
-        }
-        item_callback(range_scan_item{ { reinterpret_cast<const char*>(remaining.data()), key_length } });
-        if (remaining.size() == key_length) {
-            return {};
-        }
-        data = gsl::make_span(remaining.data() + key_length, remaining.size() - key_length);
-    } while (!data.empty());
-    return {};
+  do {
+    if (data.empty() || request->is_cancelled()) {
+      return {};
+    }
+    auto [key_length, remaining] =
+      utils::decode_unsigned_leb128<std::size_t>(data, core::utils::leb_128_no_throw{});
+    if (remaining.size() < key_length) {
+      return errc::network::protocol_error;
+    }
+    item_callback(
+      range_scan_item{ { reinterpret_cast<const char*>(remaining.data()), key_length } });
+    if (remaining.size() == key_length) {
+      return {};
+    }
+    data = gsl::make_span(remaining.data() + key_length, remaining.size() - key_length);
+  } while (!data.empty());
+  return {};
 }
 
 auto
@@ -139,55 +143,60 @@ parse_range_scan_documents(gsl::span<std::byte> data,
                            std::shared_ptr<mcbp::queue_request> request,
                            range_scan_item_callback&& item_callback) -> std::error_code
 {
-    do {
-        if (data.empty() || request->is_cancelled()) {
-            return {};
-        }
+  do {
+    if (data.empty() || request->is_cancelled()) {
+      return {};
+    }
 
-        range_scan_item_body body{};
-        static constexpr std::size_t header_offset =
-          sizeof(body.flags) + sizeof(body.expiry) + sizeof(body.sequence_number) + sizeof(body.cas) + sizeof(body.datatype);
+    range_scan_item_body body{};
+    static constexpr std::size_t header_offset = sizeof(body.flags) + sizeof(body.expiry) +
+                                                 sizeof(body.sequence_number) + sizeof(body.cas) +
+                                                 sizeof(body.datatype);
 
-        if (data.size() < header_offset) {
-            return errc::network::protocol_error;
-        }
+    if (data.size() < header_offset) {
+      return errc::network::protocol_error;
+    }
 
-        body.flags = mcbp::big_endian::read_uint32(data, 0);
-        body.expiry = mcbp::big_endian::read_uint32(data, 4);
-        body.sequence_number = mcbp::big_endian::read_uint64(data, 8);
-        body.cas = couchbase::cas{ mcbp::big_endian::read_uint64(data, 16) };
-        body.datatype = data[24];
-        data = gsl::make_span(data.data() + header_offset, data.size() - header_offset);
-
-        std::string key{};
-        {
-            auto [key_length, remaining] = utils::decode_unsigned_leb128<std::size_t>(data, core::utils::leb_128_no_throw{});
-            if (remaining.size() < key_length) {
-                return errc::network::protocol_error;
-            }
-            key = { reinterpret_cast<const char*>(remaining.data()), key_length };
-            data = gsl::make_span(remaining.data() + key_length, remaining.size() - key_length);
-        }
+    body.flags = mcbp::big_endian::read_uint32(data, 0);
+    body.expiry = mcbp::big_endian::read_uint32(data, 4);
+    body.sequence_number = mcbp::big_endian::read_uint64(data, 8);
+    body.cas = couchbase::cas{ mcbp::big_endian::read_uint64(data, 16) };
+    body.datatype = data[24];
+    data = gsl::make_span(data.data() + header_offset, data.size() - header_offset);
+
+    std::string key{};
+    {
+      auto [key_length, remaining] =
+        utils::decode_unsigned_leb128<std::size_t>(data, core::utils::leb_128_no_throw{});
+      if (remaining.size() < key_length) {
+        return errc::network::protocol_error;
+      }
+      key = { reinterpret_cast<const char*>(remaining.data()), key_length };
+      data = gsl::make_span(remaining.data() + key_length, remaining.size() - key_length);
+    }
 
-        {
-            auto [value_length, remaining] = utils::decode_unsigned_leb128<std::size_t>(data, core::utils::leb_128_no_throw{});
-            if (remaining.size() < value_length) {
-                return errc::network::protocol_error;
-            }
-            body.value = { remaining.begin(), remaining.begin() + static_cast<std::ptrdiff_t>(value_length) };
-            if ((body.datatype & static_cast<std::byte>(protocol::datatype::snappy)) != std::byte{ 0 }) {
-                std::string uncompressed;
-                if (snappy::Uncompress(reinterpret_cast<const char*>(body.value.data()), body.value.size(), &uncompressed)) {
-                    body.value = core::utils::to_binary(uncompressed);
-                    body.datatype &= ~static_cast<std::byte>(protocol::datatype::snappy);
-                }
-            }
-            data = gsl::make_span(remaining.data() + value_length, remaining.size() - value_length);
+    {
+      auto [value_length, remaining] =
+        utils::decode_unsigned_leb128<std::size_t>(data, core::utils::leb_128_no_throw{});
+      if (remaining.size() < value_length) {
+        return errc::network::protocol_error;
+      }
+      body.value = { remaining.begin(),
+                     remaining.begin() + static_cast<std::ptrdiff_t>(value_length) };
+      if ((body.datatype & static_cast<std::byte>(protocol::datatype::snappy)) != std::byte{ 0 }) {
+        std::string uncompressed;
+        if (snappy::Uncompress(
+              reinterpret_cast<const char*>(body.value.data()), body.value.size(), &uncompressed)) {
+          body.value = core::utils::to_binary(uncompressed);
+          body.datatype &= ~static_cast<std::byte>(protocol::datatype::snappy);
         }
+      }
+      data = gsl::make_span(remaining.data() + value_length, remaining.size() - value_length);
+    }
 
-        item_callback(range_scan_item{ std::move(key), std::move(body) });
-    } while (!data.empty());
-    return {};
+    item_callback(range_scan_item{ std::move(key), std::move(body) });
+  } while (!data.empty());
+  return {};
 }
 
 auto
@@ -196,195 +205,215 @@ parse_range_scan_data(gsl::span<std::byte> payload,
                       range_scan_item_callback&& items,
                       bool keys_only) -> std::error_code
 {
-    if (keys_only) {
-        return parse_range_scan_keys(payload, std::move(request), std::move(items));
-    }
-    return parse_range_scan_documents(payload, std::move(request), std::move(items));
+  if (keys_only) {
+    return parse_range_scan_keys(payload, std::move(request), std::move(items));
+  }
+  return parse_range_scan_documents(payload, std::move(request), std::move(items));
 }
 
 class crud_component_impl
 {
-  public:
-    crud_component_impl(asio::io_context& io, collections_component collections, std::shared_ptr<retry_strategy> default_retry_strategy)
-      : io_{ io }
-      , collections_{ std::move(collections) }
-      , default_retry_strategy_{ std::move(default_retry_strategy) }
-    {
-        (void)io_;
+public:
+  crud_component_impl(asio::io_context& io,
+                      collections_component collections,
+                      std::shared_ptr<retry_strategy> default_retry_strategy)
+    : io_{ io }
+    , collections_{ std::move(collections) }
+    , default_retry_strategy_{ std::move(default_retry_strategy) }
+  {
+    (void)io_;
+  }
+
+  auto range_scan_create(std::uint16_t vbucket_id,
+                         const range_scan_create_options& options,
+                         range_scan_create_callback&& callback)
+    -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>
+  {
+    auto handler = [cb = std::move(callback),
+                    options](std::shared_ptr<mcbp::queue_response> response,
+                             std::shared_ptr<mcbp::queue_request> /* request */,
+                             std::error_code error) {
+      if (error) {
+        return cb({}, error);
+      }
+      return cb(range_scan_create_result{ response->value_, options.ids_only }, {});
+    };
+
+    auto req = std::make_shared<mcbp::queue_request>(protocol::magic::client_request,
+                                                     protocol::client_opcode::range_scan_create,
+                                                     std::move(handler));
+
+    req->retry_strategy_ =
+      options.retry_strategy ? options.retry_strategy : default_retry_strategy_;
+    req->datatype_ = static_cast<std::byte>(protocol::datatype::json);
+    req->vbucket_ = vbucket_id;
+    req->scope_name_ = options.scope_name;
+    req->collection_name_ = options.collection_name;
+    if (auto [value, ec] = serialize_range_scan_create_options(options); !ec) {
+      req->value_ = std::move(value);
+    } else {
+      return tl::unexpected(ec);
     }
 
-    auto range_scan_create(std::uint16_t vbucket_id, const range_scan_create_options& options, range_scan_create_callback&& callback)
-      -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>
-    {
-        auto handler = [cb = std::move(callback), options](std::shared_ptr<mcbp::queue_response> response,
-                                                           std::shared_ptr<mcbp::queue_request> /* request */,
-                                                           std::error_code error) {
-            if (error) {
-                return cb({}, error);
-            }
-            return cb(range_scan_create_result{ response->value_, options.ids_only }, {});
-        };
-
-        auto req = std::make_shared<mcbp::queue_request>(
-          protocol::magic::client_request, protocol::client_opcode::range_scan_create, std::move(handler));
-
-        req->retry_strategy_ = options.retry_strategy ? options.retry_strategy : default_retry_strategy_;
-        req->datatype_ = static_cast<std::byte>(protocol::datatype::json);
-        req->vbucket_ = vbucket_id;
-        req->scope_name_ = options.scope_name;
-        req->collection_name_ = options.collection_name;
-        if (auto [value, ec] = serialize_range_scan_create_options(options); !ec) {
-            req->value_ = std::move(value);
-        } else {
-            return tl::unexpected(ec);
-        }
+    auto op = collections_.dispatch(req);
+    if (!op) {
+      return op;
+    }
 
-        auto op = collections_.dispatch(req);
-        if (!op) {
-            return op;
+    if (options.timeout != std::chrono::milliseconds::zero()) {
+      auto timer = std::make_shared<asio::steady_timer>(io_);
+      timer->expires_after(options.timeout);
+      timer->async_wait([req](auto error) {
+        if (error == asio::error::operation_aborted) {
+          return;
         }
+        req->cancel(couchbase::errc::common::unambiguous_timeout);
+      });
+      req->set_deadline(timer);
+    }
 
-        if (options.timeout != std::chrono::milliseconds::zero()) {
-            auto timer = std::make_shared<asio::steady_timer>(io_);
-            timer->expires_after(options.timeout);
-            timer->async_wait([req](auto error) {
-                if (error == asio::error::operation_aborted) {
-                    return;
-                }
-                req->cancel(couchbase::errc::common::unambiguous_timeout);
-            });
-            req->set_deadline(timer);
-        }
+    return op;
+  }
 
-        return op;
+  auto range_scan_continue(std::vector<std::byte> scan_uuid,
+                           std::uint16_t vbucket_id,
+                           range_scan_continue_options options,
+                           range_scan_item_callback&& item_callback,
+                           range_scan_continue_callback&& callback)
+    -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>
+  {
+    if (scan_uuid.size() != 16) {
+      return tl::unexpected(errc::common::invalid_argument);
     }
-
-    auto range_scan_continue(std::vector<std::byte> scan_uuid,
-                             std::uint16_t vbucket_id,
-                             range_scan_continue_options options,
-                             range_scan_item_callback&& item_callback,
-                             range_scan_continue_callback&& callback) -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>
-    {
-        if (scan_uuid.size() != 16) {
-            return tl::unexpected(errc::common::invalid_argument);
+    auto handler = [item_cb = std::move(item_callback), cb = std::move(callback), options](
+                     std::shared_ptr<mcbp::queue_response> response,
+                     std::shared_ptr<mcbp::queue_request> request,
+                     std::error_code error) mutable {
+      if (error) {
+        // in case or error code, the request will be automatically canceled
+        return cb({}, error);
+      }
+      if (response->extras_.size() != 4) {
+        if (request->internal_cancel()) {
+          cb({}, errc::network::protocol_error);
         }
-        auto handler =
-          [item_cb = std::move(item_callback), cb = std::move(callback), options](
-            std::shared_ptr<mcbp::queue_response> response, std::shared_ptr<mcbp::queue_request> request, std::error_code error) mutable {
-              if (error) {
-                  // in case or error code, the request will be automatically canceled
-                  return cb({}, error);
-              }
-              if (response->extras_.size() != 4) {
-                  if (request->internal_cancel()) {
-                      cb({}, errc::network::protocol_error);
-                  }
-                  return;
-              }
-              bool ids_only = mcbp::big_endian::read_uint32(response->extras_, 0) == 0;
-
-              if (auto ec = parse_range_scan_data(response->value_, request, std::move(item_cb), ids_only); ec) {
-                  if (request->internal_cancel()) {
-                      cb({}, ec);
-                  }
-                  return;
-              }
-
-              range_scan_continue_result res{
-                  response->status_code_ == key_value_status_code::range_scan_more,
-                  response->status_code_ == key_value_status_code::range_scan_complete,
-                  ids_only,
-              };
-
-              if ((res.more || res.complete) && request->internal_cancel()) {
-                  cb(res, {});
-              }
-          };
-
-        auto req = std::make_shared<mcbp::queue_request>(
-          protocol::magic::client_request, protocol::client_opcode::range_scan_continue, std::move(handler));
-
-        req->persistent_ = true;
-        req->vbucket_ = vbucket_id;
-
-        if (options.timeout != std::chrono::milliseconds::zero()) {
-            auto timer = std::make_shared<asio::steady_timer>(io_);
-            timer->expires_after(options.timeout);
-            timer->async_wait([req](auto error) {
-                if (error == asio::error::operation_aborted) {
-                    return;
-                }
-                req->cancel(couchbase::errc::common::unambiguous_timeout);
-            });
-            req->set_deadline(timer);
+        return;
+      }
+      bool ids_only = mcbp::big_endian::read_uint32(response->extras_, 0) == 0;
+
+      if (auto ec = parse_range_scan_data(response->value_, request, std::move(item_cb), ids_only);
+          ec) {
+        if (request->internal_cancel()) {
+          cb({}, ec);
         }
-
-        mcbp::buffer_writer buf{ scan_uuid.size() + sizeof(std::uint32_t) * 3 };
-        buf.write(scan_uuid);
-        buf.write_uint32(options.batch_item_limit);
-        buf.write_uint32(gsl::narrow_cast<std::uint32_t>(options.batch_time_limit.count()));
-        buf.write_uint32(options.batch_byte_limit);
-        req->extras_ = std::move(buf.store_);
-
-        return collections_.dispatch(req);
-    }
-
-    auto range_scan_cancel(std::vector<std::byte> scan_uuid,
-                           std::uint16_t vbucket_id,
-                           const range_scan_cancel_options& options,
-                           range_scan_cancel_callback&& callback) -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>
-    {
-        if (scan_uuid.size() != 16) {
-            return tl::unexpected(errc::common::invalid_argument);
+        return;
+      }
+
+      range_scan_continue_result res{
+        response->status_code_ == key_value_status_code::range_scan_more,
+        response->status_code_ == key_value_status_code::range_scan_complete,
+        ids_only,
+      };
+
+      if ((res.more || res.complete) && request->internal_cancel()) {
+        cb(res, {});
+      }
+    };
+
+    auto req = std::make_shared<mcbp::queue_request>(protocol::magic::client_request,
+                                                     protocol::client_opcode::range_scan_continue,
+                                                     std::move(handler));
+
+    req->persistent_ = true;
+    req->vbucket_ = vbucket_id;
+
+    if (options.timeout != std::chrono::milliseconds::zero()) {
+      auto timer = std::make_shared<asio::steady_timer>(io_);
+      timer->expires_after(options.timeout);
+      timer->async_wait([req](auto error) {
+        if (error == asio::error::operation_aborted) {
+          return;
         }
-        auto handler = [cb = std::move(callback), options](std::shared_ptr<mcbp::queue_response> /* response */,
-                                                           std::shared_ptr<mcbp::queue_request> /* request */,
-                                                           std::error_code error) mutable { cb({}, error); };
-
-        auto req = std::make_shared<mcbp::queue_request>(
-          protocol::magic::client_request, protocol::client_opcode::range_scan_cancel, std::move(handler));
-
-        req->vbucket_ = vbucket_id;
-        req->extras_ = std::move(scan_uuid);
+        req->cancel(couchbase::errc::common::unambiguous_timeout);
+      });
+      req->set_deadline(timer);
+    }
 
-        auto op = collections_.dispatch(req);
-        if (!op) {
-            return op;
-        }
+    mcbp::buffer_writer buf{ scan_uuid.size() + sizeof(std::uint32_t) * 3 };
+    buf.write(scan_uuid);
+    buf.write_uint32(options.batch_item_limit);
+    buf.write_uint32(gsl::narrow_cast<std::uint32_t>(options.batch_time_limit.count()));
+    buf.write_uint32(options.batch_byte_limit);
+    req->extras_ = std::move(buf.store_);
+
+    return collections_.dispatch(req);
+  }
+
+  auto range_scan_cancel(std::vector<std::byte> scan_uuid,
+                         std::uint16_t vbucket_id,
+                         const range_scan_cancel_options& options,
+                         range_scan_cancel_callback&& callback)
+    -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>
+  {
+    if (scan_uuid.size() != 16) {
+      return tl::unexpected(errc::common::invalid_argument);
+    }
+    auto handler = [cb = std::move(callback),
+                    options](std::shared_ptr<mcbp::queue_response> /* response */,
+                             std::shared_ptr<mcbp::queue_request> /* request */,
+                             std::error_code error) mutable {
+      cb({}, error);
+    };
+
+    auto req = std::make_shared<mcbp::queue_request>(protocol::magic::client_request,
+                                                     protocol::client_opcode::range_scan_cancel,
+                                                     std::move(handler));
+
+    req->vbucket_ = vbucket_id;
+    req->extras_ = std::move(scan_uuid);
+
+    auto op = collections_.dispatch(req);
+    if (!op) {
+      return op;
+    }
 
-        if (options.timeout != std::chrono::milliseconds::zero()) {
-            auto timer = std::make_shared<asio::steady_timer>(io_);
-            timer->expires_after(options.timeout);
-            timer->async_wait([req](auto error) {
-                if (error == asio::error::operation_aborted) {
-                    return;
-                }
-                req->cancel(couchbase::errc::common::unambiguous_timeout);
-            });
-            req->set_deadline(timer);
+    if (options.timeout != std::chrono::milliseconds::zero()) {
+      auto timer = std::make_shared<asio::steady_timer>(io_);
+      timer->expires_after(options.timeout);
+      timer->async_wait([req](auto error) {
+        if (error == asio::error::operation_aborted) {
+          return;
         }
-
-        return op;
+        req->cancel(couchbase::errc::common::unambiguous_timeout);
+      });
+      req->set_deadline(timer);
     }
 
-  private:
-    asio::io_context& io_;
-    collections_component collections_;
-    std::shared_ptr<retry_strategy> default_retry_strategy_;
+    return op;
+  }
+
+private:
+  asio::io_context& io_;
+  collections_component collections_;
+  std::shared_ptr<retry_strategy> default_retry_strategy_;
 };
 
 crud_component::crud_component(asio::io_context& io,
                                collections_component collections,
                                std::shared_ptr<retry_strategy> default_retry_strategy)
-  : impl_{ std::make_shared<crud_component_impl>(io, std::move(collections), std::move(default_retry_strategy)) }
+  : impl_{ std::make_shared<crud_component_impl>(io,
+                                                 std::move(collections),
+                                                 std::move(default_retry_strategy)) }
 {
 }
 
 auto
-crud_component::range_scan_create(std::uint16_t vbucket_id, range_scan_create_options options, range_scan_create_callback&& callback)
+crud_component::range_scan_create(std::uint16_t vbucket_id,
+                                  range_scan_create_options options,
+                                  range_scan_create_callback&& callback)
   -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>
 {
-    return impl_->range_scan_create(vbucket_id, std::move(options), std::move(callback));
+  return impl_->range_scan_create(vbucket_id, std::move(options), std::move(callback));
 }
 
 auto
@@ -395,7 +424,11 @@ crud_component::range_scan_continue(std::vector<std::byte> scan_uuid,
                                     range_scan_continue_callback&& callback)
   -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>
 {
-    return impl_->range_scan_continue(std::move(scan_uuid), vbucket_id, std::move(options), std::move(item_callback), std::move(callback));
+  return impl_->range_scan_continue(std::move(scan_uuid),
+                                    vbucket_id,
+                                    std::move(options),
+                                    std::move(item_callback),
+                                    std::move(callback));
 }
 
 auto
@@ -405,6 +438,7 @@ crud_component::range_scan_cancel(std::vector<std::byte> scan_uuid,
                                   range_scan_cancel_callback&& callback)
   -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>
 {
-    return impl_->range_scan_cancel(std::move(scan_uuid), vbucket_id, std::move(options), std::move(callback));
+  return impl_->range_scan_cancel(
+    std::move(scan_uuid), vbucket_id, std::move(options), std::move(callback));
 }
 } // namespace couchbase::core