couchbase 4.2.0 → 4.2.2

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

@@ -0,0 +1,78 @@
+/* -*- 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 "utils/movable_function.hxx"
+
+#include <chrono>
+#include <cinttypes>
+#include <map>
+#include <memory>
+#include <optional>
+#include <string>
+#include <system_error>
+#include <vector>
+
+namespace couchbase
+{
+class retry_strategy;
+namespace tracing
+{
+class request_span;
+} // namespace tracing
+} // namespace couchbase
+
+namespace couchbase::core
+{
+class view_query_options
+{
+  public:
+    std::string design_document_name{};
+    std::string view_name{};
+    std::string view_type{};
+    std::map<std::string, std::string> options{};
+
+    std::shared_ptr<couchbase::retry_strategy> retry_strategy{};
+    std::chrono::milliseconds timeout{};
+    std::shared_ptr<couchbase::tracing::request_span> parent_span{};
+
+    struct {
+        std::string user{};
+    } internal{};
+};
+
+class view_query_row_reader_impl;
+
+class view_query_row_reader
+{
+  public:
+    view_query_row_reader();
+
+    auto next_row() -> std::vector<std::byte>;
+
+    auto error() -> std::error_code;
+
+    auto meta_data() -> std::optional<std::vector<std::byte>>;
+
+    auto close() -> std::error_code;
+
+  private:
+    std::shared_ptr<view_query_row_reader_impl> impl_;
+};
+
+using view_query_callback = utils::movable_function<void(view_query_row_reader reader, std::error_code ec)>;
+
+} // namespace couchbase::core

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

@@ -0,0 +1,52 @@
+/* -*- 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 "cluster_state.hxx"
+#include "service_type.hxx"
+#include "utils/movable_function.hxx"
+
+#include <memory>
+#include <system_error>
+#include <vector>
+
+namespace couchbase
+{
+class retry_strategy;
+} // namespace couchbase
+
+namespace couchbase::core
+{
+class wait_until_ready_options
+{
+  public:
+    cluster_state desired_state{ cluster_state::online };
+    std::vector<service_type> services{
+        service_type::query,
+        service_type::analytics,
+        service_type::search,
+        service_type::management,
+    };
+    std::shared_ptr<couchbase::retry_strategy> retry_strategy{};
+};
+
+class wait_until_ready_result
+{
+};
+
+using wait_until_ready_callback = utils::movable_function<void(wait_until_ready_result result, std::error_code ec)>;
+
+} // namespace couchbase::core

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

@@ -61,7 +61,8 @@ struct append_options : public common_durability_options<append_options> {
      */
     [[nodiscard]] auto build() const -> built
     {
-        return { build_common_durability_options(), cas_ };
+        auto base = build_common_durability_options();
+        return { base, cas_ };
     }
 
     /**
@@ -80,7 +81,6 @@ struct append_options : public common_durability_options<append_options> {
      */
     auto cas(couchbase::cas cas) -> append_options&
     {
-
         cas_ = cas;
         return self();
     }

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

@@ -0,0 +1,64 @@
+/* -*- 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 <couchbase/retry_strategy.hxx>
+
+#include <chrono>
+#include <functional>
+#include <memory>
+
+namespace couchbase
+{
+using backoff_calculator = std::function<std::chrono::milliseconds(std::size_t retry_attempts)>;
+
+/**
+ * calculates a backoff time duration from the retry attempts on a given request.
+ */
+auto
+controlled_backoff(std::size_t retry_attempts) -> std::chrono::milliseconds;
+
+/**
+ * calculates a backoff time duration from the retry attempts on a given request.
+ *
+ * @param min_backoff
+ * @param max_backoff
+ * @param backoff_factor
+ * @return backoff calculator
+ */
+auto
+exponential_backoff(std::chrono::milliseconds min_backoff, std::chrono::milliseconds max_backoff, double backoff_factor)
+  -> backoff_calculator;
+
+class best_effort_retry_strategy : public retry_strategy
+{
+  public:
+    explicit best_effort_retry_strategy(backoff_calculator calculator);
+    ~best_effort_retry_strategy() override = default;
+
+    auto retry_after(const retry_request& request, retry_reason reason) -> retry_action override;
+
+    [[nodiscard]] auto to_string() const -> std::string override;
+
+  private:
+    backoff_calculator backoff_calculator_;
+};
+
+[[nodiscard]] auto
+make_best_effort_retry_strategy(backoff_calculator calculator = controlled_backoff) -> std::shared_ptr<best_effort_retry_strategy>;
+} // namespace couchbase

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

@@ -18,6 +18,7 @@
 #pragma once
 
 #include <couchbase/common_options.hxx>
+#include <couchbase/error_codes.hxx>
 #include <couchbase/manager_error_context.hxx>
 
 #include <functional>
