couchbase 4.2.8 → 4.2.10

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

@@ -109,28 +109,4 @@ struct insert_options : public common_durability_options<insert_options> {
  * @uncommitted
  */
 using insert_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_insert_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::insert_options::built options,
-                          couchbase::insert_handler&& handler);
-#endif
-} // namespace impl
-} // namespace core
 } // namespace couchbase

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

@@ -120,5 +120,17 @@ enum class key_value_error_map_attribute {
      * The error is related to rate limitation for the client (version 2)
      */
     rate_limit,
+
+    /**
+     * The error is related to a system-defined hard limit for resource usage.
+     * Retrying the operation will most likely not succeed unless an action was
+     * taken on the server to resolve the issue (version 2)
+     */
+    system_constraint,
+
+    /**
+     * The client should not retry the operation.
+     */
+    no_retry,
 };
 } // namespace couchbase

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

@@ -34,6 +34,7 @@ enum class key_value_status_code : std::uint16_t {
     dcp_stream_not_found = 0x0a,
     opaque_no_match = 0x0b,
     locked = 0x09,
+    not_locked = 0x0e,
     auth_stale = 0x1f,
     auth_error = 0x20,
     auth_continue = 0x21,

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

@@ -92,28 +92,4 @@ struct lookup_in_options : public common_durability_options<lookup_in_options> {
  * @uncommitted
  */
 using lookup_in_handler = std::function<void(couchbase::subdocument_error_context, lookup_in_result)>;
-
-#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
-namespace core
-{
-class cluster;
-namespace impl
-{
-
-/**
- * @since 1.0.0
- * @internal
- */
-void
-initiate_lookup_in_operation(std::shared_ptr<couchbase::core::cluster> core,
-                             std::string bucket_name,
-                             std::string scope_name,
-                             std::string collection_name,
-                             std::string document_key,
-                             const std::vector<couchbase::core::impl::subdoc::command>& specs,
-                             couchbase::lookup_in_options::built options,
-                             couchbase::lookup_in_handler&& handler);
-#endif
-} // namespace impl
-} // namespace core
 } // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/management/analytics_dataset.hxx

@@ -0,0 +1,48 @@
+/* -*- 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 <string>
+
+namespace couchbase::management
+{
+/**
+ * Represents a dataset (collection) in the analytics service
+ */
+struct analytics_dataset {
+    /**
+     * The name of the dataset (collection)
+     */
+    std::string name;
+
+    /**
+     * The name of the dataverse (scope) the dataset is stored in
+     */
+    std::string dataverse_name;
+
+    /**
+     * The name of the analytics link that is associated with the dataset
+     */
+    std::string link_name;
+
+    /**
+     * The name of the bucket that the dataset includes
+     */
+    std::string bucket_name;
+};
+} // namespace couchbase::management

package/deps/couchbase-cxx-client/couchbase/management/analytics_index.hxx

@@ -0,0 +1,48 @@
+/* -*- 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 <string>
+
+namespace couchbase::management
+{
+/**
+ * Represents an index in the analytics service.
+ */
+struct analytics_index {
+    /**
+     * The name of the analytics index
+     */
+    std::string name;
+
+    /**
+     * The name of the dataset (collection) this index is part of
+     */
+    std::string dataset_name;
+
+    /**
+     * The name of the dataverse (scope) this index is part of
+     */
+    std::string dataverse_name;
+
+    /**
+     * Whether this index is a primary index
+     */
+    bool is_primary;
+};
+} // namespace couchbase::management

package/deps/couchbase-cxx-client/couchbase/management/analytics_link.hxx

