couchbase 4.1.2 → 4.1.3

package/deps/couchbase-cxx-client/docs/mainpage.hxx

@@ -0,0 +1,35 @@
+/* -*- 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
+
+/**
+ * @mainpage
+ *
+ * @note You may read about related Couchbase software at https://docs.couchbase.com/
+ *
+ * This is API reference for C++ library for connecting to a Couchbase Server and performing data operations and queries.
+ *
+ * We use interface stability taxonomy to categorize publicly visible API. See the following pages for more details:
+ *
+ * * @ref stability_committed "Committed" interfaces considered as generally available (GA) API and should be preferred in production
+ * applications.
+ * * @ref stability_uncommitted "Uncommitted" interfaces might be changed in the future, and eventually promoted to committed.
+ * * @ref stability_volatile "Volatile" interfaces should not be used in production application, and the library does not give any
+ * guarantees on them.
+ * * @ref stability_internal "Internal" interfaces like volatile, but they might be used by other project maintained by Couchbase.
+ */

package/deps/couchbase-cxx-client/docs/stability.hxx

@@ -0,0 +1,68 @@
+/* -*- 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
+
+/**
+ * @page stability_committed Committed Interfaces
+ * @brief List of the committed interfaces.
+ *
+ * A committed interface is the highest grade of stability, and is the preferred attribute level for consumers of the library.
+ *
+ * Couchbase tries at best effort to preserve committed interfaces between major versions, and changes to committed interfaces within a
+ * major version is highly exceptional. Such exceptions may include situations where the interface may lead to data corruption, security
+ * holes etc. Explicitly note that backwards-compatible extensions are always allowed since they don't break old code.
+ *
+ * @note This is the default interface level for an API, unless the API is specifically marked otherwise.
+ */
+
+/**
+ * @page stability_volatile Volatile Interfaces
+ * @brief List of the volatile interfaces.
+ *
+ * Types/Methods/Interfaces marked as volatile can change any time and for any reason.
+ *
+ * They may be volatile for reasons including:
+ *
+ * * Depends on specific implementation detail within the library which may change in the response.
+ * * Depends on specific implementation detail within the server which may change in the response.
+ * * Has been introduced as part of a trial phase for the specific feature.
+ */
+
+/**
+ * @page stability_uncommitted Uncommitted Interfaces
+ * @brief List of the uncommitted interfaces.
+ *
+ * No commitment is made about the interface.
+ *
+ * It may be changed in incompatible ways and dropped from one release to another. The difference between an uncommitted interface and a
+ * @ref stability_volatile "volatile" interface is its maturity and likelihood of being changed. Uncommitted interfaces may mature into @ref
+ * stability_committed "committed" interfaces.
+ */
+
+/**
+ * @page stability_internal Internal Interfaces
+ * @brief List of the internal interfaces.
+ *
+ * This is internal API and may not be relied on at all.
+ *
+ * Similar to @ref stability_volatile "volatile" interfaces, no promises are made about these kinds of interfaces and they change or may
+ * vanish at every point in time. But in addition to that, those interfaces are explicitly marked as being designed for internal use and not
+ * for external consumption in the first place.
+ *
+ * @warning Use at your own risk
+ */

package/deps/couchbase-cxx-client/test/CMakeLists.txt

@@ -11,11 +11,17 @@ integration_test(arithmetic)
 integration_test(collections)
 integration_test(subdoc)
 integration_test(analytics)
+integration_test(read_replica)
+integration_test(tracer)
+integration_test(meter)
+integration_test(transcoders)
 
 unit_test(connection_string)
 unit_test(utils)
+unit_test(json_transcoder)
 unit_test(json_streaming_lexer)
 unit_test(jsonsl)
+unit_test(config_profiles)
 target_link_libraries(test_unit_jsonsl jsonsl)
 
 integration_benchmark(get)

package/deps/couchbase-cxx-client/test/benchmark_integration_get.cxx

@@ -23,23 +23,22 @@ TEST_CASE("benchmark: get a document", "[benchmark]")
 
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
-    couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
 
     {
         const tao::json::value value = {
             { "a", 1.0 },
             { "b", 2.0 },
         };
-        couchbase::operations::upsert_request req{ id, couchbase::utils::json::generate_binary(value) };
+        couchbase::core::operations::upsert_request req{ id, couchbase::core::utils::json::generate_binary(value) };
         auto resp = test::utils::execute(integration.cluster, req);
-        INFO(resp.ctx.ec.message())
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec());
     }
 
     BENCHMARK("get")
     {
-        couchbase::operations::get_request req{ id };
+        couchbase::core::operations::get_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec());
     };
 }

