couchbase 4.1.2 → 4.1.3

package/deps/couchbase-transactions-cxx/tests/transactions/simple_t.cpp

@@ -16,7 +16,7 @@
 
 #include "helpers.hxx"
 #include "transactions_env.h"
-#include <couchbase/errors.hxx>
+#include <couchbase/error_codes.hxx>
 #include <couchbase/transactions.hxx>
 #include <gtest/gtest.h>
 #include <spdlog/spdlog.h>
@@ -430,7 +430,7 @@ TEST(SimpleTransactions, CanRollbackInsert)
         FAIL() << "expect a client_error with document_not_found, got result instead";
 
     } catch (const client_error& e) {
-        ASSERT_EQ(e.res()->ec, couchbase::error::key_value_errc::document_not_found);
+        ASSERT_EQ(e.res()->ec, couchbase::errc::key_value::document_not_found);
     }
 }
 
@@ -652,7 +652,7 @@ TEST(SimpleQueryTransactions, CanRollbackKVInsert)
         auto doc = TransactionsTestEnvironment::get_doc(id);
         FAIL() << "expected doc to not exist";
     } catch (const client_error& e) {
-        ASSERT_EQ(e.res()->ec, couchbase::error::key_value_errc::document_not_found);
+        ASSERT_EQ(e.res()->ec, couchbase::errc::key_value::document_not_found);
     }
 }
 
@@ -736,7 +736,7 @@ TEST(SimpleQueryTransactions, CanKVRemove)
         auto doc = TransactionsTestEnvironment::get_doc(id);
         FAIL() << "expected doc to not exist";
     } catch (const client_error& e) {
-        ASSERT_EQ(e.res()->ec, couchbase::error::key_value_errc::document_not_found);
+        ASSERT_EQ(e.res()->ec, couchbase::errc::key_value::document_not_found);
     }
 }
 

package/deps/couchbase-transactions-cxx/tests/transactions/transaction_context_t.cpp

@@ -17,7 +17,6 @@
 #include "../../src/transactions/attempt_context_impl.hxx"
 #include "helpers.hxx"
 #include "transactions_env.h"
-#include <couchbase/errors.hxx>
 #include <couchbase/transactions.hxx>
 #include <couchbase/transactions/internal/transaction_context.hxx>
 #include <gtest/gtest.h>
@@ -319,7 +318,7 @@ TEST(SimpleTxnContext, CanDoQuery)
     ASSERT_TRUE(TransactionsTestEnvironment::upsert_doc(id, tx_content.dump()));
     auto query = fmt::format("SELECT * FROM `{}` USE KEYS '{}'", id.bucket(), id.key());
     transaction_query_options opts;