@@ -0,0 +1,239 @@
+/* -*- 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 <optional>
+#include <string>
+
+namespace couchbase::management
+{
+
+enum analytics_link_type {
+    /**
+     * S3 external analytics link. Corresponds to a @ref s3_external_analytics_link
+     */
+    s3_external,
+
+    /**
+     * Azure external analytics link. Corresponds to a @ref azure_blob_external_analytics_link
+     */
+    azure_external,
+
+    /**
+     * A remote analytics link that uses a Couchbase data service that is not part of the same cluster as the Analytics service.
+     * Corresponds to a @ref couchbase_remote_analytics_link
+     */
+    couchbase_remote,
+};
+
+enum analytics_encryption_level {
+    /**
+     * Connect to the remote Couchbase cluster using an unsecured channel. Send the password in plaintext.
+     */
+    none,
+
+    /**
+     * Connect to the remote Couchbase cluster using an unsecured channel. Send the password securely using SASL.
+     */
+    half,
+
+    /**
+     * Connect to the remote Couchbase cluster using a channel secured by TLS. If a password is used, it is sent over the secure channel.
+     *
+     * Requires specifying the certificate to trust.
+     */
+    full
+};
+
+struct analytics_link {
+    std::string name;
+    std::string dataverse_name;
+
+    virtual ~analytics_link() = default;
+
+    /**
+     * Returns the type of this analytics link
+     *
+     * @return the link type
+     */
+    [[nodiscard]] virtual analytics_link_type link_type() const = 0;
+
+    analytics_link() = default;
+    analytics_link(std::string name, std::string dataverse_name);
+};
+
+struct couchbase_analytics_encryption_settings {
+    /**
+     * Specifies what level of encryption should be applied
+     */
+    analytics_encryption_level encryption_level{ analytics_encryption_level::none };
+
+    /**
+     * The certificate to use for encryption when the encryption level is set to 'full'.
+     */
+    std::optional<std::string> certificate{};
+
+    /**
+     * The certificate to use for authenticating when the encryption level is set to 'full'. Cannot be set if a username and password are
+     * provided
+     */
+    std::optional<std::string> client_certificate{};
+
+    /**
+     * The client key to use for authenticating when the encryption level is set to 'full'.  Cannot be set if a username and password are
+     * provided
+     */
+    std::optional<std::string> client_key{};
+};
+
+struct couchbase_remote_analytics_link : analytics_link {
+    std::string hostname;
+    couchbase_analytics_encryption_settings encryption{};
+    std::optional<std::string> username{};
+    std::optional<std::string> password{};
+
+    [[nodiscard]] analytics_link_type link_type() const override
+    {
+        return analytics_link_type::couchbase_remote;
+    }
+
+    /**
+     * Constructs an empty remote Couchbase analytics link.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    couchbase_remote_analytics_link() = default;
+
+    /**
+     * Constructs and initializes a remote Couchbase analytics link with the given parameters. A remote analytics link uses a Couchbase data
+     * service that is not part of the same cluster as the Analytics service.
+     *
+     * @param name the name of the link
+     * @param dataverse_name the dataverse that the link belongs to. Its format can be one part `dataversename` or two parts
+     * `bucket_name/scope_name`
+     * @param hostname the hostname of the target Couchbase cluster
+     * @param encryption the encryption settings for the link
+     * @param username the username to use for authentication with the remote cluster. Optional if client certificate authentication is
+     * being used
+     * @param password the password to use for authentication with the remote cluster. Optional if client-certificate authentication is
+     * being used
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    couchbase_remote_analytics_link(std::string name,
+                                    std::string dataverse_name,
+                                    std::string hostname,
+                                    couchbase_analytics_encryption_settings encryption = {},
+                                    std::optional<std::string> username = {},
+                                    std::optional<std::string> password = {});
+};
+
+struct s3_external_analytics_link : analytics_link {
+    std::string access_key_id;
+    std::string secret_access_key;
+    std::string region;
+    std::optional<std::string> session_token{};
+    std::optional<std::string> service_endpoint{};
+
+    [[nodiscard]] analytics_link_type link_type() const override
+    {
+        return analytics_link_type::s3_external;
+    }
+
+    /**
+     * Constructs an empty external S3 analytics link
+     *
+     * @committed
+     * @since 1.0.0
+     */
+    s3_external_analytics_link() = default;
+
+    /**
+     * Constructs and initializes an external S3 analytics link with the given parameters.
+     *
+     * @param name the name of the link
+     * @param dataverse_name the name of the dataverse the link belongs to
+     * @param access_key_id the AWS S3 access key
+     * @param secret_access_key the AWS S3 secret key
+     * @param region the AWS S3 region
+     * @param session_token the AWS S3 token if temporary credentials are provided
+     * @param service_endpoint the AWS S3 service endpoint
+     *
+     * @committed
+     * @since 1.0.0
+     */
+    s3_external_analytics_link(std::string name,
+                               std::string dataverse_name,
+                               std::string access_key_id,
+                               std::string secret_access_key,
+                               std::string region,
+                               std::optional<std::string> session_token = {},
+                               std::optional<std::string> service_endpoint = {});
+};
+
+struct azure_blob_external_analytics_link : analytics_link {
+    std::optional<std::string> connection_string{};
+    std::optional<std::string> account_name{};
+    std::optional<std::string> account_key{};
+    std::optional<std::string> shared_access_signature{};
+    std::optional<std::string> blob_endpoint{};
+    std::optional<std::string> endpoint_suffix{};
+
+    [[nodiscard]] analytics_link_type link_type() const override
+    {
+        return analytics_link_type::azure_external;
+    }
+
+    /**
+     * Constructs an empty external Azure blob analytics link.
+     *
+     * @committed
+     * @since 1.0.0
+     */
+    azure_blob_external_analytics_link() = default;
+
+    /**
+     * Constructs and initializes an external Azure blob analytics link.
+     *
+     * @param name the name of the link
+     * @param dataverse_name the name of the dataverse the link belongs to
+     * @param connection_string the connection string that can be used as an authentication method. It contains other authentication methods
+     * embedded inside the string. Only a single authentication method can be used (e.g.
+     * "AccountName=myAccountName;AccountKey=myAccountKey").
+     * @param account_name the Azure blob storage account name
+     * @param account_key the Azure blob storage account key
+     * @param shared_access_signature token that can be used for authentication
+     * @param blob_endpoint the Azure blob storage endpoint
+     * @param endpoint_suffix the Azure blob endpoint suffix
+     *
+     * @committed
+     * @since 1.0.0
+     */
+    azure_blob_external_analytics_link(std::string name,
+                                       std::string dataverse_name,
+                                       std::optional<std::string> connection_string = {},
+                                       std::optional<std::string> account_name = {},
+                                       std::optional<std::string> account_key = {},
+                                       std::optional<std::string> shared_access_signature = {},
+                                       std::optional<std::string> blob_endpoint = {},
+                                       std::optional<std::string> endpoint_suffix = {});
+};
+
+} // namespace couchbase::management

