couchbase 4.2.8 → 4.2.10

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

@@ -0,0 +1,93 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2023-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/common_options.hxx>
+#include <couchbase/ping_result.hxx>
+#include <couchbase/service_type.hxx>
+
+#include <functional>
+#include <memory>
+#include <optional>
+#include <set>
+#include <string>
+
+namespace couchbase
+{
+struct ping_options : public common_options<ping_options> {
+    /**
+     * Sets a custom report ID that will be used in the report. If no report ID is provided, the client will generate a
+     * unique one.
+     *
+     * @param report_id the report ID that should be used.
+     * @return reference to this object, for use in chaining.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto report_id(std::string report_id) -> ping_options&
+    {
+        report_id_ = std::move(report_id);
+        return self();
+    }
+
+    /**
+     * Customizes the set of services to ping.
+     *
+     * @param service_types the services to ping.
+     * @return reference to this object, for use in chaining.
+     */
+    auto service_types(std::set<service_type> service_types) -> ping_options&
+    {
+        service_types_ = std::move(service_types);
+        return self();
+    }
+
+    /**
+     * Immutable value object representing consistent options.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    struct built : public common_options<ping_options>::built {
+        std::optional<std::string> report_id;
+        std::set<service_type> service_types;
+    };
+
+    /**
+     * Validates the options and returns them as an immutable value.
+     *
+     * @return consistent options as an immutable value
+     *
+     * @exception std::system_error with code errc::common::invalid_argument if the options are not valid
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    [[nodiscard]] auto build() const -> built
+    {
+        return { build_common_options(), report_id_, service_types_ };
+    }
+
+  private:
+    std::optional<std::string> report_id_{};
+    std::set<service_type> service_types_{};
+};
+
+using ping_handler = std::function<void(ping_result)>;
+} // namespace couchbase

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

@@ -0,0 +1,118 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2023-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/codec/tao_json_serializer.hxx>
+#include <couchbase/endpoint_ping_report.hxx>
+#include <couchbase/service_type.hxx>
+
+#include <cstdint>
+#include <map>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace couchbase
+{
+class ping_result
+{
+  public:
+    /**
+     * @since 1.0.0
+     * @internal
+     */
+    ping_result() = default;
+
+    /**
+     * @since 1.0.0
+     * @internal
+     */
+    ping_result(std::string id, std::uint16_t version, std::string sdk, std::map<service_type, std::vector<endpoint_ping_report>> endpoints)
+      : id_{ std::move(id) }
+      , version_{ version }
+      , sdk_{ std::move(sdk) }
+      , endpoints_{ std::move(endpoints) }
+    {
+    }
+
+    /**
+     * Returns the ID of this report.
+     *
+     * @return the report ID.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto id() const -> std::string
+    {
+        return id_;
+    }
+
+    /**
+     * Returns the version of this report (useful when exporting to JSON).
+     *
+     * @return the report version.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto version() const -> std::uint16_t
+    {
+        return version_;
+    }
+
+    /**
+     * Returns the identifier of this SDK (useful when exporting to JSON).
+     *
+     * @return the SDK identifier.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto sdk() const -> std::string
+    {
+        return sdk_;
+    }
+
+    /**
+     * Returns the ping reports for each individual endpoint, organised by service type.
+     *
+     * @return the service type to ping reports map.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto endpoints() const -> std::map<service_type, std::vector<endpoint_ping_report>>
+    {
+        return endpoints_;
+    }
+
+    /**
+     * Exports the ping report as JSON.
+     *
+     * @return the JSON report.
+     */
+    [[nodiscard]] auto as_json() const -> codec::tao_json_serializer::document_type;
+
+  private:
+    std::string id_{};
+    std::uint16_t version_{};
+    std::string sdk_{};
+    std::map<service_type, std::vector<endpoint_ping_report>> endpoints_{};
+};
+} // namespace couchbase

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

@@ -97,28 +97,4 @@ struct prepend_options : public common_durability_options<prepend_options> {
  * @uncommitted
  */
 using prepend_handler = std::function<void(couchbase::key_value_error_context, mutation_result)>;
-
-#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
-namespace core
-{
-class cluster;
-namespace impl
-{
-
-/**
- * @since 1.0.0
- * @internal
- */
-void
-initiate_prepend_operation(std::shared_ptr<couchbase::core::cluster> core,
-                           std::string bucket_name,
-                           std::string scope_name,
-                           std::string collection_name,
-                           std::string document_key,
-                           std::vector<std::byte> data,
-                           prepend_options::built options,
-                           prepend_handler&& handler);
-#endif
-} // namespace impl
-} // namespace core
 } // namespace couchbase

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

@@ -23,22 +23,22 @@
 #include <couchbase/drop_primary_query_index_options.hxx>
 #include <couchbase/drop_query_index_options.hxx>
 #include <couchbase/get_all_query_indexes_options.hxx>
+#include <couchbase/management/query_index.hxx>
 #include <couchbase/watch_query_indexes_options.hxx>
 
 #include <future>
 #include <memory>
 
