couchbase 4.2.5 → 4.2.6-dev

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

@@ -18,6 +18,7 @@
 #include "range_scan_options.hxx"
 #include "range_scan_orchestrator_options.hxx"
 #include "scan_result.hxx"
+#include "topology/configuration.hxx"
 
 #include <tl/expected.hpp>
 
@@ -34,15 +35,25 @@ namespace couchbase::core
 class agent;
 class range_scan_orchestrator_impl;
 
+class scan_stream_manager
+{
+  public:
+    virtual ~scan_stream_manager() = default;
+    virtual void stream_start_failed(std::int16_t node_id, bool fatal) = 0;
+    virtual void stream_start_failed_awaiting_retry(std::int16_t node_id, std::uint16_t vbucket_id) = 0;
+    virtual void stream_continue_failed(std::int16_t node_id, bool fatal) = 0;
+    virtual void stream_completed(std::int16_t node_id) = 0;
+};
+
 class range_scan_orchestrator
 {
   public:
     range_scan_orchestrator(asio::io_context& io,
                             agent kv_provider,
-                            std::size_t num_vbuckets,
+                            topology::configuration::vbucket_map vbucket_map,
                             std::string scope_name,
                             std::string collection_name,
-                            std::variant<std::monostate, range_scan, sampling_scan> scan_type,
+                            std::variant<std::monostate, range_scan, prefix_scan, sampling_scan> scan_type,
                             range_scan_orchestrator_options options);
 
     auto scan() -> tl::expected<scan_result, std::error_code>;

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

@@ -16,6 +16,7 @@
 #pragma once
 
 #include "scan_options.hxx"
+#include "timeout_defaults.hxx"
 
 #include <couchbase/mutation_token.hxx>
 #include <couchbase/retry_strategy.hxx>
@@ -40,15 +41,16 @@ namespace couchbase::core
 {
 
 struct range_scan_orchestrator_options {
+    static constexpr std::uint16_t default_concurrency{ 1 };
+
     bool ids_only{ false };
     std::optional<mutation_state> consistent_with{};
-    scan_sort sort{ scan_sort::none };
     std::uint32_t batch_item_limit{ range_scan_continue_options::default_batch_item_limit };
     std::uint32_t batch_byte_limit{ range_scan_continue_options::default_batch_byte_limit };
-    std::chrono::milliseconds batch_time_limit{ range_scan_continue_options::default_batch_time_limit };
+    std::uint16_t concurrency{ default_concurrency };
 
     std::shared_ptr<couchbase::retry_strategy> retry_strategy{ nullptr };
-    std::chrono::milliseconds timeout{};
+    std::chrono::milliseconds timeout{ timeout_defaults::key_value_scan_timeout };
     std::shared_ptr<couchbase::tracing::request_span> parent_span{};
 };
 } // namespace couchbase::core

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

@@ -38,26 +38,7 @@ class request_span;
 
 namespace couchbase::core
 {
-
-enum class scan_sort {
-    none,
-    ascending,
-};
-
 struct mutation_state {
     std::vector<couchbase::mutation_token> tokens;
 };
-
-struct scan_options {
-    bool ids_only{ false };
-    std::optional<mutation_state> consistent_with{};
-    scan_sort sort{ scan_sort::none };
-    std::uint32_t batch_item_limit{ range_scan_continue_options::default_batch_item_limit };
-    std::uint32_t batch_byte_limit{ range_scan_continue_options::default_batch_byte_limit };
-    std::chrono::milliseconds batch_time_limit{ range_scan_continue_options::default_batch_time_limit };
-
-    std::shared_ptr<couchbase::retry_strategy> retry_strategy{ nullptr };
-    std::chrono::milliseconds timeout{};
-    std::shared_ptr<couchbase::tracing::request_span> parent_span{};
-};
 } // namespace couchbase::core

package/deps/couchbase-cxx-client/core/scan_result.cxx

@@ -32,10 +32,7 @@ class scan_result_impl
 
     [[nodiscard]] auto next() const -> tl::expected<range_scan_item, std::error_code>
     {
-        if (auto item = iterator_->next().get(); item) {
-            return item.value();
-        }
-        return tl::unexpected{ errc::key_value::range_scan_completed };
+        return iterator_->next().get();
     }
 
     void next(utils::movable_function<void(range_scan_item, std::error_code)> callback) const
@@ -43,6 +40,16 @@ class scan_result_impl
         return iterator_->next(std::move(callback));
     }
 
