couchbase 4.2.5 → 4.2.6-dev

package/src/binding.cpp

@@ -3,6 +3,7 @@
 #include "connection.hpp"
 #include "constants.hpp"
 #include "mutationtoken.hpp"
+#include "scan_iterator.hpp"
 #include "transaction.hpp"
 #include "transactions.hpp"
 #include <napi.h>
@@ -55,11 +56,13 @@ Napi::Object Init(Napi::Env env, Napi::Object exports)
     Connection::Init(env, exports);
     Transactions::Init(env, exports);
     Transaction::Init(env, exports);
+    ScanIterator::Init(env, exports);
 
     exports.Set(Napi::String::New(env, "cbppVersion"),
                 Napi::String::New(env, "1.0.0-beta"));
-    exports.Set(Napi::String::New(env, "cbppMetadata"),
-                Napi::String::New(env, couchbase::core::meta::sdk_build_info_json()));
+    exports.Set(
+        Napi::String::New(env, "cbppMetadata"),
+        Napi::String::New(env, couchbase::core::meta::sdk_build_info_json()));
     return exports;
 }
 

package/src/connection.cpp

@@ -3,8 +3,11 @@
 #include "instance.hpp"
 #include "jstocbpp.hpp"
 #include "mutationtoken.hpp"
+#include "scan_iterator.hpp"
 #include "transcoder.hpp"
+#include <core/agent_group.hxx>
 #include <core/operations/management/freeform.hxx>
+#include <core/range_scan_orchestrator.hxx>
 #include <type_traits>
 
 namespace couchnode
@@ -35,6 +38,7 @@ void Connection::Init(Napi::Env env, Napi::Object exports)
             InstanceMethod<&Connection::jsOpenBucket>("openBucket"),
             InstanceMethod<&Connection::jsDiagnostics>("diagnostics"),
             InstanceMethod<&Connection::jsPing>("ping"),
+            InstanceMethod<&Connection::jsScan>("scan"),
 
             //#region Autogenerated Method Registration
 
@@ -253,9 +257,30 @@ Napi::Value Connection::jsConnect(const Napi::CallbackInfo &info)
         jsToCbpp<couchbase::core::cluster_credentials>(credentialsJsObj);
 
     if (!info[2].IsNull()) {
-        auto dnsConfigJsObj = info[2].As<Napi::Object>();
+        auto jsDnsConfigObj = info[2].As<Napi::Object>();
+        auto jsNameserver = jsDnsConfigObj.Get("nameserver");
+        if (jsNameserver.IsNull() || jsNameserver.IsUndefined() ||
+            jsNameserver.IsEmpty()) {
+            jsDnsConfigObj.Set(
+                "nameserver",
+                cbpp_to_js<std::string>(
+                    info.Env(), connstrInfo.options.dns_config.nameserver()));
+        }
+        auto jsPort = jsDnsConfigObj.Get("port");
+        if (jsPort.IsNull() || jsPort.IsUndefined()) {
+            jsDnsConfigObj.Set(
+                "port", cbpp_to_js<std::uint16_t>(
+                            info.Env(), connstrInfo.options.dns_config.port()));
+        }
+        auto jsTimeout = jsDnsConfigObj.Get("dnsSrvTimeout");
+        if (jsTimeout.IsNull() || jsTimeout.IsUndefined()) {
+            jsDnsConfigObj.Set(
+                "dnsSrvTimeout",
+                cbpp_to_js<std::chrono::milliseconds>(
+                    info.Env(), connstrInfo.options.dns_config.timeout()));
+        }
         auto cppDnsConfig =
-            jsToCbpp<couchbase::core::io::dns::dns_config>(dnsConfigJsObj);
+            jsToCbpp<couchbase::core::io::dns::dns_config>(jsDnsConfigObj);
         connstrInfo.options.dns_config = cppDnsConfig;
     }
 