+namespace couchbase
+{
 #ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
-namespace couchbase::core
+namespace core
 {
 class cluster;
-} // namespace couchbase::core
+} // namespace core
+class query_index_manager_impl;
 #endif
 
-namespace couchbase
-{
-class cluster;
-
 /**
  * The Query Index Manager interface contains the means for managing indexes used for queries.
  *
@@ -63,8 +63,19 @@ class query_index_manager
                          const get_all_query_indexes_options& options,
                          get_all_query_indexes_handler&& handler) const;
 
+    /**
+     * Get all indexes within a bucket.
+     *
+     *
+     * @param bucket_name specifies the bucket in which we look for the indexes
+     * @param options optional parameters
+     * @return future object that carries result of the operation
+     *
+     * @since 1.0.0
+     * @committed
+     */
     [[nodiscard]] auto get_all_indexes(std::string bucket_name, const get_all_query_indexes_options& options) const
-      -> std::future<std::pair<manager_error_context, std::vector<couchbase::management::query::index>>>;
+      -> std::future<std::pair<manager_error_context, std::vector<management::query_index>>>;
 
     /**
      * Create an index on a bucket.
@@ -84,6 +95,18 @@ class query_index_manager
                       const create_query_index_options& options,
                       create_query_index_handler&& handler) const;
 
+    /**
+     * Create an index on a bucket.
+     *
+     * @param bucket_name specifies the bucket in which to create the index
+     * @param index_name name of the index
+     * @param fields the fields to create the index over
+     * @param options optional parameters
+     * @return future object that carries result of the operation
+     *
+     * @since 1.0.0
+     * @committed
+     */
     [[nodiscard]] auto create_index(std::string bucket_name,
                                     std::string index_name,
                                     std::vector<std::string> fields,
@@ -101,10 +124,21 @@ class query_index_manager
      */
     void create_primary_index(std::string bucket_name,
                               const create_primary_query_index_options& options,
-                              create_query_index_handler&& handler);
+                              create_query_index_handler&& handler) const;
 
-    [[nodiscard]] auto create_primary_index(std::string bucket_name, const create_primary_query_index_options& options)
+    /**
+     * Create a primary index on a bucket.
+     *
+     * @param bucket_name specifies the bucket in which to create the index
+     * @param options optional parameters
+     * @return future object that carries result of the operation
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto create_primary_index(std::string bucket_name, const create_primary_query_index_options& options) const
       -> std::future<manager_error_context>;
+
     /**
      * Drop primary index on a bucket.
      *
@@ -115,12 +149,25 @@ class query_index_manager
      * @since 1.0.0
      * @committed
      */
-    void drop_primary_index(std::string bucket_name, const drop_primary_query_index_options& options, drop_query_index_handler&& handler);
+    void drop_primary_index(std::string bucket_name,
+                            const drop_primary_query_index_options& options,
+                            drop_query_index_handler&& handler) const;
 
-    [[nodiscard]] auto drop_primary_index(std::string bucket_name, const drop_primary_query_index_options& options)
+    /**
+     * Drop primary index on a bucket.
+     *
+     * @param bucket_name name of the bucket in which to drop the primary index
+     * @param options optional parameters
+     * @return future object that carries result of the operation
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto drop_primary_index(std::string bucket_name, const drop_primary_query_index_options& options) const
       -> std::future<manager_error_context>;
 
     /**
+     * Drop specified query index.
      *
      * @param bucket_name name of the bucket in which to drop the index
      * @param index_name name of the index to drop
@@ -133,10 +180,22 @@ class query_index_manager
     void drop_index(std::string bucket_name,
                     std::string index_name,
                     const drop_query_index_options& options,
-                    drop_query_index_handler&& handler);
+                    drop_query_index_handler&& handler) const;
 
-    [[nodiscard]] auto drop_index(std::string bucket_name, std::string index_name, const drop_query_index_options& options)
+    /**
+     * Drop specified query index.
+     *
+     * @param bucket_name name of the bucket in which to drop the index
+     * @param index_name name of the index to drop
+     * @param options optional parameters
+     * @return future object that carries result of the operation
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto drop_index(std::string bucket_name, std::string index_name, const drop_query_index_options& options) const
       -> std::future<manager_error_context>;
+
     /**
      * Builds all currently deferred indexes.
      *
@@ -153,6 +212,18 @@ class query_index_manager
                                 const build_query_index_options& options,
                                 build_deferred_query_indexes_handler&& handler) const;
 
+    /**
+     * Builds all currently deferred indexes.
+     *
+     * By default, this method will build the indexes on the bucket.
+     *
+     * @param bucket_name name of the bucket
+     * @param options the custom options
+     * @return future object that carries result of the operation
+     *
+     * @since 1.0.0
+     * @committed
+     */
     [[nodiscard]] auto build_deferred_indexes(std::string bucket_name, const build_query_index_options& options) const
       -> std::future<manager_error_context>;
 
@@ -170,20 +241,28 @@ class query_index_manager
     void watch_indexes(std::string bucket_name,
                        std::vector<std::string> index_names,
                        const watch_query_indexes_options& options,
-                       watch_query_indexes_handler&& handler);
+                       watch_query_indexes_handler&& handler) const;
 