+    void cancel()
+    {
+        return iterator_->cancel();
+    }
+
+    [[nodiscard]] auto is_cancelled() -> bool
+    {
+        return iterator_->is_cancelled();
+    }
+
   private:
     std::shared_ptr<range_scan_item_iterator> iterator_;
 };
@@ -65,7 +72,14 @@ scan_result::next(utils::movable_function<void(range_scan_item, std::error_code)
 }
 
 void
-scan_result::cancel() const
+scan_result::cancel()
+{
+    return impl_->cancel();
+}
+
+auto
+scan_result::is_cancelled() -> bool
 {
+    return impl_->is_cancelled();
 }
 } // namespace couchbase::core

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

@@ -41,8 +41,10 @@ class range_scan_item_iterator
 {
   public:
     virtual ~range_scan_item_iterator() = default;
-    virtual auto next() -> std::future<std::optional<range_scan_item>> = 0;
+    virtual auto next() -> std::future<tl::expected<range_scan_item, std::error_code>> = 0;
     virtual void next(utils::movable_function<void(range_scan_item, std::error_code)> callback) = 0;
+    virtual void cancel() = 0;
+    virtual bool is_cancelled() = 0;
 };
 
 class scan_result
@@ -51,7 +53,8 @@ class scan_result
     explicit scan_result(std::shared_ptr<range_scan_item_iterator> iterator);
     [[nodiscard]] auto next() const -> tl::expected<range_scan_item, std::error_code>;
     void next(utils::movable_function<void(range_scan_item, std::error_code)> callback) const;
