couchbase 4.6.0 → 4.7.0-dev.1

package/package.json

@@ -20,24 +20,37 @@
   "license": "Apache-2.0",
   "name": "couchbase",
   "dependencies": {
-    "cmake-js": "^7.3.1",
+    "cmake-js": "^8.0.0",
+    "detect-libc": "^2.1.2",
+    "hdr-histogram-js": "^3.0.1",
     "node-addon-api": "^8.3.1"
   },
+  "peerDependencies": {
+    "@opentelemetry/api": "^1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@opentelemetry/api": {
+      "optional": true
+    }
+  },
   "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "@opentelemetry/api": "^1.9.0",
     "@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": "^22.14.1",
-    "@typescript-eslint/eslint-plugin": "^7.13.1",
-    "@typescript-eslint/parser": "^7.13.1",
+    "@typescript-eslint/eslint-plugin": "^8.54.0",
+    "@typescript-eslint/parser": "^8.54.0",
     "chai": "^4.5.0",
-    "eslint": "^8.57.0",
+    "eslint": "^9.39.2",
     "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-jsdoc": "^48.2.12",
+    "eslint-plugin-jsdoc": "^50.6.2",
     "eslint-plugin-mocha": "^10.5.0",
-    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-n": "^17.17.0",
     "expose-gc": "^1.0.0",
+    "globals": "^15.14.0",
     "mocha": "^11.1.0",
     "npm-check-updates": "^18.0.0",
     "nyc": "^17.1.0",
@@ -48,13 +61,14 @@
     "ts-node": "^10.9.2",
     "typedoc": "^0.28.3",
     "typescript": "~5.4.5",
+    "typescript-eslint": "^8.54.0",
     "uuid": "^11.1.0"
   },
   "repository": {
     "type": "git",
     "url": "http://github.com/couchbase/couchnode.git"
   },
-  "version": "4.6.0",
+  "version": "4.7.0-dev.1",
   "config": {
     "native": false
   },
@@ -63,7 +77,7 @@
     "build": "cmake-js build && tsc",
     "rebuild": "cmake-js rebuild && tsc",
     "prebuild": "node ./scripts/buildPrebuild.js",
-    "prepare": "tsc",
+    "prepare": "node ./scripts/updateVersion.js && tsc",
     "help-prune": "node ./scripts/prune.js",
     "build-docs": "typedoc",
     "test": "ts-mocha test/*.test.*",
@@ -78,15 +92,6 @@
       6
     ]
   },
-  "optionalDependencies": {
-    "@couchbase/couchbase-darwin-arm64-napi": "4.6.0",
-    "@couchbase/couchbase-darwin-x64-napi": "4.6.0",
-    "@couchbase/couchbase-linux-arm64-napi": "4.6.0",
-    "@couchbase/couchbase-linuxmusl-arm64-napi": "4.6.0",
-    "@couchbase/couchbase-linuxmusl-x64-napi": "4.6.0",
-    "@couchbase/couchbase-linux-x64-napi": "4.6.0",
-    "@couchbase/couchbase-win32-x64-napi": "4.6.0"
-  },
   "files": [
     "LICENSE",
     "CMakeLists.txt",
@@ -159,5 +164,14 @@
     "deps/couchbase-cxx-cache/spdlog/*/spdlog/include/**/*",
     "deps/couchbase-cxx-cache/spdlog/*/spdlog/src/**/*",
     "deps/couchbase-cxx-cache/mozilla-ca-bundle.*"
-  ]
+  ],
+  "optionalDependencies": {
+    "@couchbase/couchbase-darwin-arm64-napi": "4.7.0-dev.1",
+    "@couchbase/couchbase-darwin-x64-napi": "4.7.0-dev.1",
+    "@couchbase/couchbase-linux-arm64-napi": "4.7.0-dev.1",
+    "@couchbase/couchbase-linuxmusl-arm64-napi": "4.7.0-dev.1",
+    "@couchbase/couchbase-linuxmusl-x64-napi": "4.7.0-dev.1",
+    "@couchbase/couchbase-linux-x64-napi": "4.7.0-dev.1",
+    "@couchbase/couchbase-win32-x64-napi": "4.7.0-dev.1"
+  }
 }

