couchbase 4.2.8 → 4.2.10

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

@@ -140,27 +140,4 @@ struct decrement_options : public common_durability_options<decrement_options> {
  * @uncommitted
  */
 using decrement_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_decrement_operation(std::shared_ptr<couchbase::core::cluster> core,
-                             std::string bucket_name,
-                             std::string scope_name,
-                             std::string collection_name,
-                             std::string document_key,
-                             decrement_options::built options,
-                             decrement_handler&& handler);
-#endif
-} // namespace impl
-} // namespace core
 } // namespace couchbase

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

@@ -0,0 +1,75 @@
+/* -*- 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/diagnostics_result.hxx>
+
+#include <optional>
+#include <utility>
+
+namespace couchbase
+{
+struct diagnostics_options : public common_options<diagnostics_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) -> diagnostics_options&
+    {
+        report_id_ = std::move(report_id);
+        return self();
+    }
+
+    /**
+     * Immutable value object representing consistent options.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    struct built : public common_options<diagnostics_options>::built {
+        std::optional<std::string> report_id;
+    };
+
+    /**
+     * 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_ };
+    }
+
+  private:
+    std::optional<std::string> report_id_{};
+};
+
+using diagnostics_handler = std::function<void(diagnostics_result)>;
+} // namespace couchbase

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

@@ -0,0 +1,124 @@
+/* -*- 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_diagnostics.hxx>
+#include <couchbase/service_type.hxx>
+
+#include <cstdint>
+#include <map>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace couchbase
+{
+class diagnostics_result
+{
+  public:
+    /**
+     * @since 1.0.0
+     * @internal
+     */
+    diagnostics_result() = default;
+
+    /**
+     * @since 1.0.0
+     * @internal
+     */
+    diagnostics_result(std::string id,
+                       std::uint16_t version,
+                       std::string sdk,
+                       std::map<service_type, std::vector<endpoint_diagnostics>> 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 diagnostics for each individual endpoint, organised by service type.
+     *
+     * @return the service type to endpoint diagnostics reports map.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto endpoints() const -> std::map<service_type, std::vector<endpoint_diagnostics>>
+    {
+        return endpoints_;
+    }
+
+    /**
+     * Exports the diagnostics report as JSON.
+     *
+     * @return the JSON report.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[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_diagnostics>> endpoints_{};
+};
+} // namespace couchbase

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

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

@@ -0,0 +1,105 @@
+/* -*- 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>
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+class disconnect_link_analytics_options : public common_options<disconnect_link_analytics_options>
+{
+  public:
+    /**
+     * The name of the dataverse to connect to.
+     *
+     * defaults to `Default`
+     *
+     * @param dataverse_name
+     * @return reference to this object, for use in chaining
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto dataverse_name(std::string dataverse_name) -> disconnect_link_analytics_options&
+    {
+        dataverse_name_ = std::move(dataverse_name);
+        return self();
+    }
+
+    /**
+     * The name of the link
+     *
+     * defaults to `Local`
+     *
+     * @param link_name
+     * @return reference to this object, for use in chaining
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto link_name(std::string link_name) -> disconnect_link_analytics_options&
+    {
+        link_name_ = std::move(link_name);
+        return self();
+    }
+
+    /**
+     * Immutable value object representing consistent options.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    struct built : public common_options<disconnect_link_analytics_options>::built {
+        std::optional<std::string> dataverse_name{};
+        std::optional<std::string> link_name{};
+    };
+
+    /**
+     * 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_, link_name_ };
+    }
+
+  private:
+    std::optional<std::string> dataverse_name_{};
+    std::optional<std::string> link_name_{};
+};
+
+/**
+ * The signature for the handler of the @ref analytics_index_manager#disconnect_link() operation
+ *
+ * @since 1.0.0
+ * @uncommitted
+ */
+using disconnect_link_analytics_handler = std::function<void(couchbase::manager_error_context)>;
+} // namespace couchbase

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

