couchbase 4.4.6-dev.1 → 4.5.0

package/dist/transactions.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Transactions = exports.TransactionAttemptContext = exports.TransactionQueryResult = exports.TransactionGetResult = exports.TransactionResult = exports.DocumentId = void 0;
+exports.Transactions = exports.TransactionAttemptContext = exports.TransactionQueryResult = exports.TransactionGetMultiReplicasFromPreferredServerGroupResult = exports.TransactionGetMultiReplicasFromPreferredServerGroupResultEntry = exports.TransactionGetMultiResult = exports.TransactionGetMultiResultEntry = exports.TransactionGetResult = exports.TransactionResult = exports.TransactionGetMultiReplicasFromPreferredServerGroupSpec = exports.TransactionGetMultiSpec = exports.TransactionGetMultiReplicasFromPreferredServerGroupMode = exports.TransactionGetMultiMode = exports.DocumentId = void 0;
 const binding_1 = __importDefault(require("./binding"));
 const bindingutilities_1 = require("./bindingutilities");
 const errors_1 = require("./errors");
@@ -24,6 +24,94 @@ class DocumentId {
     }
 }
 exports.DocumentId = DocumentId;
+/**
+ * Represents the mode of the Transactional GetMulti operation.
+ *
+ * @category Transactions
+ */
+var TransactionGetMultiMode;
+(function (TransactionGetMultiMode) {
+    /**
+     * Indicates that the Transactional GetMulti op should prioritise latency.
+     */
+    TransactionGetMultiMode["PrioritiseLatency"] = "prioritise_latency";
+    /**
+     * Indicates that the Transactional GetMulti op should disable read skew detection.
+     */
+    TransactionGetMultiMode["DisableReadSkewDetection"] = "disable_read_skew_detection";
+    /**
+     * Indicates that the Transactional GetMulti op should prioritise read skew detection.
+     */
+    TransactionGetMultiMode["PrioritiseReadSkewDetection"] = "prioritise_read_skew_detection";
+})(TransactionGetMultiMode || (exports.TransactionGetMultiMode = TransactionGetMultiMode = {}));
+/**
+ * Represents the mode of the Transactional GetMultiReplicasFromPreferredServerGroup operation.
+ *
+ * @category Transactions
+ */
+var TransactionGetMultiReplicasFromPreferredServerGroupMode;
+(function (TransactionGetMultiReplicasFromPreferredServerGroupMode) {
+    /**
+     * Indicates that the Transactional GetMultiReplicasFromPreferredServerGroup op should prioritise latency.
+     */
+    TransactionGetMultiReplicasFromPreferredServerGroupMode["PrioritiseLatency"] = "prioritise_latency";
+    /**
+     * Indicates that the Transactional GetMultiReplicasFromPreferredServerGroup op should disable read skew detection.
+     */
+    TransactionGetMultiReplicasFromPreferredServerGroupMode["DisableReadSkewDetection"] = "disable_read_skew_detection";
+    /**
+     * Indicates that the Transactional GetMultiReplicasFromPreferredServerGroup op should prioritise read skew detection.
+     */
+    TransactionGetMultiReplicasFromPreferredServerGroupMode["PrioritiseReadSkewDetection"] = "prioritise_read_skew_detection";
+})(TransactionGetMultiReplicasFromPreferredServerGroupMode || (exports.TransactionGetMultiReplicasFromPreferredServerGroupMode = TransactionGetMultiReplicasFromPreferredServerGroupMode = {}));
+/**
+ * Represents the path to a document.
+ *
+ * @category Transactions
+ */
+class TransactionGetMultiSpec {
+    constructor(collection, id, transcoder) {
+        this.collection = collection;
+        this.id = id;
+        this.transcoder = transcoder;
+    }
+    /**
+     * @internal
+     */
+    _toCppDocumentId() {
+        return {
+            bucket: this.collection.scope.bucket.name,
+            scope: this.collection.scope.name || '_default',
+            collection: this.collection.name || '_default',
+            key: this.id,
+        };
+    }
+}
+exports.TransactionGetMultiSpec = TransactionGetMultiSpec;
+/**
+ * Represents the path to a document.
+ *
+ * @category Transactions
+ */
+class TransactionGetMultiReplicasFromPreferredServerGroupSpec {
+    constructor(collection, id, transcoder) {
+        this.collection = collection;
+        this.id = id;
+        this.transcoder = transcoder;
+    }
+    /**
+     * @internal
+     */
+    _toCppDocumentId() {
+        return {
+            bucket: this.collection.scope.bucket.name,
+            scope: this.collection.scope.name || '_default',
+            collection: this.collection.name || '_default',
+            key: this.id,
+        };
+    }
+}
+exports.TransactionGetMultiReplicasFromPreferredServerGroupSpec = TransactionGetMultiReplicasFromPreferredServerGroupSpec;
 /**
  * Contains the results of a Transaction.
  *
@@ -57,6 +145,113 @@ class TransactionGetResult {
     }
 }
 exports.TransactionGetResult = TransactionGetResult;
+/**
+ * Contains the results of a specific sub-operation within a transactional GetMulti operation.
+ *
+ * @category Transactions
+ */
+class TransactionGetMultiResultEntry {
+    /**
+     * @internal
+     */
+    constructor(data) {
+        this.error = data.error || null;
+        this.value = data.value;
+    }
+}
+exports.TransactionGetMultiResultEntry = TransactionGetMultiResultEntry;
+/**
+ * Contains the results of a transactional GetMulti operation.
+ *
+ * @category Transactions
+ */
+class TransactionGetMultiResult {
+    /**
+     * @internal
+     */
+    constructor(data) {
+        this.content = data.content;
+    }
+    /**
+     * Indicates whether the document at the specified index exists.
+     *
+     * @param index The result index to check.
+     */
+    exists(index) {
+        if (index < 0 || index >= this.content.length) {
+            throw new Error(`Index (${index}) out of bounds.`);
+        }
+        return (this.content[index].error === undefined ||
+            this.content[index].error === null);
+    }
+    /**
+     * Provides the content at the specified index, if it exists.
+     *
+     * @param index The result index to check.
+     */
+    contentAt(index) {
+        if (!this.exists(index)) {
+            throw (this.content[index].error ||
+                new errors_1.DocumentNotFoundError(new Error(`Document does not exist at index=${index}.`)));
+        }
+        return this.content[index].value;
+    }
+}
+exports.TransactionGetMultiResult = TransactionGetMultiResult;
+/**
+ * Contains the results of a specific sub-operation within
+ * a transactional GetMultiReplicasFromPreferredServerGroup operation.
+ *
+ * @category Transactions
+ */
+class TransactionGetMultiReplicasFromPreferredServerGroupResultEntry {
+    /**
+     * @internal
+     */
+    constructor(data) {
+        this.error = data.error || null;
+        this.value = data.value;
+    }
+}
+exports.TransactionGetMultiReplicasFromPreferredServerGroupResultEntry = TransactionGetMultiReplicasFromPreferredServerGroupResultEntry;
+/**
+ * Contains the results of a transactional GetMultiReplicasFromPreferredServerGroup operation.
+ *
+ * @category Transactions
+ */
+class TransactionGetMultiReplicasFromPreferredServerGroupResult {
+    /**
+     * @internal
+     */
+    constructor(data) {
+        this.content = data.content;
+    }
+    /**
+     * Indicates whether the document at the specified index exists.
+     *
+     * @param index The result index to check.
+     */
+    exists(index) {
+        if (index < 0 || index >= this.content.length) {
+            throw new Error(`Index (${index}) out of bounds.`);
+        }
+        return (this.content[index].error === undefined ||
+            this.content[index].error === null);
+    }
+    /**
+     * Provides the content at the specified index, if it exists.
+     *
+     * @param index The result index to check.
+     */
+    contentAt(index) {
+        if (!this.exists(index)) {
+            throw (this.content[index].error ||
+                new errors_1.DocumentNotFoundError(new Error(`Document does not exist at index=${index}.`)));
+        }
+        return this.content[index].value;
+    }
+}
+exports.TransactionGetMultiReplicasFromPreferredServerGroupResult = TransactionGetMultiReplicasFromPreferredServerGroupResult;
 /**
  * Contains the results of a transactional Query operation.
  *
@@ -91,6 +286,58 @@ function translateGetResult(cppRes, transcoder) {
         _metadata: cppRes.metadata,
     });
 }
+/**
+ * @internal
+ */
+function translateGetMultiResult(cppRes, transcoders) {
+    if (!cppRes) {
+        return null;
+    }
+    const content = [];
+    for (let i = 0; i < cppRes.content.length; ++i) {
+        const cppEntry = cppRes.content[i];
+        let resultEntry, resultError;
+        if (cppEntry && cppEntry.data && cppEntry.data.length > 0) {
+            resultEntry = transcoders[i].decode(cppEntry.data, cppEntry.flags);
+        }
+        else {
+            resultError = new errors_1.DocumentNotFoundError(new Error(`Document not found at index=${i}.`));
+        }
+        content.push(new TransactionGetMultiResultEntry({
+            value: resultEntry,
+            error: resultError,
+        }));
+    }
+    return new TransactionGetMultiResult({
+        content,
+    });
+}
+/**
+ * @internal
+ */
+function translateGetMultiReplicasFromPreferredServerGroupResult(cppRes, transcoders) {
+    if (!cppRes) {
+        return null;
+    }
+    const content = [];
+    for (let i = 0; i < cppRes.content.length; ++i) {
+        const cppEntry = cppRes.content[i];
+        let resultEntry, resultError;
+        if (cppEntry && cppEntry.data && cppEntry.data.length > 0) {
+            resultEntry = transcoders[i].decode(cppEntry.data, cppEntry.flags);
+        }
+        else {
+            resultError = new errors_1.DocumentNotFoundError(new Error(`Document not found at index=${i}.`));
+        }
+        content.push(new TransactionGetMultiReplicasFromPreferredServerGroupResultEntry({
+            value: resultEntry,
+            error: resultError,
+        }));
+    }
+    return new TransactionGetMultiReplicasFromPreferredServerGroupResult({
+        content,
+    });
+}
 /**
  * Provides an interface to preform transactional operations in a transaction.
  *
@@ -150,6 +397,72 @@ class TransactionAttemptContext {
             });
         });
     }
+    /**
+     * Retrieves the value of a document from the collection.
+     *
+     * @param collection The collection the document lives in.
+     * @param key The document key to retrieve.
+     * @param options Optional parameters for this operation.
+     */
+    async getReplicaFromPreferredServerGroup(collection, key, options) {
+        const transcoder = (options === null || options === void 0 ? void 0 : options.transcoder) || this._transcoder;
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            const id = collection._cppDocId(key);
+            this._impl.getReplicaFromPreferredServerGroup({
+                id,
+            }, (cppErr, cppRes) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                wrapCallback(err, translateGetResult(cppRes, transcoder));
+            });
+        });
+    }
+    /**
+     * Retrieves the documents specified in the list of specs.
+     *
+     * @param specs The documents to retrieve.
+     * @param options Optional parameters for this operation.
+     */
+    async getMultiReplicasFromPreferredServerGroup(specs, options) {
+        const ids = specs.map((spec) => spec._toCppDocumentId());
+        const transcoders = specs.map((spec) => spec.transcoder || this._transcoder);
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._impl.getMultiReplicasFromPreferredServerGroup({
+                ids,
+                mode: (0, bindingutilities_1.transactionGetMultiReplicasFromPreferredServerGroupModeToCpp)(options === null || options === void 0 ? void 0 : options.mode),
+            }, (cppErr, cppRes) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                wrapCallback(err, translateGetMultiReplicasFromPreferredServerGroupResult(cppRes, transcoders));
+            });
+        });
+    }
+    /**
+     * Retrieves the documents specified in the list of specs.
+     *
+     * @param specs The documents to retrieve.
+     * @param options Optional parameters for this operation.
+     */
+    async getMulti(specs, options) {
+        const ids = specs.map((spec) => spec._toCppDocumentId());
+        const transcoders = specs.map((spec) => spec.transcoder || this._transcoder);
+        return utilities_1.PromiseHelper.wrap((wrapCallback) => {
+            this._impl.getMulti({
+                ids,
+                mode: (0, bindingutilities_1.transactionGetMultiModeToCpp)(options === null || options === void 0 ? void 0 : options.mode),
+            }, (cppErr, cppRes) => {
+                const err = (0, bindingutilities_1.errorFromCpp)(cppErr);
+                if (err) {
+                    return wrapCallback(err, null);
+                }
+                wrapCallback(err, translateGetMultiResult(cppRes, transcoders));
+            });
+        });
+    }
     /**
      * Inserts a new document to the collection, failing if the document already exists.
      *
@@ -387,6 +700,10 @@ class Transactions {
                 if (e instanceof errors_1.TransactionOperationFailedError) {
                     throw new errors_1.TransactionFailedError(e.cause, e.context);
                 }
+                else if (e instanceof errors_1.TransactionExpiredError ||
+                    e instanceof errors_1.TransactionCommitAmbiguousError) {
+                    throw e;
+                }
                 throw new errors_1.TransactionFailedError(e);
             }
             try {

package/dist/transcoders.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 /**
  * Transcoders provide functionality for converting values passed to and from
  * the SDK to byte arrays and flags data that can be stored to the server.

package/dist/utilities.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { DurabilityLevel } from './generaltypes';
 /**
  * CAS represents an opaque value which can be used to compare documents to

package/package.json

@@ -20,41 +20,41 @@
   "license": "Apache-2.0",
   "name": "couchbase",
   "dependencies": {
-    "cmake-js": "^7.3.0",
-    "node-addon-api": "^8.0.0"
+    "cmake-js": "^7.3.1",
+    "node-addon-api": "^8.3.1"
   },
   "devDependencies": {
-    "@trivago/prettier-plugin-sort-imports": "^4.3.0",
-    "@tsconfig/node12": "^12.1.3",
+    "@trivago/prettier-plugin-sort-imports": "^5.2.2",
+    "@tsconfig/node12": "^12.1.4",
     "@types/bindings": "^1.5.5",
     "@types/debug": "^4.1.12",
-    "@types/node": "^20.14.5",
+    "@types/node": "^22.14.1",
     "@typescript-eslint/eslint-plugin": "^7.13.1",
     "@typescript-eslint/parser": "^7.13.1",
-    "chai": "^4.4.1",
+    "chai": "^4.5.0",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-jsdoc": "^48.2.12",
-    "eslint-plugin-mocha": "^10.4.3",
+    "eslint-plugin-mocha": "^10.5.0",
     "eslint-plugin-node": "^11.1.0",
     "expose-gc": "^1.0.0",
-    "mocha": "^10.4.0",
-    "npm-check-updates": "^16.14.20",
-    "nyc": "^17.0.0",
-    "prettier": "^3.3.2",
+    "mocha": "^11.1.0",
+    "npm-check-updates": "^18.0.0",
+    "nyc": "^17.1.0",
+    "prettier": "^3.5.3",
     "segfault-handler": "^1.3.0",
-    "semver": "^7.6.2",
-    "ts-mocha": "^10.0.0",
+    "semver": "^7.7.1",
+    "ts-mocha": "^11.1.0",
     "ts-node": "^10.9.2",
-    "typedoc": "^0.25.13",
-    "typescript": "^5.4.5",
-    "uuid": "^10.0.0"
+    "typedoc": "^0.28.3",
+    "typescript": "~5.4.5",
+    "uuid": "^11.1.0"
   },
   "repository": {
     "type": "git",
     "url": "http://github.com/couchbase/couchnode.git"
   },
-  "version": "4.4.6-dev.1",
+  "version": "4.5.0",
   "config": {
     "native": false
   },
@@ -79,13 +79,13 @@
     ]
   },
   "optionalDependencies": {
-    "@couchbase/couchbase-darwin-arm64-napi": "4.4.6-dev.1",
-    "@couchbase/couchbase-darwin-x64-napi": "4.4.6-dev.1",
-    "@couchbase/couchbase-linux-arm64-napi": "4.4.6-dev.1",
-    "@couchbase/couchbase-linuxmusl-arm64-napi": "4.4.6-dev.1",
-    "@couchbase/couchbase-linuxmusl-x64-napi": "4.4.6-dev.1",
-    "@couchbase/couchbase-linux-x64-napi": "4.4.6-dev.1",
-    "@couchbase/couchbase-win32-x64-napi": "4.4.6-dev.1"
+    "@couchbase/couchbase-darwin-arm64-napi": "4.5.0",
+    "@couchbase/couchbase-darwin-x64-napi": "4.5.0",
+    "@couchbase/couchbase-linux-arm64-napi": "4.5.0",
+    "@couchbase/couchbase-linuxmusl-arm64-napi": "4.5.0",
+    "@couchbase/couchbase-linuxmusl-x64-napi": "4.5.0",
+    "@couchbase/couchbase-linux-x64-napi": "4.5.0",
+    "@couchbase/couchbase-win32-x64-napi": "4.5.0"
   },
   "files": [
     "LICENSE",

package/src/connection.cpp

@@ -279,7 +279,7 @@ Napi::Value Connection::jsConnect(const Napi::CallbackInfo &info)
 {
     auto connstr = info[0].ToString().Utf8Value();
     auto credentialsJsObj = info[1].As<Napi::Object>();
-    auto callbackJsFn = info[3].As<Napi::Function>();
+    auto callbackJsFn = info[4].As<Napi::Function>();
 
     auto connstrInfo = couchbase::core::utils::parse_connection_string(connstr);
     auto creds =
@@ -313,6 +313,36 @@ Napi::Value Connection::jsConnect(const Napi::CallbackInfo &info)
         connstrInfo.options.dns_config = cppDnsConfig;
     }
 
+    if (!info[3].IsNull()) {
+        auto jsAppTelemetryConfigObj = info[3].As<Napi::Object>();
+        auto jsEnabled = jsAppTelemetryConfigObj.Get("enabled");
+        if (!(jsEnabled.IsNull() || jsEnabled.IsUndefined())) {
+            connstrInfo.options.enable_app_telemetry =
+                js_to_cbpp<bool>(jsEnabled);
+        }
+        auto jsEndpoint = jsAppTelemetryConfigObj.Get("endpoint");
+        if (!(jsEndpoint.IsNull() || jsEndpoint.IsUndefined() ||
+              jsEndpoint.IsEmpty())) {
+            connstrInfo.options.app_telemetry_endpoint =
+                js_to_cbpp<std::string>(jsEndpoint);
+        }
+        auto jsBackoff = jsAppTelemetryConfigObj.Get("backoff");
+        if (!(jsBackoff.IsNull() || jsBackoff.IsUndefined())) {
+            connstrInfo.options.app_telemetry_backoff_interval =
+                js_to_cbpp<std::chrono::milliseconds>(jsBackoff);
+        }
+        auto jsPingInterval = jsAppTelemetryConfigObj.Get("pingInterval");
+        if (!(jsPingInterval.IsNull() || jsPingInterval.IsUndefined())) {
+            connstrInfo.options.app_telemetry_ping_interval =
+                js_to_cbpp<std::chrono::milliseconds>(jsPingInterval);
+        }
+        auto jsPingTimeout = jsAppTelemetryConfigObj.Get("pingTimeout");
+        if (!(jsPingTimeout.IsNull() || jsPingTimeout.IsUndefined())) {
+            connstrInfo.options.app_telemetry_ping_timeout =
+                js_to_cbpp<std::chrono::milliseconds>(jsPingTimeout);
+        }
+    }
+
     auto cookie = CallCookie(info.Env(), callbackJsFn, "cbConnectCallback");
     this->_instance->_cluster.open(
         couchbase::core::origin(creds, connstrInfo),
@@ -440,9 +470,9 @@ Napi::Value Connection::jsScan(const Napi::CallbackInfo &info)
     auto f = barrier->get_future();
     this->_instance->_cluster.with_bucket_configuration(
         bucketName,
-        [barrier](
-            std::error_code ec,
-            std::shared_ptr<couchbase::core::topology::configuration> config) mutable {
+        [barrier](std::error_code ec,
+                  std::shared_ptr<couchbase::core::topology::configuration>
+                      config) mutable {
             if (ec) {
                 return barrier->set_value(tl::unexpected(ec));
             }

package/src/constants.cpp

@@ -4,6 +4,8 @@
 #include <core/impl/subdoc/path_flags.hxx>
 #include <core/transactions.hxx>
 #include <core/transactions/internal/exceptions_internal.hxx>
+#include <core/transactions/transaction_get_multi_mode.hxx>
+#include <core/transactions/transaction_get_multi_replicas_from_preferred_server_group_result.hxx>
 #include <couchbase/error_context.hxx>
 #include <set>
 #include <vector>
@@ -1102,6 +1104,128 @@ void Constants::InitAutogen(Napi::Env env, Napi::Object exports)
                  couchbase::core::vector_query_combination::combination_or},
             }));
 
+    exports.Set(
+        "transactions_failure_type",
+        cbppEnumToJs<couchbase::core::transactions::failure_type>(
+            env,
+            {
+                {"FAIL", couchbase::core::transactions::failure_type::FAIL},
+                {"EXPIRY", couchbase::core::transactions::failure_type::EXPIRY},
+                {"COMMIT_AMBIGUOUS",
+                 couchbase::core::transactions::failure_type::COMMIT_AMBIGUOUS},
+            }));
+
+    exports.Set(
+        "transactions_external_exception",
+        cbppEnumToJs<couchbase::core::transactions::external_exception>(
+            env,
+            {
+                {"UNKNOWN",
+                 couchbase::core::transactions::external_exception::UNKNOWN},
+                {"ACTIVE_TRANSACTION_RECORD_ENTRY_NOT_FOUND",
+                 couchbase::core::transactions::external_exception::
+                     ACTIVE_TRANSACTION_RECORD_ENTRY_NOT_FOUND},
+                {"ACTIVE_TRANSACTION_RECORD_FULL",
+                 couchbase::core::transactions::external_exception::
+                     ACTIVE_TRANSACTION_RECORD_FULL},
+                {"ACTIVE_TRANSACTION_RECORD_NOT_FOUND",
+                 couchbase::core::transactions::external_exception::
+                     ACTIVE_TRANSACTION_RECORD_NOT_FOUND},
+                {"DOCUMENT_ALREADY_IN_TRANSACTION",
+                 couchbase::core::transactions::external_exception::
+                     DOCUMENT_ALREADY_IN_TRANSACTION},
+                {"DOCUMENT_EXISTS_EXCEPTION",
+                 couchbase::core::transactions::external_exception::
+                     DOCUMENT_EXISTS_EXCEPTION},
+                {"DOCUMENT_NOT_FOUND_EXCEPTION",
+                 couchbase::core::transactions::external_exception::
+                     DOCUMENT_NOT_FOUND_EXCEPTION},
+                {"NOT_SET",
+                 couchbase::core::transactions::external_exception::NOT_SET},
+                {"FEATURE_NOT_AVAILABLE_EXCEPTION",
+                 couchbase::core::transactions::external_exception::
+                     FEATURE_NOT_AVAILABLE_EXCEPTION},
+                {"TRANSACTION_ABORTED_EXTERNALLY",
+                 couchbase::core::transactions::external_exception::
+                     TRANSACTION_ABORTED_EXTERNALLY},
+                {"PREVIOUS_OPERATION_FAILED",
+                 couchbase::core::transactions::external_exception::
+                     PREVIOUS_OPERATION_FAILED},
+                {"FORWARD_COMPATIBILITY_FAILURE",
+                 couchbase::core::transactions::external_exception::
+                     FORWARD_COMPATIBILITY_FAILURE},
+                {"PARSING_FAILURE", couchbase::core::transactions::
+                                        external_exception::PARSING_FAILURE},
+                {"ILLEGAL_STATE_EXCEPTION",
+                 couchbase::core::transactions::external_exception::
+                     ILLEGAL_STATE_EXCEPTION},
+                {"COUCHBASE_EXCEPTION",
+                 couchbase::core::transactions::external_exception::
+                     COUCHBASE_EXCEPTION},
+                {"SERVICE_NOT_AVAILABLE_EXCEPTION",
+                 couchbase::core::transactions::external_exception::
+                     SERVICE_NOT_AVAILABLE_EXCEPTION},
+                {"REQUEST_CANCELED_EXCEPTION",
+                 couchbase::core::transactions::external_exception::
+                     REQUEST_CANCELED_EXCEPTION},
+                {"CONCURRENT_OPERATIONS_DETECTED_ON_SAME_DOCUMENT",
+                 couchbase::core::transactions::external_exception::
+                     CONCURRENT_OPERATIONS_DETECTED_ON_SAME_DOCUMENT},
+                {"COMMIT_NOT_PERMITTED",
+                 couchbase::core::transactions::external_exception::
+                     COMMIT_NOT_PERMITTED},
+                {"ROLLBACK_NOT_PERMITTED",
+                 couchbase::core::transactions::external_exception::
+                     ROLLBACK_NOT_PERMITTED},
+                {"TRANSACTION_ALREADY_ABORTED",
+                 couchbase::core::transactions::external_exception::
+                     TRANSACTION_ALREADY_ABORTED},
+                {"TRANSACTION_ALREADY_COMMITTED",
+                 couchbase::core::transactions::external_exception::
+                     TRANSACTION_ALREADY_COMMITTED},
+                {"DOCUMENT_UNRETRIEVABLE_EXCEPTION",
+                 couchbase::core::transactions::external_exception::
+                     DOCUMENT_UNRETRIEVABLE_EXCEPTION},
+            }));
+
+    exports.Set(
+        "transactions_transaction_get_multi_mode",
+        cbppEnumToJs<couchbase::core::transactions::transaction_get_multi_mode>(
+            env,
+            {
+                {"prioritise_latency",
+                 couchbase::core::transactions::transaction_get_multi_mode::
+                     prioritise_latency},
+                {"disable_read_skew_detection",
+                 couchbase::core::transactions::transaction_get_multi_mode::
+                     disable_read_skew_detection},
+                {"prioritise_read_skew_detection",
+                 couchbase::core::transactions::transaction_get_multi_mode::
+                     prioritise_read_skew_detection},
+            }));
+
+    exports.Set(
+        "transactions_transaction_get_multi_replicas_from_preferred_server_"
+        "group_mode",
+        cbppEnumToJs<
+            couchbase::core::transactions::
+                transaction_get_multi_replicas_from_preferred_server_group_mode>(
+            env,
+            {
+                {"prioritise_latency",
+                 couchbase::core::transactions::
+                     transaction_get_multi_replicas_from_preferred_server_group_mode::
+                         prioritise_latency},
+                {"disable_read_skew_detection",
+                 couchbase::core::transactions::
+                     transaction_get_multi_replicas_from_preferred_server_group_mode::
+                         disable_read_skew_detection},
+                {"prioritise_read_skew_detection",
+                 couchbase::core::transactions::
+                     transaction_get_multi_replicas_from_preferred_server_group_mode::
+                         prioritise_read_skew_detection},
+            }));
+
     //#endregion Autogenerated Constants
 }