package/scripts/buildPrebuild.js

@@ -1,3 +1,5 @@
+'use strict'
+
 const prebuilds = require('./prebuilds')
 
 function buildPrebuild(

package/scripts/install.js

@@ -1,3 +1,5 @@
+'use strict'
+
 const path = require('path')
 const prebuilds = require('./prebuilds')
 

package/scripts/prebuilds.js

@@ -1,6 +1,9 @@
+'use strict'
+
 const fs = require('fs')
 const path = require('path')
 var proc = require('child_process')
+const { familySync, MUSL } = require('detect-libc')
 
 // Workaround to fix webpack's build warnings: 'the request of a dependency is an expression'
 const runtimeRequire =
@@ -18,15 +21,15 @@ const platform = process.platform
 const libc = getLinuxType(platform)
 const sslType = getSSLType(runtime, nodeVersion)
 
-CN_ROOT = path.resolve(path.dirname(__filename), '..')
+const CN_ROOT = path.resolve(path.dirname(__filename), '..')
 // CN_CXXCBC_CACHE_DIR should only need to be used on Windows when setting the CPM cache (CN_SET_CPM_CACHE=ON).
 // It helps prevent issues w/ path lengths.
 // NOTE: Setting the CPM cache on a Windows machine should be a _rare_ occasion.  When doing so and setting
 // CN_CXXCBC_CACHE_DIR, be sure to copy the cache to <root source dir>\deps\couchbase-cxx-cache if building a sdist.
-CXXCBC_CACHE_DIR =
+const CXXCBC_CACHE_DIR =
   process.env.CN_CXXCBC_CACHE_DIR ||
   path.join(CN_ROOT, 'deps', 'couchbase-cxx-cache')
-ENV_TRUE = ['true', '1', 'y', 'yes', 'on']
+const ENV_TRUE = ['true', '1', 'y', 'yes', 'on']
 
 function buildBinary(
   runtime,
@@ -274,7 +277,7 @@ function getLinuxType(platform) {
   if (platform !== 'linux') {
     return ''
   }
-  return `linux${isAlpine(platform) ? 'musl' : ''}`
+  return `linux${familySync() === MUSL ? 'musl' : ''}`
 }
 
 function getNodeMajorVersion(version) {
@@ -344,10 +347,6 @@ function getSupportedPlatformPackages(packageName) {
   return packageNames
 }
 
-function isAlpine(platform) {
-  return platform === 'linux' && fs.existsSync('/etc/alpine-release')
-}
-
 function isElectron() {
   if (process.versions && process.versions.electron) return true
   if (process.env.ELECTRON_RUN_AS_NODE) return true

package/scripts/prune.js

@@ -1,3 +1,5 @@
+'use strict'
+
 const fs = require('fs')
 const path = require('path')
 const prebuilds = require('./prebuilds')

package/scripts/updateVersion.js

@@ -0,0 +1,26 @@
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+
+// 1. Define the paths relative to this script
+const packageJsonPath = path.join(__dirname, '../package.json')
+const versionTsPath = path.join(__dirname, '../lib/version.ts')
+
+// 2. Read and parse package.json
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'))
+const version = packageJson.version;
+const name = packageJson.name;
+
+// 3. Generate the TypeScript content
+const tsContent = `// This file is auto-generated by scripts/updateVersion.js during the build process.
+// DO NOT EDIT DIRECTLY.
+
+export const SDK_VERSION = '${version}';
+export const SDK_NAME = '${name}';
+`;
+
+// 4. Write it to the lib directory
+fs.writeFileSync(versionTsPath, tsContent, 'utf8');
+
+console.log(`[Build] Wrote ${name} v${version} to lib/version.ts`);

package/src/connection.cpp

@@ -4,8 +4,9 @@
 #include "jstocbpp.hpp"
 #include "mutationtoken.hpp"
 #include "scan_iterator.hpp"
-#include "transcoder.hpp"
 #include <core/agent_group.hxx>
+#include <core/cluster.hxx>
+#include <core/cluster_label_listener.hxx>
 #include <core/operations/management/freeform.hxx>
 #include <core/range_scan_orchestrator.hxx>
 #include <core/utils/connection_string.hxx>
@@ -35,11 +36,14 @@ void Connection::Init(Napi::Env env, Napi::Object exports)
         env, "Connection",
         {
             InstanceMethod<&Connection::jsConnect>("connect"),
+            InstanceMethod<&Connection::jsUpdateCredentials>(
+                "updateCredentials"),
             InstanceMethod<&Connection::jsShutdown>("shutdown"),
             InstanceMethod<&Connection::jsOpenBucket>("openBucket"),
             InstanceMethod<&Connection::jsDiagnostics>("diagnostics"),
             InstanceMethod<&Connection::jsPing>("ping"),
             InstanceMethod<&Connection::jsScan>("scan"),
+            InstanceMethod<&Connection::jsGetClusterLabels>("getClusterLabels"),
 
             //#region Autogenerated Method Registration
 
@@ -279,7 +283,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[7].As<Napi::Function>();
+    auto callbackJsFn = info[6].As<Napi::Function>();
 
     auto connstrInfo = couchbase::core::utils::parse_connection_string(connstr);
     auto creds =
@@ -343,121 +347,51 @@ Napi::Value Connection::jsConnect(const Napi::CallbackInfo &info)
         }
     }
 
-    couchbase::core::tracing::threshold_logging_options tracing_options{};
-    bool has_tracing_options = false;
-
-    if (!info[4].IsNull()) {
-        auto jsTracingConfigObj = info[4].As<Napi::Object>();
-        auto jsEnableTracing = jsTracingConfigObj.Get("enableTracing");
-        if (!(jsEnableTracing.IsNull() || jsEnableTracing.IsUndefined())) {
-            connstrInfo.options.enable_tracing =
-                js_to_cbpp<bool>(jsEnableTracing);
-        }
-        auto jsEmitInterval = jsTracingConfigObj.Get("emitInterval");
-        if (!(jsEmitInterval.IsNull() || jsEmitInterval.IsUndefined())) {
-            tracing_options.threshold_emit_interval =
-                js_to_cbpp<std::chrono::milliseconds>(jsEmitInterval);
-            has_tracing_options = true;
-        }
-        auto jsSampleSize = jsTracingConfigObj.Get("sampleSize");
-        if (!(jsSampleSize.IsNull() || jsSampleSize.IsUndefined())) {
-            tracing_options.threshold_sample_size =
-                js_to_cbpp<std::size_t>(jsSampleSize);
-            has_tracing_options = true;
-        }
-        auto jsKvThreshold = jsTracingConfigObj.Get("kvThreshold");
-        if (!(jsKvThreshold.IsNull() || jsKvThreshold.IsUndefined())) {
-            tracing_options.key_value_threshold =
-                js_to_cbpp<std::chrono::milliseconds>(jsKvThreshold);
-            has_tracing_options = true;
-        }
-        auto jsQueryThreshold = jsTracingConfigObj.Get("queryThreshold");
-        if (!(jsQueryThreshold.IsNull() || jsQueryThreshold.IsUndefined())) {
-            tracing_options.query_threshold =
-                js_to_cbpp<std::chrono::milliseconds>(jsQueryThreshold);
-            has_tracing_options = true;
-        }
-        auto jsSearchThreshold = jsTracingConfigObj.Get("searchThreshold");
-        if (!(jsSearchThreshold.IsNull() || jsSearchThreshold.IsUndefined())) {
-            tracing_options.search_threshold =
-                js_to_cbpp<std::chrono::milliseconds>(jsSearchThreshold);
-            has_tracing_options = true;
-        }
-        auto jsAnalyticsThreshold =
-            jsTracingConfigObj.Get("analyticsThreshold");
-        if (!(jsAnalyticsThreshold.IsNull() ||
-              jsAnalyticsThreshold.IsUndefined())) {
-            tracing_options.analytics_threshold =
-                js_to_cbpp<std::chrono::milliseconds>(jsAnalyticsThreshold);
-            has_tracing_options = true;
-        }
-        auto jsManagementThreshold =
-            jsTracingConfigObj.Get("managementThreshold");
-        if (!(jsManagementThreshold.IsNull() ||
-              jsManagementThreshold.IsUndefined())) {
-            tracing_options.management_threshold =
-                js_to_cbpp<std::chrono::milliseconds>(jsManagementThreshold);
-            has_tracing_options = true;
-        }
-        auto jsEventingThreshold = jsTracingConfigObj.Get("eventingThreshold");
-        if (!(jsEventingThreshold.IsNull() ||
-              jsEventingThreshold.IsUndefined())) {
-            tracing_options.eventing_threshold =
-                js_to_cbpp<std::chrono::milliseconds>(jsEventingThreshold);
-            has_tracing_options = true;
-        }
-        auto jsViewsThreshold = jsTracingConfigObj.Get("viewsThreshold");
-        if (!(jsViewsThreshold.IsNull() || jsViewsThreshold.IsUndefined())) {
-            tracing_options.view_threshold =
-                js_to_cbpp<std::chrono::milliseconds>(jsViewsThreshold);
-            has_tracing_options = true;
-        }
+    // Always disable tracing, this will be ignored if we set the tracer
+    connstrInfo.options.enable_tracing = false;
+    auto setup_sdk_tracing = info[4].ToBoolean().Value();
+    if (setup_sdk_tracing) {
+        connstrInfo.options.tracer =
+            std::make_shared<couchbase::core::tracing::wrapper_sdk_tracer>();
     }
+    // For now, always disable metrics in the core
+    connstrInfo.options.enable_metrics = false;
 
     if (!info[5].IsNull()) {
+        couchbase::core::orphan_reporter_options orphan_options{};
+        bool has_orphan_options = false;
         auto jsOrphanReporterConfigObj = info[5].As<Napi::Object>();
-        // TODO(JSCBC-1364):  Migrate to orphan reporting config when available in C++ core
+        auto jsEnableOrphanReporting =
+            jsOrphanReporterConfigObj.Get("enableOrphanReporting");
+        if (!(jsEnableOrphanReporting.IsNull() ||
+              jsEnableOrphanReporting.IsUndefined())) {
+            connstrInfo.options.enable_orphan_reporting =
+                js_to_cbpp<bool>(jsEnableOrphanReporting);
+        }
         auto jsOrphanEmitInterval =
             jsOrphanReporterConfigObj.Get("emitInterval");
         if (!(jsOrphanEmitInterval.IsNull() ||
               jsOrphanEmitInterval.IsUndefined())) {
-            tracing_options.orphaned_emit_interval =
+            orphan_options.emit_interval =
                 js_to_cbpp<std::chrono::milliseconds>(jsOrphanEmitInterval);
-            has_tracing_options = true;
+            has_orphan_options = true;
         }
         auto jsOrphanSampleSize = jsOrphanReporterConfigObj.Get("sampleSize");
         if (!(jsOrphanSampleSize.IsNull() ||
               jsOrphanSampleSize.IsUndefined())) {
-            tracing_options.orphaned_sample_size =
+            orphan_options.sample_size =
                 js_to_cbpp<std::size_t>(jsOrphanSampleSize);
-            has_tracing_options = true;
+            has_orphan_options = true;
         }
-    }
 
-    if (has_tracing_options) {
-        connstrInfo.options.tracing_options = tracing_options;
-    }
-
-    if (!info[6].IsNull()) {
-        auto jsMetricsConfigObj = info[6].As<Napi::Object>();
-        auto jsEnableMetrics = jsMetricsConfigObj.Get("enableMetrics");
-        if (!(jsEnableMetrics.IsNull() || jsEnableMetrics.IsUndefined())) {
-            connstrInfo.options.enable_metrics =
-                js_to_cbpp<bool>(jsEnableMetrics);
-        }
-
-        auto jsEmitInterval = jsMetricsConfigObj.Get("emitInterval");
-        if (!(jsEmitInterval.IsNull() || jsEmitInterval.IsUndefined())) {
-            couchbase::core::metrics::logging_meter_options logging_options{};
-            logging_options.emit_interval =
-                js_to_cbpp<std::chrono::milliseconds>(jsEmitInterval);
-            connstrInfo.options.metrics_options = logging_options;
+        if (has_orphan_options) {
+            connstrInfo.options.orphan_options = orphan_options;
         }
     }
 
     auto cookie = CallCookie(info.Env(), callbackJsFn, "cbConnectCallback");
     this->_instance->_cluster.open(
-        couchbase::core::origin(creds, connstrInfo),
+        couchbase::core::origin(std::move(creds), std::move(connstrInfo)),
         [cookie = std::move(cookie)](std::error_code ec) mutable {
             cookie.invoke([ec](Napi::Env env, Napi::Function callback) {
                 callback.Call({cbpp_to_js(env, ec)});
@@ -467,6 +401,18 @@ Napi::Value Connection::jsConnect(const Napi::CallbackInfo &info)
     return info.Env().Null();
 }
 
+Napi::Value Connection::jsUpdateCredentials(const Napi::CallbackInfo &info)
+{
+    auto credentialsJsObj = info[0].As<Napi::Object>();
+    auto creds =
+        jsToCbpp<couchbase::core::cluster_credentials>(credentialsJsObj);
+    auto err = this->_instance->_cluster.update_credentials(std::move(creds));
+    if (err.ec) {
+        return cbpp_to_js(info.Env(), err.ec);
+    }
+    return info.Env().Null();
+}
+
 Napi::Value Connection::jsShutdown(const Napi::CallbackInfo &info)
 {
     auto callbackJsFn = info[0].As<Napi::Function>();
@@ -606,8 +552,15 @@ Napi::Value Connection::jsScan(const Napi::CallbackInfo &info)
         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);
+    std::shared_ptr<couchbase::core::tracing::wrapper_sdk_span> wrapper_span;
+    auto span_name = jsToCbpp<std::string>(optionsObj.Get("wrapper_span_name"));
+    if (!span_name.empty()) {
+        wrapper_span =
+            std::make_shared<couchbase::core::tracing::wrapper_sdk_span>(
+                span_name);
+    }
+    auto options = jsToCbpp<couchbase::core::range_scan_orchestrator_options>(
+        optionsObj, wrapper_span);
 
     if (!agent.has_value()) {
         resObj.Set("cppErr", cbpp_to_js(env, agent.error()));
@@ -645,4 +598,32 @@ Napi::Value Connection::jsScan(const Napi::CallbackInfo &info)
     return resObj;
 }
 
+std::pair<std::optional<std::string>, std::optional<std::string>>
+Connection::getClusterLabels()
+{
+    auto labels = std::make_pair(std::optional<std::string>{},
+                                 std::optional<std::string>{});
+    auto cppLabels =
+        this->_instance->_cluster.cluster_label_listener()->cluster_labels();
+    if (cppLabels.cluster_name.has_value()) {
+        labels.first = cppLabels.cluster_name.value();
+    }
+    if (cppLabels.cluster_uuid.has_value()) {
+        labels.second = cppLabels.cluster_uuid.value();
+    }
+    return labels;
+}
+
+Napi::Value Connection::jsGetClusterLabels(const Napi::CallbackInfo &info)
+{
+    auto env = info.Env();
+    auto resObj = Napi::Object::New(env);
+    auto clusterLabels = this->getClusterLabels();
+    resObj.Set("clusterName", cbpp_to_js<std::optional<std::string>>(
+                                  env, clusterLabels.first));
+    resObj.Set("clusterUUID", cbpp_to_js<std::optional<std::string>>(
+                                  env, clusterLabels.second));
+    return resObj;
+}
+
 } // namespace couchnode

package/src/connection.hpp

@@ -2,7 +2,7 @@
 #include "addondata.hpp"
 #include "instance.hpp"
 #include "jstocbpp.hpp"
-#include "transcoder.hpp"
+#include <core/tracing/wrapper_sdk_tracer.hxx>
 #include <core/utils/movable_function.hxx>
 #include <napi.h>
 
@@ -64,12 +64,17 @@ public:
         return _instance->_cluster;
     }
 
+    std::pair<std::optional<std::string>, std::optional<std::string>>
+    getClusterLabels();
+
     Napi::Value jsConnect(const Napi::CallbackInfo &info);
     Napi::Value jsShutdown(const Napi::CallbackInfo &info);
+    Napi::Value jsUpdateCredentials(const Napi::CallbackInfo &info);
     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);
+    Napi::Value jsGetClusterLabels(const Napi::CallbackInfo &info);
 
     //#region Autogenerated Method Declarations
 
@@ -240,45 +245,48 @@ private:
 
     template <typename Request>
     void executeOp(const std::string &opName, const Request &req,
-                   Napi::Function jsCallback)
-    {
-        using response_type = typename Request::response_type;
-        executeOp(opName, req, jsCallback,
-                  [](Napi::Env env, Napi::Function callback,
-                     response_type resp) mutable {
-                      Napi::Value jsErr, jsRes;
-                      try {
-                          jsErr = cbpp_to_js(env, resp.ctx);
-                          jsRes = cbpp_to_js(env, resp);
-                      } catch (const Napi::Error &e) {
-                          jsErr = e.Value();
-                          jsRes = env.Null();
-                      }
-
-                      callback.Call({jsErr, jsRes});
-                  });
-    }
-
-    template <typename Request>
-    void executeOp(const std::string &opName, const Request &req,
-                   Napi::Function jsCallback, Transcoder &&transcoder)
+                   Napi::Function jsCallback,
+                   std::shared_ptr<couchbase::core::tracing::wrapper_sdk_span>
+                       wrapperSpan = nullptr)
     {
         using response_type = typename Request::response_type;
-        executeOp(opName, req, jsCallback,
-                  [transcoder = std::move(transcoder)](
-                      Napi::Env env, Napi::Function callback,
-                      response_type resp) mutable {
-                      Napi::Value jsErr, jsRes;
-                      try {
-                          jsErr = cbpp_to_js(env, resp.ctx);
-                          jsRes = cbpp_to_js(env, resp, transcoder);
-                      } catch (const Napi::Error &e) {
-                          jsErr = e.Value();
-                          jsRes = env.Null();
-                      }
-
-                      callback.Call({jsErr, jsRes});
-                  });
+        auto clusterLabels = wrapperSpan != nullptr
+                                 ? this->getClusterLabels()
+                                 : std::make_pair(std::optional<std::string>{},
+                                                  std::optional<std::string>{});
+        executeOp(
+            opName, req, jsCallback,
+            [wrapperSpan, clusterLabels = std::move(clusterLabels)](
+                Napi::Env env, Napi::Function callback,
+                response_type resp) mutable {
+                Napi::Value jsErr, jsRes;
+                try {
+                    if (auto retries = get_cbpp_retries(resp.ctx);
+                        retries > 0 && wrapperSpan) {
+                        wrapperSpan->add_tag("retries", retries);
+                    }
+                    if (wrapperSpan) {
+                        if (clusterLabels.first.has_value()) {
+                            wrapperSpan->add_tag("cluster_name",
+                                                 clusterLabels.first.value());
+                        }
+                        if (clusterLabels.second.has_value()) {
+                            wrapperSpan->add_tag("cluster_uuid",
+                                                 clusterLabels.second.value());
+                        }
+                    }
+                    jsErr = cbpp_to_js(env, resp.ctx, wrapperSpan);
+                    jsRes = cbpp_to_js(env, resp, wrapperSpan);
+                } catch (const Napi::Error &e) {
+                    Napi::Value err = e.Value();
+                    Napi::Object errObj = err.As<Napi::Object>();
+                    errObj.Set("cpp_core_span",
+                               cbpp_wrapper_span_to_js(env, wrapperSpan));
+                    jsErr = errObj;
+                    jsRes = env.Null();
+                }
+                callback.Call({jsErr, jsRes});
+            });
     }
 
     Instance *_instance;