@@ -0,0 +1,103 @@
+/* -*- 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>
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+class drop_dataset_analytics_options : public common_options<drop_dataset_analytics_options>
+{
+  public:
+    /**
+     * Ignore error if the dataset does not exist.
+     *
+     * defaults to `false`
+     *
+     * @param ignore_if_not_exists
+     * @return reference to this object, for use in chaining
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto ignore_if_not_exists(bool ignore_if_not_exists) -> drop_dataset_analytics_options&
+    {
+        ignore_if_not_exists_ = ignore_if_not_exists;
+        return self();
+    }
+
+    /**
+     * The name of the dataverse the dataset should be dropped from
+     *
+     * @param dataverse_name
+     * @return reference to this object, for use in chaining
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto dataverse_name(std::string dataverse_name) -> drop_dataset_analytics_options&
+    {
+        dataverse_name_ = std::move(dataverse_name);
+        return self();
+    }
+
+    /**
+     * Immutable value object representing consistent options.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    struct built : public common_options<drop_dataset_analytics_options>::built {
+        bool ignore_if_not_exists{};
+        std::optional<std::string> dataverse_name{};
+    };
+
+    /**
+     * 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(), ignore_if_not_exists_, dataverse_name_ };
+    }
+
+  private:
+    bool ignore_if_not_exists_{ false };
+    std::optional<std::string> dataverse_name_{};
+};
+
+/**
+ * The signature for the handler of the @ref analytics_index_manager#drop_dataset() operation
+ *
+ * @since 1.0.0
+ * @uncommitted
+ */
+using drop_dataset_analytics_handler = std::function<void(couchbase::manager_error_context)>;
+} // namespace couchbase

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

@@ -0,0 +1,84 @@
+/* -*- 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 drop_dataverse_analytics_options : public common_options<drop_dataverse_analytics_options>
+{
+  public:
+    /**
+     * Ignore error if the dataverse does not exist.
+     *
+     * defaults to `false`
+     *
+     * @param ignore_if_not_exists
+     * @return reference to this object, for use in chaining
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto ignore_if_not_exists(bool ignore_if_not_exists) -> drop_dataverse_analytics_options&
+    {
+        ignore_if_not_exists_ = ignore_if_not_exists;
+        return self();
+    }
+
+    /**
+     * Immutable value object representing consistent options.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    struct built : public common_options<drop_dataverse_analytics_options>::built {
+        bool ignore_if_not_exists{};
+    };
+
+    /**
+     * 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(), ignore_if_not_exists_ };
+    }
+
+  private:
+    bool ignore_if_not_exists_{ false };
+};
+
+/**
+ * The signature for the handler of the @ref analytics_index_manager#drop_dataverse() operation
+ *
+ * @since 1.0.0
+ * @uncommitted
+ */
+using drop_dataverse_analytics_handler = std::function<void(couchbase::manager_error_context)>;
+} // namespace couchbase

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

@@ -0,0 +1,103 @@
+/* -*- 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>
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+class drop_index_analytics_options : public common_options<drop_index_analytics_options>
+{
+  public:
+    /**
+     * Ignore error if the index does not exist.
+     *
+     * defaults to `false`
+     *
+     * @param ignore_if_not_exists
+     * @return reference to this object, for use in chaining
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto ignore_if_not_exists(bool ignore_if_not_exists) -> drop_index_analytics_options&
+    {
+        ignore_if_not_exists_ = ignore_if_not_exists;
+        return self();
+    }
+
+    /**
+     * The name of the dataverse the index should be dropped from
+     *
+     * @param dataverse_name
+     * @return reference to this object, for use in chaining
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    auto dataverse_name(std::string dataverse_name) -> drop_index_analytics_options&
+    {
+        dataverse_name_ = std::move(dataverse_name);
+        return self();
+    }
+
+    /**
+     * Immutable value object representing consistent options.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    struct built : public common_options<drop_index_analytics_options>::built {
+        bool ignore_if_not_exists{};
+        std::optional<std::string> dataverse_name{};
+    };
+
+    /**
+     * 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(), ignore_if_not_exists_, dataverse_name_ };
+    }
+
+  private:
+    bool ignore_if_not_exists_{ false };
+    std::optional<std::string> dataverse_name_{};
+};
+
+/**
+ * The signature for the handler of the @ref analytics_index_manager#drop_index() operation
+ *
+ * @since 1.0.0
+ * @uncommitted
+ */
+using drop_index_analytics_handler = std::function<void(couchbase::manager_error_context)>;
+} // namespace couchbase