package/deps/couchbase-cxx-client/couchbase/management/collection_spec.hxx

@@ -22,7 +22,7 @@ namespace couchbase::management::bucket
 struct collection_spec {
     std::string name;
     std::string scope_name;
-    std::uint32_t max_expiry{};
+    std::int32_t max_expiry{};
     std::optional<bool> history{};
 };
 

package/deps/couchbase-cxx-client/couchbase/management/query_index.hxx

@@ -21,9 +21,9 @@
 #include <string>
 #include <vector>
 
-namespace couchbase::management::query
+namespace couchbase::management
 {
-struct index {
+struct query_index {
     bool is_primary{ false };
     std::string name;
     std::string state;
@@ -36,4 +36,4 @@ struct index {
     std::optional<std::string> collection_name{};
 };
 
-} // namespace couchbase::management::query
+} // namespace couchbase::management

package/deps/couchbase-cxx-client/couchbase/management/search_index.hxx

@@ -0,0 +1,40 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 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 <map>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace couchbase::management::search
+{
+struct index {
+
+    std::string name;
+    std::string type = "fulltext-index";
+    std::string source_name;
+    std::string source_type = "couchbase";
+
+    std::optional<std::string> uuid; // Must be empty on create, set on update
+    std::optional<std::string> params_json;
+    std::optional<std::string> source_uuid;
+    std::optional<std::string> source_params_json;
+    std::optional<std::string> plan_params_json;
+};
+} // namespace couchbase::management::search

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

@@ -17,7 +17,6 @@
 
 #pragma once
 
-#include "core/impl/internal_manager_error_context.hxx"
 #include <couchbase/error_context.hxx>
 
 #include <cstdint>

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

@@ -206,28 +206,4 @@ struct mutate_in_options : public common_durability_options<mutate_in_options> {
  * @uncommitted
  */
 using mutate_in_handler = std::function<void(couchbase::subdocument_error_context, mutate_in_result)>;
-
-#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
-namespace core
-{
-class cluster;
-namespace impl
-{
-
-/**
- * @since 1.0.0
- * @internal
- */
-void
-initiate_mutate_in_operation(std::shared_ptr<couchbase::core::cluster> core,
-                             std::string bucket_name,
-                             std::string scope_name,
-                             std::string collection_name,
-                             std::string document_key,
-                             const std::vector<couchbase::core::impl::subdoc::command>& specs,
-                             couchbase::mutate_in_options::built options,
-                             couchbase::mutate_in_handler&& handler);
-#endif
-} // namespace impl
-} // namespace core
 } // namespace couchbase

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

@@ -17,7 +17,7 @@
 
 #pragma once
 
-#include "ip_protocol.hxx"
+#include <couchbase/ip_protocol.hxx>
 
 #include <cstdint>
 #include <optional>

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

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

@@ -62,6 +62,25 @@ class phrase_query : public search_query
         }
     }
 
+    /**
+     * Create a new phrase query.
+     *
+     * The mandatory list of terms that must exactly match in the index. Note that the index can (and usually will) contain terms that are
+     * derived from the text in documents, as analyzers can apply process like stemming.
+     *
+     * @param terms non-empty vector of terms.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    explicit phrase_query(std::vector<std::string> terms)
+      : terms_{ std::move(terms) }
+    {
+        if (terms_.empty()) {
+            throw std::invalid_argument("terms must not be empty in phrase_query");
+        }
+    }
+
     /**
      * If a field is specified, only terms in that field will be matched.
      *