package/deps/couchbase-cxx-client/test/profile.hxx

@@ -0,0 +1,62 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 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 <cinttypes>
+#include <string>
+
+#include <tao/json/forward.hpp>
+
+struct profile {
+    std::string username{};
+    std::string full_name{};
+    std::uint32_t birth_year{};
+
+    bool operator==(const profile& other) const
+    {
+        return username == other.username && full_name == other.full_name && birth_year == other.birth_year;
+    }
+};
+
+template<>
+struct tao::json::traits<profile> {
+    template<template<typename...> class Traits>
+    static void assign(tao::json::basic_value<Traits>& v, const profile& p)
+    {
+        v = {
+            { "username", p.username },
+            { "full_name", p.full_name },
+            { "birth_year", p.birth_year },
+        };
+    }
+
+    template<template<typename...> class Traits>
+    static profile as(const tao::json::basic_value<Traits>& v)
+    {
+        profile result;
+        const auto& object = v.get_object();
+        result.username = object.at("username").template as<std::string>();
+        result.full_name = object.at("full_name").template as<std::string>();
+        if (object.count("birth_year") != 0) {
+            // expect incomplete JSON here, as we might use projections to fetch reduced document
+            // as an alternative we might use std::optional<> here
+            result.birth_year = object.at("birth_year").template as<std::uint32_t>();
+        }
+        return result;
+    }
+};

package/deps/couchbase-cxx-client/test/test_helper.hxx

@@ -19,7 +19,10 @@
 
 #define CATCH_CONFIG_MAIN
 
+#include "utils/binary.hxx"
 #include "utils/test_context.hxx"
 #include "utils/uniq_id.hxx"
 
 #include <catch2/catch.hpp>
+
+#define REQUIRE_SUCCESS(ec) INFO((ec).message()) REQUIRE_FALSE(ec)

package/deps/couchbase-cxx-client/test/test_helper_integration.hxx

@@ -21,4 +21,4 @@
 #include "utils/integration_test_guard.hxx"
 #include "utils/wait_until.hxx"
 
-#include <couchbase/utils/json.hxx>
+#include "core/utils/json.hxx"

package/deps/couchbase-cxx-client/test/test_integration_analytics.cxx

@@ -15,10 +15,10 @@
  *   limitations under the License.
  */
 
+#include "core/operations/management/analytics.hxx"
+#include "core/operations/management/collection_create.hxx"
+#include "core/operations/management/scope_create.hxx"
 #include "test_helper_integration.hxx"
-#include <couchbase/operations/management/analytics.hxx>
-#include <couchbase/operations/management/collection_create.hxx>
-#include <couchbase/operations/management/scope_create.hxx>
 
 TEST_CASE("integration: analytics query")
 {
@@ -33,123 +33,124 @@ TEST_CASE("integration: analytics query")
     auto dataset_name = test::utils::uniq_id("dataset");
 
     {
-        couchbase::operations::management::analytics_dataset_create_request req{};
+        couchbase::core::operations::management::analytics_dataset_create_request req{};
         req.dataset_name = dataset_name;
         req.bucket_name = integration.ctx.bucket;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
     }
 
     {
-        couchbase::operations::management::analytics_link_connect_request req{};
+        couchbase::core::operations::management::analytics_link_connect_request req{};
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
     }
 
     auto key = test::utils::uniq_id("key");
     auto test_value = test::utils::uniq_id("value");
-    auto value = couchbase::utils::json::generate({ { "testkey", test_value } });
+    auto value = couchbase::core::utils::json::generate({ { "testkey", test_value } });
     {
-        auto id = couchbase::document_id(integration.ctx.bucket, "_default", "_default", key);
-        couchbase::operations::upsert_request req{ id, couchbase::utils::to_binary(value) };
+        auto id = couchbase::core::document_id(integration.ctx.bucket, "_default", "_default", key);
+        couchbase::core::operations::upsert_request req{ id, couchbase::core::utils::to_binary(value) };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec());
     }
 
     SECTION("simple query")
     {
-        couchbase::operations::analytics_response resp{};
+        couchbase::core::operations::analytics_response resp{};
         REQUIRE(test::utils::wait_until([&]() {
-            couchbase::operations::analytics_request req{};
+            couchbase::core::operations::analytics_request req{};
             req.statement = fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = "{}")", dataset_name, test_value);
             resp = test::utils::execute(integration.cluster, req);
             return resp.rows.size() == 1;
         }));
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         REQUIRE(resp.rows[0] == value);
         REQUIRE_FALSE(resp.meta.request_id.empty());
         REQUIRE_FALSE(resp.meta.client_context_id.empty());
