couchbase 4.2.8 → 4.2.10

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

@@ -0,0 +1,66 @@
+/* -*- 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/management/analytics_dataset.hxx>
+#include <couchbase/manager_error_context.hxx>
+
+#include <functional>
+#include <vector>
+
+namespace couchbase
+{
+class get_all_datasets_analytics_options : public common_options<get_all_datasets_analytics_options>
+{
+  public:
+    /**
+     * Immutable value object representing consistent options.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    struct built : public common_options<get_all_datasets_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#get_all_datasets() operation
+ *
+ * @since 1.0.0
+ * @uncommitted
+ */
+using get_all_datasets_analytics_handler =
+  std::function<void(couchbase::manager_error_context, std::vector<management::analytics_dataset>)>;
+} // namespace couchbase

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

@@ -0,0 +1,65 @@
+/* -*- 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/management/analytics_index.hxx>
+#include <couchbase/manager_error_context.hxx>
+
+#include <functional>
+#include <vector>
+
+namespace couchbase
+{
+class get_all_indexes_analytics_options : public common_options<get_all_indexes_analytics_options>
+{
+  public:
+    /**
+     * Immutable value object representing consistent options.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    struct built : public common_options<get_all_indexes_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#get_all_indexes() operation
+ *
+ * @since 1.0.0
+ * @uncommitted
+ */
+using get_all_indexes_analytics_handler = std::function<void(couchbase::manager_error_context, std::vector<management::analytics_index>)>;
+} // namespace couchbase

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

@@ -55,8 +55,6 @@ class get_all_query_indexes_options : public common_options<get_all_query_indexe
     {
         return { build_common_options() };
     }
-
-  private:
 };
 
 /**
@@ -66,6 +64,5 @@ class get_all_query_indexes_options : public common_options<get_all_query_indexe
  * @uncommitted
  */
 
-using get_all_query_indexes_handler =
-  std::function<void(couchbase::manager_error_context, std::vector<couchbase::management::query::index>)>;
+using get_all_query_indexes_handler = std::function<void(couchbase::manager_error_context, std::vector<management::query_index>)>;
 } // namespace couchbase

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

@@ -76,27 +76,4 @@ using get_all_replicas_result = std::vector<get_replica_result>;
  * @uncommitted
  */
 using get_all_replicas_handler = std::function<void(couchbase::key_value_error_context, get_all_replicas_result)>;
-
-#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
-namespace core
-{
-class cluster;
-namespace impl
-{
-
-/**
- * @since 1.0.0
- * @internal
- */
-void
-initiate_get_all_replicas_operation(std::shared_ptr<couchbase::core::cluster> core,
-                                    const std::string& bucket_name,
-                                    const std::string& scope_name,
-                                    const std::string& collection_name,
-                                    std::string document_key,
-                                    get_all_replicas_options::built options,
-                                    get_all_replicas_handler&& handler);
-#endif
-} // namespace impl
-} // namespace core
 } // namespace couchbase

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

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

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

@@ -67,28 +67,4 @@ struct get_and_lock_options : public common_options<get_and_lock_options> {
  * @uncommitted
  */
 using get_and_lock_handler = std::function<void(couchbase::key_value_error_context, get_result)>;
-
-#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
-namespace core
-{
-class cluster;
-namespace impl
-{
-
-/**
- * @since 1.0.0
- * @internal
- */
-void
-initiate_get_and_lock_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::chrono::seconds lock_duration,
-                                couchbase::get_and_lock_options::built options,
-                                couchbase::get_and_lock_handler&& handler);
-#endif
-} // namespace impl
-} // namespace core
 } // namespace couchbase

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

@@ -67,28 +67,4 @@ struct get_and_touch_options : public common_options<get_and_touch_options> {
  * @uncommitted
  */
 using get_and_touch_handler = std::function<void(couchbase::key_value_error_context, get_result)>;
-
-#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
-namespace core
-{
-class cluster;
-namespace impl
-{
-
-/**
- * @since 1.0.0
- * @internal
- */
-void
-initiate_get_and_touch_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::uint32_t expiry,
-                                 couchbase::get_and_touch_options::built options,
-                                 couchbase::get_and_touch_handler&& handler);
-#endif
-} // namespace impl
-} // namespace core
 } // namespace couchbase

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

@@ -67,27 +67,4 @@ struct get_any_replica_options : public common_options<get_any_replica_options>
  * @uncommitted
  */
 using get_any_replica_handler = std::function<void(key_value_error_context, get_replica_result)>;
