couchbase 4.1.2 → 4.1.3

package/src/jstocbpp_basic.hpp

@@ -5,32 +5,33 @@
 #include "jstocbpp_cpptypes.hpp"
 #include "mutationtoken.hpp"
 
-#include <couchbase/cluster.hxx>
+#include <core/cluster.hxx>
 
 namespace couchnode
 {
 
 template <>
-struct js_to_cbpp_t<couchbase::json_string> {
+struct js_to_cbpp_t<couchbase::core::json_string> {
     static inline Napi::Value to_js(Napi::Env env,
-                                    const couchbase::json_string &cppObj)
+                                    const couchbase::core::json_string &cppObj)
     {
         return js_to_cbpp_t<std::string>::to_js(env, cppObj.str());
     }
 
-    static inline couchbase::json_string from_js(Napi::Value jsVal)
+    static inline couchbase::core::json_string from_js(Napi::Value jsVal)
     {
         auto str = js_to_cbpp_t<std::string>::from_js(jsVal);
-        return couchbase::json_string(std::move(str));
+        return couchbase::core::json_string(std::move(str));
     }
 };
 
 template <>
-struct js_to_cbpp_t<couchbase::cluster_credentials> {
-    static inline couchbase::cluster_credentials from_js(Napi::Value jsVal)
+struct js_to_cbpp_t<couchbase::core::cluster_credentials> {
+    static inline couchbase::core::cluster_credentials
+    from_js(Napi::Value jsVal)
     {
         auto jsObj = jsVal.ToObject();
-        couchbase::cluster_credentials cppObj;
+        couchbase::core::cluster_credentials cppObj;
         js_to_cbpp(cppObj.username, jsObj.Get("username"));
         js_to_cbpp(cppObj.password, jsObj.Get("password"));
         js_to_cbpp(cppObj.certificate_path, jsObj.Get("certificate_path"));
@@ -42,9 +43,9 @@ struct js_to_cbpp_t<couchbase::cluster_credentials> {
 };
 
 template <>
-struct js_to_cbpp_t<couchbase::document_id> {
+struct js_to_cbpp_t<couchbase::core::document_id> {
     static inline Napi::Value to_js(Napi::Env env,
-                                    const couchbase::document_id &cppObj)
+                                    const couchbase::core::document_id &cppObj)
     {
         auto resObj = Napi::Object::New(env);
         resObj.Set("bucket", cbpp_to_js(env, cppObj.bucket()));
@@ -54,10 +55,10 @@ struct js_to_cbpp_t<couchbase::document_id> {
         return resObj;
     }
 
-    static inline couchbase::document_id from_js(Napi::Value jsVal)
+    static inline couchbase::core::document_id from_js(Napi::Value jsVal)
     {
         auto jsObj = jsVal.ToObject();
-        return couchbase::document_id(
+        return couchbase::core::document_id(
             js_to_cbpp<std::string>(jsObj.Get("bucket")),
             js_to_cbpp<std::string>(jsObj.Get("scope")),
             js_to_cbpp<std::string>(jsObj.Get("collection")),

package/src/jstocbpp_errors.hpp

@@ -4,8 +4,8 @@
 #include "jstocbpp_basic.hpp"
 #include "jstocbpp_cpptypes.hpp"
 
-#include <couchbase/cluster.hxx>
-#include <couchbase/operations/management/error_utils.hxx>
+#include <core/cluster.hxx>
+#include <core/operations/management/error_utils.hxx>
 
 namespace couchnode
 {
@@ -34,53 +34,86 @@ struct js_to_cbpp_t<std::error_code> {
 
     static inline std::error_code from_js(Napi::Value jsVal)
     {
-        throw Napi::Error::New(jsVal.Env(), "invalid std::error_code marshal from js");
+        throw Napi::Error::New(jsVal.Env(),
+                               "invalid std::error_code marshal from js");
     }
 };
 
 template <>
-struct js_to_cbpp_t<couchbase::protocol::enhanced_error_info> {
+struct js_to_cbpp_t<couchbase::key_value_extended_error_info> {
     static inline Napi::Value
-    to_js(Napi::Env env, const couchbase::protocol::enhanced_error_info &cppObj)
+    to_js(Napi::Env env, const couchbase::key_value_extended_error_info &cppObj)
     {
         auto resObj = Napi::Object::New(env);
-        resObj.Set("reference", cbpp_to_js(env, cppObj.reference));
-        resObj.Set("context", cbpp_to_js(env, cppObj.context));
+        resObj.Set("reference", cbpp_to_js(env, cppObj.reference()));
+        resObj.Set("context", cbpp_to_js(env, cppObj.context()));
         return resObj;
     }
 };
 
 template <>
-struct js_to_cbpp_t<couchbase::error_context::key_value> {
+struct js_to_cbpp_t<couchbase::key_value_error_context> {
     static inline Napi::Value
-    to_js(Napi::Env env, const couchbase::error_context::key_value &ctx)
+    to_js(Napi::Env env, const couchbase::key_value_error_context &ctx)
     {
-        if (!ctx.ec) {
+        if (!ctx.ec()) {
             return env.Null();
         }
 
-        Napi::Error err = Napi::Error::New(env, ctx.ec.message());
+        Napi::Error err = Napi::Error::New(env, ctx.ec().message());
         err.Set("ctxtype", Napi::String::New(env, "key_value"));
-        err.Set("code", cbpp_to_js(env, ctx.ec.value()));
-        err.Set("id", cbpp_to_js(env, ctx.id));
-        err.Set("opaque", cbpp_to_js(env, ctx.opaque));
-        err.Set("cas", cbpp_to_js(env, ctx.cas));
-        err.Set("status_code", cbpp_to_js(env, ctx.status_code));
+        err.Set("code", cbpp_to_js(env, ctx.ec().value()));
+        err.Set("id", cbpp_to_js(env, ctx.id()));
+        err.Set("opaque", cbpp_to_js(env, ctx.opaque()));
+        err.Set("cas", cbpp_to_js(env, ctx.cas()));
+        err.Set("status_code", cbpp_to_js(env, ctx.status_code()));
         err.Set("enhanced_error_info",
-                cbpp_to_js(env, ctx.enhanced_error_info));
-        err.Set("last_dispatched_to", cbpp_to_js(env, ctx.last_dispatched_to));
+                cbpp_to_js(env, ctx.extended_error_info()));
+        err.Set("last_dispatched_to",
+                cbpp_to_js(env, ctx.last_dispatched_to()));
         err.Set("last_dispatched_from",
-                cbpp_to_js(env, ctx.last_dispatched_from));
-        err.Set("retry_attempts", cbpp_to_js(env, ctx.retry_attempts));
-        err.Set("retry_reasons", cbpp_to_js(env, ctx.retry_reasons));
+                cbpp_to_js(env, ctx.last_dispatched_from()));
+        err.Set("retry_attempts", cbpp_to_js(env, ctx.retry_attempts()));
+        err.Set("retry_reasons", cbpp_to_js(env, ctx.retry_reasons()));
         return err.Value();
     }
 };
 
 template <>
-struct js_to_cbpp_t<couchbase::error_context::view> {
-    static inline Napi::Value to_js(Napi::Env env,
-                                    const couchbase::error_context::view &ctx)
+struct js_to_cbpp_t<couchbase::subdocument_error_context> {
+    static inline Napi::Value
+    to_js(Napi::Env env, const couchbase::subdocument_error_context &ctx)
+    {
+        if (!ctx.ec()) {
+            return env.Null();
+        }
+
+        Napi::Error err = Napi::Error::New(env, ctx.ec().message());
+        err.Set("ctxtype", Napi::String::New(env, "subdocument"));
+        err.Set("code", cbpp_to_js(env, ctx.ec().value()));
+        err.Set("id", cbpp_to_js(env, ctx.id()));
+        err.Set("opaque", cbpp_to_js(env, ctx.opaque()));
+        err.Set("cas", cbpp_to_js(env, ctx.cas()));
+        err.Set("status_code", cbpp_to_js(env, ctx.status_code()));
+        err.Set("enhanced_error_info",
+                cbpp_to_js(env, ctx.extended_error_info()));
+        err.Set("last_dispatched_to",
+                cbpp_to_js(env, ctx.last_dispatched_to()));
+        err.Set("last_dispatched_from",
+                cbpp_to_js(env, ctx.last_dispatched_from()));
+        err.Set("retry_attempts", cbpp_to_js(env, ctx.retry_attempts()));
+        err.Set("retry_reasons", cbpp_to_js(env, ctx.retry_reasons()));
+        err.Set("first_error_path", cbpp_to_js(env, ctx.first_error_path()));
+        err.Set("first_error_index", cbpp_to_js(env, ctx.first_error_index()));
+        err.Set("deleted", cbpp_to_js(env, ctx.deleted()));
+        return err.Value();
+    }
+};
+
+template <>
+struct js_to_cbpp_t<couchbase::core::error_context::view> {
+    static inline Napi::Value
+    to_js(Napi::Env env, const couchbase::core::error_context::view &ctx)
     {
         if (!ctx.ec) {
             return env.Null();
@@ -111,9 +144,9 @@ struct js_to_cbpp_t<couchbase::error_context::view> {
 };
 
 template <>
-struct js_to_cbpp_t<couchbase::error_context::query> {
-    static inline Napi::Value to_js(Napi::Env env,
-                                    const couchbase::error_context::query &ctx)
+struct js_to_cbpp_t<couchbase::core::error_context::query> {
+    static inline Napi::Value
+    to_js(Napi::Env env, const couchbase::core::error_context::query &ctx)
     {
         if (!ctx.ec) {
             return env.Null();
@@ -121,9 +154,9 @@ struct js_to_cbpp_t<couchbase::error_context::query> {
 
         auto ec = ctx.ec;
         if (ec) {
-            auto maybeEc =
-                couchbase::operations::management::translate_query_error_code(
-                    ctx.first_error_code, ctx.first_error_message, 0);
+            auto maybeEc = couchbase::core::operations::management::
+                translate_query_error_code(ctx.first_error_code,
+                                           ctx.first_error_message, 0);
             if (maybeEc.has_value()) {
                 ec = maybeEc.value();
             }
@@ -155,9 +188,9 @@ struct js_to_cbpp_t<couchbase::error_context::query> {
 };
 
 template <>
-struct js_to_cbpp_t<couchbase::error_context::search> {
-    static inline Napi::Value to_js(Napi::Env env,
-                                    const couchbase::error_context::search &ctx)
+struct js_to_cbpp_t<couchbase::core::error_context::search> {
+    static inline Napi::Value
+    to_js(Napi::Env env, const couchbase::core::error_context::search &ctx)
     {
         if (!ctx.ec) {
             return env.Null();
@@ -165,9 +198,8 @@ struct js_to_cbpp_t<couchbase::error_context::search> {
 
         auto ec = ctx.ec;
         if (ec) {
-            auto maybeEc =
-                couchbase::operations::management::translate_search_error_code(
-                    ctx.http_status, ctx.http_body);
+            auto maybeEc = couchbase::core::operations::management::
+                translate_search_error_code(ctx.http_status, ctx.http_body);
             if (maybeEc.has_value()) {
                 ec = maybeEc.value();
             }
@@ -197,9 +229,9 @@ struct js_to_cbpp_t<couchbase::error_context::search> {
 };
 
 template <>
-struct js_to_cbpp_t<couchbase::error_context::analytics> {
+struct js_to_cbpp_t<couchbase::core::error_context::analytics> {
     static inline Napi::Value
-    to_js(Napi::Env env, const couchbase::error_context::analytics &ctx)
+    to_js(Napi::Env env, const couchbase::core::error_context::analytics &ctx)
     {
         if (!ctx.ec) {
             return env.Null();
@@ -207,7 +239,7 @@ struct js_to_cbpp_t<couchbase::error_context::analytics> {
 
         auto ec = ctx.ec;
         if (ec) {
-            auto maybeEc = couchbase::operations::management::
+            auto maybeEc = couchbase::core::operations::management::
                 translate_analytics_error_code(ctx.first_error_code,
                                                ctx.first_error_message);
             if (maybeEc.has_value()) {
@@ -241,9 +273,9 @@ struct js_to_cbpp_t<couchbase::error_context::analytics> {
 };
 
 template <>
-struct js_to_cbpp_t<couchbase::error_context::http> {
-    static inline Napi::Value to_js(Napi::Env env,
-                                    const couchbase::error_context::http &ctx)
+struct js_to_cbpp_t<couchbase::core::error_context::http> {
+    static inline Napi::Value
+    to_js(Napi::Env env, const couchbase::core::error_context::http &ctx)
     {
         if (!ctx.ec) {
             return env.Null();

package/src/jstocbpp_transactions.hpp

@@ -4,7 +4,7 @@
 #include "jstocbpp_basic.hpp"
 #include "jstocbpp_cpptypes.hpp"
 
-#include <couchbase/cluster.hxx>
+#include <core/cluster.hxx>
 #include <couchbase/transactions.hxx>
 #include <couchbase/transactions/internal/exceptions_internal.hxx>
 
@@ -36,26 +36,25 @@ struct js_to_cbpp_t<cbtxns::transaction_config> {
         cbtxns::transaction_config cppObj;
 
         auto durability_level =
-            js_to_cbpp<std::optional<couchbase::protocol::durability_level>>(
+            js_to_cbpp<std::optional<couchbase::durability_level>>(
                 jsObj.Get("durability_level"));
         if (durability_level.has_value()) {
             // BUG(JSCBC-1012): This translation should not be neccessary.
             switch (durability_level.value()) {
-            case couchbase::protocol::durability_level::none:
+            case couchbase::durability_level::none:
                 cppObj.durability_level(
                     couchbase::transactions::durability_level::NONE);
                 break;
-            case couchbase::protocol::durability_level::majority:
+            case couchbase::durability_level::majority:
                 cppObj.durability_level(
                     couchbase::transactions::durability_level::MAJORITY);
                 break;
-            case couchbase::protocol::durability_level::
-                majority_and_persist_to_active:
+            case couchbase::durability_level::majority_and_persist_to_active:
                 cppObj.durability_level(
                     couchbase::transactions::durability_level::
                         MAJORITY_AND_PERSIST_TO_ACTIVE);
                 break;
-            case couchbase::protocol::durability_level::persist_to_majority:
+            case couchbase::durability_level::persist_to_majority:
                 cppObj.durability_level(
                     couchbase::transactions::durability_level::
                         PERSIST_TO_MAJORITY);
@@ -80,7 +79,7 @@ struct js_to_cbpp_t<cbtxns::transaction_config> {
         }
 
         auto query_scan_consistency =
-            js_to_cbpp<std::optional<couchbase::query_scan_consistency>>(
+            js_to_cbpp<std::optional<couchbase::core::query_scan_consistency>>(
                 jsObj.Get("query_scan_consistency"));
         if (query_scan_consistency.has_value()) {
             cppObj.scan_consistency(query_scan_consistency.value());
@@ -117,26 +116,25 @@ struct js_to_cbpp_t<cbtxns::per_transaction_config> {
         cbtxns::per_transaction_config cppObj;
 
         auto durability_level =
-            js_to_cbpp<std::optional<couchbase::protocol::durability_level>>(
+            js_to_cbpp<std::optional<couchbase::durability_level>>(
                 jsObj.Get("durability_level"));
         if (durability_level.has_value()) {
             // BUG(JSCBC-1012): This translation should not be neccessary.
             switch (durability_level.value()) {
-            case couchbase::protocol::durability_level::none:
+            case couchbase::durability_level::none:
                 cppObj.durability_level(
                     couchbase::transactions::durability_level::NONE);
                 break;
-            case couchbase::protocol::durability_level::majority:
+            case couchbase::durability_level::majority:
                 cppObj.durability_level(
                     couchbase::transactions::durability_level::MAJORITY);
                 break;
-            case couchbase::protocol::durability_level::
-                majority_and_persist_to_active:
+            case couchbase::durability_level::majority_and_persist_to_active:
                 cppObj.durability_level(
                     couchbase::transactions::durability_level::
                         MAJORITY_AND_PERSIST_TO_ACTIVE);
                 break;
-            case couchbase::protocol::durability_level::persist_to_majority:
+            case couchbase::durability_level::persist_to_majority:
                 cppObj.durability_level(
                     couchbase::transactions::durability_level::
                         PERSIST_TO_MAJORITY);
@@ -161,7 +159,7 @@ struct js_to_cbpp_t<cbtxns::per_transaction_config> {
         }
 
         auto query_scan_consistency =
-            js_to_cbpp<std::optional<couchbase::query_scan_consistency>>(
+            js_to_cbpp<std::optional<couchbase::core::query_scan_consistency>>(
                 jsObj.Get("query_scan_consistency"));
         if (query_scan_consistency.has_value()) {
             cppObj.scan_consistency(query_scan_consistency.value());
@@ -254,9 +252,10 @@ struct js_to_cbpp_t<cbtxns::transaction_get_result> {
     {
         auto jsObj = jsVal.ToObject();
         return cbtxns::transaction_get_result(
-            js_to_cbpp<couchbase::document_id>(jsObj.Get("id")),
-            js_to_cbpp<couchbase::json_string>(jsObj.Get("content")).str(),
-            js_to_cbpp<couchbase::cas>(jsObj.Get("cas")).value,
+            js_to_cbpp<couchbase::core::document_id>(jsObj.Get("id")),
+            js_to_cbpp<couchbase::core::json_string>(jsObj.Get("content"))
+                .str(),
+            js_to_cbpp<couchbase::cas>(jsObj.Get("cas")).value(),
             js_to_cbpp<cbtxns::transaction_links>(jsObj.Get("links")),
             js_to_cbpp<std::optional<cbtxns::document_metadata>>(
                 jsObj.Get("metadata")));
@@ -267,7 +266,7 @@ struct js_to_cbpp_t<cbtxns::transaction_get_result> {
     {
         auto resObj = Napi::Object::New(env);
         resObj.Set("id", cbpp_to_js(env, res.id()));
-        resObj.Set("content", cbpp_to_js(env, couchbase::json_string(
+        resObj.Set("content", cbpp_to_js(env, couchbase::core::json_string(
                                                   res.content<std::string>())));
         resObj.Set("cas", cbpp_to_js(env, couchbase::cas{res.cas()}));
         resObj.Set("links", cbpp_to_js(env, res.links()));
@@ -284,7 +283,7 @@ struct js_to_cbpp_t<cbtxns::transaction_query_options> {
         cbtxns::transaction_query_options cppObj;
 
         auto raw = js_to_cbpp<
-            std::optional<std::map<std::string, couchbase::json_string>>>(
+            std::optional<std::map<std::string, couchbase::core::json_string>>>(
             jsObj.Get("raw"));
         if (raw.has_value()) {
             for (auto &v : *raw) {
@@ -298,14 +297,15 @@ struct js_to_cbpp_t<cbtxns::transaction_query_options> {
         }
 
         auto scan_consistency =
-            js_to_cbpp<std::optional<couchbase::query_scan_consistency>>(
+            js_to_cbpp<std::optional<couchbase::core::query_scan_consistency>>(
                 jsObj.Get("scan_consistency"));
         if (scan_consistency.has_value()) {
             cppObj.scan_consistency(scan_consistency.value());
         }
 
-        auto profile = js_to_cbpp<std::optional<couchbase::query_profile_mode>>(
-            jsObj.Get("profile"));
+        auto profile =
+            js_to_cbpp<std::optional<couchbase::core::query_profile_mode>>(
+                jsObj.Get("profile"));
         if (profile.has_value()) {
             cppObj.profile(profile.value());
         }
@@ -356,15 +356,15 @@ struct js_to_cbpp_t<cbtxns::transaction_query_options> {
             cppObj.max_parallelism(max_parallelism.value());
         }
 
-        auto positional_parameters =
-            js_to_cbpp<std::optional<std::vector<couchbase::json_string>>>(
-                jsObj.Get("positional_parameters"));
+        auto positional_parameters = js_to_cbpp<
+            std::optional<std::vector<couchbase::core::json_string>>>(
+            jsObj.Get("positional_parameters"));
         if (positional_parameters.has_value()) {
             cppObj.positional_parameters(positional_parameters.value());
         }
 
         auto named_parameters = js_to_cbpp<
-            std::optional<std::map<std::string, couchbase::json_string>>>(
+            std::optional<std::map<std::string, couchbase::core::json_string>>>(
             jsObj.Get("named_parameters"));
         if (named_parameters.has_value()) {
             cppObj.named_parameters(named_parameters.value());

package/src/mutationtoken.cpp

@@ -48,11 +48,11 @@ Napi::Value MutationToken::toBuffer(Napi::Env env,
                                     const couchbase::mutation_token &token)
 {
     MutationTokenData tokenData;
-    tokenData.partitionId = token.partition_id;
-    tokenData.partitionUuid = token.partition_uuid;
-    tokenData.sequenceNumber = token.sequence_number;
-    memcpy(tokenData.bucketName, token.bucket_name.c_str(),
-           token.bucket_name.size() + 1);
+    tokenData.partitionId = token.partition_id();
+    tokenData.partitionUuid = token.partition_uuid();
+    tokenData.sequenceNumber = token.sequence_number();
+    memcpy(tokenData.bucketName, token.bucket_name().c_str(),
+           token.bucket_name().size() + 1);
     return utils::napiDataToBuffer<MutationTokenData>(env, tokenData);
 }
 
@@ -61,12 +61,9 @@ couchbase::mutation_token MutationToken::fromBuffer(Napi::Value val)
     MutationTokenData tokenData =
         utils::napiBufferToData<MutationTokenData>(val);
 
-    couchbase::mutation_token token;
-    token.partition_id = tokenData.partitionId;
-    token.partition_uuid = tokenData.partitionUuid;
-    token.sequence_number = tokenData.sequenceNumber;
-    token.bucket_name = tokenData.bucketName;
-    return token;
+    return couchbase::mutation_token{
+        tokenData.partitionUuid, tokenData.partitionId,
+        static_cast<uint16_t>(tokenData.sequenceNumber), tokenData.bucketName};
 }
 
 Napi::Value MutationToken::create(Napi::Env env,
@@ -102,8 +99,8 @@ Napi::Value MutationToken::jsToString(const Napi::CallbackInfo &info)
     auto token = MutationToken::parse(info.This());
 
     std::stringstream stream;
-    stream << token.bucket_name << ":" << token.partition_id << ":"
-           << token.partition_uuid << ":" << token.sequence_number;
+    stream << token.bucket_name() << ":" << token.partition_id() << ":"
+           << token.partition_uuid() << ":" << token.sequence_number();
     return Napi::String::New(info.Env(), stream.str());
 }
 
@@ -113,12 +110,12 @@ Napi::Value MutationToken::jsToJSON(const Napi::CallbackInfo &info)
     auto token = MutationToken::parse(info.This());
 
     auto resObj = Napi::Object::New(env);
-    resObj.Set("bucket_name", Napi::String::New(env, token.bucket_name));
-    resObj.Set("partition_id", Napi::Number::New(env, token.partition_id));
+    resObj.Set("bucket_name", Napi::String::New(env, token.bucket_name()));
+    resObj.Set("partition_id", Napi::Number::New(env, token.partition_id()));
     resObj.Set("partition_uuid",
-               Napi::String::New(env, std::to_string(token.partition_uuid)));
+               Napi::String::New(env, std::to_string(token.partition_uuid())));
     resObj.Set("sequence_number",
-               Napi::String::New(env, std::to_string(token.sequence_number)));
+               Napi::String::New(env, std::to_string(token.sequence_number())));
     return resObj;
 }
 
@@ -127,9 +124,9 @@ Napi::Value MutationToken::jsInspect(const Napi::CallbackInfo &info)
     auto token = MutationToken::parse(info.This());
 
     std::stringstream stream;
-    stream << "MutationToken<" << token.bucket_name << ":" << token.partition_id
-           << ":" << token.partition_uuid << ":" << token.sequence_number
-           << ">";
+    stream << "MutationToken<" << token.bucket_name() << ":"
+           << token.partition_id() << ":" << token.partition_uuid() << ":"
+           << token.sequence_number() << ">";
     return Napi::String::New(info.Env(), stream.str());
 }
 

package/src/mutationtoken.hpp

@@ -1,7 +1,7 @@
 #pragma once
 #include "addondata.hpp"
 #include "napi.h"
-#include <couchbase/cluster.hxx>
+#include <core/cluster.hxx>
 
 namespace couchnode
 {

package/src/transaction.cpp

@@ -91,7 +91,7 @@ Napi::Value Transaction::jsGet(const Napi::CallbackInfo &info)
     auto callbackJsFn = info[1].As<Napi::Function>();
     auto cookie = RefCallCookie(info.Env(), callbackJsFn, "txnGetCallback");
 
-    auto docId = jsToCbpp<couchbase::document_id>(optsJsObj.Get("id"));
+    auto docId = jsToCbpp<couchbase::core::document_id>(optsJsObj.Get("id"));
 
     _impl->get_optional(
         docId, [this, cookie = std::move(cookie)](
@@ -102,10 +102,10 @@ Napi::Value Transaction::jsGet(const Napi::CallbackInfo &info)
                 // BUG(JSCBC-1024): We should revert to using direct get
                 // operations once the underlying issue has been resolved.
                 if (!err && !res.has_value()) {
-                    callback.Call(
-                        {cbpp_to_js(env, couchbase::error::make_error_code(
-                                             couchbase::error::key_value_errc::
-                                                 document_not_found))});
+                    callback.Call({cbpp_to_js(
+                        env,
+                        couchbase::errc::make_error_code(
+                            couchbase::errc::key_value::document_not_found))});
                     return;
                 }
 
@@ -122,8 +122,9 @@ Napi::Value Transaction::jsInsert(const Napi::CallbackInfo &info)
     auto callbackJsFn = info[1].As<Napi::Function>();
     auto cookie = RefCallCookie(info.Env(), callbackJsFn, "txnInsertCallback");
 
-    auto docId = jsToCbpp<couchbase::document_id>(optsJsObj.Get("id"));
-    auto content = jsToCbpp<couchbase::json_string>(optsJsObj.Get("content"));
+    auto docId = jsToCbpp<couchbase::core::document_id>(optsJsObj.Get("id"));
+    auto content =
+        jsToCbpp<couchbase::core::json_string>(optsJsObj.Get("content"));
 
     _impl->insert(
         docId, content.str(),
@@ -147,7 +148,8 @@ Napi::Value Transaction::jsReplace(const Napi::CallbackInfo &info)
 
     auto doc = jsToCbpp<couchbase::transactions::transaction_get_result>(
         optsJsObj.Get("doc"));
-    auto content = jsToCbpp<couchbase::json_string>(optsJsObj.Get("content"));
+    auto content =
+        jsToCbpp<couchbase::core::json_string>(optsJsObj.Get("content"));
 
     _impl->replace(
         doc, content.str(),
@@ -194,25 +196,26 @@ Napi::Value Transaction::jsQuery(const Napi::CallbackInfo &info)
     auto options =
         jsToCbpp<couchbase::transactions::transaction_query_options>(optsJsObj);
 
-    _impl->query(
-        statement, options,
-        [this, cookie = std::move(cookie)](
-            std::exception_ptr err,
-            std::optional<couchbase::operations::query_response> resp) mutable {
-            cookie.invoke([err = std::move(err), resp = std::move(resp)](
-                              Napi::Env env, Napi::Function callback) mutable {
-                Napi::Value jsErr, jsRes;
-                try {
-                    jsErr = cbpp_to_js(env, err);
-                    jsRes = cbpp_to_js(env, resp);
-                } catch (const Napi::Error &e) {
-                    jsErr = e.Value();
-                    jsRes = env.Null();
-                }
-
-                callback.Call({jsErr, jsRes});
-            });
-        });
+    _impl->query(statement, options,
+                 [this, cookie = std::move(cookie)](
+                     std::exception_ptr err,
+                     std::optional<couchbase::core::operations::query_response>
+                         resp) mutable {
+                     cookie.invoke(
+                         [err = std::move(err), resp = std::move(resp)](
+                             Napi::Env env, Napi::Function callback) mutable {
+                             Napi::Value jsErr, jsRes;
+                             try {
+                                 jsErr = cbpp_to_js(env, err);
+                                 jsRes = cbpp_to_js(env, resp);
+                             } catch (const Napi::Error &e) {
+                                 jsErr = e.Value();
+                                 jsRes = env.Null();
+                             }
+
+                             callback.Call({jsErr, jsRes});
+                         });
+                 });
 
     return info.Env().Null();
 }

package/src/transactions.hpp

@@ -27,7 +27,7 @@ public:
     Transactions(const Napi::CallbackInfo &info);
     ~Transactions();
 
- Napi::Value jsClose(const Napi::CallbackInfo &info);
+    Napi::Value jsClose(const Napi::CallbackInfo &info);
 
 private:
     std::shared_ptr<cbtxns::transactions> _impl;