@@ -36,40 +37,6 @@ namespace couchbase
 class build_query_index_options : public common_options<build_query_index_options>
 {
   public:
-    /**
-     * Sets the scope name for this query management operation.
-     *
-     * Please note that if the scope name is set, the {@link #collection_name} must also be set.
-     *
-     * @since 1.0.0
-     * @committed
-     */
-    auto scope_name(std::string scope_name) -> build_query_index_options&
-    {
-        scope_name_.emplace(std::move(scope_name));
-        return self();
-    }
-
-    /**
-     * Sets the collection name for this query management operation.
-     *
-     * Please note that if the collection name is set, the {@link #scope_name} must also be set.
-     *
-     * @since 1.0.0
-     * @committed
-     */
-    auto collection_name(std::string collection_name) -> build_query_index_options&
-    {
-        collection_name_.emplace(std::move(collection_name));
-        return self();
-    }
-
-    /**
-     * Immutable value object representing consistent options.
-     *
-     * @since 1.0.0
-     * @internal
-     */
     struct built : public common_options<build_query_index_options>::built {
         const std::optional<std::string> scope_name{};
         const std::optional<std::string> collection_name{};
@@ -87,18 +54,9 @@ class build_query_index_options : public common_options<build_query_index_option
      */
     [[nodiscard]] auto build() const -> built
     {
-        if (scope_name_.has_value() && !collection_name_.has_value()) {
-            throw std::system_error(errc::common::invalid_argument, "if a scope_name is provided, a collection_name must also be provided");
-        }
-        if (!scope_name_.has_value() && collection_name_.has_value()) {
-            throw std::system_error(errc::common::invalid_argument, "if a collection_name is provided, a scope_name must also be provided");
-        }
-        return { build_common_options(), scope_name_, collection_name_ };
-    }
 
-  private:
-    std::optional<std::string> scope_name_{};
-    std::optional<std::string> collection_name_{};
+        return { build_common_options() };
+    }
 };
 
 /**
@@ -113,6 +71,7 @@ using build_deferred_query_indexes_handler = std::function<void(couchbase::manag
 namespace core
 {
 class cluster;
+class query_context;
 namespace impl
 {
 
@@ -121,6 +80,14 @@ namespace impl
  * @internal
  */
 void