@@ -366,4 +391,85 @@ Napi::Value Connection::jsPing(const Napi::CallbackInfo &info)
     return info.Env().Null();
 }
 
+Napi::Value Connection::jsScan(const Napi::CallbackInfo &info)
+{
+    auto bucketName = info[0].ToString().Utf8Value();
+    auto scopeName = info[1].ToString().Utf8Value();
+    auto collectionName = info[2].ToString().Utf8Value();
+    auto scanTypeName = info[3].ToString().Utf8Value();
+    // scanType handled below
+    auto optionsObj = info[5].As<Napi::Object>();
+
+    auto env = info.Env();
+    auto resObj = Napi::Object::New(env);
+
+    auto barrier = std::make_shared<std::promise<
+        tl::expected<couchbase::core::topology::configuration::vbucket_map,
+                     std::error_code>>>();
+    auto f = barrier->get_future();
+    this->_instance->_cluster->with_bucket_configuration(
+        bucketName,
+        [barrier](
+            std::error_code ec,
+            const couchbase::core::topology::configuration &config) mutable {
+            if (ec) {
+                return barrier->set_value(tl::unexpected(ec));
+            }
+            if (!config.vbmap || config.vbmap->empty()) {
+                return barrier->set_value(tl::unexpected(
+                    couchbase::errc::common::feature_not_available));
+            }
+            barrier->set_value(config.vbmap.value());
+        });
+    auto vbucket_map = f.get();
+    if (!vbucket_map.has_value()) {
+        resObj.Set("cppErr", cbpp_to_js(env, vbucket_map.error()));
+        resObj.Set("result", env.Null());
+        return resObj;
+    }
+
+    auto agentGroup = couchbase::core::agent_group(
+        this->_instance->_io,
+        couchbase::core::agent_group_config{{this->_instance->_cluster}});
+    agentGroup.open_bucket(bucketName);
+    auto agent = agentGroup.get_agent(bucketName);
+    auto options = js_to_cbpp<couchbase::core::range_scan_orchestrator_options>(
+        optionsObj);
+
+    if (!agent.has_value()) {
+        resObj.Set("cppErr", cbpp_to_js(env, agent.error()));
+        resObj.Set("result", env.Null());
+        return resObj;
+    }
+
+    std::variant<std::monostate, couchbase::core::range_scan,
+                 couchbase::core::prefix_scan, couchbase::core::sampling_scan>
+        scanType;
+    if (scanTypeName.compare("range_scan") == 0) {
+        scanType = js_to_cbpp<couchbase::core::range_scan>(info[4]);
+    } else if (scanTypeName.compare("sampling_scan") == 0) {
+        scanType = js_to_cbpp<couchbase::core::sampling_scan>(info[4]);
+    } else {
+        scanType = js_to_cbpp<couchbase::core::prefix_scan>(info[4]);
+    }
+
+    auto orchestrator = couchbase::core::range_scan_orchestrator(
+        this->_instance->_io, agent.value(), vbucket_map.value(), scopeName,
+        collectionName, scanType, options);
+    auto scanResult = orchestrator.scan();
+    if (!scanResult.has_value()) {
+        resObj.Set("cppErr", cbpp_to_js(env, scanResult.error()));
+        resObj.Set("result", env.Null());
+        return resObj;
+    }
+
+    auto ext = Napi::External<couchbase::core::scan_result>::New(
+        env, &scanResult.value());
+    auto scanIterator = ScanIterator::constructor(info.Env()).New({ext});
+    resObj.Set("cppErr", env.Null());
+    resObj.Set("result", scanIterator);
+
+    return resObj;
+}
+
 } // namespace couchnode

package/src/connection.hpp

@@ -69,6 +69,7 @@ public:
     Napi::Value jsOpenBucket(const Napi::CallbackInfo &info);
     Napi::Value jsDiagnostics(const Napi::CallbackInfo &info);
     Napi::Value jsPing(const Napi::CallbackInfo &info);
