couchbase 4.1.0 → 4.1.1

package/deps/couchbase-cxx-client/test/test_integration_query.cxx

@@ -82,28 +82,22 @@ TEST_CASE("integration: query on a collection", "[integration]")
     };
     auto json = couchbase::utils::json::generate(value);
 
-    uint64_t scope_uid;
-    uint64_t collection_uid;
-
     {
         couchbase::operations::management::scope_create_request req{ integration.ctx.bucket, scope_name };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
-        scope_uid = resp.uid;
+        auto created = test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, resp.uid);
+        REQUIRE(created);
     }
 
     {
         couchbase::operations::management::collection_create_request req{ integration.ctx.bucket, scope_name, collection_name };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
-        collection_uid = resp.uid;
+        auto created = test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, resp.uid);
+        REQUIRE(created);
     }
 
-    auto current_manifest_uid = std::max(collection_uid, scope_uid);
-    auto created =
-      test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, current_manifest_uid);
-    REQUIRE(created);
-
     {
         couchbase::operations::management::query_index_create_request req{};
         req.bucket_name = integration.ctx.bucket;
@@ -405,3 +399,25 @@ TEST_CASE("integration: sticking query to the service node", "[integration]")
         REQUIRE(std::set(used_nodes.begin(), used_nodes.end()).size() == 1);
     }
 }
+
+TEST_CASE("analytics create dataset")
+{
+    test::utils::integration_test_guard integration;
+
+    if (!integration.cluster_version().supports_analytics() || !integration.has_analytics_service() ||
+        !integration.cluster_version().supports_collections()) {
+        return;
+    }
+    if (!integration.cluster_version().supports_gcccp()) {
+        test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    }
+    couchbase::operations::analytics_request req{ fmt::format("CREATE DATAVERSE `{}`.`test-scope` IF NOT EXISTS", integration.ctx.bucket) };
+    std::vector<std::string> rows{};
+    req.row_callback = [&rows](std::string&& row) {
+        rows.emplace_back(std::move(row));
+        return couchbase::utils::json::stream_control::next_row;
+    };
+
+    auto resp = test::utils::execute(integration.cluster, req);
+    REQUIRE_FALSE(resp.ctx.ec);
+}

package/deps/couchbase-cxx-client/test/test_unit_json_streaming_lexer.cxx

@@ -113,3 +113,122 @@ TEST_CASE("unit: json_streaming_lexer parse query result", "[unit]")
     REQUIRE(result.rows.size() == 3);
     REQUIRE(result.meta == chunks[0] + chunks[4]);
 }
