couchbase 4.2.2 → 4.2.3

package/deps/couchbase-cxx-client/tools/query.cxx

@@ -34,13 +34,13 @@ namespace cbc
 {
 namespace
 {
-static auto
+auto
 usage() -> std::string
 {
     static const std::string default_bucket_name{ "default" };
 
     static const std::string usage_string = fmt::format(
-      R"(Display version information.
+      R"(Perform N1QL query.
 
 Usage:
   cbc query [options] <statement>...
@@ -67,7 +67,7 @@ Options:
   --pipeline-batch=INTEGER       Number of items execution operators can batch for fetch from the Key/Value service.
   --pipeline-cap=INTEGER         Maximum number of items each execution operator can buffer between various operators.
   --raw=NAME=VALUE               Set any query option for the query. Read the documentation: https://docs.couchbase.com/server/current/n1ql/n1ql-rest-api.
-  --json-lines                   Use JSON Lines format (https://jsonlines.org/) to print results.
+  --json-lines                   Use JSON Lines format (https://jsonlines.org) to print results.
 
 {logger_options}{cluster_options}
 
@@ -97,13 +97,13 @@ struct scope_with_bucket {
 };
 
 template<typename QueryEndpoint>
-static auto
+auto
 do_query(QueryEndpoint& endpoint, std::string statement, const couchbase::query_options& options)
 {
     return endpoint.query(std::move(statement), options);
 }
 
-static void
+void
 print_result_json_line(const std::optional<scope_with_bucket>& scope_id,
                        const std::string& statement,
                        const couchbase::query_error_context& ctx,
@@ -201,10 +201,10 @@ print_result_json_line(const std::optional<scope_with_bucket>& scope_id,
     }
     line["meta"] = meta;
     fmt::print(stdout, "{}\n", tao::json::to_string<tao::json::events::binary_to_base64>(line));
-    fflush(stdout);
+    (void)fflush(stdout);
 }
 
-static void
+void
 print_result(const std::optional<scope_with_bucket>& scope_id,
              const std::string& statement,
              const couchbase::query_error_context& ctx,
@@ -247,7 +247,7 @@ print_result(const std::optional<scope_with_bucket>& scope_id,
     } else {
         auto meta = fmt::memory_buffer();
         fmt::format_to(std::back_inserter(meta),
-                       "status: {}, client_context_id: \"{}\", request_id: \"{}\"",
+                       R"(status: {}, client_context_id: "{}", request_id: "{}")",
                        resp.meta_data().status(),
                        resp.meta_data().client_context_id(),
                        resp.meta_data().request_id());
@@ -266,12 +266,12 @@ print_result(const std::optional<scope_with_bucket>& scope_id,
         if (!resp.meta_data().warnings().empty()) {
             for (const auto& item : resp.meta_data().warnings()) {
                 auto warning = fmt::memory_buffer();
-                fmt::format_to(std::back_inserter(warning), "WARNING. code: {}, message: \"{}\"\n", item.code(), item.message());
+                fmt::format_to(std::back_inserter(warning), "WARNING. code: {}, message: \"{}\"", item.code(), item.message());
                 if (item.reason()) {
-                    fmt::format_to(std::back_inserter(warning), ", reason: {}\n", item.reason().value());
+                    fmt::format_to(std::back_inserter(warning), ", reason: {}", item.reason().value());
                 }
                 if (item.retry()) {
-                    fmt::format_to(std::back_inserter(warning), ", retry: {}\n", item.retry().value());
+                    fmt::format_to(std::back_inserter(warning), ", retry: {}", item.retry().value());
                 }
                 fmt::print(stdout, "{}\n", std::string_view{ warning.data(), warning.size() });
             }
@@ -291,12 +291,12 @@ print_result(const std::optional<scope_with_bucket>& scope_id,
             }
         }
     }
-    fflush(stdout);
+    (void)fflush(stdout);
 }
 
-static void
+void
 do_work(const std::string& connection_string,
-        couchbase::cluster_options& cluster_options,
+        const couchbase::cluster_options& cluster_options,
         const std::vector<std::string>& statements,
         const std::optional<scope_with_bucket>& scope_id,
         const couchbase::query_options& query_options,
@@ -308,6 +308,9 @@ do_work(const std::string& connection_string,
 
     auto [cluster, ec] = couchbase::cluster::connect(io, connection_string, cluster_options).get();
     if (ec) {
+        guard.reset();
+        io_thread.join();
+
         throw std::system_error(ec);
     }
 
@@ -336,106 +339,99 @@ do_work(const std::string& connection_string,
 void
 cbc::query::execute(const std::vector<std::string>& argv)
 {
-    try {
+    auto options = cbc::parse_options(usage(), argv);
+    if (options["--help"].asBool()) {
+        fmt::print(stdout, "{}", usage());
+        return;
+    }
 
-        auto options = cbc::parse_options(usage(), argv);
-        if (options["--help"].asBool()) {
-            fmt::print(stdout, usage());
-            return;
+    cbc::apply_logger_options(options);
+
+    couchbase::cluster_options cluster_options{ cbc::default_cluster_options() };
+    std::string connection_string{ cbc::default_connection_string() };
+    cbc::fill_cluster_options(options, cluster_options, connection_string);
+
+    couchbase::query_options query_options{};
+    parse_disable_option(query_options.adhoc, "--prepare");
+    parse_enable_option(query_options.readonly, "--read-only");
+    parse_enable_option(query_options.preserve_expiry, "--preserve-expiry");
+    parse_disable_option(query_options.metrics, "--disable-metrics");
+    parse_enable_option(query_options.flex_index, "--flex-index");
+    parse_integer_option(query_options.max_parallelism, "--maximum-parallelism");
+    parse_integer_option(query_options.scan_cap, "--scan-cap");
+    parse_integer_option(query_options.pipeline_batch, "--pipeline-batch");
+    parse_integer_option(query_options.pipeline_cap, "--pipeline-cap");
+    parse_duration_option(query_options.scan_wait, "--scan-wait");
+    parse_string_option(query_options.client_context_id, "--client-context-id");
+
+    if (options.find("--scan-consistency") != options.end() && options.at("--scan-consistency")) {
+        if (auto value = options.at("--scan-consistency").asString(); value == "not_bounded") {
+            query_options.scan_consistency(couchbase::query_scan_consistency::not_bounded);
+        } else if (value == "request_plus") {
+            query_options.scan_consistency(couchbase::query_scan_consistency::request_plus);
+        } else {
+            throw docopt::DocoptArgumentError(fmt::format("unexpected value '{}' for --scan-consistency", value));
         }
+    }
 
-        cbc::apply_logger_options(options);
-
-        couchbase::cluster_options cluster_options{ cbc::default_cluster_options() };
-        std::string connection_string{ cbc::default_connection_string() };
-        cbc::fill_cluster_options(options, cluster_options, connection_string);
-
-        couchbase::query_options query_options{};
-        parse_disable_option(query_options.adhoc, "--prepare");
-        parse_enable_option(query_options.readonly, "--read-only");
-        parse_enable_option(query_options.preserve_expiry, "--preserve-expiry");
-        parse_disable_option(query_options.metrics, "--disable-metrics");
-        parse_enable_option(query_options.flex_index, "--flex-index");
-        parse_integer_option(query_options.max_parallelism, "--maximum-parallelism");
-        parse_integer_option(query_options.scan_cap, "--scan-cap");
-        parse_integer_option(query_options.pipeline_batch, "--pipeline-batch");
-        parse_integer_option(query_options.pipeline_cap, "--pipeline-cap");
-        parse_duration_option(query_options.scan_wait, "--scan-wait");
-        parse_string_option(query_options.client_context_id, "--client-context-id");
-
-        if (options.find("--scan-consistency") != options.end() && options.at("--scan-consistency")) {
-            if (auto value = options.at("--scan-consistency").asString(); value == "not_bounded") {
-                query_options.scan_consistency(couchbase::query_scan_consistency::not_bounded);
-            } else if (value == "request_plus") {
-                query_options.scan_consistency(couchbase::query_scan_consistency::request_plus);
-            } else {
-                throw docopt::DocoptArgumentError(fmt::format("unexpected value '{}' for --scan-consistency", value));
-            }
+    if (options.find("--profile") != options.end() && options.at("--profile")) {
+        if (auto value = options.at("--profile").asString(); value == "off") {
+            query_options.profile(couchbase::query_profile::off);
+        } else if (value == "phases") {
+            query_options.profile(couchbase::query_profile::phases);
+        } else if (value == "timings") {
+            query_options.profile(couchbase::query_profile::phases);
+        } else {
+            throw docopt::DocoptArgumentError(fmt::format("unexpected value '{}' for --profile", value));
         }
+    }
+
+    std::optional<scope_with_bucket> scope{};
+    if (options.find("--bucket-name") != options.end() && options.at("--bucket-name") && options.find("--scope-name") != options.end() &&
+        options.at("--scope-name")) {
+        scope = { options.at("--bucket-name").asString(), options.at("--scope-name").asString() };
+    }
+
+    static const std::regex named_param_regex{ R"(^([\w\d_]+)=(.*)$)" };
+    if (options.find("--param") != options.end() && options.at("--param")) {
+        std::vector<couchbase::codec::binary> positional_params{};
+        std::map<std::string, couchbase::codec::binary, std::less<>> named_params{};
 
-        if (options.find("--profile") != options.end() && options.at("--profile")) {
-            if (auto value = options.at("--profile").asString(); value == "off") {
-                query_options.profile(couchbase::query_profile::off);
-            } else if (value == "phases") {
-                query_options.profile(couchbase::query_profile::phases);
-            } else if (value == "timings") {
-                query_options.profile(couchbase::query_profile::phases);
+        for (const auto& param : options.at("--param").asStringList()) {
+            if (std::smatch match; std::regex_match(param, match, named_param_regex)) {
+                named_params[match[1].str()] = couchbase::core::utils::to_binary(match[2].str());
             } else {
-                throw docopt::DocoptArgumentError(fmt::format("unexpected value '{}' for --profile", value));
+                positional_params.push_back(couchbase::core::utils::to_binary(param));
             }
         }
-
-        std::optional<scope_with_bucket> scope{};
-        if (options.find("--bucket-name") != options.end() && options.at("--bucket-name") &&
-            options.find("--scope-name") != options.end() && options.at("--scope-name")) {
-            scope = { options.at("--bucket-name").asString(), options.at("--scope-name").asString() };
+        if (!positional_params.empty() && !named_params.empty()) {
+            throw docopt::DocoptArgumentError("mixing positional and named parameters is not allowed (parameters must be specified "
+                                              "either as --param=VALUE or --param=NAME=VALUE)");
         }
-
-        static const std::regex named_param_regex{ R"(^([\w\d_]+)=(.*)$)" };
-        if (options.find("--param") != options.end() && options.at("--param")) {
-            std::vector<couchbase::codec::binary> positional_params{};
-            std::map<std::string, couchbase::codec::binary, std::less<>> named_params{};
-
-            for (const auto& param : options.at("--param").asStringList()) {
-                if (std::smatch match; std::regex_match(param, match, named_param_regex)) {
-                    named_params[match[1].str()] = std::move(couchbase::core::utils::to_binary(match[2].str()));
-                } else {
-                    positional_params.push_back(couchbase::core::utils::to_binary(param));
-                }
-            }
-            if (!positional_params.empty() && !named_params.empty()) {
-                throw docopt::DocoptArgumentError("mixing positional and named parameters is not allowed (parameters must be specified "
-                                                  "either as --param=VALUE or --param=NAME=VALUE)");
-            }
-            if (!positional_params.empty()) {
-                query_options.encoded_positional_parameters(std::move(positional_params));
-            } else if (!named_params.empty()) {
-                query_options.encoded_named_parameters(std::move(named_params));
-            }
+        if (!positional_params.empty()) {
+            query_options.encoded_positional_parameters(std::move(positional_params));
+        } else if (!named_params.empty()) {
+            query_options.encoded_named_parameters(std::move(named_params));
         }
-        if (options.find("--raw") != options.end() && options.at("--raw")) {
-            std::map<std::string, couchbase::codec::binary, std::less<>> raw_params{};
-            for (const auto& param : options.at("--raw").asStringList()) {
-                if (std::smatch match; std::regex_match(param, match, named_param_regex)) {
-                    raw_params.emplace(match[1].str(), couchbase::core::utils::to_binary(match[2].str()));
-                } else {
-                    throw docopt::DocoptArgumentError("raw parameters should be in NAME=VALUE form, (i.e. --raw=NAME=VALUE)");
-                }
-            }
-            if (!raw_params.empty()) {
-                query_options.encoded_raw_options(raw_params);
+    }
+    if (options.find("--raw") != options.end() && options.at("--raw")) {
+        std::map<std::string, couchbase::codec::binary, std::less<>> raw_params{};
+        for (const auto& param : options.at("--raw").asStringList()) {
+            if (std::smatch match; std::regex_match(param, match, named_param_regex)) {
+                raw_params[match[1].str()] = couchbase::core::utils::to_binary(match[2].str());
+            } else {
+                throw docopt::DocoptArgumentError("raw parameters should be in NAME=VALUE form, (i.e. --raw=NAME=VALUE)");
             }
         }
+        if (!raw_params.empty()) {
+            query_options.encoded_raw_options(raw_params);
+        }
+    }
 
-        console_output_options output_options{};
-        output_options.json_lines = cbc::get_bool_option(options, "--json-lines");
+    console_output_options output_options{};
+    output_options.json_lines = cbc::get_bool_option(options, "--json-lines");
 
-        auto statements{ options["<statement>"].asStringList() };
-        do_work(connection_string, cluster_options, statements, scope, query_options, output_options);
-    } catch (const docopt::DocoptArgumentError& e) {
-        fmt::print(stderr, "Error: {}\n", e.what());
-    } catch (const std::system_error& e) {
-        fmt::print(stderr, "Error: {}\n", e.what());
-    }
+    auto statements{ options["<statement>"].asStringList() };
+    do_work(connection_string, cluster_options, statements, scope, query_options, output_options);
 }
 } // namespace cbc

package/deps/couchbase-cxx-client/tools/query.hxx

@@ -21,6 +21,6 @@ namespace cbc
 {
 class query : public command
 {
-    void execute(const std::vector<std::string>& argv);
+    void execute(const std::vector<std::string>& argv) override;
 };
 } // namespace cbc

package/deps/couchbase-cxx-client/tools/utils.cxx

@@ -143,7 +143,7 @@ Transactions options:
 
 Metrics options:
   --disable-metrics                 Disable collecting and reporting metrics.
-  --metrics-emit-interval=DURATION  Interval to emit metrics report on INFO log level. [default:{metrics_emit_interval}]
+  --metrics-emit-interval=DURATION  Interval to emit metrics report on INFO log level. [default: {metrics_emit_interval}]
 
 Tracing options:
   --disable-tracing                           Disable collecting and reporting trace information.
@@ -165,6 +165,7 @@ Behavior options:
   --enable-clustermap-notifications  Allow server to send notifications when cluster configuration changes.
   --disable-mutation-tokens          Do not request Key/Value service to send mutation tokens.
   --disable-unordered-execution      Disable unordered execution for Key/Value service.
+  --dump-configuration               Dump every new configuration on TRACE log level.
 )",
       fmt::arg("connection_string", connection_string),
       fmt::arg("username", default_options.username),
@@ -340,6 +341,7 @@ fill_cluster_options(const docopt::Options& options, couchbase::cluster_options&
 
     parse_string_option(cluster_options.behavior().append_to_user_agent, "--user-agent-extra");
     parse_enable_option(cluster_options.behavior().show_queries, "--show-queries");
+    parse_enable_option(cluster_options.behavior().dump_configuration, "--dump-configuration");
     parse_enable_option(cluster_options.behavior().enable_clustermap_notification, "--enable-clustermap-notification");
     parse_disable_option(cluster_options.behavior().enable_mutation_tokens, "--disable-mutation-tokens");
     parse_disable_option(cluster_options.behavior().enable_unordered_execution, "--disable-disable-unordered-execution");
@@ -415,4 +417,16 @@ get_bool_option(const docopt::Options& options, const std::string& name)
 {
     return options.find(name) != options.end() && options.at(name) && options.at(name).asBool();
 }
+
+double
+get_double_option(const docopt::Options& options, const std::string& name)
+{
+    auto value = options.at(name).asString();
+    std::size_t pos;
+    const double ret = std::stod(value, &pos);
+    if (pos != value.length()) {
+        throw std::runtime_error(value + " contains non-numeric characters.");
+    }
+    return ret;
+}
 } // namespace cbc

package/deps/couchbase-cxx-client/tools/utils.hxx

@@ -74,6 +74,9 @@ struct passthrough_transcoder {
 
 [[nodiscard]] bool
 get_bool_option(const docopt::Options& options, const std::string& name);
+
+[[nodiscard]] double
+get_double_option(const docopt::Options& options, const std::string& name);
 } // namespace cbc
 
 template<>

package/deps/couchbase-cxx-client/tools/version.hxx

@@ -21,6 +21,6 @@ namespace cbc
 {
 class version : public command
 {
-    void execute(const std::vector<std::string>& argv);
+    void execute(const std::vector<std::string>& argv) override;
 };
 } // namespace cbc

package/dist/authenticators.d.ts

@@ -97,4 +97,4 @@ export declare class CertificateAuthenticator implements ICertificateAuthenticat
  *
  * @category Authentication
  */
-export declare type Authenticator = IPasswordAuthenticator | ICertificateAuthenticator;
+export type Authenticator = IPasswordAuthenticator | ICertificateAuthenticator;

package/dist/binding.d.ts

@@ -1,10 +1,10 @@
 /// <reference types="node" />
-export declare type CppMilliseconds = number;
-export declare type CppSeconds = number;
-export declare type CppBytes = string | Buffer;
-export declare type CppDocFlags = number;
-export declare type CppExpiry = number;
-export declare type CppJsonString = string | Buffer;
+export type CppMilliseconds = number;
+export type CppSeconds = number;
+export type CppBytes = string | Buffer;
+export type CppDocFlags = number;
+export type CppExpiry = number;
+export type CppJsonString = string | Buffer;
 export interface CppClusterCredentials {
     username?: string;
     password?: string;
@@ -837,7 +837,6 @@ export interface CppSearchRequest {
     highlight_style?: CppSearchHighlightStyle;
     highlight_fields: string[];
     fields: string[];
-    scope_name?: string;
     collections: string[];
     scan_consistency?: CppSearchScanConsistency;
     mutation_state: CppMutationToken[];
@@ -2399,7 +2398,7 @@ export interface CppBindingAutogen {
         ascending: CppScanSort;
     };
 }
-export declare type CppErrc = CppErrcCommon | CppErrcKeyValue | CppErrcQuery | CppErrcAnalytics | CppErrcSearch | CppErrcView | CppErrcManagement | CppErrcFieldLevelEncryption | CppErrcNetwork;
+export type CppErrc = CppErrcCommon | CppErrcKeyValue | CppErrcQuery | CppErrcAnalytics | CppErrcSearch | CppErrcView | CppErrcManagement | CppErrcFieldLevelEncryption | CppErrcNetwork;
 export declare enum CppTxnFailureType {
 }
 export declare enum CppTxnExternalException {
@@ -2502,17 +2501,31 @@ export interface CppHttpError extends CppErrorBase {
 }
 export interface CppTxnOperationFailed extends CppErrorBase {
     ctxtype: 'transaction_operation_failed';
+    ctx: CppTransactionErrorContext;
     should_not_retry: boolean;
     should_not_rollback: boolean;
     cause: CppTxnExternalException;
 }
+export interface CppTxnOpException extends CppErrorBase {
+    ctxtype: 'transaction_op_exception';
+    ctx: CppTransactionOpErrorContext | undefined;
+    cause: CppTxnExternalException;
+}
 export interface CppTxnError extends CppErrorBase {
     ctxtype: 'transaction_exception';
     result: CppTransactionResult;
     cause: CppTxnExternalException;
     type: CppTxnFailureType;
 }
-export declare type CppError = CppGenericError | CppKeyValueError | CppViewError | CppQueryError | CppSearchError | CppAnalyticsError | CppHttpError | CppTxnOperationFailed | CppTxnError;
+export interface CppTransactionErrorContext {
+    code: CppErrc;
+    cause: CppErrc;
+}
+export interface CppTransactionOpErrorContext {
+    code: CppErrc;
+    cause: CppKeyValueError | CppQueryError | undefined;
+}
+export type CppError = CppGenericError | CppKeyValueError | CppViewError | CppQueryError | CppSearchError | CppAnalyticsError | CppHttpError | CppTxnOperationFailed | CppTxnOpException | CppTxnError;
 export interface CppConnection extends CppConnectionAutogen {
     connect(connStr: string, credentials: CppClusterCredentials, dnsOptions: CppDnsConfig | null, callback: (err: CppError | null) => void): void;
     shutdown(callback: (err: CppError | null) => void): void;
@@ -2580,6 +2593,7 @@ export interface CppTransactionLinks {
     atr_collection_name: string;
     staged_transaction_id: string;
     staged_attempt_id: string;
+    staged_operation_id: string;
     staged_content: string;
     cas_pre_txn: string;
     revid_pre_txn: string;
@@ -2651,6 +2665,7 @@ export interface CppTransaction {
 }
 export interface CppBinding extends CppBindingAutogen {
     cbppVersion: string;
+    cbppMetadata: string;
     Connection: {
         new (): CppConnection;
     };

package/dist/bindingutilities.d.ts

@@ -1,5 +1,5 @@
 import { AnalyticsScanConsistency, AnalyticsStatus } from './analyticstypes';
-import { CppAnalyticsScanConsistency, CppAnalyticsResponseAnalyticsStatus, CppDurabilityLevel, CppDiagEndpointState, CppMutationState, CppDiagPingState, CppQueryProfile, CppQueryScanConsistency, CppSearchHighlightStyle, CppSearchScanConsistency, CppServiceType, CppStoreSemantics, CppTxnExternalException, CppViewScanConsistency, CppViewSortOrder, CppPersistTo, CppReplicateTo } from './binding';
+import { CppAnalyticsScanConsistency, CppAnalyticsResponseAnalyticsStatus, CppDurabilityLevel, CppDiagEndpointState, CppMutationState, CppDiagPingState, CppQueryProfile, CppQueryScanConsistency, CppSearchHighlightStyle, CppSearchScanConsistency, CppServiceType, CppStoreSemantics, CppTxnExternalException, CppViewScanConsistency, CppViewSortOrder, CppPersistTo, CppReplicateTo, CppTxnOpException } from './binding';
 import { CppError } from './binding';
 import { EndpointState, PingState } from './diagnosticstypes';
 import { ErrorContext } from './errorcontexts';
@@ -75,7 +75,11 @@ export declare function endpointStateFromCpp(service: CppDiagEndpointState): End
 /**
  * @internal
  */
-export declare function txnExternalExeptionFromCpp(cause: CppTxnExternalException): string;
+export declare function txnExternalExceptionStringFromCpp(cause: CppTxnExternalException): string;
+/**
+ * @internal
+ */
+export declare function txnOpExeptionFromCpp(err: CppTxnOpException | null, ctx: ErrorContext | null): Error | null;
 /**
  * @internal
  */

package/dist/bindingutilities.js

@@ -26,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.errorFromCpp = exports.contextFromCpp = exports.pingStateFromCpp = exports.txnExternalExeptionFromCpp = exports.endpointStateFromCpp = exports.serviceTypeFromCpp = exports.serviceTypeToCpp = exports.mutationStateToCpp = exports.searchHighlightStyleToCpp = exports.searchScanConsistencyToCpp = exports.analyticsStatusFromCpp = exports.analyticsScanConsistencyToCpp = exports.queryProfileToCpp = exports.queryScanConsistencyToCpp = exports.viewOrderingToCpp = exports.viewScanConsistencyToCpp = exports.storeSemanticToCpp = exports.replicateToToCpp = exports.persistToToCpp = exports.durabilityToCpp = void 0;
+exports.errorFromCpp = exports.contextFromCpp = exports.pingStateFromCpp = exports.txnOpExeptionFromCpp = exports.txnExternalExceptionStringFromCpp = exports.endpointStateFromCpp = exports.serviceTypeFromCpp = exports.serviceTypeToCpp = exports.mutationStateToCpp = exports.searchHighlightStyleToCpp = exports.searchScanConsistencyToCpp = exports.analyticsStatusFromCpp = exports.analyticsScanConsistencyToCpp = exports.queryProfileToCpp = exports.queryScanConsistencyToCpp = exports.viewOrderingToCpp = exports.viewScanConsistencyToCpp = exports.storeSemanticToCpp = exports.replicateToToCpp = exports.persistToToCpp = exports.durabilityToCpp = void 0;
 const analyticstypes_1 = require("./analyticstypes");
 const binding_1 = __importDefault(require("./binding"));
 const diagnosticstypes_1 = require("./diagnosticstypes");
@@ -384,7 +384,7 @@ exports.endpointStateFromCpp = endpointStateFromCpp;
 /**
  * @internal
  */
-function txnExternalExeptionFromCpp(cause) {
+function txnExternalExceptionStringFromCpp(cause) {
     if (cause === binding_1.default.txn_external_exception.unknown) {
         return 'unknown';
     }
@@ -456,7 +456,31 @@ function txnExternalExeptionFromCpp(cause) {
     }
     throw new errs.InvalidArgumentError();
 }
-exports.txnExternalExeptionFromCpp = txnExternalExeptionFromCpp;
+exports.txnExternalExceptionStringFromCpp = txnExternalExceptionStringFromCpp;
+/**
+ * @internal
+ */
+function txnOpExeptionFromCpp(err, ctx) {
+    if (!err) {
+        return null;
+    }
+    const context = ctx ? ctx : undefined;
+    if (err.cause === binding_1.default.txn_external_exception.document_exists_exception) {
+        return new errs.DocumentExistsError(new Error(txnExternalExceptionStringFromCpp(err.cause)), context);
+    }
+    else if (err.cause === binding_1.default.txn_external_exception.document_not_found_exception) {
+        return new errs.DocumentNotFoundError(new Error(txnExternalExceptionStringFromCpp(err.cause)), context);
+    }
+    else if (err.cause === binding_1.default.txn_external_exception.parsing_failure) {
+        return new errs.ParsingFailureError(new Error(txnExternalExceptionStringFromCpp(err.cause)), context);
+    }
+    else if (err.cause === binding_1.default.txn_external_exception.couchbase_exception) {
+        const cause = txnExternalExceptionStringFromCpp(err.cause);
+        return new errs.CouchbaseError(cause, new Error(cause), context);
+    }
+    return err;
+}
+exports.txnOpExeptionFromCpp = txnOpExeptionFromCpp;
 /**
  * @internal
  */
@@ -545,22 +569,30 @@ exports.contextFromCpp = contextFromCpp;
  * @internal
  */
 function errorFromCpp(err) {
+    var _a;
     if (!err) {
         return null;
     }
     // BUG(JSCBC-1010): We shouldn't need to special case these.
     if (err.ctxtype === 'transaction_operation_failed') {
-        return new errs.TransactionOperationFailedError(new Error(txnExternalExeptionFromCpp(err.cause)));
+        return new errs.TransactionOperationFailedError(new Error(txnExternalExceptionStringFromCpp(err.cause)));
+    }
+    else if (err.ctxtype === 'transaction_op_exception') {
+        let txnContext = null;
+        if ((_a = err.ctx) === null || _a === void 0 ? void 0 : _a.cause) {
+            txnContext = contextFromCpp(err.ctx.cause);
+        }
+        return txnOpExeptionFromCpp(err, txnContext);
     }
     else if (err.ctxtype === 'transaction_exception') {
         if (err.type === binding_1.default.txn_failure_type.fail) {
-            return new errs.TransactionFailedError(new Error(txnExternalExeptionFromCpp(err.cause)));
+            return new errs.TransactionFailedError(new Error(txnExternalExceptionStringFromCpp(err.cause)));
         }
         else if (err.type === binding_1.default.txn_failure_type.expiry) {
-            return new errs.TransactionExpiredError(new Error(txnExternalExeptionFromCpp(err.cause)));
+            return new errs.TransactionExpiredError(new Error(txnExternalExceptionStringFromCpp(err.cause)));
         }
         else if (err.type === binding_1.default.txn_failure_type.commit_ambiguous) {
-            return new errs.TransactionCommitAmbiguousError(new Error(txnExternalExeptionFromCpp(err.cause)));
+            return new errs.TransactionCommitAmbiguousError(new Error(txnExternalExceptionStringFromCpp(err.cause)));
         }
         throw new errs.InvalidArgumentError();
     }

package/dist/cluster.d.ts

@@ -50,6 +50,18 @@ export interface TimeoutConfig {
      * Specifies the default timeout for management operations, specified in millseconds.
      */
     managementTimeout?: number;
+    /**
+     * Specifies the default timeout allocated to complete bootstrap, specified in millseconds.
+     */
+    bootstrapTimeout?: number;
+    /**
+     * Specifies the default timeout for attempting to connect to a node’s KV service via a socket, specified in millseconds.
+     */
+    connectTimeout?: number;
+    /**
+     * Specifies the default timeout to resolve DNS name of the node to IP address, specified in millseconds.
+     */
+    resolveTimeout?: number;
 }
 /**
  * Specifies security options for the client.
@@ -154,6 +166,9 @@ export declare class Cluster {
     private _analyticsTimeout;
     private _searchTimeout;
     private _managementTimeout;
+    private _connectTimeout;
+    private _bootstrapTimeout;
+    private _resolveTimeout;
     private _auth;
     private _conn;
     private _transcoder;
@@ -199,6 +214,18 @@ export declare class Cluster {
     get managementTimeout(): number;
     /**
     @internal
+    */
+    get bootstrapTimeout(): number | undefined;
+    /**
+    @internal
+    */
+    get connectTimeout(): number | undefined;
+    /**
+    @internal
+    */
+    get resolveTimeout(): number | undefined;
+    /**
+    @internal
     @deprecated Use the static sdk-level {@link connect} method instead.
     */
     constructor(connStr: string, options?: ConnectOptions);