-    tx.query(query, opts, [&](std::exception_ptr err, std::optional<couchbase::operations::query_response> payload) {
+    tx.query(query, opts, [&](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> payload) {
         // this should result in a transaction_operation_failed exception since the doc isn't there
         EXPECT_TRUE(payload);
         EXPECT_FALSE(err);
@@ -344,16 +343,17 @@ TEST(SimpleTxnContext, CanSeeSomeQueryErrorsButNoTxnFailed)
     auto barrier = std::make_shared<std::promise<void>>();
     auto f = barrier->get_future();
     transaction_query_options opts;
-    tx.query("jkjkjl;kjlk;  jfjjffjfj", opts, [&](std::exception_ptr err, std::optional<couchbase::operations::query_response> payload) {
-        // this should result in a query_exception since the query isn't parseable.
-        EXPECT_TRUE(err);
-        EXPECT_FALSE(payload);
-        if (err) {
-            barrier->set_exception(err);
-        } else {
-            barrier->set_value();
-        }
-    });
+    tx.query(
+      "jkjkjl;kjlk;  jfjjffjfj", opts, [&](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> payload) {
+          // this should result in a query_exception since the query isn't parseable.
+          EXPECT_TRUE(err);
+          EXPECT_FALSE(payload);
+          if (err) {
+              barrier->set_exception(err);
+          } else {
+              barrier->set_value();
+          }
+      });
     try {
         f.get();
         FAIL() << "expected future to throw exception";
@@ -373,7 +373,7 @@ TEST(SimpleTxnContext, CanSetPerTxnConfig)
     auto txns = TransactionsTestEnvironment::get_transactions();
     auto id = TransactionsTestEnvironment::get_document_id();
     per_transaction_config per_txn_cfg;
-    per_txn_cfg.scan_consistency(couchbase::query_scan_consistency::not_bounded);
+    per_txn_cfg.scan_consistency(couchbase::core::query_scan_consistency::not_bounded);
     per_txn_cfg.expiration_time(std::chrono::milliseconds(1)).kv_timeout(std::chrono::milliseconds(2));
     per_txn_cfg.durability_level(couchbase::transactions::durability_level::NONE);
     transaction_context tx(txns, per_txn_cfg);

package/deps/couchbase-transactions-cxx/tests/transactions/transactions_env.h

@@ -20,9 +20,9 @@
 #include "couchbase/transactions/internal/utils.hxx"
 #include <couchbase/transactions.hxx>
 
-#include <couchbase/cluster.hxx>
-#include <couchbase/operations.hxx>
-#include <couchbase/operations/management/bucket.hxx>
+#include <core/cluster.hxx>
+#include <core/operations.hxx>
+#include <core/operations/management/bucket.hxx>
 #include <couchbase/support.hxx>
 
 #include <algorithm>
@@ -46,18 +46,18 @@ namespace tx = couchbase::transactions;
 struct conn {
     asio::io_context io;
     std::list<std::thread> io_threads;
-    std::shared_ptr<couchbase::cluster> c;
+    std::shared_ptr<couchbase::core::cluster> c;
 
     conn(const nlohmann::json& conf)
       : io({})
-      , c(couchbase::cluster::create(io))
+      , c(couchbase::core::cluster::create(io))
     {
         // for tests, really chatty logs may be useful.
-        if (!couchbase::logger::is_initialized()) {
-            couchbase::logger::create_console_logger();
+        if (!couchbase::core::logger::is_initialized()) {
+            couchbase::core::logger::create_console_logger();
         }
-        couchbase::logger::set_log_levels(couchbase::logger::level::trace);
-        couchbase::transactions::set_transactions_log_level(couchbase::logger::level::trace);
+        couchbase::core::logger::set_log_levels(couchbase::core::logger::level::trace);
+        couchbase::transactions::set_transactions_log_level(couchbase::core::logger::level::trace);
         size_t num_threads = conf.contains("io_threads") ? conf["io_threads"].get<uint32_t>() : 4;
         couchbase::transactions::txn_log->trace("using {} io completion threads", num_threads);
         for (size_t i = 0; i < num_threads; i++) {
@@ -83,17 +83,17 @@ struct conn {
 
     void connect(const nlohmann::json& conf)
     {
-        couchbase::cluster_credentials auth{};
+        couchbase::core::cluster_credentials auth{};
         {
             if (auto env_val = std::getenv("COUCHBASE_CXX_CLIENT_LOG_LEVEL")) {
-                couchbase::logger::set_log_levels(couchbase::logger::level_from_str(env_val));
+                couchbase::core::logger::set_log_levels(couchbase::core::logger::level_from_str(env_val));
             }
-            auto connstr = couchbase::utils::parse_connection_string(conf["connection_string"]);
+            auto connstr = couchbase::core::utils::parse_connection_string(conf["connection_string"]);
             auth.username = "Administrator";
             auth.password = "password";
             auto barrier = std::make_shared<std::promise<std::error_code>>();
             auto f = barrier->get_future();
-            c->open(couchbase::origin(auth, connstr), [barrier](std::error_code ec) { barrier->set_value(ec); });
+            c->open(couchbase::core::origin(auth, connstr), [barrier](std::error_code ec) { barrier->set_value(ec); });
             auto rc = f.get();
             if (rc) {
                 std::cout << "ERROR opening cluster: " << rc.message() << std::endl;
@@ -138,11 +138,12 @@ struct conn {
                 std::this_thread::sleep_for(std::chrono::milliseconds(sleep_time));
                 // TEMPORARILY only ping key_value.   See CCXCBC-94 for details -- ping not returning any service
                 // except KV.
-                std::set<couchbase::service_type> services{ couchbase::service_type::key_value };
-                auto barrier = std::make_shared<std::promise<couchbase::diag::ping_result>>();
+                std::set<couchbase::core::service_type> services{ couchbase::core::service_type::key_value };
+                auto barrier = std::make_shared<std::promise<couchbase::core::diag::ping_result>>();
                 auto f = barrier->get_future();
-                c->ping(
-                  "tests_startup", "default", services, [barrier](couchbase::diag::ping_result result) { barrier->set_value(result); });
+                c->ping("tests_startup", "default", services, [barrier](couchbase::core::diag::ping_result result) {
+                    barrier->set_value(result);
+                });
                 auto result = f.get();
                 ok = true;
                 for (auto& svc : services) {
@@ -150,8 +151,8 @@ struct conn {
                         if (result.services[svc].size() > 0) {
                             ok = ok && std::all_of(result.services[svc].begin(),
                                                    result.services[svc].end(),
-                                                   [&](const couchbase::diag::endpoint_ping_info& info) {
-                                                       return (!info.error && info.state == couchbase::diag::ping_state::ok);
+                                                   [&](const couchbase::core::diag::endpoint_ping_info& info) {
+                                                       return (!info.error && info.state == couchbase::core::diag::ping_state::ok);
                                                    });
                         } else {
                             ok = false;
@@ -199,14 +200,14 @@ class TransactionsTestEnvironment : public ::testing::Environment
         return conf;
     }
 
-    static bool upsert_doc(const couchbase::document_id& id, const std::string& content)
+    static bool upsert_doc(const couchbase::core::document_id& id, const std::string& content)
     {
         auto& c = get_cluster();
-        couchbase::operations::upsert_request req{ id };
-        req.value = couchbase::utils::to_binary(content);
+        couchbase::core::operations::upsert_request req{ id };
+        req.value = couchbase::core::utils::to_binary(content);
         auto barrier = std::make_shared<std::promise<std::error_code>>();
         auto f = barrier->get_future();
-        c.execute(req, [barrier](couchbase::operations::upsert_response resp) { barrier->set_value(resp.ctx.ec); });
+        c.execute(req, [barrier](couchbase::core::operations::upsert_response resp) { barrier->set_value(resp.ctx.ec()); });
         auto ec = f.get();
         if (ec) {
             spdlog::error("upsert doc failed with {}", ec.message());
@@ -214,14 +215,14 @@ class TransactionsTestEnvironment : public ::testing::Environment
         return !ec;
     }
 
-    static bool insert_doc(const couchbase::document_id& id, const std::string& content)
+    static bool insert_doc(const couchbase::core::document_id& id, const std::string& content)
     {
         auto& c = get_cluster();
-        couchbase::operations::insert_request req{ id };
-        req.value = couchbase::utils::to_binary(content);
+        couchbase::core::operations::insert_request req{ id };
+        req.value = couchbase::core::utils::to_binary(content);
         auto barrier = std::make_shared<std::promise<std::error_code>>();
         auto f = barrier->get_future();
-        c.execute(req, [barrier](couchbase::operations::insert_response resp) { barrier->set_value(resp.ctx.ec); });
+        c.execute(req, [barrier](couchbase::core::operations::insert_response resp) { barrier->set_value(resp.ctx.ec()); });
         auto ec = f.get();
         if (ec) {
             spdlog::error("insert doc failed with {}", ec.message());
@@ -229,29 +230,30 @@ class TransactionsTestEnvironment : public ::testing::Environment
         return !ec;
     }
 
-    static tx::result get_doc(const couchbase::document_id& id)
+    static tx::result get_doc(const couchbase::core::document_id& id)
     {
         auto& c = get_cluster();
-        couchbase::operations::get_request req{ id };
+        couchbase::core::operations::get_request req{ id };
         auto barrier = std::make_shared<std::promise<tx::result>>();
         auto f = barrier->get_future();
-        c.execute(req, [barrier](couchbase::operations::get_response resp) { barrier->set_value(tx::result::create_from_response(resp)); });
+        c.execute(
+          req, [barrier](couchbase::core::operations::get_response resp) { barrier->set_value(tx::result::create_from_response(resp)); });
         return tx::wrap_operation_future(f);
     }
 
-    static couchbase::cluster& get_cluster()
+    static couchbase::core::cluster& get_cluster()
     {
         static conn connection(get_conf());
         return *connection.c;
     }
 
-    static couchbase::document_id get_document_id(const std::string& id = {})
+    static couchbase::core::document_id get_document_id(const std::string& id = {})
     {
         std::string key = (id.empty() ? couchbase::transactions::uid_generator::next() : id);
         return { "default", "_default", "_default", key };
     }
 
-    static couchbase::transactions::transactions get_transactions(couchbase::cluster& c = get_cluster(),
+    static couchbase::transactions::transactions get_transactions(couchbase::core::cluster& c = get_cluster(),
                                                                   bool cleanup_client_attempts = false,
                                                                   bool cleanup_lost_txns = false)
     {

package/deps/couchbase-transactions-cxx/tests/transactions/waitable_op_list_t.cpp

@@ -15,10 +15,13 @@
  */
 
 #include "../../src/transactions/waitable_op_list.hxx"
-#include <future>
+
 #include <gtest/gtest.h>
+
+#include <future>
 #include <list>
 #include <random>
+#include <thread>
 
 static const std::string NODE{ "someipaddress" };
 
@@ -83,13 +86,13 @@ TEST(WaitableOpList, SetModeCallsAppropriateCallbacks)
           [&] {
               begin_work_calls++;
               op_list.set_query_node(NODE);
-                  op_list.decrement_in_flight();
-                  op_list.decrement_ops();
+              op_list.decrement_in_flight();
+              op_list.decrement_ops();
           },
           [&]() {
               do_work_calls++;
-                  op_list.decrement_in_flight();
-                  op_list.decrement_ops();
+              op_list.decrement_in_flight();
+              op_list.decrement_ops();
           });
     };
 

package/dist/analyticsexecutor.js

@@ -82,7 +82,7 @@ class AnalyticsExecutor {
                 const meta = new analyticstypes_1.AnalyticsMetaData({
                     requestId: metaData.request_id,
                     clientContextId: metaData.client_context_id,
-                    status: metaData.status,
+                    status: (0, bindingutilities_1.analyticsStatusFromCpp)(metaData.status),
                     signature: metaData.signature
                         ? JSON.parse(metaData.signature)
                         : undefined,

package/dist/authenticators.d.ts

@@ -13,6 +13,10 @@ export interface IPasswordAuthenticator {
      * The password to autehnticate with.
      */
     password: string;
+    /**
+     * The sasl mechanisms to authenticate with.
+     */
+    allowed_sasl_mechanisms?: string[];
 }
 /**
  * IPasswordAuthenticator specifies an authenticator which uses an SSL
@@ -44,6 +48,10 @@ export declare class PasswordAuthenticator implements IPasswordAuthenticator {
      * The password that will be used to authenticate with.
      */
     password: string;
+    /**
+     * The sasl mechanisms to authenticate with.
+     */
+    allowed_sasl_mechanisms?: string[];
     /**
      * Constructs this PasswordAuthenticator with the passed username and password.
      *
@@ -51,6 +59,16 @@ export declare class PasswordAuthenticator implements IPasswordAuthenticator {
      * @param password The password to initialize this authenticator with.
      */
     constructor(username: string, password: string);
+    /**
+     * Creates a LDAP compatible password authenticator which is INSECURE if not used with TLS.
+     * <p>
+     * Please note that this is INSECURE and will leak user credentials on the wire to eavesdroppers.
+     * This should only be enabled in trusted environments.
+     *
+     * @param username The username to initialize this authenticator with.
+     * @param password The password to initialize this authenticator with.
+     */
+    static ldapCompatible(username: string, password: string): PasswordAuthenticator;
 }
 /**
  * CertificateAuthenticator implements a simple ICertificateAuthenticator.

package/dist/authenticators.js

@@ -16,6 +16,21 @@ class PasswordAuthenticator {
     constructor(username, password) {
         this.username = username;
         this.password = password;
+        this.allowed_sasl_mechanisms = ['SCRAM-SHA512', 'SCRAM-SHA256', 'SCRAM-SHA1'];
+    }
+    /**
+     * Creates a LDAP compatible password authenticator which is INSECURE if not used with TLS.
+     * <p>
+     * Please note that this is INSECURE and will leak user credentials on the wire to eavesdroppers.
+     * This should only be enabled in trusted environments.
+     *
+     * @param username The username to initialize this authenticator with.
+     * @param password The password to initialize this authenticator with.
+     */
+    static ldapCompatible(username, password) {
+        const auth = new PasswordAuthenticator(username, password);
+        auth.allowed_sasl_mechanisms = ['PLAIN'];
+        return auth;
     }
 }
 exports.PasswordAuthenticator = PasswordAuthenticator;

package/dist/binarycollection.d.ts

@@ -21,6 +21,18 @@ export interface IncrementOptions {
      * Specifies the level of synchronous durability for this operation.
      */
     durabilityLevel?: DurabilityLevel;
+    /**
+     * Specifies the number of nodes this operation should be persisted to
+     * before it is considered successful.  Note that this option is mutually
+     * exclusive of {@link durabilityLevel}.
+     */
+    durabilityPersistTo?: number;
+    /**
+     * Specifies the number of nodes this operation should be replicated to
+     * before it is considered successful.  Note that this option is mutually
+     * exclusive of {@link durabilityLevel}.
+     */
+    durabilityReplicateTo?: number;
     /**
      * The timeout for this operation, represented in milliseconds.
      */
@@ -44,6 +56,18 @@ export interface DecrementOptions {
      * Specifies the level of synchronous durability for this operation.
      */
     durabilityLevel?: DurabilityLevel;
+    /**
+     * Specifies the number of nodes this operation should be persisted to
+     * before it is considered successful.  Note that this option is mutually
+     * exclusive of {@link durabilityLevel}.
+     */
+    durabilityPersistTo?: number;
+    /**
+     * Specifies the number of nodes this operation should be replicated to
+     * before it is considered successful.  Note that this option is mutually
+     * exclusive of {@link durabilityLevel}.
+     */
+    durabilityReplicateTo?: number;
     /**
      * The timeout for this operation, represented in milliseconds.
      */
@@ -57,6 +81,18 @@ export interface AppendOptions {
      * Specifies the level of synchronous durability for this operation.
      */
     durabilityLevel?: DurabilityLevel;
+    /**
+     * Specifies the number of nodes this operation should be persisted to
+     * before it is considered successful.  Note that this option is mutually
+     * exclusive of {@link durabilityLevel}.
+     */
+    durabilityPersistTo?: number;
+    /**
+     * Specifies the number of nodes this operation should be replicated to
+     * before it is considered successful.  Note that this option is mutually
+     * exclusive of {@link durabilityLevel}.
+     */
+    durabilityReplicateTo?: number;
     /**
      * The timeout for this operation, represented in milliseconds.
      */
@@ -70,6 +106,18 @@ export interface PrependOptions {
      * Specifies the level of synchronous durability for this operation.
      */
     durabilityLevel?: DurabilityLevel;
+    /**
+     * Specifies the number of nodes this operation should be persisted to
+     * before it is considered successful.  Note that this option is mutually
+     * exclusive of {@link durabilityLevel}.
+     */
+    durabilityPersistTo?: number;
+    /**
+     * Specifies the number of nodes this operation should be replicated to
+     * before it is considered successful.  Note that this option is mutually
+     * exclusive of {@link durabilityLevel}.
+     */
+    durabilityReplicateTo?: number;
     /**
      * The timeout for this operation, represented in milliseconds.
      */