+
+TEST_CASE("unit: json_streaming_lexer parse query result in multiple chunks", "[unit]")
+{
+    test::utils::init_logger();
+
+    const std::vector<std::string> chunks{
+        /* 0 */
+        R"({"requestID": "34a4e4b2-3f69-4bf8-a6e2-ae06798de3d9","clientContextID": "dfea5193-ead9-4ac2-5558-8fd5c4631959","signature": {"greeting":"string"},"results": [{"greeting":"ruby rules"}],"status": "success","profile": {"phaseTimes": {"authorize":"10.473µs","instantiate":"10.29µs","parse":"183.413µs","plan":"19.155µs","project":"5.712µs","run":"43.258µs","stream":"7.078µs"},"phaseOperators": {"authorize":1,"project":1,"stream":1},"requestTime": "2022-05-11T11:01:14.943Z","servicingHost": "10.112.220.101:8091","executionTimings": {"#operator":"Authorize","#stats":{"#phaseSwitches":4,"execTime":"1.372µs","servTime":"9.101µs"},"privileges":{"List":[]},"~child":{"#operator":"Sequence","#stats":{"#phaseSwitches":2,"execTime":"838ns"},"~children":[{"#operator":"DummyScan","#stats":{"#itemsOut":1,"#phaseSwitches":3,"execTime":"794ns","kernTime":"514ns"},"optimizer_estimates":{"cardinality":1,"cost":1.0842021724855044e-19,"fr_cost":1.0842021724855044e-19,"size":1}},{"#operator":"InitialProject","#stats":{"#itemsIn":1,"#itemsOut":1,"#phaseSwitches":8,"execTime":"110.717µs","kernTime":"4.786µs","state":"running"},"optimizer_estimates":{"cardinality":1,"cost":0.001,"fr_cost":0.001,"size":1},"result_terms":[{"as":"greeting","expr":"\"ruby rules\""}]},{"#operator":"Stream","#stats":{"#itemsIn":)",
+        /* 1 */
+        R"(1,"#itemsOut":1,"#phaseSwitches":2,"execTime":"7.078µs"},"optimizer_estimates":{"cardinality":1,"cost":0.001,"fr_cost":0.001,"size":1}}]},"~versions":["7.1.0-N1QL","7.1.0-2534-enterprise"]},"optimizerEstimates": {"cardinality":1,"cost":0.001}}})"
+    };
+
+    couchbase::utils::json::streaming_lexer lexer("/results/^", 4);
+    query_result result{};
+    lexer.on_row([&result](std::string&& row) {
+        result.rows.emplace_back(std::move(row));
+        return couchbase::utils::json::stream_control::next_row;
+    });
+    lexer.on_complete([&result](std::error_code ec, std::size_t number_of_rows, std::string&& meta) {
+        result.ec = ec;
+        result.number_of_rows = number_of_rows;
+        result.meta = std::move(meta);
+    });
+    for (const auto& chunk : chunks) {
+        lexer.feed(chunk);
+    }
+    REQUIRE_FALSE(result.ec);
+    REQUIRE(result.number_of_rows == 1);
+    REQUIRE(result.rows.size() == 1);
+
+    const auto* expected_meta =
+      R"({"requestID": "34a4e4b2-3f69-4bf8-a6e2-ae06798de3d9","clientContextID": "dfea5193-ead9-4ac2-5558-8fd5c4631959","signature": {"greeting":"string"},"results": [],"status": "success","profile": {"phaseTimes": {"authorize":"10.473µs","instantiate":"10.29µs","parse":"183.413µs","plan":"19.155µs","project":"5.712µs","run":"43.258µs","stream":"7.078µs"},"phaseOperators": {"authorize":1,"project":1,"stream":1},"requestTime": "2022-05-11T11:01:14.943Z","servicingHost": "10.112.220.101:8091","executionTimings": {"#operator":"Authorize","#stats":{"#phaseSwitches":4,"execTime":"1.372µs","servTime":"9.101µs"},"privileges":{"List":[]},"~child":{"#operator":"Sequence","#stats":{"#phaseSwitches":2,"execTime":"838ns"},"~children":[{"#operator":"DummyScan","#stats":{"#itemsOut":1,"#phaseSwitches":3,"execTime":"794ns","kernTime":"514ns"},"optimizer_estimates":{"cardinality":1,"cost":1.0842021724855044e-19,"fr_cost":1.0842021724855044e-19,"size":1}},{"#operator":"InitialProject","#stats":{"#itemsIn":1,"#itemsOut":1,"#phaseSwitches":8,"execTime":"110.717µs","kernTime":"4.786µs","state":"running"},"optimizer_estimates":{"cardinality":1,"cost":0.001,"fr_cost":0.001,"size":1},"result_terms":[{"as":"greeting","expr":"\"ruby rules\""}]},{"#operator":"Stream","#stats":{"#itemsIn":1,"#itemsOut":1,"#phaseSwitches":2,"execTime":"7.078µs"},"optimizer_estimates":{"cardinality":1,"cost":0.001,"fr_cost":0.001,"size":1}}]},"~versions":["7.1.0-N1QL","7.1.0-2534-enterprise"]},"optimizerEstimates": {"cardinality":1,"cost":0.001}}})";
+
+    REQUIRE(result.meta == expected_meta);
+}
+
+TEST_CASE("unit: json_streaming_lexer parse chunked metadata trailer", "[unit]")
+{
+    test::utils::init_logger();
+
+    const std::vector<std::string> chunks{
+        /* 0 */
+        R"({"requestID": "2640a5b5-2e67-44e7-86ec-31cc388b7427","results": [42],)",
+        /* 1 */
+        R"("clientContextID":)",
+        /* 2 */
+        R"("730ecac3-e8d0-4d6e-4ed9-e2d4abd1d7b9",)",
+        /* 3 */
+        R"("status": "success"})",
+    };
+    couchbase::utils::json::streaming_lexer lexer("/results/^", 4);
+    query_result result{};
+    lexer.on_row([&result](std::string&& row) {
+        result.rows.emplace_back(std::move(row));
+        return couchbase::utils::json::stream_control::next_row;
+    });
+    lexer.on_complete([&result](std::error_code ec, std::size_t number_of_rows, std::string&& meta) {
+        result.ec = ec;
+        result.number_of_rows = number_of_rows;
+        result.meta = std::move(meta);
+    });
+    for (const auto& chunk : chunks) {
+        lexer.feed(chunk);
+    }
+    REQUIRE_FALSE(result.ec);
+    REQUIRE(result.number_of_rows == 1);
+    REQUIRE(result.rows.size() == 1);
+    const auto* expected_meta =
+      R"({"requestID": "2640a5b5-2e67-44e7-86ec-31cc388b7427","results": [],"clientContextID":"730ecac3-e8d0-4d6e-4ed9-e2d4abd1d7b9","status": "success"})";
+    REQUIRE(result.meta == expected_meta);
+    REQUIRE(result.rows[0] == R"(42)");
+}
+
+TEST_CASE("unit: json_streaming_lexer parse payload with missing results", "[unit]")
+{
+    test::utils::init_logger();
+
+    std::string chunk = R"(
+{
+
+	"requestID": "d07c0cde-cd80-4620-bb6b-d0641f272420",
+	"clientContextID": "a7bbe750-20a2-4e46-eb67-315e3733b2a8",
+	"signature": {
+		"*": "*"
+	},
+	"plans":{},
+	"status": "success",
+	"metrics": {
+		"elapsedTime": "6.56579ms",
+		"executionTime": "5.552905ms",
+		"resultCount": 0,
+		"resultSize": 0,
+		"processedObjects": 0
+	}
+}
+)";
+    couchbase::utils::json::streaming_lexer lexer("/results/^", 4);
+    query_result result{};
+    bool on_row_handler_executed = false;
+    lexer.on_row([&result, &on_row_handler_executed](std::string&& row) {
+        on_row_handler_executed = true;
+        result.rows.emplace_back(std::move(row));
+        return couchbase::utils::json::stream_control::next_row;
+    });
+    bool on_complete_handler_excecuted = false;
+    lexer.on_complete([&result, &on_complete_handler_excecuted](std::error_code ec, std::size_t number_of_rows, std::string&& meta) {
+        on_complete_handler_excecuted = true;
+        result.ec = ec;
+        result.number_of_rows = number_of_rows;
+        result.meta = std::move(meta);
+    });
+    lexer.feed(chunk);
+    REQUIRE_FALSE(on_row_handler_executed);
+    REQUIRE(on_complete_handler_excecuted);
+    REQUIRE_FALSE(result.ec);
+    REQUIRE(result.number_of_rows == 0);
+    REQUIRE(result.rows.empty());
+    REQUIRE(result.meta == chunk);
+}