-        REQUIRE_FALSE(resp.meta.status.empty());
+        REQUIRE(resp.meta.status == couchbase::core::operations::analytics_response::analytics_status::success);
     }
 
     SECTION("positional params")
     {
-        couchbase::operations::analytics_response resp{};
+        couchbase::core::operations::analytics_response resp{};
         REQUIRE(test::utils::wait_until([&]() {
-            couchbase::operations::analytics_request req{};
+            couchbase::core::operations::analytics_request req{};
             req.statement = fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = ?)", dataset_name);
-            req.positional_parameters.emplace_back(couchbase::json_string(couchbase::utils::json::generate(test_value)));
+            req.positional_parameters.emplace_back(couchbase::core::json_string(couchbase::core::utils::json::generate(test_value)));
             resp = test::utils::execute(integration.cluster, req);
             return resp.rows.size() == 1;
         }));
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         REQUIRE(resp.rows[0] == value);
     }
 
     SECTION("named params")
     {
-        couchbase::operations::analytics_response resp{};
+        couchbase::core::operations::analytics_response resp{};
         REQUIRE(test::utils::wait_until([&]() {
-            couchbase::operations::analytics_request req{};
+            couchbase::core::operations::analytics_request req{};
             req.statement = fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = $testkey)", dataset_name);
-            req.named_parameters["testkey"] = couchbase::json_string(couchbase::utils::json::generate(test_value));
+            req.named_parameters["testkey"] = couchbase::core::json_string(couchbase::core::utils::json::generate(test_value));
             resp = test::utils::execute(integration.cluster, req);
             return resp.rows.size() == 1;
         }));
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         REQUIRE(resp.rows[0] == value);
     }
 
     SECTION("named params preformatted")
     {
-        couchbase::operations::analytics_response resp{};
+        couchbase::core::operations::analytics_response resp{};
         REQUIRE(test::utils::wait_until([&]() {
-            couchbase::operations::analytics_request req{};
+            couchbase::core::operations::analytics_request req{};
             req.statement = fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = $testkey)", dataset_name);
-            req.named_parameters["$testkey"] = couchbase::json_string(couchbase::utils::json::generate(test_value));
+            req.named_parameters["$testkey"] = couchbase::core::json_string(couchbase::core::utils::json::generate(test_value));
             resp = test::utils::execute(integration.cluster, req);
             return resp.rows.size() == 1;
         }));
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         REQUIRE(resp.rows[0] == value);
     }
 
     SECTION("raw")
     {
-        couchbase::operations::analytics_response resp{};
+        couchbase::core::operations::analytics_response resp{};
         REQUIRE(test::utils::wait_until([&]() {
-            couchbase::operations::analytics_request req{};
+            couchbase::core::operations::analytics_request req{};
             req.statement = fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = $testkey)", dataset_name);
-            req.raw["$testkey"] = couchbase::json_string(couchbase::utils::json::generate(test_value));
+            req.raw["$testkey"] = couchbase::core::json_string(couchbase::core::utils::json::generate(test_value));
             resp = test::utils::execute(integration.cluster, req);
             return resp.rows.size() == 1;
         }));
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         REQUIRE(resp.rows[0] == value);
     }
 
     SECTION("consistency")
     {
-        couchbase::operations::analytics_request req{};
+        couchbase::core::operations::analytics_request req{};
         req.statement = fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = "{}")", dataset_name, test_value);
-        req.scan_consistency = couchbase::analytics_scan_consistency::request_plus;
+        req.scan_consistency = couchbase::core::analytics_scan_consistency::request_plus;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         REQUIRE(resp.rows.size() == 1);
         REQUIRE(resp.rows[0] == value);
     }
 
     SECTION("readonly")
     {
-        couchbase::operations::analytics_request req{};
+        couchbase::core::operations::analytics_request req{};
         req.statement = fmt::format("DROP DATASET Default.`{}`", dataset_name);
         req.readonly = true;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::common_errc::internal_server_failure);
+        REQUIRE(resp.ctx.ec == couchbase::errc::common::internal_server_failure);
+        REQUIRE(resp.meta.status == couchbase::core::operations::analytics_response::analytics_status::fatal);
     }
 
     {
-        couchbase::operations::management::analytics_dataset_drop_request req{};
+        couchbase::core::operations::management::analytics_dataset_drop_request req{};
         req.dataset_name = dataset_name;
         test::utils::execute(integration.cluster, req);
     }
