couchbase 4.2.0 → 4.2.2

package/deps/couchbase-cxx-client/core/operations/management/query_index_drop.cxx

@@ -18,34 +18,33 @@
 #include "query_index_drop.hxx"
 
 #include "core/utils/json.hxx"
+#include "core/utils/keyspace.hxx"
 #include "error_utils.hxx"
 
 namespace couchbase::core::operations::management
 {
 std::error_code
-query_index_drop_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+query_index_drop_request::encode_to(encoded_request_type& encoded, http_context& /*context*/) const
 {
-    if ((scope_name.empty() && !collection_name.empty()) || (!scope_name.empty() && collection_name.empty())) {
+    if (!utils::check_query_management_request(*this)) {
         return errc::common::invalid_argument;
     }
     encoded.headers["content-type"] = "application/json";
-    std::string keyspace = fmt::format("`{}`", bucket_name);
-    if (!scope_name.empty()) {
-        keyspace += ".`" + scope_name + "`";
-    }
-    if (!collection_name.empty()) {
-        keyspace += ".`" + collection_name + "`";
-    }
-
+    auto keyspace = utils::build_keyspace(*this);
     std::string drop_index_stmt;
     if (is_primary && index_name.empty()) {
         drop_index_stmt = fmt::format(R"(DROP PRIMARY INDEX ON {} USING GSI)", keyspace);
-    } else if (!scope_name.empty() || !collection_name.empty()) {
+    } else if (bucket_name.empty() || (!collection_name.empty() && !scope_name.empty())) {
         drop_index_stmt = fmt::format(R"(DROP INDEX `{}` ON {} USING GSI)", index_name, keyspace);
     } else {
-        drop_index_stmt = fmt::format(R"(DROP INDEX {}.`{}` USING GSI)", keyspace, index_name);
+        // this works on 6.6 and earlier
+        drop_index_stmt = fmt::format(R"(DROP INDEX `{}`.`{}` USING GSI)", bucket_name, index_name);
     }
+
     tao::json::value body{ { "statement", drop_index_stmt }, { "client_context_id", encoded.client_context_id } };
+    if (query_ctx.has_value()) {
+        body["query_context"] = query_ctx.value();
+    }
     encoded.method = "POST";
     encoded.path = "/query/service";
     encoded.body = utils::json::generate(body);

package/deps/couchbase-cxx-client/core/operations/management/query_index_drop.hxx

@@ -21,6 +21,7 @@
 #include "core/io/http_context.hxx"
 #include "core/io/http_message.hxx"
 #include "core/platform/uuid.h"
+#include "core/query_context.hxx"
 #include "core/timeout_defaults.hxx"
 
 namespace couchbase::core::operations::management
@@ -48,6 +49,7 @@ struct query_index_drop_request {
     std::string scope_name;
     std::string collection_name;
     std::string index_name;
+    query_context query_ctx;
     bool is_primary{ false };
     bool ignore_if_does_not_exist{ false };
 

package/deps/couchbase-cxx-client/core/operations/management/query_index_get_all.cxx

@@ -52,9 +52,13 @@ query_index_get_all_request::encode_to(encoded_request_type& encoded, couchbase:
     encoded.headers["content-type"] = "application/json";
     tao::json::value body{ { "statement", statement },
                            { "client_context_id", encoded.client_context_id },
-                           { "$bucket_name", bucket_name },
-                           { "$scope_name", scope_name },
+                           { "$bucket_name", query_ctx.has_value() ? query_ctx.bucket_name() : bucket_name },
+                           { "$scope_name", query_ctx.has_value() ? query_ctx.scope_name() : scope_name },
                            { "$collection_name", collection_name } };
+
+    if (query_ctx.has_value()) {
+        body["query_context"] = query_ctx.value();
+    }
     encoded.method = "POST";
     encoded.path = "/query/service";
     encoded.body = utils::json::generate(body);
@@ -82,7 +86,7 @@ query_index_get_all_request::make_response(couchbase::core::error_context::http&
             return response;
         }
         for (const auto& entry : payload.at("results").get_array()) {
-            couchbase::core::management::query::index index;
+            couchbase::management::query::index index;
             index.type = entry.at("using").get_string();
             index.name = entry.at("name").get_string();
             index.state = entry.at("state").get_string();

package/deps/couchbase-cxx-client/core/operations/management/query_index_get_all.hxx

@@ -20,16 +20,17 @@
 #include "core/error_context/http.hxx"
 #include "core/io/http_context.hxx"
 #include "core/io/http_message.hxx"
-#include "core/management/query_index.hxx"
 #include "core/platform/uuid.h"
+#include "core/query_context.hxx"
 #include "core/timeout_defaults.hxx"
+#include "couchbase/management/query_index.hxx"
 
 namespace couchbase::core::operations::management
 {
 struct query_index_get_all_response {
     error_context::http ctx;
     std::string status{};
-    std::vector<couchbase::core::management::query::index> indexes{};
+    std::vector<couchbase::management::query::index> indexes{};
 };
 
 struct query_index_get_all_request {
@@ -39,11 +40,12 @@ struct query_index_get_all_request {
     using error_context_type = error_context::http;
 
     static const inline service_type type = service_type::query;
+    static constexpr auto namespace_id = "default";
 
     std::string bucket_name;
     std::string scope_name;
     std::string collection_name;
-
+    query_context query_ctx;
     std::optional<std::string> client_context_id{};
     std::optional<std::chrono::milliseconds> timeout{};
 

package/deps/couchbase-cxx-client/core/operations/management/query_index_get_all_deferred.cxx

@@ -25,11 +25,25 @@ namespace couchbase::core::operations::management
 std::error_code
 query_index_get_all_deferred_request::encode_to(encoded_request_type& encoded, couchbase::core::http_context& /* context */) const
 {
+
+    // essentially same as query_index_get_all_request::encode_to, except for the state condition.   If you
+    // change this, you probably need to change that as well.
+    std::string bucket_cond = "bucket_id = $bucket_name";
+    std::string scope_cond = "(" + bucket_cond + " AND scope_id = $scope_name)";
+    std::string collection_cond = "(" + scope_cond + " AND keyspace_id = $collection_name)";
+
     std::string where;
-    if (collection_name.empty()) {
-        where = "(keyspace_id = $bucket_name AND bucket_id IS MISSING)";
+    if (!collection_name.empty()) {
+        where = collection_cond;
+    } else if (!scope_name.empty()) {
+        where = scope_cond;
     } else {
-        where = "(bucket_id = $bucket_name AND scope_id = $scope_name AND keyspace_id = $collection_name)";
+        where = bucket_cond;
+    }
+
+    if (collection_name == "_default" || collection_name.empty()) {
+        std::string default_collection_cond = "(bucket_id IS MISSING AND keyspace_id = $bucket_name)";
+        where = "(" + where + " OR " + default_collection_cond + ")";
     }
 
     std::string statement = "SELECT RAW name FROM system:indexes"
@@ -41,9 +55,12 @@ query_index_get_all_deferred_request::encode_to(encoded_request_type& encoded, c
     encoded.headers["content-type"] = "application/json";
     tao::json::value body{ { "statement", statement },
                            { "client_context_id", encoded.client_context_id },
-                           { "$bucket_name", bucket_name },
-                           { "$scope_name", scope_name },
+                           { "$bucket_name", query_ctx.has_value() ? query_ctx.bucket_name() : bucket_name },
+                           { "$scope_name", query_ctx.has_value() ? query_ctx.scope_name() : scope_name },
                            { "$collection_name", collection_name } };
+    if (query_ctx.has_value()) {
+        body["query_context"] = query_ctx.value();
+    }
     encoded.method = "POST";
     encoded.path = "/query/service";
     encoded.body = utils::json::generate(body);

package/deps/couchbase-cxx-client/core/operations/management/query_index_get_all_deferred.hxx

@@ -20,9 +20,10 @@
 #include "core/error_context/http.hxx"
 #include "core/io/http_context.hxx"
 #include "core/io/http_message.hxx"
-#include "core/management/query_index.hxx"
 #include "core/platform/uuid.h"
+#include "core/query_context.hxx"
 #include "core/timeout_defaults.hxx"
+#include "couchbase/management/query_index.hxx"
 
 namespace couchbase::core::operations::management
 {
@@ -39,11 +40,12 @@ struct query_index_get_all_deferred_request {
     using error_context_type = error_context::http;
 
     static const inline service_type type = service_type::query;
+    static constexpr auto namespace_id = "default";
 
     std::string bucket_name;
     std::string scope_name;
     std::string collection_name;
-
+    query_context query_ctx;
     std::optional<std::string> client_context_id{};
     std::optional<std::chrono::milliseconds> timeout{};
 

package/deps/couchbase-cxx-client/core/operations/management/user.hxx

@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include "change_password.hxx"
 #include "group_drop.hxx"
 #include "group_get.hxx"
 #include "group_get_all.hxx"

package/deps/couchbase-cxx-client/core/operations/mcbp_noop.hxx

@@ -39,7 +39,7 @@ struct mcbp_noop_request {
     std::uint16_t partition{};
     std::uint32_t opaque{};
     std::optional<std::chrono::milliseconds> timeout{};
-    io::retry_context<io::retry_strategy::best_effort> retries{ true };
+    io::retry_context<true> retries{};
 
     [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&& context) const;
 

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

@@ -31,7 +31,7 @@ struct cluster_credentials {
     std::string password{};
     std::string certificate_path{};
     std::string key_path{};
-    std::vector<std::string> allowed_sasl_mechanisms{ "SCRAM-SHA512", "SCRAM-SHA256", "SCRAM-SHA1", "PLAIN" };
+    std::optional<std::vector<std::string>> allowed_sasl_mechanisms{};
 
     [[nodiscard]] bool uses_certificate() const
     {

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

@@ -0,0 +1,26 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ * Copyright 2022-Present Couchbase, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of the License at
+ *
+ *     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
+
+namespace couchbase::core
+{
+class pending_operation
+{
+  public:
+    virtual ~pending_operation() = default;
+    virtual void cancel() = 0;
+};
+} // namespace couchbase::core

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

@@ -0,0 +1,32 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 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
+
+#include "ping_reporter.hxx"
+
+#include <memory>
+
+namespace couchbase::core::diag
+{
+class ping_collector
+{
+  public:
+    virtual ~ping_collector() = default;
+    virtual auto build_reporter() -> std::shared_ptr<ping_reporter> = 0;
+};
+} // namespace couchbase::core::diag

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

@@ -0,0 +1,86 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ * Copyright 2022-Present Couchbase, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of the License at
+ *
+ *     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
+
+#include "service_type.hxx"
+#include "utils/movable_function.hxx"
+
+#include <chrono>
+#include <cinttypes>
+#include <map>
+#include <memory>
+#include <string>
+#include <system_error>
+#include <vector>
+
+namespace couchbase::tracing
+{
+class request_span;
+} // namespace couchbase::tracing
+
+namespace couchbase::core
+{
+class ping_options
+{
+  public:
+    std::chrono::milliseconds key_value_timeout{};
+    std::chrono::milliseconds analytics_timeout{};
+    std::chrono::milliseconds n1ql_timeout{};
+    std::chrono::milliseconds search_timeout{};
+    std::chrono::milliseconds capi_timeout{};
+    std::chrono::milliseconds management_timeout{};
+
+    std::vector<service_type> services{
+        service_type::query,
+        service_type::analytics,
+        service_type::search,
+        service_type::management,
+    };
+
+    bool ignore_missing_services{ false };
+
+    std::shared_ptr<couchbase::tracing::request_span> parent_span{};
+
+    struct {
+        std::string user{};
+    } internal{};
+};
+
+enum class ping_state {
+    ok,
+    timeout,
+    error,
+};
+
+struct endpoint_ping_result {
+    std::string endpoint;
+    std::error_code error;
+    std::chrono::milliseconds latency;
+    std::string id;
+    std::string scope;
+    ping_state state;
+};
+
+class ping_result
+{
+  public:
+    std::uint64_t config_revision;
+    std::map<service_type, std::vector<endpoint_ping_result>> services;
+};
+
+using ping_callback = utils::movable_function<void(ping_result result, std::error_code ec)>;
+
+} // namespace couchbase::core

package/deps/couchbase-cxx-client/core/{io/retry_action.hxx → ping_reporter.hxx}

@@ -17,14 +17,14 @@
 
 #pragma once
 
-#include <chrono>
-#include <optional>
+#include "diagnostics.hxx"
 
-namespace couchbase::core::io
+namespace couchbase::core::diag
 {
-struct retry_action {
-    bool retry_requested{ false };
-    std::chrono::milliseconds duration{};
+class ping_reporter
+{
+  public:
+    virtual ~ping_reporter() = default;
+    virtual void report(diag::endpoint_ping_info&& info) = 0;
 };
-
-} // namespace couchbase::core::io
+} // namespace couchbase::core::diag

package/deps/couchbase-cxx-client/core/platform/base64.cc

@@ -24,8 +24,8 @@
 #include "base64.h"
 
 #include <algorithm>
+#include <array>
 #include <cctype>
-#include <cstdint>
 #include <stdexcept>
 #include <string>
 #include <vector>
@@ -33,7 +33,10 @@
 /**
  * An array of the legal characters used for direct lookup
  */
-static const std::uint8_t codemap[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+static const std::array codemap{ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
+                                 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
+                                 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
+                                 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/' };
 
 /**
  * A method to map the code back to the value
@@ -42,22 +45,22 @@ static const std::uint8_t codemap[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmno
  * @return the byte value for the code character
  */
 static std::uint32_t
-code2val(const std::uint8_t code)
+code2val(const char code)
 {
     if (code >= 'A' && code <= 'Z') {
-        return std::uint32_t(code) - 'A';
+        return static_cast<std::uint32_t>(code) - static_cast<std::uint32_t>('A');
     }
     if (code >= 'a' && code <= 'z') {
-        return std::uint32_t(code) - 'a' + std::uint8_t(26);
+        return static_cast<std::uint32_t>(code) - static_cast<std::uint32_t>('a') + 26U;
     }
     if (code >= '0' && code <= '9') {
-        return std::uint32_t(code) - '0' + std::uint8_t(52);
+        return static_cast<std::uint32_t>(code) - static_cast<std::uint32_t>('0') + 52U;
     }
     if (code == '+') {
-        return std::uint32_t(62);
+        return 62U;
     }
     if (code == '/') {
-        return std::uint32_t(63);
+        return 63U;
     }
     throw std::invalid_argument("couchbase::core::base64::code2val Invalid input character");
 }
@@ -70,25 +73,25 @@ code2val(const std::uint8_t code)
  * @param num the number of characters from s to encode
  */
 static void
-encode_rest(const std::uint8_t* s, std::string& result, size_t num)
+encode_rest(const std::byte* s, std::string& result, size_t num)
 {
-    std::uint32_t val = 0;
+    std::uint32_t val;
 
     switch (num) {
         case 2:
-            val = static_cast<std::uint32_t>((*s << 16U) | (*(s + 1) << 8U));
+            val = (static_cast<std::uint32_t>(*s) << 16U) | (static_cast<std::uint32_t>(*(s + 1)) << 8U);
             break;
         case 1:
-            val = static_cast<std::uint32_t>((*s << 16U));
+            val = static_cast<std::uint32_t>(*s) << 16U;
             break;
         default:
             throw std::invalid_argument("base64::encode_rest num may be 1 or 2");
     }
 
-    result.push_back(static_cast<char>(codemap[(val >> 18U) & 63]));
-    result.push_back(static_cast<char>(codemap[(val >> 12U) & 63]));
+    result.push_back(codemap[(val >> 18U) & 63]);
+    result.push_back(codemap[(val >> 12U) & 63]);
     if (num == 2) {
-        result.push_back(static_cast<char>(codemap[(val >> 6U) & 63]));
+        result.push_back(codemap[(val >> 6U) & 63]);
     } else {
         result.push_back('=');
     }
@@ -102,13 +105,15 @@ encode_rest(const std::uint8_t* s, std::string& result, size_t num)
  * @param d pointer to the output stream
  */
 static void
-encode_triplet(const std::uint8_t* s, std::string& str)
+encode_triplet(const std::byte* s, std::string& str)
 {
-    auto val = static_cast<std::uint32_t>((*s << 16U) | (*(s + 1) << 8U) | (*(s + 2)));
-    str.push_back(static_cast<char>(codemap[(val >> 18U) & 63]));
-    str.push_back(static_cast<char>(codemap[(val >> 12U) & 63]));
-    str.push_back(static_cast<char>(codemap[(val >> 6U) & 63]));
-    str.push_back(static_cast<char>(codemap[val & 63]));
+    auto val = (static_cast<std::uint32_t>(*s) << 16U) |      //
+               (static_cast<std::uint32_t>(*(s + 1)) << 8U) | //
+               static_cast<std::uint32_t>(*(s + 2));
+    str.push_back(codemap[(val >> 18U) & 63]);
+    str.push_back(codemap[(val >> 12U) & 63]);
+    str.push_back(codemap[(val >> 6U) & 63]);
+    str.push_back(codemap[val & 63]);
 }
 
 /**
@@ -119,7 +124,7 @@ encode_triplet(const std::uint8_t* s, std::string& str)
  * @return the number of characters inserted
  */
 static int
-decode_quad(const std::uint8_t* s, std::string& d)
+decode_quad(const char* s, std::vector<std::byte>& d)
 {
     std::uint32_t value = code2val(s[0]) << 18U;
     value |= code2val(s[1]) << 12U;
@@ -137,11 +142,11 @@ decode_quad(const std::uint8_t* s, std::string& d)
         }
     }
 
-    d.push_back(static_cast<char>(value >> 16U));
+    d.push_back(static_cast<std::byte>(value >> 16U));
     if (ret > 1) {
-        d.push_back(static_cast<char>(value >> 8U));
+        d.push_back(static_cast<std::byte>(value >> 8U));
         if (ret > 2) {
-            d.push_back(static_cast<char>(value));
+            d.push_back(static_cast<std::byte>(value));
         }
     }
 
@@ -151,9 +156,9 @@ decode_quad(const std::uint8_t* s, std::string& d)
 namespace couchbase::core::base64
 {
 std::string
-encode(const std::string_view blob, bool prettyprint)
+encode(gsl::span<const std::byte> blob, bool pretty_print)
 {
-    // base64 encoding encodes up to 3 input characters to 4 output
+    // base64 encodes up to 3 input characters to 4 output
     // characters in the alphabet above.
     auto triplets = blob.size() / 3;
     auto rest = blob.size() % 3;
@@ -163,7 +168,7 @@ encode(const std::string_view blob, bool prettyprint)
     }
 
     std::string result;
-    if (prettyprint) {
+    if (pretty_print) {
         // In pretty-print mode we insert a newline after adding
         // 16 chunks (four characters).
         result.reserve(chunks * 4 + chunks / 16);
@@ -171,14 +176,14 @@ encode(const std::string_view blob, bool prettyprint)
         result.reserve(chunks * 4);
     }
 
-    const auto* in = reinterpret_cast<const std::uint8_t*>(blob.data());
+    const auto* in = blob.data();
 
     chunks = 0;
     for (size_t ii = 0; ii < triplets; ++ii) {
         encode_triplet(in, result);
         in += 3;
 
-        if (prettyprint && (++chunks % 16) == 0) {
+        if (pretty_print && (++chunks % 16) == 0) {
             result.push_back('\n');
         }
     }
@@ -187,17 +192,17 @@ encode(const std::string_view blob, bool prettyprint)
         encode_rest(in, result, rest);
     }
 
-    if (prettyprint && result.back() != '\n') {
+    if (pretty_print && result.back() != '\n') {
         result.push_back('\n');
     }
 
     return result;
 }
 
-std::string
+std::vector<std::byte>
 decode(std::string_view blob)
 {
-    std::string destination;
+    std::vector<std::byte> destination;
 
     if (blob.empty()) {
         return destination;
@@ -209,7 +214,7 @@ decode(std::string_view blob)
     size_t estimate = blob.size() / 100 * 75;
     destination.reserve(estimate + 3);
 
-    const auto* in = reinterpret_cast<const std::uint8_t*>(blob.data());
+    const auto* in = blob.data();
     size_t offset = 0;
     while (offset < blob.size()) {
         if (std::isspace(static_cast<int>(*in)) != 0) {
@@ -231,4 +236,17 @@ decode(std::string_view blob)
     return destination;
 }
 
+std::string
+decode_to_string(std::string_view blob)
+{
+    auto decoded = decode(blob);
+    return { reinterpret_cast<const char*>(decoded.data()), decoded.size() };
+}
+
+std::string
+encode(std::string_view blob, bool pretty_print)
+{
+    return encode(gsl::as_bytes(gsl::span{ blob.data(), blob.size() }), pretty_print);
+}
+
 } // namespace couchbase::core::base64

package/deps/couchbase-cxx-client/core/platform/base64.h

@@ -16,6 +16,8 @@
  */
 #pragma once
 
+#include <gsl/span>
+
 #include <string>
 #include <vector>
 
@@ -29,7 +31,10 @@ namespace couchbase::core::base64
  * @return the base64 encoded value
  */
 std::string
-encode(std::string_view blob, bool prettyprint = false);
+encode(gsl::span<const std::byte> blob, bool pretty_print = false);
+
+std::string
+encode(std::string_view blob, bool pretty_print = false);
 
 /**
  * Decode a base64 encoded blob (which may be pretty-printed to avoid
@@ -38,7 +43,10 @@ encode(std::string_view blob, bool prettyprint = false);
  * @param source string to decode
  * @return the decoded data
  */
-std::string
+std::vector<std::byte>
 decode(std::string_view blob);
 
+std::string
+decode_to_string(std::string_view blob);
+
 } // namespace couchbase::core::base64