+    Napi::Value jsScan(const Napi::CallbackInfo &info);
 
     //#region Autogenerated Method Declarations
 

package/src/constants.cpp

@@ -701,10 +701,8 @@ void Constants::InitAutogen(Napi::Env env, Napi::Object exports)
                  couchbase::errc::key_value::xattr_no_access},
                 {"cannot_revive_living_document",
                  couchbase::errc::key_value::cannot_revive_living_document},
-                {"range_scan_cancelled",
-                 couchbase::errc::key_value::range_scan_cancelled},
-                {"range_scan_vb_uuid_not_equal",
-                 couchbase::errc::key_value::range_scan_vb_uuid_not_equal},
+                {"mutation_token_outdated",
+                 couchbase::errc::key_value::mutation_token_outdated},
                 {"range_scan_completed",
                  couchbase::errc::key_value::range_scan_completed},
             }));
@@ -1050,14 +1048,6 @@ void Constants::InitAutogen(Napi::Env env, Napi::Object exports)
                              {"three", couchbase::replicate_to::three},
                          }));
 
-    exports.Set(
-        "scan_sort",
-        cbppEnumToJs<couchbase::core::scan_sort>(
-            env, {
-                     {"none", couchbase::core::scan_sort::none},
-                     {"ascending", couchbase::core::scan_sort::ascending},
-                 }));
-
     //#endregion Autogenerated Constants
 }
 

package/src/jstocbpp_autogen.hpp