@@ -169,66 +170,66 @@ TEST_CASE("integration: analytics scope query")
     auto collection_name = test::utils::uniq_id("collection");
 
     {
-        couchbase::operations::management::scope_create_request req{ integration.ctx.bucket, scope_name };
+        couchbase::core::operations::management::scope_create_request req{ integration.ctx.bucket, scope_name };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         auto created = test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, resp.uid);
         REQUIRE(created);
     }
 
     {
-        couchbase::operations::management::collection_create_request req{ integration.ctx.bucket, scope_name, collection_name };
+        couchbase::core::operations::management::collection_create_request req{ integration.ctx.bucket, scope_name, collection_name };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         auto created = test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, resp.uid);
         REQUIRE(created);
     }
 
     {
-        couchbase::operations::analytics_request req{};
+        couchbase::core::operations::analytics_request req{};
         req.statement =
           fmt::format("ALTER COLLECTION `{}`.`{}`.`{}` ENABLE ANALYTICS", integration.ctx.bucket, scope_name, collection_name);
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
     }
 
     auto key = test::utils::uniq_id("key");
     auto test_value = test::utils::uniq_id("value");
-    auto value = couchbase::utils::json::generate({ { "testkey", test_value } });
+    auto value = couchbase::core::utils::json::generate({ { "testkey", test_value } });
     {
-        auto id = couchbase::document_id(integration.ctx.bucket, scope_name, collection_name, key);
-        couchbase::operations::upsert_request req{ id, couchbase::utils::to_binary(value) };
+        auto id = couchbase::core::document_id(integration.ctx.bucket, scope_name, collection_name, key);
+        couchbase::core::operations::upsert_request req{ id, couchbase::core::utils::to_binary(value) };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec());
     }
 
-    couchbase::operations::analytics_response resp{};
+    couchbase::core::operations::analytics_response resp{};
     REQUIRE(test::utils::wait_until([&]() {
-        couchbase::operations::analytics_request req{};
+        couchbase::core::operations::analytics_request req{};
         req.statement = fmt::format(R"(SELECT testkey FROM `{}` WHERE testkey = "{}")", collection_name, test_value);
         req.bucket_name = integration.ctx.bucket;
         req.scope_name = scope_name;
         resp = test::utils::execute(integration.cluster, req);
         return resp.rows.size() == 1;
     }));
-    REQUIRE_FALSE(resp.ctx.ec);
+    REQUIRE_SUCCESS(resp.ctx.ec);
     REQUIRE(resp.rows[0] == value);
 
     {
-        couchbase::operations::management::scope_drop_request req{ integration.ctx.bucket, scope_name };
+        couchbase::core::operations::management::scope_drop_request req{ integration.ctx.bucket, scope_name };
         test::utils::execute(integration.cluster, req);
     }
 }
 
-couchbase::http_context
+couchbase::core::http_context
 make_http_context()
 {
-    couchbase::topology::configuration config{};
-    couchbase::query_cache query_cache{};
-    couchbase::cluster_options cluster_options{};
+    couchbase::core::topology::configuration config{};
+    couchbase::core::query_cache query_cache{};
+    couchbase::core::cluster_options cluster_options{};
     std::string hostname{};
     std::uint16_t port{};
-    couchbase::http_context ctx{ config, cluster_options, query_cache, hostname, port };
+    couchbase::core::http_context ctx{ config, cluster_options, query_cache, hostname, port };
     return ctx;
 }
 
@@ -236,12 +237,12 @@ TEST_CASE("unit: analytics query")
 {
     SECTION("priority true")
     {
-        couchbase::io::http_request http_req;
+        couchbase::core::io::http_request http_req;
         auto ctx = make_http_context();
-        couchbase::operations::analytics_request req{};
+        couchbase::core::operations::analytics_request req{};
         req.priority = true;
         auto ec = req.encode_to(http_req, ctx);
-        REQUIRE_FALSE(ec);
+        REQUIRE_SUCCESS(ec);
         auto priority_header = http_req.headers.find("analytics-priority");
         REQUIRE(priority_header != http_req.headers.end());
         REQUIRE(priority_header->second == "-1");
@@ -249,12 +250,12 @@ TEST_CASE("unit: analytics query")
 
     SECTION("priority false")
     {
-        couchbase::io::http_request http_req;
+        couchbase::core::io::http_request http_req;
         auto ctx = make_http_context();
-        couchbase::operations::analytics_request req{};
+        couchbase::core::operations::analytics_request req{};
         req.priority = false;
         auto ec = req.encode_to(http_req, ctx);
-        REQUIRE_FALSE(ec);
+        REQUIRE_SUCCESS(ec);
         REQUIRE(http_req.headers.find("analytics-priority") == http_req.headers.end());
     }
-}
+}