couchbase 4.2.8 → 4.2.10

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/endpoint_diagnostics.hxx

@@ -0,0 +1,206 @@
+/* -*- 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/service_type.hxx>
+
+#include <chrono>
+#include <optional>
+#include <string>
+#include <utility>
+
+namespace couchbase
+{
+enum class endpoint_state {
+    /**
+     * The endpoint is connected and ready.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    connected,
+
+    /**
+     * The endpoint is disconnected but trying to connect right now.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    connecting,
+
+    /**
+     * The endpoint is disconnected (not reachable) and not trying to connect.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    disconnected,
+
+    /**
+     * The endpoint is currently disconnecting.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    disconnecting,
+};
+
+class endpoint_diagnostics
+{
+  public:
+    endpoint_diagnostics() = default;
+
+    /**
+     * @since 1.0.0
+     * @internal
+     */
+    endpoint_diagnostics(service_type type,
+                         std::string id,
+                         std::optional<std::chrono::microseconds> last_activity,
+                         std::string local,
+                         std::string remote,
+                         std::optional<std::string> endpoint_namespace,
+                         endpoint_state state,
+                         std::optional<std::string> details)
+      : type_{ type }
+      , id_{ std::move(id) }
+      , last_activity_{ last_activity }
+      , local_{ std::move(local) }
+      , remote_{ std::move(remote) }
+      , namespace_{ std::move(endpoint_namespace) }
+      , state_{ state }
+      , details_{ std::move(details) }
+    {
+    }
+
+    /**
+     * Returns the service type for this endpoint.
+     *
+     * @return the service type.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto type() const -> service_type
+    {
+        return type_;
+    }
+
+    /**
+     *
+     * Returns the ID for this endpoint.
+     *
+     * @return the endpoint ID.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto id() const -> std::string
+    {
+        return id_;
+    }
+
+    /**
+     * Returns the time since the last activity, if there has been one.
+     *
+     * @return the duration since the last activity.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto last_activity() const -> std::optional<std::chrono::microseconds>
+    {
+        return last_activity_;
+    }
+
+    /**
+     * Returns the local socket address for this endpoint.
+     *
+     * @return the local socket address.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto local() const -> std::string
+    {
+        return local_;
+    }
+
+    /**
+     * Returns the remote socket address for this endpoint.
+     *
+     * @return the remote socket address.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto remote() const -> std::string
+    {
+        return remote_;
+    }
+
+    /**
+     * Returns the namespace of this endpoint (likely the bucket name if present).
+     *
+     * @return the namespace.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto endpoint_namespace() const -> std::optional<std::string>
+    {
+        return namespace_;
+    }
+
+    /**
+     * Returns the current state of the endpoint.
+     *
+     * @return the endpoint state.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto state() const -> endpoint_state
+    {
+        return state_;
+    }
+
+    /**
+     * Returns any additional details about the endpoint, if available.
+     *
+     * @return endpoint details.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto details() const -> std::optional<std::string>
+    {
+        return details_;
+    }
+
+  private:
+    service_type type_{};
+    std::string id_{};
+    std::optional<std::chrono::microseconds> last_activity_{};
+    std::string local_{};
+    std::string remote_{};
+    std::optional<std::string> namespace_{};
+    endpoint_state state_{};
+    std::optional<std::string> details_{};
+};
+} // namespace couchbase

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

@@ -0,0 +1,205 @@
+/* -*- 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 <chrono>
+#include <cstdint>
+#include <map>
+#include <optional>
+#include <string>
+
+#include <couchbase/codec/tao_json_serializer.hxx>
+#include <couchbase/endpoint_ping_report.hxx>
+#include <couchbase/service_type.hxx>
+
+namespace couchbase
+{
+enum class ping_state {
+    /**
+     * Indicates that the ping operation was successful.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    ok,
+
+    /**
+     * Indicates that the ping operation timed out.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    timeout,
+
+    /**
+     * Indicates that the ping operation failed.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    error,
+};
+
+class endpoint_ping_report
+{
+  public:
+    /**
+     * @since 1.0.0
+     * @internal
+     */
+    endpoint_ping_report() = default;
+
+    /**
+     * @since 1.0.0
+     * @internal
+     */
+    endpoint_ping_report(service_type type,
+                         std::string id,
+                         std::string local,
+                         std::string remote,
+                         ping_state state,
+                         std::optional<std::string> error,
+                         std::optional<std::string> endpoint_namespace,
+                         std::chrono::microseconds latency)
+      : type_{ type }
+      , id_{ std::move(id) }
+      , local_{ std::move(local) }
+      , remote_{ std::move(remote) }
+      , state_{ state }
+      , error_{ std::move(error) }
+      , namespace_{ std::move(endpoint_namespace) }
+      , latency_{ latency }
+    {
+    }
+
+    /**
+     * Returns the service type for this endpoint.
+     *
+     * @return the service type.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto type() const -> service_type
+    {
+        return type_;
+    }
+
+    /**
+     * Returns the ID for this endpoint.
+     *
+     * @return the endpoint ID.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto id() const -> std::string
+    {
+        return id_;
+    }
+
+    /**
+     * Returns the local socket address for this endpoint.
+     *
+     * @return the local socket address.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto local() const -> std::string
+    {
+        return local_;
+    }
+
+    /**
+     * Returns the remote socket address for this endpoint.
+     *
+     * @return the remote socket address.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto remote() const -> std::string
+    {
+        return remote_;
+    }
+
+    /**
+     * Returns the state of this ping when assembling the report.
+     *
+     * @return the ping state.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto state() const -> ping_state
+    {
+        return state_;
+    }
+
+    /**
+     * Returns the reason this ping did not succeed, if applicable.
+     *
+     * @return error description.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto error() const -> std::optional<std::string>
+    {
+        return error_;
+    }
+
+    /**
+     * Returns the namespace of this endpoint (likely the bucket name if present).
+     *
+     * @return the namespace.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto endpoint_namespace() const -> std::optional<std::string>
+    {
+        return namespace_;
+    }
+
+    /**
+     * Returns the latency of this ping.
+     *
+     * @return the latency in microseconds.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto latency() const -> std::chrono::microseconds
+    {
+        return latency_;
+    }
+
+  private:
+    service_type type_;
+    std::string id_;
+    std::string local_;
+    std::string remote_;
+    ping_state state_;
+    std::optional<std::string> error_{};
+    std::optional<std::string> namespace_{};
+    std::chrono::microseconds latency_;
+};
+
+} // 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);
+    }
+};

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