couchbase 3.4.3 → 3.4.5

data/ext/couchbase/couchbase/create_bucket_options.hxx

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

data/ext/couchbase/couchbase/create_collection_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 <functional>
+#include <memory>
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+struct create_collection_options : public common_options<create_collection_options> {
+  public:
+    struct built : public common_options<create_collection_options>::built {
+    };
+
+    [[nodiscard]] auto build() const -> built
+    {
+        return { build_common_options() };
+    }
+};
+
+struct create_collection_settings {
+    std::uint32_t max_expiry{ 0 };
+    std::optional<bool> history{};
+};
+
+using create_collection_handler = std::function<void(couchbase::manager_error_context)>;
+} // namespace couchbase

data/ext/couchbase/couchbase/create_primary_query_index_options.hxx

@@ -134,33 +134,4 @@ class create_primary_query_index_options : public common_options<create_primary_
  */
 
 using create_primary_query_index_handler = std::function<void(couchbase::manager_error_context)>;
-
-#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
-namespace core
-{
-class cluster;
-class query_context;
-namespace impl
-{
-
-/**
- * @since 1.0.0
- * @internal
- */
-void
-initiate_create_primary_query_index(std::shared_ptr<couchbase::core::cluster> core,
-                                    std::string bucket_name,
-                                    couchbase::create_primary_query_index_options::built options,
-                                    query_context query_ctx,
-                                    std::string collection_name,
-                                    create_primary_query_index_handler&& handler);
-void
-initiate_create_primary_query_index(std::shared_ptr<couchbase::core::cluster> core,
-                                    std::string bucket_name,
-                                    couchbase::create_primary_query_index_options::built options,
-                                    create_primary_query_index_handler&& handler);
-
-#endif
-} // namespace impl
-} // namespace core
 } // namespace couchbase

data/ext/couchbase/couchbase/create_query_index_options.hxx

@@ -136,37 +136,4 @@ class create_query_index_options : public common_options<create_query_index_opti
  */
 
 using create_query_index_handler = std::function<void(couchbase::manager_error_context)>;
-
-#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
-namespace core
-{
-class cluster;
-class query_context;
-namespace impl
-{
-
-/**
- * @since 1.0.0
- * @internal
- */
-void
-initiate_create_query_index(std::shared_ptr<couchbase::core::cluster> core,
-                            std::string bucket_name,
-                            std::string index_name,
-                            std::vector<std::string> fields,
-                            couchbase::create_query_index_options::built options,
-                            create_query_index_handler&& handler);
-void
-initiate_create_query_index(std::shared_ptr<couchbase::core::cluster> core,
-                            std::string bucket_name,
-                            std::string index_name,
-                            std::vector<std::string> fields,
-                            couchbase::create_query_index_options::built options,
-                            query_context query_ctx,
-                            std::string collection_name,
-                            create_query_index_handler&& handler);
-
-#endif
-} // namespace impl
-} // namespace core
 } // namespace couchbase

data/ext/couchbase/couchbase/create_scope_options.hxx

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

data/ext/couchbase/couchbase/drop_bucket_options.hxx

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

data/ext/couchbase/couchbase/drop_collection_options.hxx

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

data/ext/couchbase/couchbase/drop_primary_query_index_options.hxx

@@ -96,34 +96,4 @@ class drop_primary_query_index_options : public common_options<drop_primary_quer
  */
 
 using drop_primary_query_index_handler = std::function<void(couchbase::manager_error_context)>;
-
-#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
-namespace core
-{
-class cluster;
-class query_context;
-namespace impl
-{
-
-/**
- * @since 1.0.0
- * @internal
- */
-void
-initiate_drop_primary_query_index(std::shared_ptr<couchbase::core::cluster> core,
-                                  std::string bucket_name,
-                                  couchbase::drop_primary_query_index_options::built options,
-                                  query_context query_ctx,
-                                  std::string collection_name,
-                                  drop_primary_query_index_handler&& handler);
-
-void
-initiate_drop_primary_query_index(std::shared_ptr<couchbase::core::cluster> core,
-                                  std::string bucket_name,
-                                  couchbase::drop_primary_query_index_options::built options,
-                                  drop_primary_query_index_handler&& handler);
-
-#endif
-} // namespace impl
-} // namespace core
 } // namespace couchbase

data/ext/couchbase/couchbase/drop_query_index_options.hxx