@@ -2418,6 +2418,8 @@ struct js_to_cbpp_t<couchbase::core::operations::query_request> {
         js_to_cbpp<bool>(cppObj.readonly, jsObj.Get("readonly"));
         js_to_cbpp<bool>(cppObj.flex_index, jsObj.Get("flex_index"));
         js_to_cbpp<bool>(cppObj.preserve_expiry, jsObj.Get("preserve_expiry"));
+        js_to_cbpp<std::optional<bool>>(cppObj.use_replica,
+                                        jsObj.Get("use_replica"));
         js_to_cbpp<std::optional<std::uint64_t>>(cppObj.max_parallelism,
                                                  jsObj.Get("max_parallelism"));
         js_to_cbpp<std::optional<std::uint64_t>>(cppObj.scan_cap,
@@ -2469,6 +2471,8 @@ struct js_to_cbpp_t<couchbase::core::operations::query_request> {
         resObj.Set("flex_index", cbpp_to_js<bool>(env, cppObj.flex_index));
         resObj.Set("preserve_expiry",
                    cbpp_to_js<bool>(env, cppObj.preserve_expiry));
+        resObj.Set("use_replica",
+                   cbpp_to_js<std::optional<bool>>(env, cppObj.use_replica));
         resObj.Set("max_parallelism", cbpp_to_js<std::optional<std::uint64_t>>(
                                           env, cppObj.max_parallelism));
         resObj.Set("scan_cap", cbpp_to_js<std::optional<std::uint64_t>>(
@@ -9888,7 +9892,7 @@ struct js_to_cbpp_t<couchbase::core::scan_term> {
     {
         auto jsObj = jsVal.ToObject();
         couchbase::core::scan_term cppObj;
-        js_to_cbpp<std::vector<std::byte>>(cppObj.id, jsObj.Get("id"));
+        js_to_cbpp<std::string>(cppObj.term, jsObj.Get("term"));
         js_to_cbpp<bool>(cppObj.exclusive, jsObj.Get("exclusive"));
         return cppObj;
     }
@@ -9896,7 +9900,7 @@ struct js_to_cbpp_t<couchbase::core::scan_term> {
                                     const couchbase::core::scan_term &cppObj)
     {
         auto resObj = Napi::Object::New(env);
-        resObj.Set("id", cbpp_to_js<std::vector<std::byte>>(env, cppObj.id));
+        resObj.Set("term", cbpp_to_js<std::string>(env, cppObj.term));
         resObj.Set("exclusive", cbpp_to_js<bool>(env, cppObj.exclusive));
         return resObj;
     }
@@ -9908,19 +9912,39 @@ struct js_to_cbpp_t<couchbase::core::range_scan> {
     {
         auto jsObj = jsVal.ToObject();
         couchbase::core::range_scan cppObj;
-        js_to_cbpp<couchbase::core::scan_term>(cppObj.start_,
-                                               jsObj.Get("start_"));
-        js_to_cbpp<couchbase::core::scan_term>(cppObj.end_, jsObj.Get("end_"));
+        js_to_cbpp<std::optional<couchbase::core::scan_term>>(
+            cppObj.from, jsObj.Get("from"));
+        js_to_cbpp<std::optional<couchbase::core::scan_term>>(cppObj.to,
+                                                              jsObj.Get("to"));
         return cppObj;
     }
     static inline Napi::Value to_js(Napi::Env env,
                                     const couchbase::core::range_scan &cppObj)
     {
         auto resObj = Napi::Object::New(env);
-        resObj.Set("start_",
-                   cbpp_to_js<couchbase::core::scan_term>(env, cppObj.start_));
-        resObj.Set("end_",
-                   cbpp_to_js<couchbase::core::scan_term>(env, cppObj.end_));
+        resObj.Set("from",
+                   cbpp_to_js<std::optional<couchbase::core::scan_term>>(
+                       env, cppObj.from));
+        resObj.Set("to", cbpp_to_js<std::optional<couchbase::core::scan_term>>(
+                             env, cppObj.to));
+        return resObj;
+    }
+};
+
+template <>
+struct js_to_cbpp_t<couchbase::core::prefix_scan> {
+    static inline couchbase::core::prefix_scan from_js(Napi::Value jsVal)
+    {
+        auto jsObj = jsVal.ToObject();
+        couchbase::core::prefix_scan cppObj;
+        js_to_cbpp<std::string>(cppObj.prefix, jsObj.Get("prefix"));
+        return cppObj;
+    }
+    static inline Napi::Value to_js(Napi::Env env,
+                                    const couchbase::core::prefix_scan &cppObj)
+    {
+        auto resObj = Napi::Object::New(env);
+        resObj.Set("prefix", cbpp_to_js<std::string>(env, cppObj.prefix));
         return resObj;
     }
 };
@@ -9932,7 +9956,7 @@ struct js_to_cbpp_t<couchbase::core::sampling_scan> {
         auto jsObj = jsVal.ToObject();
         couchbase::core::sampling_scan cppObj;
         js_to_cbpp<std::size_t>(cppObj.limit, jsObj.Get("limit"));
-        js_to_cbpp<std::optional<std::uint32_t>>(cppObj.seed,
+        js_to_cbpp<std::optional<std::uint64_t>>(cppObj.seed,
                                                  jsObj.Get("seed"));
         return cppObj;
     }
@@ -9942,7 +9966,7 @@ struct js_to_cbpp_t<couchbase::core::sampling_scan> {
         auto resObj = Napi::Object::New(env);
         resObj.Set("limit", cbpp_to_js<std::size_t>(env, cppObj.limit));
         resObj.Set("seed",
-                   cbpp_to_js<std::optional<std::uint32_t>>(env, cppObj.seed));
+                   cbpp_to_js<std::optional<std::uint64_t>>(env, cppObj.seed));
         return resObj;
     }
 };
@@ -9986,11 +10010,15 @@ struct js_to_cbpp_t<couchbase::core::range_scan_create_options> {
         auto scan_type_name =
             jsToCbpp<std::string>(jsObj.Get("scan_type_name"));
         std::variant<std::monostate, couchbase::core::range_scan,
+                     couchbase::core::prefix_scan,
                      couchbase::core::sampling_scan>
             scan_type;
         if (scan_type_name.compare("range_scan") == 0) {
             scan_type = js_to_cbpp<couchbase::core::range_scan>(
                 jsObj.Get("scan_type_value"));
+        } else if (scan_type_name.compare("prefix_scan") == 0) {
+            scan_type = js_to_cbpp<couchbase::core::prefix_scan>(
+                jsObj.Get("scan_type_value"));
         } else if (scan_type_name.compare("sampling_scan") == 0) {
             scan_type = js_to_cbpp<couchbase::core::sampling_scan>(
                 jsObj.Get("scan_type_value"));
@@ -10023,6 +10051,7 @@ struct js_to_cbpp_t<couchbase::core::range_scan_create_options> {
         resObj.Set(
             "scan_type",
             cbpp_to_js<std::variant<std::monostate, couchbase::core::range_scan,
+                                    couchbase::core::prefix_scan,
                                     couchbase::core::sampling_scan>>(
                 env, cppObj.scan_type));
         resObj.Set("timeout",
@@ -10076,10 +10105,11 @@ struct js_to_cbpp_t<couchbase::core::range_scan_continue_options> {
                                   jsObj.Get("batch_item_limit"));
         js_to_cbpp<std::uint32_t>(cppObj.batch_byte_limit,
                                   jsObj.Get("batch_byte_limit"));
+        js_to_cbpp<std::chrono::milliseconds>(cppObj.timeout,
+                                              jsObj.Get("timeout"));
         js_to_cbpp<std::chrono::milliseconds>(cppObj.batch_time_limit,
                                               jsObj.Get("batch_time_limit"));
         // retry_strategy
-        js_to_cbpp<bool>(cppObj.ids_only, jsObj.Get("ids_only"));
         // internal
         return cppObj;
     }
@@ -10092,10 +10122,11 @@ struct js_to_cbpp_t<couchbase::core::range_scan_continue_options> {
                    cbpp_to_js<std::uint32_t>(env, cppObj.batch_item_limit));
         resObj.Set("batch_byte_limit",
                    cbpp_to_js<std::uint32_t>(env, cppObj.batch_byte_limit));
+        resObj.Set("timeout",
+                   cbpp_to_js<std::chrono::milliseconds>(env, cppObj.timeout));
         resObj.Set("batch_time_limit", cbpp_to_js<std::chrono::milliseconds>(
                                            env, cppObj.batch_time_limit));
         // retry_strategy
-        resObj.Set("ids_only", cbpp_to_js<bool>(env, cppObj.ids_only));
         // internal
         return resObj;
     }
@@ -10189,7 +10220,7 @@ struct js_to_cbpp_t<couchbase::core::range_scan_item> {
     {
         auto jsObj = jsVal.ToObject();
         couchbase::core::range_scan_item cppObj;
-        js_to_cbpp<std::vector<std::byte>>(cppObj.key, jsObj.Get("key"));
+        js_to_cbpp<std::string>(cppObj.key, jsObj.Get("key"));
         js_to_cbpp<std::optional<couchbase::core::range_scan_item_body>>(
             cppObj.body, jsObj.Get("body"));
         return cppObj;
@@ -10198,7 +10229,7 @@ struct js_to_cbpp_t<couchbase::core::range_scan_item> {
     to_js(Napi::Env env, const couchbase::core::range_scan_item &cppObj)
     {
         auto resObj = Napi::Object::New(env);
-        resObj.Set("key", cbpp_to_js<std::vector<std::byte>>(env, cppObj.key));
+        resObj.Set("key", cbpp_to_js<std::string>(env, cppObj.key));
         resObj.Set(
             "body",
             cbpp_to_js<std::optional<couchbase::core::range_scan_item_body>>(
@@ -10255,13 +10286,11 @@ struct js_to_cbpp_t<couchbase::core::range_scan_orchestrator_options> {
         js_to_cbpp<bool>(cppObj.ids_only, jsObj.Get("ids_only"));
         js_to_cbpp<std::optional<couchbase::core::mutation_state>>(
             cppObj.consistent_with, jsObj.Get("consistent_with"));
-        js_to_cbpp<couchbase::core::scan_sort>(cppObj.sort, jsObj.Get("sort"));
         js_to_cbpp<std::uint32_t>(cppObj.batch_item_limit,
                                   jsObj.Get("batch_item_limit"));
         js_to_cbpp<std::uint32_t>(cppObj.batch_byte_limit,
                                   jsObj.Get("batch_byte_limit"));
-        js_to_cbpp<std::chrono::milliseconds>(cppObj.batch_time_limit,
-                                              jsObj.Get("batch_time_limit"));
+        js_to_cbpp<std::uint16_t>(cppObj.concurrency, jsObj.Get("concurrency"));
         // retry_strategy
         js_to_cbpp<std::chrono::milliseconds>(cppObj.timeout,
                                               jsObj.Get("timeout"));
@@ -10277,14 +10306,12 @@ struct js_to_cbpp_t<couchbase::core::range_scan_orchestrator_options> {
         resObj.Set("consistent_with",
                    cbpp_to_js<std::optional<couchbase::core::mutation_state>>(
                        env, cppObj.consistent_with));
-        resObj.Set("sort",
-                   cbpp_to_js<couchbase::core::scan_sort>(env, cppObj.sort));
         resObj.Set("batch_item_limit",
                    cbpp_to_js<std::uint32_t>(env, cppObj.batch_item_limit));
         resObj.Set("batch_byte_limit",
                    cbpp_to_js<std::uint32_t>(env, cppObj.batch_byte_limit));
-        resObj.Set("batch_time_limit", cbpp_to_js<std::chrono::milliseconds>(
-                                           env, cppObj.batch_time_limit));
+        resObj.Set("concurrency",
+                   cbpp_to_js<std::uint16_t>(env, cppObj.concurrency));
         // retry_strategy
         resObj.Set("timeout",
                    cbpp_to_js<std::chrono::milliseconds>(env, cppObj.timeout));

package/src/jstocbpp_basic.hpp

@@ -49,15 +49,9 @@ struct js_to_cbpp_t<couchbase::core::io::dns::dns_config> {
     from_js(Napi::Value jsVal)
     {
         auto jsObj = jsVal.ToObject();
-        auto nameserver = js_to_cbpp<std::string>(jsObj.Get("nameserver"));
-        auto jsPort = jsObj.Get("port");
         auto cppObj = couchbase::core::io::dns::dns_config{
-            nameserver.empty()
-                ? couchbase::core::io::dns::dns_config::default_nameserver
-                : nameserver,
-            jsPort.IsNull() || jsPort.IsUndefined()
-                ? couchbase::core::io::dns::dns_config::default_port
-                : js_to_cbpp<std::uint16_t>(jsPort),
+            js_to_cbpp<std::string>(jsObj.Get("nameserver")),
+            js_to_cbpp<std::uint16_t>(jsObj.Get("port")),
             js_to_cbpp<std::chrono::milliseconds>(jsObj.Get("dnsSrvTimeout"))};
         return cppObj;
     }

package/src/mutationtoken.cpp

@@ -1,4 +1,5 @@
 #include "mutationtoken.hpp"
+#include "jstocbpp.hpp"
 #include "utils.hpp"
 #include <sstream>
 
@@ -81,6 +82,18 @@ couchbase::mutation_token MutationToken::parse(Napi::Value val)
         return couchbase::mutation_token{};
     } else if (val.IsObject()) {
         auto objVal = val.As<Napi::Object>();
+        if (objVal.HasOwnProperty("partition_uuid")) {
+            auto partitionUuid =
+                jsToCbpp<std::uint64_t>(objVal.Get("partition_uuid"));
+            auto sequenceNumber =
+                jsToCbpp<std::uint64_t>(objVal.Get("sequence_number"));
+            auto partitionId =
+                jsToCbpp<std::uint16_t>(objVal.Get("partition_id"));
+            auto bucketName = jsToCbpp<std::string>(objVal.Get("bucket_name"));
+            return couchbase::mutation_token{partitionUuid, sequenceNumber,
+                                             partitionId, bucketName};
+        }
+
         auto maybeRawVal = objVal.Get("raw");
         if (!maybeRawVal.IsEmpty()) {
             return MutationToken::fromBuffer(maybeRawVal);

package/src/scan_iterator.cpp

@@ -0,0 +1,90 @@
+#include "scan_iterator.hpp"
+#include "connection.hpp"
+#include "jstocbpp.hpp"
+
+namespace couchnode
+{
+
+void ScanIterator::Init(Napi::Env env, Napi::Object exports)
+{
+    Napi::Function func = DefineClass(
+        env, "ScanIterator",
+        {
+            InstanceMethod<&ScanIterator::jsNext>("next"),
+            InstanceMethod<&ScanIterator::jsCancel>("cancel"),
+            InstanceAccessor<&ScanIterator::jsCancelled>("cancelled"),
+        });
+
+    constructor(env) = Napi::Persistent(func);
+    exports.Set("ScanIterator", func);
+}
+
+ScanIterator::ScanIterator(const Napi::CallbackInfo &info)
+    : Napi::ObjectWrap<ScanIterator>(info)
+{
+    if (info.Length() > 0) {
+        auto wrapped_result =
+            *info[0]
+                 .As<const Napi::External<couchbase::core::scan_result>>()
+                 .Data();
+        this->result_ =
+            std::make_shared<couchbase::core::scan_result>(wrapped_result);
+    }
+}
+
+ScanIterator::~ScanIterator()
+{
+}
+
+Napi::Value ScanIterator::jsNext(const Napi::CallbackInfo &info)
+{
+    auto env = info.Env();
+    auto callbackJsFn = info[0].As<Napi::Function>();
+    auto cookie = CallCookie(env, callbackJsFn, "cbRangeScanNext");
+
+    auto handler = [](Napi::Env env, Napi::Function callback,
+                      couchbase::core::range_scan_item resp,
+                      std::error_code ec) mutable {
+        Napi::Value jsErr, jsRes;
+        if (ec && ec == couchbase::errc::key_value::range_scan_completed) {
+            jsErr = env.Null();
+            jsRes = env.Undefined();
+        } else {
+            try {
+                jsErr = cbpp_to_js(env, ec);
+                jsRes = cbpp_to_js(env, resp);
+            } catch (const Napi::Error &e) {
+                jsErr = e.Value();
+                jsRes = env.Null();
+            }
+        }
+        callback.Call({jsErr, jsRes});
+    };
+
+    this->result_->next(
+        [cookie = std::move(cookie), handler = std::move(handler)](
+            couchbase::core::range_scan_item resp, std::error_code ec) mutable {
+            cookie.invoke([handler = std::move(handler), resp = std::move(resp),
+                           ec = std::move(ec)](
+                              Napi::Env env, Napi::Function callback) mutable {
+                handler(env, callback, std::move(resp), std::move(ec));
+            });
+        });
+
+    return env.Null();
+}
+
+Napi::Value ScanIterator::jsCancel(const Napi::CallbackInfo &info)
+{
+    auto env = info.Env();
+    this->result_->cancel();
+    return Napi::Boolean::New(env, this->result_->is_cancelled());
+}
+
+Napi::Value ScanIterator::jsCancelled(const Napi::CallbackInfo &info)
+{
+    auto env = info.Env();
+    return Napi::Boolean::New(env, this->result_->is_cancelled());
+}
+
+} // namespace couchnode

package/src/scan_iterator.hpp

@@ -0,0 +1,30 @@
+#pragma once
+#include "addondata.hpp"
+#include "napi.h"
+#include <core/scan_result.hxx>
+
+namespace couchnode
+{
+
+class ScanIterator : public Napi::ObjectWrap<ScanIterator>
+{
+public:
+    static Napi::FunctionReference &constructor(Napi::Env env)
+    {
+        return AddonData::fromEnv(env)->_scanIteratorCtor;
+    }
+
+    static void Init(Napi::Env env, Napi::Object exports);
+
+    ScanIterator(const Napi::CallbackInfo &info);
+    ~ScanIterator();
+
+    Napi::Value jsNext(const Napi::CallbackInfo &info);
+    Napi::Value jsCancel(const Napi::CallbackInfo &info);
+    Napi::Value jsCancelled(const Napi::CallbackInfo &info);
+
+private:
+    std::shared_ptr<couchbase::core::scan_result> result_;
+};
+
+} // namespace couchnode

package/tools/gen-bindings-json.py

@@ -1,15 +1,12 @@
-from logging.config import valid_ident
 import os
 import json
 import re
-import subprocess
-from unittest import TestCase
 import clang.cindex
 
 # configurable part
 
 CLANG_VERSION='13.0.1'
-#   homebrew installs for llvm (brew info llvm gives details):  
+#   homebrew installs for llvm (brew info llvm gives details):
 #       x64: /usr/local/opt/llvm/lib
 #       arm64: /opt/homebrew/opt/llvm/lib
 llvmLibPath = "/usr/local/Cellar/llvm/13.0.1_1/lib/"
@@ -148,6 +145,7 @@ typeList = [
     "couchbase::core::scan_term",
     "couchbase::core::scan_sort",
     "couchbase::core::range_scan",
+    "couchbase::core::prefix_scan",
     "couchbase::core::sampling_scan",
     "couchbase::core::range_snapshot_requirements",
     "couchbase::core::range_scan_item_body",
@@ -341,7 +339,7 @@ def parse_type_str(typeStr):
                     "to": parse_type_str(variantParts[1]),
                     "comparator": parse_type_str(variantParts[2])
                 }
-            
+
         if tplClassName == "std::shared_ptr":
             return {
                 "name": "std::shared_ptr",
@@ -358,6 +356,7 @@ def parse_type_str(typeStr):
     return {"name": typeStr}
 
 internal_structs = []
+UNNAMED_STRUCT_DELIM = '::(unnamed struct'
 
 def traverse(node, namespace, main_file):
     # only scan the elements of the file we parsed
@@ -366,8 +365,9 @@ def traverse(node, namespace, main_file):
 
     if node.kind == clang.cindex.CursorKind.STRUCT_DECL or node.kind == clang.cindex.CursorKind.CLASS_DECL:
         fullStructName = "::".join([*namespace, node.displayname])
-        if fullStructName.endswith('::'): 
-            match = next((s for s in internal_structs if fullStructName in s), None)
+        if fullStructName.endswith('::') or UNNAMED_STRUCT_DELIM in fullStructName:
+            struct_name = fullStructName if fullStructName.endswith('::') else fullStructName.split(UNNAMED_STRUCT_DELIM)[0]
+            match = next((s for s in internal_structs if struct_name in s), None)
             if match:
                 fullStructName = match
 
@@ -451,7 +451,8 @@ for headerPath in fullFileList:
         "-I" + cxxClientRoot + "/third_party/json/include",
         "-I" + cxxClientRoot + "/third_party/json/external/PEGTL/include",
         "-I" + cxxClientRoot + "/third_party/asio/asio/include",
-        "-I" + f"/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/clang/{CLANG_VERSION}/include"
+        "-I" + f"/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/clang/{CLANG_VERSION}/include",
+        # "-I" + f'/opt/homebrew/Cellar/llvm/{CLANG_VERSION}/lib/clang/{CLANG_VERSION[:2]}/include',
     ]
     translation_unit = index.parse(headerPath, args=args)