couchbase 4.2.8-dev.1 → 4.2.9

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

package/deps/couchbase-cxx-client/couchbase/drop_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 drop_link_analytics_options : public common_options<drop_link_analytics_options>
+{
+  public:
+    /**
+     * Immutable value object representing consistent options.
+     *
+     * @since 1.0.0
+     * @internal
+     */
+    struct built : public common_options<drop_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#drop_link() operation
+ *
+ * @since 1.0.0
+ * @uncommitted
+ */
+using drop_link_analytics_handler = std::function<void(couchbase::manager_error_context)>;
+} // namespace couchbase

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

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

@@ -590,6 +590,15 @@ enum class key_value {
     // KV Code: 0x24
     xattr_no_access = 130,
 
+    /**
+     * The document is already locked - generally returned when an unlocking operation is being performed.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    // KV Code: 0x0e
+    document_not_locked = 131,
+
     /**
      * Only deleted document could be revived
      *
@@ -597,9 +606,21 @@ enum class key_value {
      * @committed
      */
     // KV Code: 0xd6
-    cannot_revive_living_document = 131,
+    cannot_revive_living_document = 132,
 
+    /**
+     * The provided mutation token is outdated compared to the current state of the server.
+     *
+     * @since 1.0.0
+     * @uncommitted
+     */
+    // KV Code: 0xa8
     mutation_token_outdated = 133,
+
+    /**
+     * @internal
+     */
+    // KV Code: 0xa7
     range_scan_completed = 134,
 };
 

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

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

package/deps/couchbase-cxx-client/couchbase/fmt/key_value_error_map_attribute.hxx

@@ -88,6 +88,12 @@ struct fmt::formatter<couchbase::key_value_error_map_attribute> {
             case couchbase::key_value_error_map_attribute::rate_limit:
                 name = "rate-limit";
                 break;
+            case couchbase::key_value_error_map_attribute::system_constraint:
+                name = "system-constraint";
+                break;
+            case couchbase::key_value_error_map_attribute::no_retry:
+                name = "no-retry";
+                break;
         }
         return format_to(ctx.out(), "{}", name);
     }

package/deps/couchbase-cxx-client/couchbase/fmt/key_value_status_code.hxx

@@ -71,6 +71,9 @@ struct fmt::formatter<couchbase::key_value_status_code> {
             case key_value_status_code::locked:
                 name = "locked (0x09)";
                 break;
+            case key_value_status_code::not_locked:
+                name = "not_locked (0x0e)";
+                break;
             case key_value_status_code::auth_stale:
                 name = "auth_stale (0x1f)";
                 break;

package/deps/couchbase-cxx-client/couchbase/fmt/transaction_keyspace.hxx

@@ -0,0 +1,37 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2021-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/transactions/transaction_keyspace.hxx>
+
+#include <fmt/core.h>
+
+template<>
+struct fmt::formatter<couchbase::transactions::transaction_keyspace> {
+  public:
+    template<typename ParseContext>
+    constexpr auto parse(ParseContext& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(const couchbase::transactions::transaction_keyspace& k, FormatContext& ctx) const
+    {
+        return format_to(ctx.out(), "transaction_keyspace:{{ bucket: {}, scope: {}, collection: {} }}", k.bucket, k.scope, k.collection);
+    }
+};