couchbase 4.1.0 → 4.1.1

package/README.md

@@ -85,6 +85,14 @@ respectively.
 Finally, to build the API reference for the project, run `make docs` from the
 root directory, and a docs folder will be created with the api reference.
 
+# Support & Additional Resources
+
+If you found an issue, please file it in our [JIRA](https://issues.couchbase.com/projects/JSCBC/issues/).
+
+The Couchbase Discord server is a place where you can collaborate about all things Couchbase. Connect with others from the community, learn tips and tricks, and ask questions. [Join Discord and contribute](https://discord.com/invite/sQ5qbPZuTh).
+
+You can ask questions in our [forums](https://forums.couchbase.com/).
+
 ## License
 
 Copyright 2013 Couchbase Inc.

package/deps/couchbase-cxx-client/.github/workflows/linters.yml

@@ -2,9 +2,9 @@ name: linters
 
 on:
   push:
-    branches: [ master ]
+    branches: [ main ]
   pull_request:
-    branches: [ master ]
+    branches: [ main ]
 
 jobs:
   clang_format:

package/deps/couchbase-cxx-client/.github/workflows/sanitizers.yml

@@ -2,9 +2,9 @@ name: sanitizers
 
 on:
   push:
-    branches: [master]
+    branches: [main]
   pull_request:
-    branches: [master]
+    branches: [main]
 
 jobs:
   address:
@@ -29,6 +29,10 @@ jobs:
           submodules: recursive
       - name: Initialize couchbase
         run: ./bin/init-cluster
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2
+        with:
+          key: ${{ github.job }}
       - name: Build tests
         env:
           CB_SANITIZER: asan
@@ -68,6 +72,10 @@ jobs:
           submodules: recursive
       - name: Initialize couchbase
         run: ./bin/init-cluster
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2
+        with:
+          key: ${{ github.job }}
       - name: Build tests
         env:
           CB_SANITIZER: lsan
@@ -107,6 +115,10 @@ jobs:
           submodules: recursive
       - name: Initialize couchbase
         run: ./bin/init-cluster
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2
+        with:
+          key: ${{ github.job }}
       - name: Build tests
         env:
           CB_SANITIZER: ubsan
@@ -146,6 +158,10 @@ jobs:
           submodules: recursive
       - name: Initialize couchbase
         run: ./bin/init-cluster
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2
+        with:
+          key: ${{ github.job }}
       - name: Build tests
         env:
           CB_SANITIZER: tsan

package/deps/couchbase-cxx-client/.github/workflows/tests.yml

@@ -2,16 +2,22 @@ name: tests
 
 on:
   push:
-    branches: [master]
+    branches: [main]
   pull_request:
-    branches: [master]
+    branches: [main]
 
 jobs:
-  cheshire_cat:
+  test:
+    strategy:
+      matrix:
+        server:
+          - 7.1.0
+          - 7.0.3
+          - 6.6.5
     runs-on: ubuntu-20.04
     services:
       couchbase:
-        image: couchbase:enterprise-7.0.3
+        image: couchbase:enterprise-${{ matrix.server }}
         ports:
           - 8091-8096:8091-8096
           - 11210:11210
@@ -25,36 +31,10 @@ jobs:
           submodules: recursive
       - name: Initialize couchbase
         run: ./bin/init-cluster
-      - name: Build tests
-        run: ./bin/build-tests
-      - name: Check couchbase
-        run: ./bin/check-cluster
-      - name: Run tests
-        timeout-minutes: 15
-        env:
-          TEST_SERVER_VERSION: 7.0.3
-          TEST_CONNECTION_STRING: couchbase://127.0.0.1
-          TEST_LOG_LEVEL: trace
-        run: ./bin/run-tests
-
-  mad_hatter:
-    runs-on: ubuntu-20.04
-    services:
-      couchbase:
-        image: couchbase:enterprise-6.6.4
-        ports:
-          - 8091-8096:8091-8096
-          - 11210:11210
-    steps:
-      - name: Install build environment
-        run: |
-          sudo apt-get update -y
-          sudo apt-get install -y libssl-dev cmake gcc g++ curl
-      - uses: actions/checkout@v2
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2
         with:
-          submodules: recursive
-      - name: Initialize couchbase
-        run: ./bin/init-cluster
+          key: ${{ github.job }}
       - name: Build tests
         run: ./bin/build-tests
       - name: Check couchbase
@@ -62,7 +42,7 @@ jobs:
       - name: Run tests
         timeout-minutes: 15
         env:
-          TEST_SERVER_VERSION: 6.6.4
+          TEST_SERVER_VERSION: ${{ matrix.server }}
           TEST_CONNECTION_STRING: couchbase://127.0.0.1
           TEST_LOG_LEVEL: trace
         run: ./bin/run-tests

package/deps/couchbase-cxx-client/.github/workflows/windows.yml

@@ -2,13 +2,16 @@ name: windows
 
 on:
   push:
-    branches: [master]
+    branches: [main]
   pull_request:
-    branches: [master]
+    branches: [main]
 
 jobs:
-  vs22:
-    runs-on: windows-2022
+  build:
+    strategy:
+      matrix:
+        os: [windows-2022, windows-2019]
+    runs-on: ${{ matrix.os }}
     steps:
       - name: Install build environment
         run: |
@@ -16,17 +19,12 @@ jobs:
       - uses: actions/checkout@v2
         with:
           submodules: recursive
-      - name: Build tests
-        run: ruby ./bin/build-tests.rb
-
-  vs19:
-    runs-on: windows-2019
-    steps:
-      - name: Install build environment
-        run: |
-          choco install --no-progress openssl
-      - uses: actions/checkout@v2
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2
         with:
-          submodules: recursive
+          key: ${{ github.job }}-${{ matrix.os }}
+          variant: sccache
       - name: Build tests
+        env:
+          CB_CACHE_OPTION: sccache
         run: ruby ./bin/build-tests.rb

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

@@ -101,7 +101,12 @@ target_include_directories(
 target_link_libraries(couchbase_cxx_client PRIVATE project_options project_warnings)
 
 include(cmake/DetectStandardFilesystem.cmake)
-couchbase_cxx_check_filesystem(couchbase_cxx_client "filesystem" "std::filesystem" "stdc++fs;c++fs" STD_FILESYSTEM)
+couchbase_cxx_check_filesystem(
+  couchbase_cxx_client
+  "filesystem"
+  "std::filesystem"
+  "stdc++fs;c++fs"
+  STD_FILESYSTEM)
 if(STD_FILESYSTEM)
   message(STATUS "Using std::filesystem")
 else()

package/deps/couchbase-cxx-client/bin/build-tests

@@ -32,12 +32,14 @@ CB_CC=${CB_CC:-$(which ${CB_DEFAULT_CC})}
 CB_CXX=${CB_CXX:-$(which ${CB_DEFAULT_CXX})}
 CB_NUMBER_OF_JOBS=${CB_NUMBER_OF_JOBS:-1}
 CB_CMAKE_BUILD_TYPE=${CB_CMAKE_BUILD_TYPE:-Debug}
+CB_CACHE_OPTION=${CB_CACHE_OPTION:-ccache}
 
 echo "CB_CMAKE=${CB_CMAKE}"
 echo "CB_CC=${CB_CC}"
 echo "CB_CXX=${CB_CXX}"
 echo "CB_NUMBER_OF_JOBS=${CB_NUMBER_OF_JOBS}"
 echo "CB_CMAKE_BUILD_TYPE=${CB_CMAKE_BUILD_TYPE}"
+echo "CB_CACHE_OPTION=${CB_CACHE_OPTION}"
 
 CB_CMAKE_EXTRAS=
 case "${CB_SANITIZER}" in
@@ -79,6 +81,7 @@ ${CB_CMAKE}  \
     -DCMAKE_CXX_COMPILER="${CB_CXX}" \
     -DCOUCHBASE_CXX_CLIENT_BUILD_TESTS=ON \
     -DCOUCHBASE_CXX_CLIENT_BUILD_SHARED=ON \
+    -DCACHE_OPTION="${CB_CACHE_OPTION}" \
     ${CB_CMAKE_EXTRAS} \
     -B "${BUILD_DIR}" \
     -S "${PROJECT_ROOT}"

package/deps/couchbase-cxx-client/bin/build-tests.rb

@@ -48,6 +48,7 @@ CB_CC = ENV.fetch("CB_CC", which(CB_DEFAULT_CC))
 CB_CXX = ENV.fetch("CB_CXX", which(CB_DEFAULT_CXX))
 CB_NUMBER_OF_JOBS = ENV.fetch("CB_NUMBER_OF_JOBS", "1").to_i
 CB_CMAKE_BUILD_TYPE = ENV.fetch("CB_CMAKE_BUILD_TYPE", "Debug")
+CB_CACHE_OPTION = ENV.fetch("CB_CACHE_OPTION", "ccache")
 
 puts "RUBY_PLATFORM=#{RUBY_PLATFORM}"
 puts "CB_CMAKE=#{CB_CMAKE}"
@@ -58,6 +59,7 @@ if RUBY_PLATFORM !~ /mswin|mingw/
   puts "CB_CC=#{CB_CC}"
   puts "CB_CXX=#{CB_CXX}"
 end
+puts "CB_CACHE_OPTION=#{CB_CACHE_OPTION}"
 
 CB_CMAKE_EXTRAS = []
 case CB_SANITIZER
@@ -91,6 +93,7 @@ Dir.chdir(BUILD_DIR) do
   run(CB_CMAKE,
       "-DCMAKE_BUILD_TYPE=#{CB_CMAKE_BUILD_TYPE}",
       "-DCOUCHBASE_CXX_CLIENT_BUILD_TESTS=ON",
+      "-DCACHE_OPTION=#{CB_CACHE_OPTION}",
       *CB_CMAKE_EXTRAS,
       "-B", BUILD_DIR,
       "-S", PROJECT_ROOT)

package/deps/couchbase-cxx-client/bin/init-cluster

@@ -30,7 +30,7 @@ options = {
   username: ENV.fetch("CB_USERNAME", "Administrator"),
   password: ENV.fetch("CB_PASSWORD", "password"),
   bucket: ENV.fetch("CB_BUCKET", "default"),
-  server_quota: ENV.fetch("CB_SERVER_QUOTA", 1024).to_i,
+  server_quota: ENV.fetch("CB_SERVER_QUOTA", 2048).to_i,
   index_quota: ENV.fetch("CB_INDEX_QUOTA", 256).to_i,
   bucket_quota: ENV.fetch("CB_BUCKET_QUOTA", 256).to_i,
   enable_developer_preview: ENV.fetch("CB_DEVELOPER_PREVIEW", false).to_b,

package/deps/couchbase-cxx-client/bin/run-tests

@@ -30,4 +30,4 @@ fi
 
 cd "${BUILD_DIR}"
 
-${CB_CTEST} --output-on-failure --label-regex 'integration|unit'
+${CB_CTEST} --output-on-failure --label-regex 'integration|unit' --output-junit results.xml

package/deps/couchbase-cxx-client/cmake/StandardProjectSettings.cmake

@@ -39,7 +39,7 @@ else()
   message(STATUS "No colored compiler diagnostic set for '${CMAKE_CXX_COMPILER_ID}' compiler.")
 endif()
 
-if(WIN32)
+if(MSVC)
   add_definitions(/bigobj)
 endif()
 

package/deps/couchbase-cxx-client/couchbase/cluster.hxx

@@ -49,6 +49,14 @@ class cluster : public std::enable_shared_from_this<cluster>
         return std::shared_ptr<cluster>(new cluster(ctx));
     }
 
+    [[nodiscard]] std::pair<std::error_code, couchbase::origin> origin() const
+    {
+        if (stopped_) {
+            return { error::network_errc::cluster_closed, {} };
+        }
+        return { {}, origin_ };
+    }
+
     template<typename Handler>
     void open(const couchbase::origin& origin, Handler&& handler)
     {
@@ -289,21 +297,32 @@ class cluster : public std::enable_shared_from_this<cluster>
     {
         // Warn users if they attempt to use Capella without TLS being enabled.
         {
-            bool is_capella = false;
+            bool has_capella_host = false;
+            bool has_non_capella_host = false;
             static std::string suffix = "cloud.couchbase.com";
-            auto nodes_list = origin_.get_nodes();
-            for (auto& node : nodes_list) {
+            for (const auto& node : origin_.get_hostnames()) {
                 if (auto pos = node.find(suffix); pos != std::string::npos && pos + suffix.size() == node.size()) {
-                    is_capella = true;
-                    break;
+                    has_capella_host = true;
+                } else {
+                    has_non_capella_host = true;
                 }
             }
 
-            if (is_capella && !origin_.options().enable_tls) {
+            if (has_capella_host && !origin_.options().enable_tls) {
                 LOG_WARNING("[{}]: TLS is required when connecting to Couchbase Capella. Please enable TLS by prefixing "
                             "the connection string with \"couchbases://\" (note the final 's').",
                             id_);
             }
+
+            if (origin_.options().enable_tls                   /* TLS is enabled */
+                && origin_.options().trust_certificate.empty() /* No CA certificate (or other SDK-specific trust source) is specified */
+                && origin_.options().tls_verify != tls_verify_mode::none /* The user did not disable all TLS verification */
+                && has_non_capella_host /* The connection string has a hostname that does NOT end in ".cloud.couchbase.com" */) {
+                LOG_ERROR("[{}] When TLS is enabled, the cluster options must specify certificate(s) to trust. (Unless connecting to "
+                          "cloud.couchbase.com.)",
+                          id_);
+                return handler(error::common_errc::invalid_argument);
+            }
         }
 
         if (origin_.options().enable_tls) {

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

@@ -405,7 +405,9 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
         }
     };
 
-    class normal_handler : public message_handler
+    class normal_handler
+      : public message_handler
+      , public std::enable_shared_from_this<normal_handler>
     {
       private:
         std::shared_ptr<mcbp_session> session_;
@@ -413,11 +415,18 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
         std::atomic_bool stopped_{ false };
 
       public:
-        ~normal_handler() override = default;
+        ~normal_handler() override
+        {
+            stop();
+        }
 
         explicit normal_handler(std::shared_ptr<mcbp_session> session)
           : session_(session)
           , heartbeat_timer_(session_->ctx_)
+        {
+        }
+
+        void start()
         {
             if (session_->supports_gcccp_) {
                 fetch_config({});
@@ -559,11 +568,11 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
             req.opaque(session_->next_opaque());
             session_->write_and_flush(req.data());
             heartbeat_timer_.expires_after(std::chrono::milliseconds(2500));
-            heartbeat_timer_.async_wait([this](std::error_code e) {
+            heartbeat_timer_.async_wait([self = shared_from_this()](std::error_code e) {
                 if (e == asio::error::operation_aborted) {
                     return;
                 }
-                fetch_config(e);
+                self->fetch_config(e);
             });
         }
     };
@@ -782,6 +791,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
         }
         if (handler_) {
             handler_->stop();
+            handler_ = nullptr;
         }
         {
             std::scoped_lock lock(command_handlers_mutex_);
@@ -1053,7 +1063,11 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
             return stop(retry_reason::node_not_available);
         }
         state_ = diag::endpoint_state::connected;
-        handler_ = std::make_unique<normal_handler>(shared_from_this());
+        {
+            auto handler = std::make_shared<normal_handler>(shared_from_this());
+            handler->start();
+            handler_ = handler;
+        }
         std::scoped_lock lock(pending_buffer_mutex_);
         bootstrapped_ = true;
         if (!pending_buffer_.empty()) {
@@ -1149,7 +1163,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
                                       bootstrap_hostname_,
                                       endpoint_address_,
                                       endpoint_.port());
-            handler_ = std::make_unique<bootstrap_handler>(shared_from_this());
+            handler_ = std::make_shared<bootstrap_handler>(shared_from_this());
             connection_deadline_.expires_at(asio::steady_timer::time_point::max());
             connection_deadline_.cancel();
         }
@@ -1271,7 +1285,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
     couchbase::origin origin_;
     std::optional<std::string> bucket_name_;
     mcbp_parser parser_;
-    std::unique_ptr<message_handler> handler_;
+    std::shared_ptr<message_handler> handler_;
     utils::movable_function<void(std::error_code, const topology::configuration&)> bootstrap_handler_{};
     std::mutex command_handlers_mutex_{};
     std::map<uint32_t, utils::movable_function<void(std::error_code, retry_reason, io::mcbp_message&&)>> command_handlers_{};

package/deps/couchbase-cxx-client/couchbase/meta/version.cxx

@@ -88,6 +88,13 @@ sdk_build_info()
 #elif defined(SSLEAY_VERSION)
     info["openssl_runtime"] = SSLeay_version(SSLEAY_VERSION);
 #endif
+    info["__cplusplus"] = fmt::format("{}", __cplusplus);
+#if defined(_MSC_VER)
+    info["_MSC_VER"] = fmt::format("{}", _MSC_VER);
+#endif
+#if defined(__GLIBC__)
+    info["libc"] = fmt::format("glibc {}.{}", __GLIBC__, __GLIBC_MINOR__);
+#endif
 
     return info;
 }

package/deps/couchbase-cxx-client/couchbase/operations/document_decrement.cxx

@@ -35,9 +35,6 @@ decrement_request::encode_to(decrement_request::encoded_request_type& encoded, m
         encoded.body().initial_value(0);
         encoded.body().expiry(0xffff'ffff);
     }
-    if (preserve_expiry) {
-        encoded.body().preserve_expiry();
-    }
     return {};
 }
 

package/deps/couchbase-cxx-client/couchbase/operations/document_decrement.hxx

@@ -50,7 +50,6 @@ struct decrement_request {
     protocol::durability_level durability_level{ protocol::durability_level::none };
     std::optional<std::chrono::milliseconds> timeout{};
     io::retry_context<io::retry_strategy::best_effort> retries{ false };
-    bool preserve_expiry{ false };
 
     [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&& context) const;
 

package/deps/couchbase-cxx-client/couchbase/operations/document_increment.cxx

@@ -35,9 +35,6 @@ increment_request::encode_to(increment_request::encoded_request_type& encoded, m
         encoded.body().initial_value(0);
         encoded.body().expiry(0xffff'ffff);
     }
-    if (preserve_expiry) {
-        encoded.body().preserve_expiry();
-    }
     return {};
 }
 

package/deps/couchbase-cxx-client/couchbase/operations/document_increment.hxx

@@ -50,7 +50,6 @@ struct increment_request {
     protocol::durability_level durability_level{ protocol::durability_level::none };
     std::optional<std::chrono::milliseconds> timeout{};
     io::retry_context<io::retry_strategy::best_effort> retries{ false };
-    bool preserve_expiry{ false };
 
     [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&& context) const;
 

package/deps/couchbase-cxx-client/couchbase/operations/management/analytics_dataset_get_all.cxx

@@ -27,7 +27,7 @@ std::error_code
 analytics_dataset_get_all_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
 {
     tao::json::value body{
-        { "statement", "SELECT d.* FROM Metadata.`Dataset` d WHERE d.DataverseName <> \"Metadata\"" },
+        { "statement", R"(SELECT d.* FROM Metadata.`Dataset` d WHERE d.DataverseName <> "Metadata" AND d.DatasetType = "INTERNAL")" },
     };
     encoded.headers["content-type"] = "application/json";
     encoded.method = "POST";

package/deps/couchbase-cxx-client/couchbase/operations/management/analytics_get_pending_mutations.cxx

@@ -47,7 +47,7 @@ analytics_get_pending_mutations_request::make_response(error_context::http&& ctx
             if (payload.is_object()) {
                 for (const auto& [dataverse, entry] : payload.get_object()) {
                     for (const auto& [dataset, counter] : entry.get_object()) {
-                        response.stats.try_emplace(fmt::format("{}.{}", dataverse, dataset), counter.get_unsigned());
+                        response.stats.try_emplace(fmt::format("{}.{}", dataverse, dataset), counter.as<std::int64_t>());
                     }
                 }
             }

package/deps/couchbase-cxx-client/couchbase/operations/management/analytics_get_pending_mutations.hxx

@@ -30,7 +30,7 @@ struct analytics_get_pending_mutations_response {
     error_context::http ctx;
     std::string status{};
     std::vector<analytics_problem> errors{};
-    std::map<std::string, std::uint64_t> stats{};
+    std::map<std::string, std::int64_t> stats{};
 };
 
 struct analytics_get_pending_mutations_request {

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

@@ -39,13 +39,14 @@ query_index_drop_request::encode_to(encoded_request_type& encoded, http_context&
     }
 
     std::string drop_index_stmt;
-    if (!scope_name.empty() || !collection_name.empty()) {
+    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()) {
         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);
     }
-    tao::json::value body{ { "statement", is_primary ? fmt::format(R"(DROP PRIMARY INDEX ON {} USING GSI)", keyspace) : drop_index_stmt },
-                           { "client_context_id", encoded.client_context_id } };
+    tao::json::value body{ { "statement", drop_index_stmt }, { "client_context_id", encoded.client_context_id } };
     encoded.method = "POST";
     encoded.path = "/query/service";
     encoded.body = utils::json::generate(body);

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

@@ -118,6 +118,16 @@ struct origin {
         return credentials_.key_path;
     }
 
+    [[nodiscard]] std::vector<std::string> get_hostnames() const
+    {
+        std::vector<std::string> res;
+        res.reserve(nodes_.size());
+        for (const auto& [hostname, _] : nodes_) {
+            res.emplace_back(hostname);
+        }
+        return res;
+    }
+
     [[nodiscard]] std::vector<std::string> get_nodes() const
     {
         std::vector<std::string> res;

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_decrement.cxx

@@ -54,6 +54,7 @@ decrement_response_body::parse(protocol::status status,
     }
     return false;
 }
+
 void
 decrement_request_body::id(const document_id& id)
 {
@@ -63,6 +64,7 @@ decrement_request_body::id(const document_id& id)
         key_.insert(0, encoded.get());
     }
 }
+
 void
 decrement_request_body::durability(protocol::durability_level level, std::optional<std::uint16_t> timeout)
 {
@@ -83,14 +85,7 @@ decrement_request_body::durability(protocol::durability_level level, std::option
         framing_extras_[extras_size + 1] = static_cast<std::uint8_t>(level);
     }
 }
-void
-decrement_request_body::preserve_expiry()
-{
-    auto frame_id = static_cast<uint8_t>(protocol::request_frame_info_id::preserve_ttl);
-    auto extras_size = framing_extras_.size();
-    framing_extras_.resize(extras_size + 1);
-    framing_extras_[extras_size + 0] = static_cast<std::uint8_t>(static_cast<std::uint32_t>(frame_id) << 4U | 0U);
-}
+
 void
 decrement_request_body::fill_extras()
 {

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_decrement.hxx

@@ -91,8 +91,6 @@ class decrement_request_body
 
     void durability(protocol::durability_level level, std::optional<std::uint16_t> timeout);
 
-    void preserve_expiry();
-
     [[nodiscard]] const std::string& key() const
     {
         return key_;

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_increment.cxx

@@ -87,15 +87,6 @@ increment_request_body::durability(protocol::durability_level level, std::option
     }
 }
 
-void
-increment_request_body::preserve_expiry()
-{
-    auto frame_id = static_cast<uint8_t>(protocol::request_frame_info_id::preserve_ttl);
-    auto extras_size = framing_extras_.size();
-    framing_extras_.resize(extras_size + 1);
-    framing_extras_[extras_size + 0] = static_cast<std::uint8_t>(static_cast<std::uint32_t>(frame_id) << 4U | 0U);
-}
-
 void
 increment_request_body::fill_extras()
 {

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_increment.hxx

@@ -91,8 +91,6 @@ class increment_request_body
 
     void durability(protocol::durability_level level, std::optional<std::uint16_t> timeout);
 
-    void preserve_expiry();
-
     [[nodiscard]] const std::string& key() const
     {
         return key_;

package/deps/couchbase-cxx-client/couchbase/utils/json_streaming_lexer.cxx

@@ -39,7 +39,7 @@ noop_on_row(std::string&& /* row */)
 }
 
 #define STATE_MARKER_ROOT (reinterpret_cast<void*>(1))
-#define STATE_MARKER_ROWSET (reinterpret_cast<void*>(1))
+#define STATE_MARKER_ROWSET (reinterpret_cast<void*>(2))
 
 struct streaming_lexer_impl {
     streaming_lexer_impl(jsonsl_t lexer, jsonsl_jpr_t pointer)
@@ -310,7 +310,7 @@ row_pop_callback(jsonsl_t lexer, jsonsl_action_t /* action */, struct jsonsl_sta
 }
 
 static void
-initial_action_pop_callback(jsonsl_t lexer, jsonsl_action_t /* action */, struct jsonsl_state_st* state, const jsonsl_char_t* /* at */)
+initial_action_pop_callback(jsonsl_t lexer, jsonsl_action_t action, struct jsonsl_state_st* state, const jsonsl_char_t* at)
 {
     auto* impl = static_cast<detail::streaming_lexer_impl*>(lexer->data);
 
@@ -321,6 +321,10 @@ initial_action_pop_callback(jsonsl_t lexer, jsonsl_action_t /* action */, struct
     if (state->type == JSONSL_T_HKEY) {
         impl->last_key_ = impl->buffer_.substr(state->pos_begin + 1, state->pos_cur - state->pos_begin - 1);
     }
+
+    if (state->data == STATE_MARKER_ROOT) {
+        trailer_pop_callback(lexer, action, state, at);
+    }
 }
 
 static void