-    void cancel() const;
+    void cancel();
+    [[nodiscard]] auto is_cancelled() -> bool;
 
   private:
     std::shared_ptr<scan_result_impl> impl_{};

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

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *   Copyright 2020-2021 Couchbase, Inc.
+ *   Copyright 2020-2023 Couchbase, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -27,6 +27,7 @@ constexpr std::chrono::milliseconds resolve_timeout{ 2'000 };
 constexpr std::chrono::milliseconds connect_timeout{ 2'000 };
 constexpr std::chrono::milliseconds key_value_timeout{ 2'500 };
 constexpr std::chrono::milliseconds key_value_durable_timeout{ 10'000 };
+constexpr std::chrono::milliseconds key_value_scan_timeout{ 75'000 };
 constexpr std::chrono::milliseconds view_timeout{ 75'000 };
 constexpr std::chrono::milliseconds query_timeout{ 75'000 };
 constexpr std::chrono::milliseconds analytics_timeout{ 75'000 };
@@ -34,8 +35,6 @@ constexpr std::chrono::milliseconds search_timeout{ 75'000 };
 constexpr std::chrono::milliseconds management_timeout{ 75'000 };
 constexpr std::chrono::milliseconds eventing_timeout{ 75'000 };
 
-constexpr std::chrono::milliseconds range_scan_timeout{ 75'000 };
-
 constexpr std::chrono::milliseconds dns_srv_timeout{ 500 };
 constexpr std::chrono::milliseconds tcp_keep_alive_interval{ 60'000 };
 constexpr std::chrono::milliseconds config_poll_interval{ 2'500 };

package/deps/couchbase-cxx-client/core/topology/capabilities.hxx

@@ -39,5 +39,6 @@ enum class cluster_capability {
     n1ql_javascript_functions,
     n1ql_inline_functions,
     n1ql_enhanced_prepared_statements,
+    n1ql_read_from_replica,
 };
 } // namespace couchbase::core

package/deps/couchbase-cxx-client/core/topology/capabilities_fmt.hxx

@@ -100,6 +100,8 @@ struct fmt::formatter<couchbase::core::cluster_capability> {
             case couchbase::core::cluster_capability::n1ql_enhanced_prepared_statements:
                 name = "n1ql_enhanced_prepared_statements";
                 break;
+            case couchbase::core::cluster_capability::n1ql_read_from_replica:
+                name = "n1ql_read_from_replica";
         }
         return format_to(ctx.out(), "{}", name);
     }

package/deps/couchbase-cxx-client/core/topology/collections_manifest_fmt.hxx

@@ -47,6 +47,6 @@ struct fmt::formatter<couchbase::core::topology::collections_manifest> {
                          couchbase::core::uuid::to_string(manifest.id),
                          manifest.uid,
                          collections.size(),
-                         utils::join_strings(collections, ", "));
+                         couchbase::core::utils::join_strings(collections, ", "));
     }
 };

package/deps/couchbase-cxx-client/core/topology/configuration.hxx

@@ -112,6 +112,11 @@ struct configuration {
         return cluster_capabilities.find(cluster_capability::n1ql_enhanced_prepared_statements) != cluster_capabilities.end();
     }
 
+    [[nodiscard]] bool supports_read_from_replica() const
+    {
+        return cluster_capabilities.find(cluster_capability::n1ql_read_from_replica) != cluster_capabilities.end();
+    }
+
     [[nodiscard]] bool ephemeral() const
     {
         // Use bucket capabilities to identify if couchapi is missing (then its ephemeral). If its null then

package/deps/couchbase-cxx-client/core/topology/configuration_json.hxx

@@ -249,6 +249,8 @@ struct traits<couchbase::core::topology::configuration> {
                         result.cluster_capabilities.insert(couchbase::core::cluster_capability::n1ql_inline_functions);
                     } else if (name == "enhancedPreparedStatements") {
                         result.cluster_capabilities.insert(couchbase::core::cluster_capability::n1ql_enhanced_prepared_statements);
+                    } else if (name == "readFromReplica") {
+                        result.cluster_capabilities.insert(couchbase::core::cluster_capability::n1ql_read_from_replica);
                     }
                 }
             }

package/deps/couchbase-cxx-client/core/utils/connection_string.cxx

@@ -415,6 +415,10 @@ extract_options(connection_string& connstr)
             parse_option(connstr.options.tls_verify, name, value, connstr.warnings);
         } else if (name == "disable_mozilla_ca_certificates") {
             parse_option(connstr.options.disable_mozilla_ca_certificates, name, value, connstr.warnings);
+        } else if (name == "tls_disable_deprecated_protocols") {
+            parse_option(connstr.options.tls_disable_deprecated_protocols, name, value, connstr.warnings);
+        } else if (name == "tls_disable_v1_2") {
+            parse_option(connstr.options.tls_disable_v1_2, name, value, connstr.warnings);
         } else if (name == "user_agent_extra") {
             /**
              * string, that will be appended to identification fields of the server protocols (key in HELO packet for MCBP, "user-agent"

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

@@ -60,6 +60,21 @@ class behavior_options
         return *this;
     }
 
+    /**
+     * Selects network to use.
+     *
+     * @param name network name as it is exposed in the configuration.
+     * @return this object for chaining purposes.
+     *
+     * @see https://docs.couchbase.com/server/current/learn/clusters-and-availability/connectivity.html#alternate-addresses
+     * @see https://docs.couchbase.com/server/current/rest-api/rest-set-up-alternate-address.html
+     */
+    auto network(std::string name) -> behavior_options&
+    {
+        network_ = std::move(name);
+        return *this;
+    }
+
     struct built {
         std::string user_agent_extra;
         bool show_queries;
@@ -67,13 +82,14 @@ class behavior_options
         bool enable_mutation_tokens;
         bool enable_unordered_execution;
         bool dump_configuration;
+        std::string network;
     };
 
     [[nodiscard]] auto build() const -> built
     {
         return {
-            user_agent_extra_,           show_queries_,       enable_clustermap_notification_, enable_mutation_tokens_,
-            enable_unordered_execution_, dump_configuration_,
+            user_agent_extra_,   show_queries_, enable_clustermap_notification_, enable_mutation_tokens_, enable_unordered_execution_,
+            dump_configuration_, network_,
         };
     }
 
@@ -84,5 +100,6 @@ class behavior_options
     bool enable_mutation_tokens_{ true };
     bool enable_unordered_execution_{ true };
     bool dump_configuration_{ false };
+    std::string network_{ "auto" };
 };
 } // namespace couchbase

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

@@ -0,0 +1,135 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-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/create_bucket_options.hxx>
+#include <couchbase/drop_bucket_options.hxx>
+#include <couchbase/flush_bucket_options.hxx>
+#include <couchbase/get_all_buckets_options.hxx>
+#include <couchbase/get_bucket_options.hxx>
+#include <couchbase/update_bucket_options.hxx>
+
+#include <future>
+#include <memory>
+
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+namespace couchbase::core
+{
+class cluster;
+} // namespace couchbase::core
+#endif
+
+namespace couchbase
+{
+class cluster;
+
+class bucket_manager
+{
+  public:
+    /**
+     * Get specific bucket within the cluster
+     *
+     * @param bucket_name the name of the bucket to get
+     * @param options optional parameters
+     * @param handler  handler that implements @ref get_bucket_handler
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    void get_bucket(std::string bucket_name, const get_bucket_options& options, get_bucket_handler&& handler) const;
+
+    [[nodiscard]] auto get_bucket(std::string bucket_name, const get_bucket_options& options = {}) const
+      -> std::future<std::pair<manager_error_context, management::cluster::bucket_settings>>;
+
+    /**
+     * Get all buckets on the cluster
+     *
+     * @param options optional parameters
+     * @param handler handler that implements @ref get_all_buckets_handler
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    void get_all_buckets(const get_all_buckets_options& options, get_all_buckets_handler&& handler) const;
+
+    [[nodiscard]] auto get_all_buckets(const get_all_buckets_options& options = {}) const
+      -> std::future<std::pair<manager_error_context, std::vector<management::cluster::bucket_settings>>>;
+
+    /**
+     * Create a bucket on the cluster
+     *
+     * @param bucket_settings the settings for the bucket
+     * @param options optional parameters
+     * @param handler handler that implements @ref create_bucket_handler
+     */
+    void create_bucket(const management::cluster::bucket_settings& bucket_settings,
+                       const create_bucket_options& options,
+                       create_bucket_handler&& handler) const;
+
+    [[nodiscard]] auto create_bucket(const management::cluster::bucket_settings& bucket_settings,
+                                     const create_bucket_options& options = {}) const -> std::future<manager_error_context>;
+
+    /**
+     * Update an existing bucket
+     *
+     * @param bucket_settings the settings for the bucket
+     * @param options optional parameters
+     * @param handler handler that implements @ref update_bucket_handler
+     */
+    void update_bucket(const management::cluster::bucket_settings& bucket_settings,
+                       const update_bucket_options& options,
+                       update_bucket_handler&& handler) const;
+
+    [[nodiscard]] auto update_bucket(const management::cluster::bucket_settings& bucket_settings,
+                                     const update_bucket_options& options = {}) const -> std::future<manager_error_context>;
+
+    /**
+     * Drop an existing bucket
+     *
+     * @param bucket_name the name of the bucket to drop
+     * @param options optional parameters
+     * @param handler handler that implements @ref drop_bucket_handler
+     */
+    void drop_bucket(std::string bucket_name, const drop_bucket_options& options, drop_bucket_handler&& handler) const;
+
+    [[nodiscard]] auto drop_bucket(std::string bucket_name, const drop_bucket_options& options = {}) const
+      -> std::future<manager_error_context>;
+
+    /**
+     * Flush an existing bucket
+     *
+     * @param bucket_name the name of the bucket to flush
+     * @param options optional parameters
+     * @param handler handler that implements @ref flush_bucket_handler
+     */
+    void flush_bucket(std::string bucket_name, const flush_bucket_options& options, flush_bucket_handler&& handler) const;
+
+    [[nodiscard]] auto flush_bucket(std::string bucket_name, const flush_bucket_options& options = {}) const
+      -> std::future<manager_error_context>;
+
+  private:
+    friend class cluster;
+
+    explicit bucket_manager(std::shared_ptr<couchbase::core::cluster> core)
+      : core_(std::move(core))
+    {
+    }
+
+    std::shared_ptr<couchbase::core::cluster> core_;
+};
+} // namespace couchbase

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

@@ -66,34 +66,4 @@ class build_query_index_options : public common_options<build_query_index_option
  * @uncommitted
  */
 using build_deferred_query_indexes_handler = std::function<void(couchbase::manager_error_context)>;
-
-#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
-namespace core
-{
-class cluster;
-class query_context;
-namespace impl
-{
-
-/**
- * @since 1.0.0
- * @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,
-                                build_deferred_query_indexes_handler&& handler);
-
-#endif
-} // namespace impl
-} // namespace core
 } // namespace couchbase

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

@@ -19,6 +19,7 @@
 
 #include <couchbase/analytics_options.hxx>
 #include <couchbase/bucket.hxx>
+#include <couchbase/bucket_manager.hxx>
 #include <couchbase/cluster_options.hxx>
 #include <couchbase/query_index_manager.hxx>
 #include <couchbase/query_options.hxx>
@@ -250,6 +251,19 @@ class cluster
         return query_index_manager{ core_ };
     }
 
+    /**
+     * Provides access to the bucket management services.
+     *
+     * @return a manager instance
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto buckets() const -> bucket_manager
+    {
+        return bucket_manager{ core_ };
+    }
+
     /**
      * Provides access to transaction services.
      *

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

@@ -64,13 +64,7 @@ class collection_query_index_manager
     void get_all_indexes(const get_all_query_indexes_options& options, get_all_query_indexes_handler&& handler) const;
 
     [[nodiscard]] auto get_all_indexes(const get_all_query_indexes_options& options) const
-      -> std::future<std::pair<manager_error_context, std::vector<couchbase::management::query::index>>>
-    {
-        auto barrier = std::make_shared<std::promise<std::pair<manager_error_context, std::vector<couchbase::management::query::index>>>>();
-        auto future = barrier->get_future();
-        get_all_indexes(options, [barrier](auto ctx, auto resp) { barrier->set_value({ ctx, resp }); });
-        return future;
-    }
+      -> std::future<std::pair<manager_error_context, std::vector<couchbase::management::query::index>>>;
     /**
      * Create an index on the collection.
      *
@@ -89,13 +83,7 @@ class collection_query_index_manager
 
     [[nodiscard]] auto create_index(std::string index_name,
                                     std::vector<std::string> fields,
-                                    const create_query_index_options& options) const -> std::future<manager_error_context>
-    {
-        auto barrier = std::make_shared<std::promise<manager_error_context>>();
-        auto future = barrier->get_future();
-        create_index(std::move(index_name), std::move(fields), options, [barrier](auto ctx) { barrier->set_value(ctx); });
-        return future;
-    }
+                                    const create_query_index_options& options) const -> std::future<manager_error_context>;
 
     /**
      * Create a primary index on a collection.
@@ -108,13 +96,7 @@ class collection_query_index_manager
      */
     void create_primary_index(const create_primary_query_index_options& options, create_query_index_handler&& handler) const;
 
-    [[nodiscard]] auto create_primary_index(const create_primary_query_index_options& options) -> std::future<manager_error_context>
-    {
-        auto barrier = std::make_shared<std::promise<manager_error_context>>();
-        auto future = barrier->get_future();
-        create_primary_index(options, [barrier](auto ctx) { barrier->set_value(ctx); });
-        return future;
-    }
+    [[nodiscard]] auto create_primary_index(const create_primary_query_index_options& options) -> std::future<manager_error_context>;
     /**
      * Drop primary index on a collection.
      *
@@ -126,13 +108,7 @@ class collection_query_index_manager
      */
     void drop_primary_index(const drop_primary_query_index_options& options, drop_query_index_handler&& handler) const;
 
-    [[nodiscard]] auto drop_primary_index(const drop_primary_query_index_options& options) const -> std::future<manager_error_context>
-    {
-        auto barrier = std::make_shared<std::promise<manager_error_context>>();
-        auto future = barrier->get_future();
-        drop_primary_index(options, [barrier](auto ctx) { barrier->set_value(ctx); });
-        return future;
-    }
+    [[nodiscard]] auto drop_primary_index(const drop_primary_query_index_options& options) const -> std::future<manager_error_context>;
 
     /**
      * Drop index in collection.
@@ -146,13 +122,7 @@ class collection_query_index_manager
      */
     void drop_index(std::string index_name, const drop_query_index_options& options, drop_query_index_handler&& handler) const;
 
-    [[nodiscard]] auto drop_index(std::string index_name, const drop_query_index_options& options) -> std::future<manager_error_context>
-    {
-        auto barrier = std::make_shared<std::promise<manager_error_context>>();
-        auto future = barrier->get_future();
-        drop_index(std::move(index_name), options, [barrier](auto ctx) { barrier->set_value(ctx); });
-        return future;
-    }
+    [[nodiscard]] auto drop_index(std::string index_name, const drop_query_index_options& options) -> std::future<manager_error_context>;
     /**
      * Builds all currently deferred indexes in this collection.
      *
@@ -166,13 +136,7 @@ class collection_query_index_manager
      */
     void build_deferred_indexes(const build_query_index_options& options, build_deferred_query_indexes_handler&& handler) const;
 
-    [[nodiscard]] auto build_deferred_indexes(const build_query_index_options& options) const -> std::future<manager_error_context>
-    {
-        auto barrier = std::make_shared<std::promise<manager_error_context>>();
-        auto future = barrier->get_future();
-        build_deferred_indexes(options, [barrier](auto ctx) { barrier->set_value(std::move(ctx)); });
-        return future;
-    }
+    [[nodiscard]] auto build_deferred_indexes(const build_query_index_options& options) const -> std::future<manager_error_context>;
 
     /**
      * Polls the state of a set of indexes, until they all are online.
@@ -189,12 +153,7 @@ class collection_query_index_manager
                        watch_query_indexes_handler&& handler) const;
 
     [[nodiscard]] auto watch_indexes(std::vector<std::string> index_names, const watch_query_indexes_options& options)
-    {
-        auto barrier = std::make_shared<std::promise<manager_error_context>>();
-        auto future = barrier->get_future();
-        watch_indexes(std::move(index_names), options, [barrier](auto ctx) { barrier->set_value(ctx); });
-        return future;
-    }
+      -> std::future<manager_error_context>;
 
   private:
     friend class collection;

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

@@ -0,0 +1,41 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-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 <functional>
+#include <memory>
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+struct create_bucket_options : public common_options<create_bucket_options> {
+  public:
+    struct built : public common_options<create_bucket_options>::built {
+    };
+
+    [[nodiscard]] auto build() const -> built
+    {
+        return { build_common_options() };
+    }
+
+  private:
+};
+
+using create_bucket_handler = std::function<void(couchbase::manager_error_context)>;
+} // namespace couchbase

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

@@ -134,33 +134,4 @@ class create_primary_query_index_options : public common_options<create_primary_
  */
 
 using create_primary_query_index_handler = std::function<void(couchbase::manager_error_context)>;
-
-#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
-namespace core
-{
-class cluster;
-class query_context;
-namespace impl
-{
-
-/**
- * @since 1.0.0
- * @internal
- */
-void
-initiate_create_primary_query_index(std::shared_ptr<couchbase::core::cluster> core,
-                                    std::string bucket_name,
-                                    couchbase::create_primary_query_index_options::built options,
-                                    query_context query_ctx,
-                                    std::string collection_name,
-                                    create_primary_query_index_handler&& handler);
-void
-initiate_create_primary_query_index(std::shared_ptr<couchbase::core::cluster> core,
-                                    std::string bucket_name,
-                                    couchbase::create_primary_query_index_options::built options,
-                                    create_primary_query_index_handler&& handler);
-
-#endif
-} // namespace impl
-} // namespace core
 } // namespace couchbase