package/deps/couchbase-cxx-client/test/utils/integration_test_guard.cxx

@@ -105,7 +105,7 @@ integration_test_guard::cluster_version()
     if (runtime_version.empty()) {
         return ctx.version;
     }
-    auto parsed_version = server_version::parse(runtime_version);
+    auto parsed_version = server_version::parse(runtime_version, ctx.deployment);
     if (parsed_version.major == 0) {
         /* the build does not specify version properly */
         return ctx.version;

package/deps/couchbase-cxx-client/test/utils/server_version.cxx

@@ -22,11 +22,12 @@
 namespace test::utils
 {
 server_version
-server_version::parse(const std::string& str)
+server_version::parse(const std::string& str, const deployment_type deployment)
 {
     std::regex version_regex(R"((\d+).(\d+).(\d+)(-(\d+))?(-(.+))?)");
     std::smatch version_match{};
     server_version ver{};
+    ver.deployment = deployment;
     if (std::regex_match(str, version_match, version_regex) && version_match.ready()) {
         ver.major = std::stoul(version_match[1]);
         ver.minor = std::stoul(version_match[2]);

package/deps/couchbase-cxx-client/test/utils/server_version.hxx

@@ -25,6 +25,8 @@ namespace test::utils
 
 enum class server_edition { unknown, enterprise, community };
 
+enum class deployment_type { on_prem, capella, elixir };
+
 struct server_version {
     unsigned long major{ 0 };
     unsigned long minor{ 0 };
@@ -32,8 +34,9 @@ struct server_version {
     unsigned long build{ 0 };
     bool developer_preview{ false };
     server_edition edition{ server_edition::unknown };
+    deployment_type deployment{ deployment_type::on_prem };
 
-    static server_version parse(const std::string& str);
+    static server_version parse(const std::string& str, const deployment_type deployment);
 
     [[nodiscard]] bool is_alice() const
     {
@@ -86,7 +89,7 @@ struct server_version {
 
     [[nodiscard]] bool supports_storage_backend() const
     {
-        return is_neo();
+        return is_neo() && is_enterprise();
     }
 
     [[nodiscard]] bool supports_preserve_expiry() const
@@ -101,7 +104,7 @@ struct server_version {
 
     [[nodiscard]] bool supports_user_groups() const
     {
-        return (is_mad_hatter() || is_cheshire_cat() || is_neo()) && is_enterprise();
+        return supports_user_management() && (is_mad_hatter() || is_cheshire_cat() || is_neo()) && is_enterprise();
     }
 
     [[nodiscard]] bool supports_query_index_management() const
@@ -146,7 +149,7 @@ struct server_version {
 
     [[nodiscard]] bool supports_eventing_functions() const
     {
-        return is_cheshire_cat() || is_neo();
+        return (is_cheshire_cat() || is_neo()) && deployment == deployment_type::on_prem;
     }
 
     [[nodiscard]] bool is_enterprise() const
@@ -158,6 +161,21 @@ struct server_version {
     {
         return edition == server_edition::community;
     }
+
+    [[nodiscard]] bool supports_bucket_management() const
+    {
+        return deployment == deployment_type::on_prem;
+    }
+
+    [[nodiscard]] bool supports_user_management() const
+    {
+        return deployment == deployment_type::on_prem;
+    }
+
+    [[nodiscard]] bool supports_views() const
+    {
+        return deployment == deployment_type::on_prem;
+    }
 };
 
 } // namespace test::utils

package/deps/couchbase-cxx-client/test/utils/test_context.cxx

@@ -51,11 +51,21 @@ test_context::load_from_environment()
     if (var != nullptr) {
         ctx.bucket = var;
     }
+    var = getenv("TEST_DEPLOYMENT_TYPE");
+    if (var != nullptr) {
+        if (strcmp(var, "on_prem") == 0) {
+            ctx.deployment = deployment_type::on_prem;
+        } else if (strcmp(var, "capella") == 0) {
+            ctx.deployment = deployment_type::capella;
+        } else if (strcmp(var, "elixir") == 0) {
+            ctx.deployment = deployment_type::elixir;
+        }
+    }
 
     // TODO: I believe this + TEST_DEVELOPER_PREVIEW will conflict
     var = getenv("TEST_SERVER_VERSION");
     if (var != nullptr) {
-        ctx.version = server_version::parse(var);
+        ctx.version = server_version::parse(var, ctx.deployment);
     }
     var = getenv("TEST_DEVELOPER_PREVIEW");
     if (var != nullptr) {

package/deps/couchbase-cxx-client/test/utils/test_context.hxx

@@ -33,6 +33,7 @@ struct test_context {
     std::string key_path{};
     std::string bucket{ "default" };
     server_version version{ 6, 6, 0 };
+    deployment_type deployment{ deployment_type::on_prem };
 
     [[nodiscard]] couchbase::cluster_credentials build_auth() const
     {

package/deps/couchbase-transactions-cxx/CMakeLists.txt

@@ -34,7 +34,7 @@ project(transactions_cxx)
 set(CB_VERSION_MAJOR 2)
 set(CB_VERSION_MINOR 0)
 set(CB_VERSION_PATCH 0)
-set(CB_VERSION_TWEAK "beta.3")
+set(CB_VERSION_TWEAK "beta.4")
 
 find_program(GIT_EXECUTABLE NAMES git git.exe)
 macro(RUNGIT outvar)
@@ -80,7 +80,7 @@ if(NOT COUCHBASE_TXNS_CXX_CLIENT_EXTERNAL)
     if (APPLE AND NOT DEFINED OPENSSL_ROOT_DIR)
         # look in typical brew location - missed by the openssl finder
         message(STATUS "no OPENSSL_ROOT_DIR specified, using MacOS, so defaulting to homebrew location")
-        set(OPENSSL_ROOT_DIR "/usr/local/opt/openssl@1.1", CACHE INTERNAL "")
+        set(OPENSSL_ROOT_DIR "/usr/local/opt/openssl@1.1" CACHE INTERNAL "")
     endif()
     message(STATUS "APPLE: '${APPLE}', SSL: '${OPENSSL_ROOT_DIR}'")
     find_package(OpenSSL REQUIRED)

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/{management/design_document_fmt.hxx → design_document_namespace_fmt.hxx}

@@ -17,12 +17,12 @@
 
 #pragma once
 
-#include <couchbase/management/design_document.hxx>
+#include <couchbase/design_document_namespace.hxx>
 
 #include <fmt/core.h>
 
 template<>
-struct fmt::formatter<couchbase::management::views::design_document::name_space> {
+struct fmt::formatter<couchbase::design_document_namespace> {
     template<typename ParseContext>
     constexpr auto parse(ParseContext& ctx)
     {
@@ -30,15 +30,15 @@ struct fmt::formatter<couchbase::management::views::design_document::name_space>
     }
 
     template<typename FormatContext>
-    auto format(couchbase::management::views::design_document::name_space ns, FormatContext& ctx) const
+    auto format(couchbase::design_document_namespace ns, FormatContext& ctx) const
     {
         string_view name = "unknown";
         switch (ns) {
-            case couchbase::management::views::design_document::name_space::development:
+            case couchbase::design_document_namespace::development:
                 name = "development";
                 break;
 
-            case couchbase::management::views::design_document::name_space::production:
+            case couchbase::design_document_namespace::production:
                 name = "production";
                 break;
         }

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

@@ -26,26 +26,36 @@ namespace couchbase::operations::management
 std::error_code
 query_index_get_all_request::encode_to(encoded_request_type& encoded, couchbase::http_context& /* context */) const
 {
-    std::string statement;
-    if (!scope_name.empty() && !collection_name.empty()) {
-        statement = fmt::format(
-          R"(SELECT idx.* FROM system:indexes AS idx WHERE keyspace_id = "{}" AND bucket_id = "{}" AND scope_id = "{}" AND `using`="gsi" ORDER BY is_primary DESC, name ASC)",
-          collection_name,
-          bucket_name,
-          scope_name);
+    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 = collection_cond;
     } else if (!scope_name.empty()) {
-        statement = fmt::format(
-          R"(SELECT idx.* FROM system:indexes AS idx WHERE bucket_id = "{}" AND scope_id = "{}" AND `using`="gsi" ORDER BY is_primary DESC, name ASC)",
-          bucket_name,
-          scope_name);
+        where = scope_cond;
     } else {
-        statement = fmt::format(
-          R"(SELECT idx.* FROM system:indexes AS idx WHERE ((keyspace_id = "{}" AND bucket_id IS MISSING) OR (bucket_id = "{}")) AND `using`="gsi" ORDER BY is_primary DESC, name ASC)",
-          bucket_name,
-          bucket_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 `idx`.* FROM system:indexes AS idx"
+                            " WHERE " +
+                            where +
+                            " AND `using` = \"gsi\""
+                            " ORDER BY is_primary DESC, name ASC";
+
     encoded.headers["content-type"] = "application/json";
-    tao::json::value body{ { "statement", statement }, { "client_context_id", encoded.client_context_id } };
+    tao::json::value body{ { "statement", statement },
+                           { "client_context_id", encoded.client_context_id },
+                           { "$bucket_name", bucket_name },
+                           { "$scope_name", scope_name },
+                           { "$collection_name", collection_name } };
     encoded.method = "POST";
     encoded.path = "/query/service";
     encoded.body = utils::json::generate(body);

package/deps/couchbase-transactions-cxx/include/couchbase/transactions/durability_level.hxx

@@ -57,6 +57,21 @@ namespace transactions
         return "MAJORITY";
     }
 
+    static std::string durability_level_to_string_for_query(durability_level l)
+    {
+        switch (l) {
+            case durability_level::NONE:
+                return "none";
+            case durability_level::MAJORITY:
+                return "majority";
+            case durability_level::MAJORITY_AND_PERSIST_TO_ACTIVE:
+                return "majorityAndPersistToActive";
+            case durability_level::PERSIST_TO_MAJORITY:
+                return "persistToMajority";
+        }
+        return "majority";
+    }
+
     static std::string store_durability_level_to_string(durability_level l)
     {
         switch (l) {

package/deps/couchbase-transactions-cxx/include/couchbase/transactions.hxx

@@ -21,6 +21,7 @@
 #include <thread>
 
 #include <couchbase/cluster.hxx>
+#include <couchbase/logger/logger.hxx>
 #include <couchbase/transactions/async_attempt_context.hxx>
 #include <couchbase/transactions/attempt_context.hxx>
 #include <couchbase/transactions/exceptions.hxx>
@@ -53,15 +54,10 @@ namespace transactions
     /** @brief AsyncTransaction callback when transaction has completed */
     using txn_complete_callback = std::function<void(std::optional<transaction_exception>, std::optional<transaction_result>)>;
 
-    /**
-     * @brief logging levels
-     */
-    enum class log_level { TRACE, DEBUG, INFO, WARN, ERROR, CRITICAL, OFF };
-
     /**
      * @brief set log level for transactions
      */
-    void set_transactions_log_level(log_level level);
+    void set_transactions_log_level(couchbase::logger::level level);
     /**
      * @mainpage
      * A transaction consists of a lambda containing all the operations you wish to perform within a transaction.

package/deps/couchbase-transactions-cxx/src/transactions/attempt_context_impl.cxx

@@ -688,7 +688,7 @@ attempt_context_impl::query_begin_work(Handler&& cb)
     txdata["config"]["numAtrs"] = 1024;
     opts.raw("numatrs", jsonify(1024));
     txdata["config"]["durabilityLevel"] = durability_level_to_string(overall_.config().durability_level());
-    opts.raw("durability_level", jsonify(durability_level_to_string(overall_.config().durability_level())));
+    opts.raw("durability_level", jsonify(durability_level_to_string_for_query(overall_.config().durability_level())));
     if (atr_id_) {
         txdata["atr"] = nlohmann::json::object();
         txdata["atr"]["scp"] = atr_id_->scope();

package/deps/couchbase-transactions-cxx/src/transactions/logging.cxx

@@ -38,29 +38,32 @@ namespace transactions
         return txnlogger;
     }
 
-    spdlog::level::level_enum cb_to_spdlog_level(couchbase::transactions::log_level level)
+    // TODO: better integration with client, so we don't need to repeat this private
+    // method.
+    spdlog::level::level_enum translate_level(couchbase::logger::level level)
     {
         switch (level) {
-            case log_level::TRACE:
-                return spdlog::level::trace;
-            case log_level::DEBUG:
-                return spdlog::level::debug;
-            case log_level::INFO:
-                return spdlog::level::info;
-            case log_level::WARN:
-                return spdlog::level::warn;
-            case log_level::ERROR:
-                return spdlog::level::err;
-            case log_level::CRITICAL:
-                return spdlog::level::critical;
-            default:
-                return spdlog::level::off;
+            case couchbase::logger::level::trace:
+                return spdlog::level::level_enum::trace;
+            case couchbase::logger::level::debug:
+                return spdlog::level::level_enum::debug;
+            case couchbase::logger::level::info:
+                return spdlog::level::level_enum::info;
+            case couchbase::logger::level::warn:
+                return spdlog::level::level_enum::warn;
+            case couchbase::logger::level::err:
+                return spdlog::level::level_enum::err;
+            case couchbase::logger::level::critical:
+                return spdlog::level::level_enum::critical;
+            case couchbase::logger::level::off:
+                return spdlog::level::level_enum::off;
         }
+        return spdlog::level::level_enum::trace;
     }
 
-    void set_transactions_log_level(log_level level)
+    void set_transactions_log_level(couchbase::logger::level level)
     {
-        spdlog::level::level_enum lvl = cb_to_spdlog_level(level);
+        spdlog::level::level_enum lvl = translate_level(level);
         txn_log->set_level(lvl);
         attempt_cleanup_log->set_level(lvl);
         lost_attempts_cleanup_log->set_level(lvl);

package/deps/couchbase-transactions-cxx/tests/transactions/simple_t.cpp

@@ -605,6 +605,28 @@ TEST(SimpleQueryTransactions, CanRollbackRetryBadKVReplace)
     ASSERT_EQ(c, TransactionsTestEnvironment::get_doc(id).content_as<nlohmann::json>());
 }
 
+TEST(SimpleQueryTransactions, QueryCanSetAnyDurability)
+{
+    // Just be sure that the query service understood the durability
+    std::list<durability_level> levels{ durability_level::NONE,
+                                        durability_level::MAJORITY,
+                                        durability_level::MAJORITY_AND_PERSIST_TO_ACTIVE,
+                                        durability_level::PERSIST_TO_MAJORITY };
+    auto txns = TransactionsTestEnvironment::get_transactions();
+    auto id = TransactionsTestEnvironment::get_document_id();
+    ASSERT_TRUE(TransactionsTestEnvironment::upsert_doc(id, content.dump()));
+    // doesn't matter if the query is read-only or not, just check that there
+    // is no error making the query.
+    auto query = fmt::format("SELECT * FROM `{}` USE KEYS '{}'", id.bucket(), id.key());
+    for (auto durability : levels) {
+        txns.run([&](attempt_context& ctx) {
+            ctx.query(query);
+            auto doc = ctx.get_optional(id);
+            ASSERT_TRUE(doc);
+        });
+    }
+}
+
 int
 main(int argc, char* argv[])
 {

package/deps/couchbase-transactions-cxx/tests/transactions/transactions_env.h

@@ -55,7 +55,7 @@ struct conn {
             couchbase::logger::create_console_logger();
         }
         couchbase::logger::set_log_levels(couchbase::logger::level::trace);
-        couchbase::transactions::set_transactions_log_level(couchbase::transactions::log_level::TRACE);
+        couchbase::transactions::set_transactions_log_level(couchbase::logger::level::trace);
         size_t num_threads = conf.contains("io_threads") ? conf["io_threads"].get<uint32_t>() : 4;
         couchbase::transactions::txn_log->trace("using {} io completion threads", num_threads);
         for (size_t i = 0; i < num_threads; i++) {

package/dist/binding.d.ts

@@ -665,7 +665,6 @@ export interface CppDecrementRequest {
     initial_value?: number;
     durability_level: CppProtocolDurabilityLevel;
     timeout?: CppMilliseconds;
-    preserve_expiry: boolean;
 }
 export interface CppSearchResponse {
     status: string;
@@ -902,7 +901,6 @@ export interface CppIncrementRequest {
     initial_value?: number;
     durability_level: CppProtocolDurabilityLevel;
     timeout?: CppMilliseconds;
-    preserve_expiry: boolean;
 }
 export interface CppManagementGroupUpsertResponse {
     errors: string[];

package/dist/collection.js

@@ -843,7 +843,6 @@ class Collection {
                 expiry: expiry || 0,
                 durability_level: (0, bindingutilities_1.durabilityToCpp)(durabilityLevel),
                 timeout,
-                preserve_expiry: false,
                 partition: 0,
                 opaque: 0,
             }, (cppErr, resp) => {
@@ -882,7 +881,6 @@ class Collection {
                 expiry: expiry || 0,
                 durability_level: (0, bindingutilities_1.durabilityToCpp)(durabilityLevel),
                 timeout,
-                preserve_expiry: false,
                 partition: 0,
                 opaque: 0,
             }, (cppErr, resp) => {

package/dist/httpexecutor.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { CppConnection } from './binding';
 import { HttpErrorContext } from './errorcontexts';
 import * as events from 'events';

package/package.json

@@ -1 +1 @@
-{"bugs":{"url":"http://www.couchbase.com/issues/browse/JSCBC"},"description":"The official Couchbase Node.js Client Library.","engines":{"node":">=12.0.0"},"homepage":"http://www.couchbase.com/communities/nodejs","keywords":["couchbase","libcouchbase","memcached","nosql","json","document"],"main":"dist/couchbase.js","types":"dist/couchbase.d.ts","license":"Apache-2.0","name":"couchbase","dependencies":{"bindings":"^1.5.0","cmake-js":"^6.3.0","node-addon-api":"^4.3.0","prebuild-install":"^7.1.0"},"devDependencies":{"@trivago/prettier-plugin-sort-imports":"^3.2.0","@tsconfig/node12":"^1.0.9","@types/bindings":"^1.5.1","@types/debug":"^4.1.7","@types/node":"^17.0.29","@typescript-eslint/eslint-plugin":"^5.21.0","@typescript-eslint/parser":"^5.21.0","chai":"^4.3.6","eslint":"^8.14.0","eslint-config-prettier":"^8.5.0","eslint-plugin-jsdoc":"^39.2.9","eslint-plugin-mocha":"^10.0.4","eslint-plugin-node":"^11.1.0","expose-gc":"^1.0.0","mocha":"^9.2.2","npm-check-updates":"^12.5.9","nyc":"^15.1.0","prebuild":"^11.0.3","prettier":"^2.6.2","segfault-handler":"^1.3.0","semver":"^7.3.7","ts-mocha":"^9.0.2","ts-node":"^10.7.0","typedoc":"^0.22.15","typescript":"^4.6.3","uuid":"^8.3.2"},"repository":{"type":"git","url":"http://github.com/couchbase/couchnode.git"},"version":"4.1.0","config":{"native":false},"scripts":{"install":"prebuild-install || cmake-js compile","build":"cmake-js build && tsc","rebuild":"cmake-js rebuild && tsc","prebuild":"prebuild --backend cmake-js --verbose --strip","prepare":"tsc","build-docs":"typedoc","test":"ts-mocha test/*.test.*","test-fast":"ts-mocha test/*.test.* -ig '(slow)'","cover":"nyc ts-mocha test/*.test.*","cover-fast":"nyc ts-mocha test/*.test.* -ig '(slow)'","lint":"eslint ./lib/ ./test/","check-deps":"ncu"}}
+{"bugs":{"url":"http://www.couchbase.com/issues/browse/JSCBC"},"description":"The official Couchbase Node.js Client Library.","engines":{"node":">=12.0.0"},"homepage":"http://www.couchbase.com/communities/nodejs","keywords":["couchbase","libcouchbase","memcached","nosql","json","document"],"main":"dist/couchbase.js","types":"dist/couchbase.d.ts","license":"Apache-2.0","name":"couchbase","dependencies":{"bindings":"^1.5.0","cmake-js":"^6.3.2","node-addon-api":"^5.0.0","prebuild-install":"^7.1.1"},"devDependencies":{"@trivago/prettier-plugin-sort-imports":"^3.2.0","@tsconfig/node12":"^1.0.9","@types/bindings":"^1.5.1","@types/debug":"^4.1.7","@types/node":"^17.0.41","@typescript-eslint/eslint-plugin":"^5.27.1","@typescript-eslint/parser":"^5.27.1","chai":"^4.3.6","eslint":"^8.17.0","eslint-config-prettier":"^8.5.0","eslint-plugin-jsdoc":"^39.3.2","eslint-plugin-mocha":"^10.0.5","eslint-plugin-node":"^11.1.0","expose-gc":"^1.0.0","mocha":"^10.0.0","npm-check-updates":"^13.1.2","nyc":"^15.1.0","prebuild":"^11.0.3","prettier":"^2.6.2","segfault-handler":"^1.3.0","semver":"^7.3.7","ts-mocha":"^10.0.0","ts-node":"^10.8.1","typedoc":"^0.22.17","typescript":"^4.7.3","uuid":"^8.3.2"},"repository":{"type":"git","url":"http://github.com/couchbase/couchnode.git"},"version":"4.1.1","config":{"native":false},"scripts":{"install":"prebuild-install || cmake-js compile","build":"cmake-js build && tsc","rebuild":"cmake-js rebuild && tsc","prebuild":"prebuild --backend cmake-js --verbose --strip","prepare":"tsc","build-docs":"typedoc","test":"ts-mocha test/*.test.*","test-fast":"ts-mocha test/*.test.* -ig '(slow)'","cover":"nyc ts-mocha test/*.test.*","cover-fast":"nyc ts-mocha test/*.test.* -ig '(slow)'","lint":"eslint ./lib/ ./test/","check-deps":"ncu"}}