@@ -82,35 +82,4 @@ class drop_query_index_options : public common_options<drop_query_index_options>
  */
 
 using drop_query_index_handler = std::function<void(couchbase::manager_error_context)>;
-
-#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
-namespace core
-{
-class cluster;
-class query_context;
-namespace impl
-{
-
-/**
- * @since 1.0.0
- * @internal
- */
-void
-initiate_drop_query_index(std::shared_ptr<couchbase::core::cluster> core,
-                          std::string bucket_name,
-                          std::string index_name,
-                          couchbase::drop_query_index_options::built options,
-                          query_context query_ctx,
-                          std::string collection_name,
-                          drop_query_index_handler&& handler);
-void
-initiate_drop_query_index(std::shared_ptr<couchbase::core::cluster> core,
-                          std::string bucket_name,
-                          std::string index_name,
-                          couchbase::drop_query_index_options::built options,
-                          drop_query_index_handler&& handler);
-
-#endif
-} // namespace impl
-} // namespace core
 } // namespace couchbase

data/ext/couchbase/couchbase/drop_scope_options.hxx

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

data/ext/couchbase/couchbase/error_codes.hxx

@@ -599,8 +599,7 @@ enum class key_value {
     // KV Code: 0xd6
     cannot_revive_living_document = 131,
 
-    range_scan_cancelled = 132,
-    range_scan_vb_uuid_not_equal = 133,
+    mutation_token_outdated = 133,
     range_scan_completed = 134,
 };
 

data/ext/couchbase/couchbase/error_context.hxx

@@ -57,12 +57,14 @@ class error_context
      * @since 1.0.0
      * @internal
      */