+    /**
+     * Polls the state of a set of indexes, until they all are online.
+     *
+     * @param bucket_name name of the bucket in which to look for the indexes
+     * @param index_names names of the indexes to watch
+     * @param options optional parameters
+     * @return future object that carries result of the operation
+     *
+     * @since 1.0.0
+     * @committed
+     */
     [[nodiscard]] auto watch_indexes(std::string bucket_name,
                                      std::vector<std::string> index_names,
-                                     const watch_query_indexes_options& options) -> std::future<manager_error_context>;
+                                     const watch_query_indexes_options& options) const -> std::future<manager_error_context>;
 
   private:
     friend class cluster;
 
-    explicit query_index_manager(std::shared_ptr<couchbase::core::cluster> core)
-      : core_(std::move(core))
-    {
-    }
+    explicit query_index_manager(core::cluster core);
 
-    std::shared_ptr<couchbase::core::cluster> core_;
+    std::shared_ptr<query_index_manager_impl> impl_;
 };
 } // namespace couchbase

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

@@ -568,25 +568,4 @@ struct query_options : public common_options<query_options> {
  * @uncommitted
  */
 using query_handler = std::function<void(couchbase::query_error_context, query_result)>;
-
-#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
-namespace core
-{
-class cluster;
-namespace impl
-{
-
-/**
- * @since 1.0.0
- * @internal
- */
-void
-initiate_query_operation(std::shared_ptr<couchbase::core::cluster> core,
-                         std::string statement,
-                         std::optional<std::string> query_context,
-                         query_options::built options,
-                         query_handler&& handler);
-#endif
-} // namespace impl
-} // namespace core
 } // namespace couchbase

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

@@ -97,27 +97,4 @@ struct remove_options : public common_durability_options<remove_options> {
  * @uncommitted
  */
 using remove_handler = std::function<void(couchbase::key_value_error_context, mutation_result)>;
-
-#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
-namespace core
-{
-class cluster;
-namespace impl
-{
-
-/**
- * @since 1.0.0
- * @internal
- */
-void
-initiate_remove_operation(std::shared_ptr<couchbase::core::cluster> core,
-                          std::string bucket_name,
-                          std::string scope_name,
-                          std::string collection_name,
-                          std::string document_key,
-                          couchbase::remove_options::built options,
-                          couchbase::remove_handler&& handler);
-#endif
-} // namespace impl
-} // namespace core
 } // namespace couchbase

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

@@ -0,0 +1,63 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2023-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/common_options.hxx>
+#include <couchbase/error_codes.hxx>
+#include <couchbase/manager_error_context.hxx>
+
+#include <functional>
+
+namespace couchbase
+{
+class replace_link_analytics_options : public common_options<replace_link_analytics_options>
+{
+  public:
+    /**
+     * Immutable value object representing consistent options.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    struct built : public common_options<replace_link_analytics_options>::built {
+    };
+
+    /**
+     * Validates options and returns them as an immutable value.
+     *
+     * @return consistent options as an immutable value
+     *
+     * @exception std::system_error with code errc::common::invalid_argument if the options are not valid
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    [[nodiscard]] auto build() const -> built
+    {
+        return { build_common_options() };
+    }
+};
+
+/**
+ * The signature for the handler of the @ref analytics_index_manager#replace_link() operation
+ *
+ * @since 1.0.0
+ * @uncommitted
+ */
+using replace_link_analytics_handler = std::function<void(couchbase::manager_error_context)>;
+} // namespace couchbase

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

@@ -157,28 +157,4 @@ struct replace_options : public common_durability_options<replace_options> {
  * @uncommitted
  */
 using replace_handler = std::function<void(couchbase::key_value_error_context, mutation_result)>;
-
-#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
-namespace core
-{
-class cluster;
-namespace impl
-{
-
-/**
- * @since 1.0.0
- * @internal
- */
-void
-initiate_replace_operation(std::shared_ptr<couchbase::core::cluster> core,
-                           std::string bucket_name,
-                           std::string scope_name,
-                           std::string collection_name,
-                           std::string document_key,
-                           couchbase::codec::encoded_value encoded,
-                           couchbase::replace_options::built options,
-                           couchbase::replace_handler&& handler);
-#endif
-} // namespace impl
-} // namespace core
 } // namespace couchbase

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

@@ -0,0 +1,43 @@
+/* -*- 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/common_options.hxx>
+
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+struct resume_ingest_search_index_options : public common_options<resume_ingest_search_index_options> {
+  public:
+    struct built : public common_options<resume_ingest_search_index_options>::built {
+    };
+
+    [[nodiscard]] auto build() const -> built
+    {
+        return { build_common_options() };
+    }
+
+  private:
+};
+
+using resume_ingest_search_index_handler = std::function<void(couchbase::manager_error_context)>;
+} // namespace couchbase