+initiate_build_deferred_indexes(std::shared_ptr<couchbase::core::cluster> resp1,
+                                std::string bucket_name,
+                                build_query_index_options::built options,
+                                query_context query_ctx,
+                                std::string collection_name,
+                                build_deferred_query_indexes_handler&& handler);
+
+void
 initiate_build_deferred_indexes(std::shared_ptr<couchbase::core::cluster> resp1,
                                 std::string bucket_name,
                                 build_query_index_options::built options,

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

@@ -94,10 +94,7 @@ class cluster
     auto operator=(const cluster& other) -> cluster& = default;
     auto operator=(cluster&& other) -> cluster& = default;
 
-    void close()
-    {
-        return core::impl::initiate_cluster_close(core_);
-    }
+    void close();
 
     /**
      * Wraps low-level implementation of the SDK to provide common API.
@@ -144,7 +141,7 @@ class cluster
     template<typename Handler>
     void query(std::string statement, const query_options& options, Handler&& handler) const
     {
-        return core::impl::initiate_query_operation(core_, std::move(statement), {}, {}, options.build(), std::forward<Handler>(handler));
+        return core::impl::initiate_query_operation(core_, std::move(statement), {}, options.build(), std::forward<Handler>(handler));
     }
 
     /**
@@ -181,8 +178,30 @@ class cluster
         return query_index_manager{ core_ };
     }
 
+    /**
+     * Provides access to transaction services.
+     *
+     * @return
+     *
+     * @since 1.0.0
+     * @committed
+     */
+
     [[nodiscard]] auto transactions() -> std::shared_ptr<couchbase::transactions::transactions>;
 
+    /**
+     * Provide access to core cluster object
+     *
+     * This is used internally, during testing, and may be removed as the API evolves.
+     *
+     * @return pointer to core cluster
+     * @volatile
+     */
+    [[nodiscard]] auto core() -> std::shared_ptr<couchbase::core::cluster>
+    {
+        return core_;
+    }
+
   private:
     std::shared_ptr<couchbase::core::cluster> core_{};
     std::shared_ptr<couchbase::core::transactions::transactions> transactions_{};

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

@@ -28,8 +28,10 @@
 #include <couchbase/security_options.hxx>
 #include <couchbase/timeout_options.hxx>
 #include <couchbase/tracing_options.hxx>
+#include <couchbase/transactions/transactions_config.hxx>
 
 #include <functional>
+#include <stdexcept>
 #include <string>
 #include <system_error>
 #include <vector>
@@ -70,8 +72,10 @@ class cluster_options
     explicit cluster_options(password_authenticator authenticator)
       : username_{ std::move(authenticator.username_) }
       , password_{ std::move(authenticator.password_) }
-      , ldap_compatible_{ authenticator.ldap_compatible_ }
     {
+        if (authenticator.ldap_compatible_) {
+            sasl_mechanisms_ = { { "PLAIN" } };
+        }
     }
 
     /**
@@ -98,7 +102,7 @@ class cluster_options
      * @see wan_development_configuration_profile
      *
      * @since 1.0.0
-     * @comitted
+     * @volatile
      */
     void apply_profile(const std::string& profile_name)
     {
@@ -209,12 +213,42 @@ class cluster_options
         return behavior_;
     }
 
+    /**
+     * Returns the transactions options which effect the transactions behavior.
+     *
+     * @return  transactions configuration.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto transactions() -> transactions::transactions_config&
+    {
+        return transactions_;
+    }
+
+    /**
+     * Override default retry strategy
+     *
+     * @return cluster options object for chaining
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto default_retry_strategy(std::shared_ptr<retry_strategy> strategy) -> cluster_options&
+    {
+        if (strategy == nullptr) {
+            throw std::invalid_argument("retry strategy cannot be null");
+        }
+        default_retry_strategy_ = std::move(strategy);
+        return *this;
+    }
+
     struct built {
         std::string username;
         std::string password;
         std::string certificate_path;
         std::string key_path;
-        std::vector<std::string> allowed_sasl_mechanisms;
+        std::optional<std::vector<std::string>> allowed_sasl_mechanisms;
         compression_options::built compression;
         timeout_options::built timeouts;
         dns_options::built dns;
@@ -223,19 +257,18 @@ class cluster_options
         metrics_options::built metrics;
         tracing_options::built tracing;
         behavior_options::built behavior;
+        transactions::transactions_config::built transactions;
+        std::shared_ptr<retry_strategy> default_retry_strategy;
     };
 
     [[nodiscard]] auto build() const -> built
     {
-        static const std::vector<std::string> default_sasl_mechanisms{ "SCRAM-SHA512", "SCRAM-SHA256", "SCRAM-SHA1" };
-        static const std::vector<std::string> ldap_sasl_mechanisms{ "PLAIN" };
-
         return {
             username_,
             password_,
             certificate_path_,
             key_path_,
-            ldap_compatible_ ? ldap_sasl_mechanisms : default_sasl_mechanisms,
+            sasl_mechanisms_,
             compression_.build(),
             timeouts_.build(),
             dns_.build(),
@@ -244,6 +277,8 @@ class cluster_options
             metrics_.build(),
             tracing_.build(),
             behavior_.build(),
+            transactions_.build(),
+            default_retry_strategy_,
         };
     }
 
@@ -252,7 +287,7 @@ class cluster_options
     std::string password_{};
     std::string certificate_path_{};
     std::string key_path_{};
-    bool ldap_compatible_{ false };
+    std::optional<std::vector<std::string>> sasl_mechanisms_{};
 
     compression_options compression_{};
     timeout_options timeouts_{};
@@ -262,6 +297,8 @@ class cluster_options
     metrics_options metrics_{};
     tracing_options tracing_{};
     behavior_options behavior_{};
+    transactions::transactions_config transactions_{};
+    std::shared_ptr<retry_strategy> default_retry_strategy_{ nullptr };
 };
 
 #ifndef COUCHBASE_CXX_CLIENT_DOXYGEN

package/deps/couchbase-cxx-client/couchbase/codec/json_transcoder.hxx

@@ -38,7 +38,7 @@ class json_transcoder
     template<typename Document>
     static auto decode(const encoded_value& encoded) -> Document
     {
-        if (!codec_flags::has_common_flags(encoded.flags, codec_flags::json_common_flags)) {
+        if (encoded.flags != 0 && !codec_flags::has_common_flags(encoded.flags, codec_flags::json_common_flags)) {
             throw std::system_error(errc::common::decoding_failure,
                                     "json_transcoder excepts document to have JSON common flags, flags=" + std::to_string(encoded.flags));
         }

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

@@ -19,6 +19,7 @@
 
 #include <couchbase/binary_collection.hxx>
 #include <couchbase/codec/default_json_transcoder.hxx>
+#include <couchbase/collection_query_index_manager.hxx>
 #include <couchbase/exists_options.hxx>
 #include <couchbase/expiry.hxx>
 #include <couchbase/get_all_replicas_options.hxx>
@@ -31,12 +32,14 @@
 #include <couchbase/lookup_in_specs.hxx>
 #include <couchbase/mutate_in_options.hxx>
 #include <couchbase/mutate_in_specs.hxx>
+#include <couchbase/query_options.hxx>
 #include <couchbase/remove_options.hxx>
 #include <couchbase/replace_options.hxx>
 #include <couchbase/touch_options.hxx>
 #include <couchbase/unlock_options.hxx>
 #include <couchbase/upsert_options.hxx>
 
+#include <fmt/format.h>
 #include <future>
 #include <memory>
 
@@ -991,6 +994,11 @@ class collection
         return future;
     }
 
+    [[nodiscard]] auto query_indexes() const -> collection_query_index_manager
+    {
+        return collection_query_index_manager(core_, bucket_name_, scope_name_, name_);
+    }
+
   private:
     friend class bucket;
     friend class scope;