-    error_context(std::error_code ec,
+    error_context(std::string operation_id,
+                  std::error_code ec,
                   std::optional<std::string> last_dispatched_to,
                   std::optional<std::string> last_dispatched_from,
                   std::size_t retry_attempts,
                   std::set<retry_reason> retry_reasons)
-      : ec_{ ec }
+      : operation_id_{ std::move(operation_id) }
+      , ec_{ ec }
       , last_dispatched_to_{ std::move(last_dispatched_to) }
       , last_dispatched_from_{ std::move(last_dispatched_from) }
       , retry_attempts_{ retry_attempts }
@@ -70,6 +72,11 @@ class error_context
     {
     }
 
+    [[nodiscard]] virtual auto operation_id() const -> const std::string&
+    {
+        return operation_id_;
+    }
+
     /**
      * Returns status of the operation.
      *
@@ -165,6 +172,7 @@ class error_context
     }
 
   private:
+    std::string operation_id_{};
     std::error_code ec_{};
     std::optional<std::string> last_dispatched_to_{};
     std::optional<std::string> last_dispatched_from_{};

data/ext/couchbase/couchbase/flush_bucket_options.hxx

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

data/ext/couchbase/{core/topology/error_map_fmt.hxx → couchbase/fmt/key_value_error_map_attribute.hxx}

@@ -17,12 +17,12 @@
 
 #pragma once
 
-#include "error_map.hxx"
+#include <couchbase/key_value_error_map_attribute.hxx>
 
 #include <fmt/core.h>
 
 template<>
-struct fmt::formatter<couchbase::api::key_value_error_map_attribute> {
+struct fmt::formatter<couchbase::key_value_error_map_attribute> {
     template<typename ParseContext>
     constexpr auto parse(ParseContext& ctx)
     {
@@ -30,62 +30,62 @@ struct fmt::formatter<couchbase::api::key_value_error_map_attribute> {
     }
 
     template<typename FormatContext>
-    auto format(couchbase::api::key_value_error_map_attribute attr, FormatContext& ctx) const
+    auto format(couchbase::key_value_error_map_attribute attr, FormatContext& ctx) const
     {
         string_view name = "unknown";
         switch (attr) {
-            case couchbase::api::key_value_error_map_attribute::success:
+            case couchbase::key_value_error_map_attribute::success:
                 name = "success";
                 break;
-            case couchbase::api::key_value_error_map_attribute::item_only:
+            case couchbase::key_value_error_map_attribute::item_only:
                 name = "item-only";
                 break;
-            case couchbase::api::key_value_error_map_attribute::invalid_input:
+            case couchbase::key_value_error_map_attribute::invalid_input:
                 name = "invalid-input";
                 break;
-            case couchbase::api::key_value_error_map_attribute::fetch_config:
+            case couchbase::key_value_error_map_attribute::fetch_config:
                 name = "fetch-config";
                 break;
-            case couchbase::api::key_value_error_map_attribute::conn_state_invalidated:
+            case couchbase::key_value_error_map_attribute::conn_state_invalidated:
                 name = "conn-state-invalidated";
                 break;
-            case couchbase::api::key_value_error_map_attribute::auth:
+            case couchbase::key_value_error_map_attribute::auth:
                 name = "auth";
                 break;
-            case couchbase::api::key_value_error_map_attribute::special_handling:
+            case couchbase::key_value_error_map_attribute::special_handling:
                 name = "special-handling";
                 break;
-            case couchbase::api::key_value_error_map_attribute::support:
+            case couchbase::key_value_error_map_attribute::support:
                 name = "support";
                 break;
-            case couchbase::api::key_value_error_map_attribute::temp:
+            case couchbase::key_value_error_map_attribute::temp:
                 name = "temp";
                 break;
-            case couchbase::api::key_value_error_map_attribute::internal:
+            case couchbase::key_value_error_map_attribute::internal:
                 name = "internal";
                 break;
-            case couchbase::api::key_value_error_map_attribute::retry_now:
+            case couchbase::key_value_error_map_attribute::retry_now:
                 name = "retry-now";
                 break;
-            case couchbase::api::key_value_error_map_attribute::retry_later:
+            case couchbase::key_value_error_map_attribute::retry_later:
                 name = "retry-later";
                 break;
-            case couchbase::api::key_value_error_map_attribute::subdoc:
+            case couchbase::key_value_error_map_attribute::subdoc:
                 name = "subdoc";
                 break;
-            case couchbase::api::key_value_error_map_attribute::dcp:
+            case couchbase::key_value_error_map_attribute::dcp:
                 name = "dcp";
                 break;
-            case couchbase::api::key_value_error_map_attribute::auto_retry:
+            case couchbase::key_value_error_map_attribute::auto_retry:
                 name = "auto-retry";
                 break;
-            case couchbase::api::key_value_error_map_attribute::item_locked:
+            case couchbase::key_value_error_map_attribute::item_locked:
                 name = "item-locked";
                 break;
-            case couchbase::api::key_value_error_map_attribute::item_deleted:
+            case couchbase::key_value_error_map_attribute::item_deleted:
                 name = "item-deleted";
                 break;
-            case couchbase::api::key_value_error_map_attribute::rate_limit:
+            case couchbase::key_value_error_map_attribute::rate_limit:
                 name = "rate-limit";
                 break;
         }

data/ext/couchbase/couchbase/get_all_buckets_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/management/bucket_settings.hxx>
+
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+struct get_all_buckets_options : public common_options<get_all_buckets_options> {
+  public:
+    struct built : public common_options<get_all_buckets_options>::built {
+    };
+
+    [[nodiscard]] auto build() const -> built
+    {
+        return { build_common_options() };
+    }
+
+  private:
+};
+
+using get_all_buckets_handler =
+  std::function<void(couchbase::manager_error_context, std::vector<couchbase::management::cluster::bucket_settings>)>;
+} // namespace couchbase

data/ext/couchbase/couchbase/get_all_query_indexes_options.hxx

@@ -68,34 +68,4 @@ class get_all_query_indexes_options : public common_options<get_all_query_indexe
 
 using get_all_query_indexes_handler =
   std::function<void(couchbase::manager_error_context, std::vector<couchbase::management::query::index>)>;
-
-#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
-namespace core
-{
-class cluster;
-class query_context;
-namespace impl
-{
-
-/**
- * @since 1.0.0
- * @internal
- */
-void
-initiate_get_all_query_indexes(std::shared_ptr<couchbase::core::cluster> core,
-                               std::string bucket_name,
-                               couchbase::get_all_query_indexes_options::built options,
-                               get_all_query_indexes_handler&& handler);
-
-void
-initiate_get_all_query_indexes(std::shared_ptr<couchbase::core::cluster> core,
-                               std::string bucket_name,
-                               couchbase::get_all_query_indexes_options::built options,
-                               query_context query_ctx,
-                               std::string collection_name,
-                               get_all_query_indexes_handler&& handler);
-
-#endif
-} // namespace impl
-} // namespace core
 } // namespace couchbase