-
-#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
-namespace core
-{
-class cluster;
-namespace impl
-{
-
-/**
- * @since 1.0.0
- * @internal
- */
-void
-initiate_get_any_replica_operation(std::shared_ptr<couchbase::core::cluster> core,
-                                   const std::string& bucket_name,
-                                   const std::string& scope_name,
-                                   const std::string& collection_name,
-                                   std::string document_key,
-                                   get_any_replica_options::built options,
-                                   get_any_replica_handler&& handler);
-#endif
-} // namespace impl
-} // namespace core
 } // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/get_indexed_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 get_indexed_search_index_options : public common_options<get_indexed_search_index_options> {
+  public:
+    struct built : public common_options<get_indexed_search_index_options>::built {
+    };
+
+    [[nodiscard]] auto build() const -> built
+    {
+        return { build_common_options() };
+    }
+
+  private:
+};
+
+using get_indexed_search_index_handler = std::function<void(couchbase::manager_error_context, std::uint64_t)>;
+} // namespace couchbase

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

@@ -0,0 +1,121 @@
+/* -*- 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/management/analytics_link.hxx>
+#include <couchbase/manager_error_context.hxx>
+
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+class get_links_analytics_options : public common_options<get_links_analytics_options>
+{
+  public:
+    /**
+     * The name of the dataverse to restrict returned links to.
+     *
+     * @param dataverse_name
+     * @return reference to this object, for use in chaining
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto dataverse_name(std::string dataverse_name) -> get_links_analytics_options&
+    {
+        dataverse_name_ = std::move(dataverse_name);
+        return self();
+    }
+
+    /**
+     * The name of the link to fetch.
+     *
+     * @param link_name
+     * @return reference to this object, for use in chaining
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto name(std::string name) -> get_links_analytics_options&
+    {
+        name_ = std::move(name);
+        return self();
+    }
+
+    /**
+     * The type of links to restrict returned links to.
+     *
+     * @param link_type
+     * @return reference to this object, for use in chaining
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto link_type(management::analytics_link_type link_type) -> get_links_analytics_options&
+    {
+        link_type_ = link_type;
+        return self();
+    }
+
+    /**
+     * Immutable value object representing consistent options.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    struct built : public common_options<get_links_analytics_options>::built {
+        std::optional<std::string> dataverse_name{};
+        std::optional<std::string> name{};
+        std::optional<management::analytics_link_type> link_type{};
+    };
+
+    /**
+     * 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(), dataverse_name_, name_, link_type_ };
+    }
+
+  private:
+    std::optional<std::string> dataverse_name_{};
+    std::optional<std::string> name_{};
+    std::optional<management::analytics_link_type> link_type_{};
+};
+
+/**
+ * The signature for the handler of the @ref analytics_index_manager#get_links() operation
+ *
+ * @since 1.0.0
+ * @uncommitted
+ */
+using get_links_analytics_handler =
+  std::function<void(couchbase::manager_error_context, std::vector<std::unique_ptr<management::analytics_link>>)>;
+} // namespace couchbase

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

@@ -46,8 +46,6 @@ struct get_options : public common_options<get_options> {
         const std::vector<std::string> projections;
     };
 
-    static constexpr std::size_t maximum_number_of_projections{ 16U };
-
     /**
      * Validates options and returns them as an immutable value.
      *
@@ -60,10 +58,7 @@ struct get_options : public common_options<get_options> {
      */
     [[nodiscard]] auto build() const -> built
     {
-        if (projections_.size() + (with_expiry_ ? 2 : 1) < maximum_number_of_projections) {
-            return { build_common_options(), with_expiry_, projections_ };
-        }
-        return { build_common_options(), with_expiry_, {} };
+        return { build_common_options(), with_expiry_, projections_ };
     }
 
     /**
@@ -111,27 +106,4 @@ struct get_options : public common_options<get_options> {
  * @uncommitted
  */
 using get_handler = std::function<void(couchbase::key_value_error_context, get_result)>;
-
-#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
-namespace core
-{
-class cluster;
-namespace impl
-{
-
-/**
- * @since 1.0.0
- * @internal
- */
-void
-initiate_get_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::get_options::built options,
-                       couchbase::get_handler&& handler);
-#endif
-} // namespace impl
-} // namespace core
 } // namespace couchbase

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

@@ -0,0 +1,67 @@
+/* -*- 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 <cstdint>
+#include <functional>
+#include <map>
+#include <string>
+
+namespace couchbase
+{
+class get_pending_mutations_analytics_options : public common_options<get_pending_mutations_analytics_options>
+{
+  public:
+    /**
+     * Immutable value object representing consistent options.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    struct built : public common_options<get_pending_mutations_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#get_pending_mutations() operation
+ *
+ * @since 1.0.0
+ * @uncommitted
+ */
+using get_pending_mutations_analytics_handler =
+  std::function<void(couchbase::manager_error_context, std::map<std::string, std::map<std::string, std::int64_t>>)>;
+} // namespace couchbase

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

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

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

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