couchbase 4.4.5 → 4.4.6

package/deps/couchbase-cxx-client/core/impl/collection.cxx

@@ -884,13 +884,14 @@ public:
         return core_.with_bucket_configuration(
           bucket_name_,
           [this, handler = std::move(handler), orchestrator_opts, core_scan_type](
-            std::error_code ec, const core::topology::configuration& config) mutable {
+            std::error_code ec,
+            const std::shared_ptr<core::topology::configuration>& config) mutable {
             if (ec) {
               return handler(
                 error(ec, "An error occurred when attempting to fetch the bucket configuration."),
                 {});
             }
-            if (!config.capabilities.supports_range_scan()) {
+            if (!config->capabilities.supports_range_scan()) {
               return handler(error(errc::common::feature_not_available,
                                    "This bucket does not support range scan."),
                              {});
@@ -913,7 +914,7 @@ public:
                         bucket_name_)),
                 {});
             }
-            if (!config.vbmap.has_value() || config.vbmap->empty()) {
+            if (!config->vbmap.has_value() || config->vbmap->empty()) {
               CB_LOG_WARNING("Unable to get vbucket map for `{}` - cannot perform scan operation",
                              bucket_name_);
               return handler(error(errc::common::request_canceled,
@@ -923,7 +924,7 @@ public:
 
             auto orchestrator = core::range_scan_orchestrator(core_.io_context(),
                                                               agent.value(),
-                                                              config.vbmap.value(),
+                                                              config->vbmap.value(),
                                                               scope_name_,
                                                               name_,
                                                               core_scan_type,
@@ -993,8 +994,8 @@ collection::get(std::string document_id, const get_options& options, get_handler
 }
 
 auto
-collection::get(std::string document_id,
-                const get_options& options) const -> std::future<std::pair<error, get_result>>
+collection::get(std::string document_id, const get_options& options) const
+  -> std::future<std::pair<error, get_result>>
 {
   auto barrier = std::make_shared<std::promise<std::pair<error, get_result>>>();
   auto future = barrier->get_future();
@@ -1296,9 +1297,8 @@ collection::unlock(std::string document_id,
 }
 
 auto
-collection::unlock(std::string document_id,
-                   couchbase::cas cas,
-                   const unlock_options& options) const -> std::future<error>
+collection::unlock(std::string document_id, couchbase::cas cas, const unlock_options& options) const
+  -> std::future<error>
 {
   auto barrier = std::make_shared<std::promise<error>>();
   auto future = barrier->get_future();
@@ -1409,8 +1409,9 @@ collection::scan(const couchbase::scan_type& scan_type,
 }
 
 auto
-collection::scan(const couchbase::scan_type& scan_type, const couchbase::scan_options& options)
-  const -> std::future<std::pair<error, scan_result>>
+collection::scan(const couchbase::scan_type& scan_type,
+                 const couchbase::scan_options& options) const
+  -> std::future<std::pair<error, scan_result>>
 {
   auto barrier = std::make_shared<std::promise<std::pair<error, scan_result>>>();
   auto future = barrier->get_future();

package/deps/couchbase-cxx-client/core/impl/observe_poll.cxx

@@ -96,24 +96,24 @@ number_of_replica_nodes_required(couchbase::replicate_to replicate_to) -> std::u
 }
 
 auto
-validate_replicas(const topology::configuration& config,
+validate_replicas(const std::shared_ptr<topology::configuration>& config,
                   couchbase::persist_to persist_to,
                   couchbase::replicate_to replicate_to) -> std::pair<std::error_code, std::uint32_t>
 {
-  if (config.node_locator != topology::configuration::node_locator_type::vbucket) {
+  if (config->node_locator != topology::configuration::node_locator_type::vbucket) {
     return { errc::common::feature_not_available, {} };
   }
 
   if (touches_replica(persist_to, replicate_to)) {
-    if (!config.num_replicas) {
+    auto number_of_replicas = config->num_replicas;
+    if (!number_of_replicas.has_value()) {
       return { errc::key_value::durability_impossible, {} };
     }
-    auto number_of_replicas = config.num_replicas.value();
     if (number_of_replica_nodes_required(persist_to) > number_of_replicas ||
         number_of_replica_nodes_required(replicate_to) > number_of_replicas) {
       return { errc::key_value::durability_impossible, {} };
     }
-    return { {}, number_of_replicas };
+    return { {}, number_of_replicas.value() };
   }
   return { {}, 0 };
 }
@@ -335,8 +335,8 @@ observe_poll(const cluster& core, std::shared_ptr<observe_context> ctx)
   const std::string bucket_name = ctx->bucket_name();
   core.with_bucket_configuration(
     bucket_name,
-    [core, ctx = std::move(ctx)](std::error_code ec,
-                                 const core::topology::configuration& config) mutable {
+    [core, ctx = std::move(ctx)](
+      std::error_code ec, const std::shared_ptr<core::topology::configuration>& config) mutable {
       if (ec) {
         return ctx->finish(ec);
       }

package/deps/couchbase-cxx-client/core/impl/replica_utils.cxx

@@ -25,7 +25,7 @@ namespace couchbase::core::impl
 
 auto
 effective_nodes(const document_id& id,
-                const topology::configuration& config,
+                const std::shared_ptr<topology::configuration>& config,
                 const read_preference& preference,
                 const std::string& preferred_server_group) -> std::vector<readable_node>
 {
@@ -37,12 +37,12 @@ effective_nodes(const document_id& id,
   std::vector<readable_node> available_nodes{};
   std::vector<readable_node> local_nodes{};
 
-  for (std::size_t idx = 0U; idx <= config.num_replicas.value_or(0U); ++idx) {
-    auto [vbid, server] = config.map_key(id.key(), idx);
-    if (server.has_value() && server.value() < config.nodes.size()) {
+  for (std::size_t idx = 0U; idx <= config->num_replicas.value_or(0U); ++idx) {
+    auto [vbid, server] = config->map_key(id.key(), idx);
+    if (server.has_value() && server.value() < config->nodes.size()) {
       const bool is_replica = idx != 0;
       available_nodes.emplace_back(readable_node{ is_replica, idx });
-      if (preferred_server_group == config.nodes[server.value()].server_group) {
+      if (preferred_server_group == config->nodes[server.value()].server_group) {
         local_nodes.emplace_back(readable_node{ is_replica, idx });
       }
     }

package/deps/couchbase-cxx-client/core/impl/replica_utils.hxx

@@ -23,6 +23,7 @@
 
 #include "couchbase/read_preference.hxx"
 
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -42,7 +43,7 @@ struct readable_node {
  */
 auto
 effective_nodes(const document_id& id,
-                const topology::configuration& config,
+                const std::shared_ptr<topology::configuration>& config,
                 const read_preference& preference,
                 const std::string& preferred_server_group) -> std::vector<readable_node>;
 } // namespace couchbase::core::impl

package/deps/couchbase-cxx-client/core/logger/logger.cxx

@@ -322,7 +322,7 @@ create_file_logger(const configuration& logger_settings) -> std::optional<std::s
   if (error) {
     return error;
   }
-  file_logger = std::move(logger);
+  update_file_logger(logger);
   return {};
 }
 

package/deps/couchbase-cxx-client/core/meta/features.hxx

@@ -206,3 +206,8 @@
  * All options classes in the Public API expose the parent_span option.
  */
 #define COUCHBASE_CXX_CLIENT_PUBLIC_API_PARENT_SPAN 1
+
+/**
+ * core API like with_bucket_configuration() yields shared_ptr instead of configuration copy
+ */
+#define COUCHBASE_CXX_CLIENT_CORE_RETURNS_POINTER_TO_CONFIG 1

package/deps/couchbase-cxx-client/core/operations/document_append.cxx

@@ -28,6 +28,7 @@ append_request::encode_to(protocol::client_request<protocol::append_request_body
 {
   encoded.opaque(opaque);
   encoded.partition(partition);
+  encoded.cas(cas);
   encoded.body().id(id);
   encoded.body().content(value);
   return {};

package/deps/couchbase-cxx-client/core/operations/document_append.hxx

@@ -50,6 +50,7 @@ struct append_request {
   std::vector<std::byte> value;
   std::uint16_t partition{};
   std::uint32_t opaque{};
+  couchbase::cas cas{ 0 };
   couchbase::durability_level durability_level{ durability_level::none };
   std::optional<std::chrono::milliseconds> timeout{};
   io::retry_context<false> retries{};

package/deps/couchbase-cxx-client/core/operations/document_get_all_replicas.hxx

@@ -26,7 +26,6 @@
 #include "core/utils/movable_function.hxx"
 #include "couchbase/error_codes.hxx"
 
-#include <functional>
 #include <memory>
 #include <mutex>
 
@@ -65,8 +64,8 @@ struct get_all_replicas_request {
        id = id,
        timeout = timeout,
        read_preference = read_preference,
-       h = std::forward<Handler>(handler)](std::error_code ec,
-                                           const topology::configuration& config) mutable {
+       h = std::forward<Handler>(handler)](
+        std::error_code ec, std::shared_ptr<topology::configuration> config) mutable {
         if (ec) {
           return h(response_type{ make_key_value_error_context(ec, id) });
         }
@@ -82,7 +81,7 @@ struct get_all_replicas_request {
             "Unable to retrieve replicas for \"{}\", server_group={}, number_of_replicas={}",
             id,
             origin.options().server_group,
-            config.num_replicas.value_or(0));
+            config->num_replicas.value_or(0));
           return h(response_type{
             make_key_value_error_context(errc::key_value::document_irretrievable, id) });
         }

package/deps/couchbase-cxx-client/core/operations/document_get_any_replica.hxx

@@ -61,8 +61,8 @@ struct get_any_replica_request {
        id = id,
        timeout = timeout,
        read_preference = read_preference,
-       h = std::forward<Handler>(handler)](std::error_code ec,
-                                           const topology::configuration& config) mutable {
+       h = std::forward<Handler>(handler)](
+        std::error_code ec, std::shared_ptr<topology::configuration> config) mutable {
         const auto [e, origin] = core->origin();
         if (e && !ec) {
           ec = e;
@@ -75,7 +75,7 @@ struct get_any_replica_request {
             "Unable to retrieve replicas for \"{}\", server_group={}, number_of_replicas={}",
             id,
             origin.options().server_group,
-            config.num_replicas.value_or(0));
+            config->num_replicas.value_or(0));
           ec = errc::key_value::document_irretrievable;
         }
 

package/deps/couchbase-cxx-client/core/operations/document_lookup_in_all_replicas.hxx

@@ -94,8 +94,8 @@ struct lookup_in_all_replicas_request {
         core->with_bucket_configuration(
           id.bucket(),
           [core, id, timeout, specs, parent_span, read_preference, h = std::forward<Handler>(h)](
-            std::error_code ec, const topology::configuration& config) mutable {
-            if (!config.capabilities.supports_subdoc_read_replica()) {
+            std::error_code ec, std::shared_ptr<topology::configuration> config) mutable {
+            if (!config->capabilities.supports_subdoc_read_replica()) {
               ec = errc::common::feature_not_available;
             }
 
@@ -111,7 +111,7 @@ struct lookup_in_all_replicas_request {
                 "Unable to retrieve replicas for \"{}\", server_group={}, number_of_replicas={}",
                 id,
                 origin.options().server_group,
-                config.num_replicas.value_or(0));
+                config->num_replicas.value_or(0));
               ec = errc::key_value::document_irretrievable;
             }
 

package/deps/couchbase-cxx-client/core/operations/document_lookup_in_any_replica.hxx

@@ -92,8 +92,8 @@ struct lookup_in_any_replica_request {
         return core->with_bucket_configuration(
           id.bucket(),
           [core, id, timeout, specs, parent_span, read_preference, h = std::forward<Handler>(h)](
-            std::error_code ec, const topology::configuration& config) mutable {
-            if (!config.capabilities.supports_subdoc_read_replica()) {
+            std::error_code ec, std::shared_ptr<topology::configuration> config) mutable {
+            if (!config->capabilities.supports_subdoc_read_replica()) {
               ec = errc::common::feature_not_available;
             }
             const auto [e, origin] = core->origin();
@@ -108,7 +108,7 @@ struct lookup_in_any_replica_request {
                 "Unable to retrieve replicas for \"{}\", server_group={}, number_of_replicas={}",
                 id,
                 origin.options().server_group,
-                config.num_replicas.value_or(0));
+                config->num_replicas.value_or(0));
               ec = errc::key_value::document_irretrievable;
             }
 

package/deps/couchbase-cxx-client/core/operations/document_prepend.cxx

@@ -28,6 +28,7 @@ prepend_request::encode_to(prepend_request::encoded_request_type& encoded,
 {
   encoded.opaque(opaque);
   encoded.partition(partition);
+  encoded.cas(cas);
   encoded.body().id(id);
   encoded.body().content(value);
   return {};

package/deps/couchbase-cxx-client/core/operations/document_prepend.hxx

@@ -50,6 +50,7 @@ struct prepend_request {
   std::vector<std::byte> value;
   std::uint16_t partition{};
   std::uint32_t opaque{};
+  couchbase::cas cas{ 0 };
   couchbase::durability_level durability_level{ durability_level::none };
   std::optional<std::chrono::milliseconds> timeout{};
   io::retry_context<false> retries{};

package/deps/couchbase-cxx-client/couchbase-sdk-cxx-black-duck-manifest.yaml

@@ -17,7 +17,7 @@ components:
     versions: [ v9.2.1 ]
   snappy:
     bd-id: fd5e5c60-2c67-4d20-8be9-b7648156cef3
-    versions: [ 1.2.1 ]
+    versions: [ 1.2.2 ]
   asio:
     bd-id: 3739d5e9-9ad8-4845-8077-1770167a69c2
     versions: [ 1.31.0 ]

package/dist/binarycollection.d.ts

@@ -2,7 +2,7 @@
 import { Collection } from './collection';
 import { CounterResult, MutationResult } from './crudoptypes';
 import { DurabilityLevel } from './generaltypes';
-import { NodeCallback } from './utilities';
+import { CasInput, NodeCallback } from './utilities';
 /**
  * @category Key-Value
  */
@@ -93,6 +93,11 @@ export interface AppendOptions {
      * exclusive of {@link durabilityLevel}.
      */
     durabilityReplicateTo?: number;
+    /**
+     * If specified, indicates that operation should be failed if the CAS
+     * has changed from this value, indicating that the document has changed.
+     */
+    cas?: CasInput;
     /**
      * The timeout for this operation, represented in milliseconds.
      */
@@ -118,6 +123,11 @@ export interface PrependOptions {
      * exclusive of {@link durabilityLevel}.
      */
     durabilityReplicateTo?: number;
+    /**
+     * If specified, indicates that operation should be failed if the CAS
+     * has changed from this value, indicating that the document has changed.
+     */
+    cas?: CasInput;
     /**
      * The timeout for this operation, represented in milliseconds.
      */

package/dist/binding.d.ts

@@ -453,6 +453,7 @@ export interface CppPrependRequest {
     value: Buffer;
     partition: number;
     opaque: number;
+    cas: CppCasInput;
     durability_level: CppDurabilityLevel;
     timeout?: CppMilliseconds;
 }
@@ -461,6 +462,7 @@ export interface CppPrependWithLegacyDurabilityRequest {
     value: Buffer;
     partition: number;
     opaque: number;
+    cas: CppCasInput;
     timeout?: CppMilliseconds;
     persist_to: CppPersistTo;
     replicate_to: CppReplicateTo;
@@ -556,6 +558,7 @@ export interface CppAppendRequest {
     value: Buffer;
     partition: number;
     opaque: number;
+    cas: CppCasInput;
     durability_level: CppDurabilityLevel;
     timeout?: CppMilliseconds;
 }
@@ -564,6 +567,7 @@ export interface CppAppendWithLegacyDurabilityRequest {
     value: Buffer;
     partition: number;
     opaque: number;
+    cas: CppCasInput;
     timeout?: CppMilliseconds;
     persist_to: CppPersistTo;
     replicate_to: CppReplicateTo;
@@ -2706,17 +2710,20 @@ export interface CppTxnOperationFailed extends CppErrorBase {
     should_not_retry: boolean;
     should_not_rollback: boolean;
     cause: CppTxnExternalException;
+    message?: string;
 }
 export interface CppTxnOpException extends CppErrorBase {
     ctxtype: 'transaction_op_exception';
     ctx: CppTransactionOpErrorContext | undefined;
     cause: CppTxnExternalException;
+    message?: string;
 }
 export interface CppTxnError extends CppErrorBase {
     ctxtype: 'transaction_exception';
     result: CppTransactionResult;
     cause: CppTxnExternalException;
     type: CppTxnFailureType;
+    message?: string;
 }
 export interface CppTransactionErrorContext {
     code: CppErrc;

package/dist/bindingutilities.d.ts

@@ -88,7 +88,7 @@ export declare function endpointStateFromCpp(service: CppDiagEndpointState): End
 /**
  * @internal
  */
-export declare function txnExternalExceptionStringFromCpp(cause: CppTxnExternalException): string;
+export declare function txnExternalExceptionStringFromCpp(cause: CppTxnExternalException, message?: string): string;
 /**
  * @internal
  */

package/dist/bindingutilities.js

@@ -431,8 +431,11 @@ exports.endpointStateFromCpp = endpointStateFromCpp;
 /**
  * @internal
  */
-function txnExternalExceptionStringFromCpp(cause) {
+function txnExternalExceptionStringFromCpp(cause, message) {
     if (cause === binding_1.default.txn_external_exception.unknown) {
+        if (message) {
+            return message;
+        }
         return 'unknown';
     }
     else if (cause ===
@@ -501,7 +504,7 @@ function txnExternalExceptionStringFromCpp(cause) {
     else if (cause === binding_1.default.txn_external_exception.transaction_already_committed) {
         return 'transaction_already_committed';
     }
-    throw new errs.InvalidArgumentError();
+    return 'unknown';
 }
 exports.txnExternalExceptionStringFromCpp = txnExternalExceptionStringFromCpp;
 /**
@@ -513,16 +516,16 @@ function txnOpExeptionFromCpp(err, ctx) {
     }
     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);
+        return new errs.DocumentExistsError(new Error(txnExternalExceptionStringFromCpp(err.cause, err.message)), 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);
+        return new errs.DocumentNotFoundError(new Error(txnExternalExceptionStringFromCpp(err.cause, err.message)), context);
     }
     else if (err.cause === binding_1.default.txn_external_exception.parsing_failure) {
-        return new errs.ParsingFailureError(new Error(txnExternalExceptionStringFromCpp(err.cause)), context);
+        return new errs.ParsingFailureError(new Error(txnExternalExceptionStringFromCpp(err.cause, err.message)), context);
     }
     else if (err.cause === binding_1.default.txn_external_exception.couchbase_exception) {
-        const cause = txnExternalExceptionStringFromCpp(err.cause);
+        const cause = txnExternalExceptionStringFromCpp(err.cause, err.message);
         return new errs.CouchbaseError(cause, new Error(cause), context);
     }
     return err;
@@ -622,12 +625,12 @@ function errorFromCpp(err) {
     }
     // BUG(JSCBC-1010): We shouldn't need to special case these.
     if (err.ctxtype === 'transaction_operation_failed') {
-        const cause = txnExternalExceptionStringFromCpp(err.cause);
+        const cause = txnExternalExceptionStringFromCpp(err.cause, err.message);
         if (cause == 'feature_not_available_exception') {
             const msg = 'Possibly attempting a binary transaction operation with a server version < 7.6.2';
             return new errs.TransactionOperationFailedError(new errs.FeatureNotAvailableError(new Error(msg)));
         }
-        return new errs.TransactionOperationFailedError(new Error(txnExternalExceptionStringFromCpp(err.cause)));
+        return new errs.TransactionOperationFailedError(new Error(txnExternalExceptionStringFromCpp(err.cause, err.message)));
     }
     else if (err.ctxtype === 'transaction_op_exception') {
         let txnContext = null;
@@ -638,15 +641,15 @@ function errorFromCpp(err) {
     }
     else if (err.ctxtype === 'transaction_exception') {
         if (err.type === binding_1.default.txn_failure_type.fail) {
-            return new errs.TransactionFailedError(new Error(txnExternalExceptionStringFromCpp(err.cause)));
+            return new errs.TransactionFailedError(new Error(txnExternalExceptionStringFromCpp(err.cause, err.message)));
         }
         else if (err.type === binding_1.default.txn_failure_type.expiry) {
-            return new errs.TransactionExpiredError(new Error(txnExternalExceptionStringFromCpp(err.cause)));
+            return new errs.TransactionExpiredError(new Error(txnExternalExceptionStringFromCpp(err.cause, err.message)));
         }
         else if (err.type === binding_1.default.txn_failure_type.commit_ambiguous) {
-            return new errs.TransactionCommitAmbiguousError(new Error(txnExternalExceptionStringFromCpp(err.cause)));
+            return new errs.TransactionCommitAmbiguousError(new Error(txnExternalExceptionStringFromCpp(err.cause, err.message)));
         }
-        throw new errs.InvalidArgumentError();
+        return new errs.TransactionFailedError(new Error(txnExternalExceptionStringFromCpp(err.cause, err.message)));
     }
     const baseErr = err;
     const contextOrNull = contextFromCpp(err);

package/dist/collection.js

@@ -1363,6 +1363,7 @@ class Collection {
         const durabilityLevel = options.durabilityLevel;
         const persistTo = options.durabilityPersistTo;
         const replicateTo = options.durabilityReplicateTo;
+        const cas = options.cas;
         const timeout = options.timeout || this.cluster.kvTimeout;
         return utilities_1.PromiseHelper.wrap((wrapCallback) => {
             if (!Buffer.isBuffer(value)) {
@@ -1371,6 +1372,7 @@ class Collection {
             const appendReq = {
                 id: this._cppDocId(key),
                 value,
+                cas: cas || binding_1.zeroCas,
                 timeout,
                 partition: 0,
                 opaque: 0,
@@ -1414,6 +1416,7 @@ class Collection {
         const durabilityLevel = options.durabilityLevel;
         const persistTo = options.durabilityPersistTo;
         const replicateTo = options.durabilityReplicateTo;
+        const cas = options.cas;
         const timeout = options.timeout || this.cluster.kvTimeout;
         return utilities_1.PromiseHelper.wrap((wrapCallback) => {
             if (!Buffer.isBuffer(value)) {
@@ -1422,6 +1425,7 @@ class Collection {
             const prependReq = {
                 id: this._cppDocId(key),
                 value,
+                cas: cas || binding_1.zeroCas,
                 timeout,
                 partition: 0,
                 opaque: 0,

package/dist/collectionmanager.d.ts

@@ -48,7 +48,7 @@ export declare class CollectionSpec {
      *
      * @see {@link IBucketSettings.maxExpiry}
      */
-    maxExpiry: number;
+    maxExpiry?: number;
     /**
      * The history retention override setting in this collection.
      * Only supported on Magma Buckets.

package/dist/collectionmanager.js

@@ -150,8 +150,8 @@ class CollectionManager {
         }
         const bucketName = this._bucket.name;
         const timeout = options.timeout || this._cluster.managementTimeout;
-        const maxExpiry = settings.maxExpiry || 0;
-        const history = settings.history || undefined;
+        const maxExpiry = settings === null || settings === void 0 ? void 0 : settings.maxExpiry;
+        const history = settings === null || settings === void 0 ? void 0 : settings.history;
         return utilities_1.PromiseHelper.wrap((wrapCallback) => {
             this._cluster.conn.managementCollectionCreate({
                 bucket_name: bucketName,

package/dist/transactions.js

@@ -387,6 +387,9 @@ class Transactions {
                 if (e instanceof errors_1.TransactionOperationFailedError) {
                     throw new errors_1.TransactionFailedError(e.cause, e.context);
                 }
+                else if (e instanceof errors_1.TransactionFailedError) {
+                    throw e;
+                }
                 throw new errors_1.TransactionFailedError(e);
             }
             try {

package/package.json

@@ -54,7 +54,7 @@
     "type": "git",
     "url": "http://github.com/couchbase/couchnode.git"
   },
-  "version": "4.4.5",
+  "version": "4.4.6",
   "config": {
     "native": false
   },
@@ -79,13 +79,13 @@
     ]
   },
   "optionalDependencies": {
-    "@couchbase/couchbase-darwin-arm64-napi": "4.4.5",
-    "@couchbase/couchbase-darwin-x64-napi": "4.4.5",
-    "@couchbase/couchbase-linux-arm64-napi": "4.4.5",
-    "@couchbase/couchbase-linuxmusl-arm64-napi": "4.4.5",
-    "@couchbase/couchbase-linuxmusl-x64-napi": "4.4.5",
-    "@couchbase/couchbase-linux-x64-napi": "4.4.5",
-    "@couchbase/couchbase-win32-x64-napi": "4.4.5"
+    "@couchbase/couchbase-darwin-arm64-napi": "4.4.6",
+    "@couchbase/couchbase-darwin-x64-napi": "4.4.6",
+    "@couchbase/couchbase-linux-arm64-napi": "4.4.6",
+    "@couchbase/couchbase-linuxmusl-arm64-napi": "4.4.6",
+    "@couchbase/couchbase-linuxmusl-x64-napi": "4.4.6",
+    "@couchbase/couchbase-linux-x64-napi": "4.4.6",
+    "@couchbase/couchbase-win32-x64-napi": "4.4.6"
   },
   "files": [
     "LICENSE",

package/scripts/buildPrebuild.js

@@ -66,7 +66,7 @@ if (args.length > 0) {
     let rt = undefined
     if (args[runtimeIdx].includes('=')) {
       rt = args[runtimeIdx].split('=')[1]
-    } else if (args.length - 1 <= runtimeIdx + 1) {
+    } else if (args.length - 1 >= runtimeIdx + 1) {
       rt = args[runtimeIdx + 1]
     }
 
@@ -81,7 +81,7 @@ if (args.length > 0) {
     let rtv = undefined
     if (args[runtimeVersionIdx].includes('=')) {
       rtv = args[runtimeVersionIdx].split('=')[1]
-    } else if (args.length - 1 <= runtimeVersionIdx + 1) {
+    } else if (args.length - 1 >= runtimeVersionIdx + 1) {
       rtv = args[runtimeVersionIdx + 1]
     }
 
@@ -112,11 +112,12 @@ if (args.length > 0) {
     let pv = undefined
     if (args[parallelIdx].includes('=')) {
       pv = args[parallelIdx].split('=')[1]
-    } else if (args.length - 1 <= parallelIdx + 1) {
+    } else if (args.length - 1 >= parallelIdx + 1) {
       pv = args[parallelIdx + 1]
     }
 
     if (pv && !isNaN(parseInt(pv))) {
+      const os = require('os')
       const pvi = parseInt(pv)
       if (pvi <= os.cpus().length) {
         cmakeParallel = pvi

package/scripts/prebuilds.js

@@ -376,6 +376,9 @@ function matchingPlatformPrebuild(filename, useElectronRuntime = false) {
     _runtime = 'electron'
   } else if (runtime === 'node') {
     _runtime = 'napi'
+  } else if (runtime === 'electron') {
+    // NOTE: electron support is experimental
+    _runtime = 'electron'
   } else {
     console.log(`Unsupported runtime: ${runtime}`)
     return false
@@ -439,6 +442,9 @@ function resolvePrebuild(
     _runtime = 'electron'
   } else if (runtime === 'node') {
     _runtime = 'napi'
+  } else if (runtime === 'electron') {
+    // NOTE: electron support is experimental
+    _runtime = 'electron'
   } else {
     throw new Error(`Unsupported runtime: ${runtime}`)
   }

package/src/binding.cpp

@@ -66,6 +66,8 @@ Napi::Object Init(Napi::Env env, Napi::Object exports)
             couchbase::core::logger::configuration configuration{};
             configuration.filename = logFileStr;
             configuration.log_level = cbppLogLevel;
+            const char *enableConsoleLoggingCstr = getenv("CBPPENABLECONSOLE");
+            configuration.console = enableConsoleLoggingCstr != nullptr;
             couchbase::core::logger::create_file_logger(configuration);
 
         } else {