From efd23fd50f82467a3b2394b93dbcf94267a2ae2d Mon Sep 17 00:00:00 2001
From: Vladimir Morozov <vmorozov@microsoft.com>
Date: Thu, 31 Mar 2022 21:05:44 -0700
Subject: [PATCH] node-api: add new napi_ref type for any napi_value

---
 doc/api/n-api.md                              | 123 +++++++++++---
 src/js_native_api.h                           |  39 +++--
 src/js_native_api_types.h                     |   7 +
 src/js_native_api_v8.cc                       | 117 +++++++++++---
 src/js_native_api_v8.h                        |  13 +-
 .../js-native-api/test_strong_ref/binding.gyp |  11 ++
 test/js-native-api/test_strong_ref/test.js    |  39 +++++
 .../test_strong_ref/test_strong_ref.cc        | 153 ++++++++++++++++++
 8 files changed, 447 insertions(+), 55 deletions(-)
 create mode 100644 test/js-native-api/test_strong_ref/binding.gyp
 create mode 100644 test/js-native-api/test_strong_ref/test.js
 create mode 100644 test/js-native-api/test_strong_ref/test_strong_ref.cc

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 76f45091fae711..1d03822dbd83e5 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -721,6 +721,33 @@ minimum lifetimes explicitly.
 
 For more details, review the [Object lifetime management][].
 
+#### `node_api_reftype`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+Type of the `napi_ref` reference.
+There are two types of reference:
+
+* `node_api_reftype_strong_or_weak` - a reference to an object (`napi_object`)
+   that can be a strong or a weak reference. References with ref count greater
+   than 0 are strong references and references with ref count equal to 0 are
+   weak references. The values referenced by weak references can be collected
+   at any time by GC if there are no other strong references to the
+   `napi_value`. To delete the reference we must use `napi_delete_reference`
+   function.
+* `node_api_reftype_strong` - a strong reference to any type of `napi_value`.
+   When the ref count goes down to 0, the reference is deleted.
+   The `napi_delete_reference` function must not be used with the strong references.
+
+```c
+typedef enum {
+  node_api_reftype_strong_or_weak,
+  node_api_reftype_strong,
+} node_api_reftype;
+```
+
 #### `napi_type_tag`
 
 <!-- YAML
@@ -1613,9 +1640,9 @@ If it is called more than once an error will be returned.
 
 This API can be called even if there is a pending JavaScript exception.
 
-### References to objects with a lifespan longer than that of the native method
+### References to values with a lifespan longer than that of the native method
 
-In some cases an addon will need to be able to create and reference objects
+In some cases an addon will need to be able to create and reference values
 with a lifespan longer than that of a single native method invocation. For
 example, to create a constructor and later use that constructor
 in a request to creates instances, it must be possible to reference
@@ -1625,39 +1652,80 @@ described in the earlier section. The lifespan of a normal handle is
 managed by scopes and all scopes must be closed before the end of a native
 method.
 
-Node-API provides methods to create persistent references to an object.
-Each persistent reference has an associated count with a value of 0
-or higher. The count determines if the reference will keep
+Node-API provides methods to create persistent references to a `napi_value`.
+There are two types of references:
+
+* `node_api_reftype_strong_or_weak` type is only for `napi_object` values.
+* `node_api_reftype_strong` type is for any value type.
+
+Each persistent strong/weak reference has an associated count with a value
+of 0 or higher. The count determines if the reference will keep
 the corresponding object live. References with a count of 0 do not
 prevent the object from being collected and are often called 'weak'
 references. Any count greater than 0 will prevent the object
 from being collected.
 
-References can be created with an initial reference count. The count can
-then be modified through [`napi_reference_ref`][] and
-[`napi_reference_unref`][]. If an object is collected while the count
-for a reference is 0, all subsequent calls to
-get the object associated with the reference [`napi_get_reference_value`][]
+The strong reference can have a reference count of 1 or higher.
+If the count becomes 0, then the reference is deleted.
+
+Strong/weak references can be created with an initial reference count, while
+the strong references always use the initial reference count 1.
+The count can then be modified through [`napi_reference_ref`][] and
+[`napi_reference_unref`][]. If an object is collected while the strong/weak
+references count is 0, all subsequent calls to get the object associated with
+the reference [`napi_get_reference_value`][]
 will return `NULL` for the returned `napi_value`. An attempt to call
 [`napi_reference_ref`][] for a reference whose object has been collected
 results in an error.
 
-References must be deleted once they are no longer required by the addon. When
-a reference is deleted, it will no longer prevent the corresponding object from
-being collected. Failure to delete a persistent reference results in
-a 'memory leak' with both the native memory for the persistent reference and
-the corresponding object on the heap being retained forever.
+Strong/weak references must be deleted once they are no longer required by
+the addon. When a reference is deleted, it will no longer prevent the
+corresponding object from being collected. Failure to delete a persistent
+reference results in a 'memory leak' with both the native memory for the
+persistent reference and the corresponding object on the heap being retained
+forever.
 
 There can be multiple persistent references created which refer to the same
-object, each of which will either keep the object live or not based on its
-individual count. Multiple persistent references to the same object
+value, each of which will either keep the value alive or not based on its
+individual count. Multiple persistent references to the same value
 can result in unexpectedly keeping alive native memory. The native structures
 for a persistent reference must be kept alive until finalizers for the
 referenced object are executed. If a new persistent reference is created
 for the same object, the finalizers for that object will not be
 run and the native memory pointed by the earlier persistent reference
 will not be freed. This can be avoided by calling
-`napi_delete_reference` in addition to `napi_reference_unref` when possible.
+`napi_delete_reference` in addition to `napi_reference_unref` for strong/weak
+references when possible. The `napi_delete_reference` must not be called for
+the `node_api_reftype_strong` references because the reference is deleted
+automatically after `napi_reference_unref` call sets reference count to 0.
+
+#### `node_api_create_reference`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+```c
+NAPI_EXTERN napi_status node_api_create_reference(napi_env env,
+                                                  napi_value value,
+                                                  node_api_reftype reftype,
+                                                  uint32_t initial_refcount,
+                                                  napi_ref* result);
+```
+
+* `[in] env`: The environment that the API is invoked under.
+* `[in] value`: `napi_value` to which we want to create a reference.
+* `[in] reftype`: Type of the reference.
+* `[in] initial_refcount`: Initial reference count for the new reference.
+* `[out] result`: `napi_ref` pointing to the new reference.
+
+Returns `napi_ok` if the API succeeded.
+
+For the `node_api_reftype_strong_or_weak` `reftype` set `initial_refcount` to 0
+for a weak reference, and value greater than 0 for a strong reference. It
+accepts only `napi_object` values.
+The `node_api_reftype_strong` ignores the `initial_refcount` and always uses 1.
+It accept `napi_value` of any type.
 
 #### `napi_create_reference`
 
@@ -1684,6 +1752,25 @@ Returns `napi_ok` if the API succeeded.
 This API creates a new reference with the specified reference count
 to the `Object` passed in.
 
+#### `node_api_get_reference_type`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+```c
+NAPI_EXTERN napi_status node_api_get_reference_type(napi_env env,
+                                                    napi_ref ref,
+                                                    node_api_reftype* result);
+```
+
+* `[in] env`: The environment that the API is invoked under.
+* `[in] ref`: `napi_ref` which type we want to get.
+* `[out] result`: `node_api_reftype` type of the `ref`.
+
+Returns `napi_ok` if the API succeeded and the `result` contains type of the
+reference.
+
 #### `napi_delete_reference`
 
 <!-- YAML
diff --git a/src/js_native_api.h b/src/js_native_api.h
index 364d3672d1c344..570a99f44e6de0 100644
--- a/src/js_native_api.h
+++ b/src/js_native_api.h
@@ -315,34 +315,53 @@ NAPI_EXTERN napi_status napi_get_value_external(napi_env env,
 
 // Methods to control object lifespan
 
+#ifdef NAPI_EXPERIMENTAL
+// For node_api_reftype_strong_or_weak set initial_refcount to 0 for a weak
+// reference, and value greater than 0 for a strong reference. The
+// node_api_reftype_strong ignores the initial_refcount and always uses 1.
+NAPI_EXTERN napi_status node_api_create_reference(napi_env env,
+                                                  napi_value value,
+                                                  node_api_reftype reftype,
+                                                  uint32_t initial_refcount,
+                                                  napi_ref* result);
+// Get type of the reference.
+NAPI_EXTERN napi_status node_api_get_reference_type(napi_env env,
+                                                    napi_ref ref,
+                                                    node_api_reftype* result);
+#endif
+
+// Create node_api_reftype_strong_or_weak reference.
 // Set initial_refcount to 0 for a weak reference, >0 for a strong reference.
 NAPI_EXTERN napi_status napi_create_reference(napi_env env,
                                               napi_value value,
                                               uint32_t initial_refcount,
                                               napi_ref* result);
 
-// Deletes a reference. The referenced value is released, and may
-// be GC'd unless there are other references to it.
+// Delete a node_api_reftype_strong_or_weak reference. The referenced value is
+// released, and may be GC'd unless there are other references to it.
+// This method cannot be used with node_api_reftype_strong references.
 NAPI_EXTERN napi_status napi_delete_reference(napi_env env, napi_ref ref);
 
-// Increments the reference count, optionally returning the resulting count.
+// Increment the reference count, optionally returning the resulting count.
 // After this call the  reference will be a strong reference because its
 // refcount is >0, and the referenced object is effectively "pinned".
-// Calling this when the refcount is 0 and the object is unavailable
-// results in an error.
 NAPI_EXTERN napi_status napi_reference_ref(napi_env env,
                                            napi_ref ref,
                                            uint32_t* result);
 
-// Decrements the reference count, optionally returning the resulting count.
-// If the result is 0 the reference is now weak and the object may be GC'd
-// at any time if there are no other references. Calling this when the
-// refcount is already 0 results in an error.
+// Decrement the reference count, optionally returning the resulting count.
+// For node_api_reftype_strong_or_weak references if the result is 0, then the
+// reference is now weak and the object may be GC'd at any time if there are no
+// other references.
+// For node_api_reftype_strong references if the result is 0, then the
+// reference is deleted and the stored napi_value may be GC'd at any time if
+// there are no other references.
+// Calling this when the refcount is already 0 results in an error.
 NAPI_EXTERN napi_status napi_reference_unref(napi_env env,
                                              napi_ref ref,
                                              uint32_t* result);
 
-// Attempts to get a referenced value. If the reference is weak,
+// Attempt to get a referenced value. If the reference is weak,
 // the value might no longer be available, in that case the call
 // is still successful but the result is NULL.
 NAPI_EXTERN napi_status napi_get_reference_value(napi_env env,
diff --git a/src/js_native_api_types.h b/src/js_native_api_types.h
index da4bff19d38044..2ddfff5dfe4488 100644
--- a/src/js_native_api_types.h
+++ b/src/js_native_api_types.h
@@ -154,4 +154,11 @@ typedef struct {
 } napi_type_tag;
 #endif  // NAPI_VERSION >= 8
 
+#ifdef NAPI_EXPERIMENTAL
+typedef enum {
+  node_api_reftype_strong_or_weak,
+  node_api_reftype_strong,
+} node_api_reftype;
+#endif
+
 #endif  // SRC_JS_NATIVE_API_TYPES_H_
diff --git a/src/js_native_api_v8.cc b/src/js_native_api_v8.cc
index 611a0521fceab8..98a9c944f5c249 100644
--- a/src/js_native_api_v8.cc
+++ b/src/js_native_api_v8.cc
@@ -247,7 +247,14 @@ class CallbackBundle {
     bundle->env = env;
 
     v8::Local<v8::Value> cbdata = v8::External::New(env->isolate, bundle);
-    Reference::New(env, cbdata, 0, true, Delete, bundle, nullptr);
+    Reference::New(env,
+                   cbdata,
+                   node_api_reftype_strong_or_weak,
+                   0,
+                   true,
+                   Delete,
+                   bundle,
+                   nullptr);
     return cbdata;
   }
   napi_env env;   // Necessary to invoke C++ NAPI callback
@@ -431,14 +438,21 @@ inline napi_status Wrap(napi_env env,
     // before then, then the finalize callback will never be invoked.)
     // Therefore a finalize callback is required when returning a reference.
     CHECK_ARG(env, finalize_cb);
-    reference = v8impl::Reference::New(
-        env, obj, 0, false, finalize_cb, native_object, finalize_hint);
+    reference = v8impl::Reference::New(env,
+                                       obj,
+                                       node_api_reftype_strong_or_weak,
+                                       0,
+                                       false,
+                                       finalize_cb,
+                                       native_object,
+                                       finalize_hint);
     *result = reinterpret_cast<napi_ref>(reference);
   } else {
     // Create a self-deleting reference.
     reference = v8impl::Reference::New(
         env,
         obj,
+        node_api_reftype_strong_or_weak,
         0,
         true,
         finalize_cb,
@@ -574,11 +588,19 @@ void RefBase::Finalize(bool is_env_teardown) {
 }
 
 template <typename... Args>
-Reference::Reference(napi_env env, v8::Local<v8::Value> value, Args&&... args)
-    : RefBase(env, std::forward<Args>(args)...),
+Reference::Reference(napi_env env,
+                     v8::Local<v8::Value> value,
+                     node_api_reftype reftype,
+                     uint32_t initial_refcount,
+                     Args&&... args)
+    : RefBase(
+          env,
+          (reftype == node_api_reftype_strong_or_weak) ? initial_refcount : 1,
+          std::forward<Args>(args)...),
       _persistent(env->isolate, value),
       _secondPassParameter(new SecondPassCallParameterRef(this)),
-      _secondPassScheduled(false) {
+      _secondPassScheduled(false),
+      _refType(reftype) {
   if (RefCount() == 0) {
     SetWeak();
   }
@@ -586,6 +608,7 @@ Reference::Reference(napi_env env, v8::Local<v8::Value> value, Args&&... args)
 
 Reference* Reference::New(napi_env env,
                           v8::Local<v8::Value> value,
+                          node_api_reftype reftype,
                           uint32_t initial_refcount,
                           bool delete_self,
                           napi_finalize finalize_callback,
@@ -593,6 +616,7 @@ Reference* Reference::New(napi_env env,
                           void* finalize_hint) {
   return new Reference(env,
                        value,
+                       reftype,
                        initial_refcount,
                        delete_self,
                        finalize_callback,
@@ -621,7 +645,11 @@ uint32_t Reference::Unref() {
   uint32_t old_refcount = RefCount();
   uint32_t refcount = RefBase::Unref();
   if (old_refcount == 1 && refcount == 0) {
-    SetWeak();
+    if (_refType == node_api_reftype_strong_or_weak) {
+      SetWeak();
+    } else {
+      Delete(this);
+    }
   }
   return refcount;
 }
@@ -634,6 +662,10 @@ v8::Local<v8::Value> Reference::Get() {
   }
 }
 
+node_api_reftype Reference::RefType() noexcept {
+  return _refType;
+}
+
 void Reference::Finalize(bool is_env_teardown) {
   // During env teardown, `~napi_env()` alone is responsible for finalizing.
   // Thus, we don't want any stray gc passes to trigger a second call to
@@ -2368,17 +2400,23 @@ napi_status napi_create_external(napi_env env,
 
   // The Reference object will delete itself after invoking the finalizer
   // callback.
-  v8impl::Reference::New(
-      env, external_value, 0, true, finalize_cb, data, finalize_hint);
+  v8impl::Reference::New(env,
+                         external_value,
+                         node_api_reftype_strong_or_weak,
+                         0,
+                         true,
+                         finalize_cb,
+                         data,
+                         finalize_hint);
 
   *result = v8impl::JsValueFromV8LocalValue(external_value);
 
   return napi_clear_last_error(env);
 }
 
-NAPI_EXTERN napi_status napi_type_tag_object(napi_env env,
-                                             napi_value object,
-                                             const napi_type_tag* type_tag) {
+napi_status napi_type_tag_object(napi_env env,
+                                 napi_value object,
+                                 const napi_type_tag* type_tag) {
   NAPI_PREAMBLE(env);
   v8::Local<v8::Context> context = env->context();
   v8::Local<v8::Object> obj;
@@ -2403,11 +2441,10 @@ NAPI_EXTERN napi_status napi_type_tag_object(napi_env env,
   return GET_RETURN_STATUS(env);
 }
 
-NAPI_EXTERN napi_status
-napi_check_object_type_tag(napi_env env,
-                           napi_value object,
-                           const napi_type_tag* type_tag,
-                           bool* result) {
+napi_status napi_check_object_type_tag(napi_env env,
+                                       napi_value object,
+                                       const napi_type_tag* type_tag,
+                                       bool* result) {
   NAPI_PREAMBLE(env);
   v8::Local<v8::Context> context = env->context();
   v8::Local<v8::Object> obj;
@@ -2458,6 +2495,15 @@ napi_status napi_create_reference(napi_env env,
                                   napi_value value,
                                   uint32_t initial_refcount,
                                   napi_ref* result) {
+  return node_api_create_reference(
+      env, value, node_api_reftype_strong_or_weak, initial_refcount, result);
+}
+
+napi_status node_api_create_reference(napi_env env,
+                                      napi_value value,
+                                      node_api_reftype reftype,
+                                      uint32_t initial_refcount,
+                                      napi_ref* result) {
   // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
   // JS exceptions.
   CHECK_ENV(env);
@@ -2465,18 +2511,36 @@ napi_status napi_create_reference(napi_env env,
   CHECK_ARG(env, result);
 
   v8::Local<v8::Value> v8_value = v8impl::V8LocalValueFromJsValue(value);
-  if (!(v8_value->IsObject() || v8_value->IsFunction() ||
-        v8_value->IsSymbol())) {
-    return napi_set_last_error(env, napi_invalid_arg);
+  if (reftype == node_api_reftype_strong_or_weak) {
+    if (!(v8_value->IsObject() || v8_value->IsFunction() ||
+          v8_value->IsSymbol())) {
+      return napi_set_last_error(env, napi_invalid_arg);
+    }
   }
-
-  v8impl::Reference* reference =
-      v8impl::Reference::New(env, v8_value, initial_refcount, false);
+  v8impl::Reference* reference = v8impl::Reference::New(
+      env,
+      v8_value,
+      reftype,
+      initial_refcount,
+      /* delete_self: */ reftype == node_api_reftype_strong);
 
   *result = reinterpret_cast<napi_ref>(reference);
   return napi_clear_last_error(env);
 }
 
+napi_status node_api_get_reference_type(napi_env env,
+                                        napi_ref ref,
+                                        node_api_reftype* result) {
+  // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
+  // JS exceptions.
+  CHECK_ENV(env);
+  CHECK_ARG(env, ref);
+  CHECK_ARG(env, result);
+
+  *result = reinterpret_cast<v8impl::Reference*>(ref)->RefType();
+  return napi_clear_last_error(env);
+}
+
 // Deletes a reference. The referenced value is released, and may be GC'd unless
 // there are other references to it.
 napi_status napi_delete_reference(napi_env env, napi_ref ref) {
@@ -2485,7 +2549,12 @@ napi_status napi_delete_reference(napi_env env, napi_ref ref) {
   CHECK_ENV(env);
   CHECK_ARG(env, ref);
 
-  v8impl::Reference::Delete(reinterpret_cast<v8impl::Reference*>(ref));
+  v8impl::Reference* reference = reinterpret_cast<v8impl::Reference*>(ref);
+  if (reference->RefType() == node_api_reftype_strong_or_weak) {
+    v8impl::Reference::Delete(reference);
+  } else {
+    return napi_set_last_error(env, napi_generic_failure);
+  }
 
   return napi_clear_last_error(env);
 }
diff --git a/src/js_native_api_v8.h b/src/js_native_api_v8.h
index ffe351f4f6c65e..5d6968c6c7a32b 100644
--- a/src/js_native_api_v8.h
+++ b/src/js_native_api_v8.h
@@ -385,16 +385,21 @@ class RefBase : protected Finalizer, RefTracker {
   bool _delete_self;
 };
 
-class Reference : public RefBase {
+class Reference final : public RefBase {
   using SecondPassCallParameterRef = Reference*;
 
- protected:
+ private:
   template <typename... Args>
-  Reference(napi_env env, v8::Local<v8::Value> value, Args&&... args);
+  Reference(napi_env env,
+            v8::Local<v8::Value> value,
+            node_api_reftype reftype,
+            uint32_t initial_refcount,
+            Args&&... args);
 
  public:
   static Reference* New(napi_env env,
                         v8::Local<v8::Value> value,
+                        node_api_reftype reftype,
                         uint32_t initial_refcount,
                         bool delete_self,
                         napi_finalize finalize_callback = nullptr,
@@ -405,6 +410,7 @@ class Reference : public RefBase {
   uint32_t Ref();
   uint32_t Unref();
   v8::Local<v8::Value> Get();
+  node_api_reftype RefType() noexcept;
 
  protected:
   void Finalize(bool is_env_teardown = false) override;
@@ -421,6 +427,7 @@ class Reference : public RefBase {
   v8impl::Persistent<v8::Value> _persistent;
   SecondPassCallParameterRef* _secondPassParameter;
   bool _secondPassScheduled;
+  node_api_reftype _refType{node_api_reftype_strong_or_weak};
 
   FRIEND_TEST(JsNativeApiV8Test, Reference);
 };
diff --git a/test/js-native-api/test_strong_ref/binding.gyp b/test/js-native-api/test_strong_ref/binding.gyp
new file mode 100644
index 00000000000000..944a8f3ee4f3ff
--- /dev/null
+++ b/test/js-native-api/test_strong_ref/binding.gyp
@@ -0,0 +1,11 @@
+{
+  "targets": [
+    {
+      "target_name": "test_strong_ref",
+      "sources": [
+        "../entry_point.c",
+        "test_strong_ref.cc"
+      ]
+    }
+  ]
+}
diff --git a/test/js-native-api/test_strong_ref/test.js b/test/js-native-api/test_strong_ref/test.js
new file mode 100644
index 00000000000000..af65bf5ed329dc
--- /dev/null
+++ b/test/js-native-api/test_strong_ref/test.js
@@ -0,0 +1,39 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+
+// Testing API calls for strong reference values.
+const test_strong_ref = require(`./build/${common.buildType}/test_strong_ref`);
+
+const value_undefined = undefined;
+const value_null = null;
+const value_boolean = false;
+const value_number = 42;
+const value_string = 'test_string';
+const value_symbol = Symbol.for('test_symbol');
+const value_object = { x: 1, y: 2 };
+const value_function = (x, y) => x + y;
+
+const all_values = [
+  value_undefined,
+  value_null,
+  value_boolean,
+  value_number,
+  value_string,
+  value_symbol,
+  value_object,
+  value_function,
+];
+
+// Go over all values of different types, create strong ref values for them,
+// read the stored values, and check how the ref count works.
+for (const value of all_values) {
+  const index = test_strong_ref.Create(value);
+  const strong_ref_value = test_strong_ref.GetValue(index);
+  assert.strictEqual(value, strong_ref_value);
+  test_strong_ref.Ref(index);
+  const isDeleted1 = test_strong_ref.Unref(index);
+  assert.strictEqual(isDeleted1, false);
+  const isDeleted2 = test_strong_ref.Unref(index);
+  assert.strictEqual(isDeleted2, true);
+}
diff --git a/test/js-native-api/test_strong_ref/test_strong_ref.cc b/test/js-native-api/test_strong_ref/test_strong_ref.cc
new file mode 100644
index 00000000000000..e17cdbc48eef13
--- /dev/null
+++ b/test/js-native-api/test_strong_ref/test_strong_ref.cc
@@ -0,0 +1,153 @@
+#define NAPI_EXPERIMENTAL
+#include <js_native_api.h>
+#include <vector>
+#include "../common.h"
+
+static napi_value Create(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NODE_API_CALL(env,
+                napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
+
+  NODE_API_ASSERT(env, argc == 1, "Wrong type of arguments. Expects one arg.");
+
+  napi_ref strong_ref;
+  NODE_API_CALL(env,
+                node_api_create_reference(
+                    env, args[0], node_api_reftype_strong, 1, &strong_ref));
+
+  std::vector<napi_ref>* strong_ref_values;
+  NODE_API_CALL(env,
+                napi_get_instance_data(
+                    env, reinterpret_cast<void**>(&strong_ref_values)));
+
+  if (strong_ref_values == nullptr) {
+    strong_ref_values = new std::vector<napi_ref>();
+    NODE_API_CALL(
+        env,
+        napi_set_instance_data(
+            env,
+            strong_ref_values,
+            [](napi_env env, void* finalize_data, void* finalize_hint) {
+              delete reinterpret_cast<std::vector<napi_ref>*>(finalize_data);
+            },
+            nullptr));
+  }
+
+  size_t index = strong_ref_values->size();
+  strong_ref_values->push_back(strong_ref);
+
+  napi_value result;
+  NODE_API_CALL(env,
+                napi_create_uint32(env, static_cast<uint32_t>(index), &result));
+
+  return result;
+}
+
+static napi_value GetValue(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NODE_API_CALL(env,
+                napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
+
+  NODE_API_ASSERT(env, argc == 1, "Wrong type of arguments. Expects one arg.");
+
+  napi_valuetype value_type;
+  NODE_API_CALL(env, napi_typeof(env, args[0], &value_type));
+  NODE_API_ASSERT(env, value_type == napi_number, "Argument must be a number.");
+
+  uint32_t index;
+  NODE_API_CALL(env, napi_get_value_uint32(env, args[0], &index));
+
+  std::vector<napi_ref>* strong_ref_values;
+  NODE_API_CALL(env,
+                napi_get_instance_data(
+                    env, reinterpret_cast<void**>(&strong_ref_values)));
+  NODE_API_ASSERT(
+      env, strong_ref_values != nullptr, "Cannot get instance data.");
+
+  napi_ref strong_ref = strong_ref_values->at(index);
+  napi_value value;
+  NODE_API_CALL(env, napi_get_reference_value(env, strong_ref, &value));
+
+  return value;
+}
+
+static napi_value Ref(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NODE_API_CALL(env,
+                napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
+
+  NODE_API_ASSERT(env, argc == 1, "Wrong type of arguments. Expects one arg.");
+
+  napi_valuetype value_type;
+  NODE_API_CALL(env, napi_typeof(env, args[0], &value_type));
+  NODE_API_ASSERT(env, value_type == napi_number, "Argument must be a number.");
+
+  uint32_t index;
+  NODE_API_CALL(env, napi_get_value_uint32(env, args[0], &index));
+
+  std::vector<napi_ref>* strong_ref_values;
+  NODE_API_CALL(env,
+                napi_get_instance_data(
+                    env, reinterpret_cast<void**>(&strong_ref_values)));
+  NODE_API_ASSERT(
+      env, strong_ref_values != nullptr, "Cannot get instance data.");
+
+  napi_ref strong_ref = strong_ref_values->at(index);
+  NODE_API_CALL(env, napi_reference_ref(env, strong_ref, nullptr));
+
+  napi_value undefined;
+  NODE_API_CALL(env, napi_get_undefined(env, &undefined));
+  return undefined;
+}
+
+static napi_value Unref(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NODE_API_CALL(env,
+                napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
+
+  NODE_API_ASSERT(env, argc == 1, "Wrong type of arguments. Expects one arg.");
+
+  napi_valuetype value_type;
+  NODE_API_CALL(env, napi_typeof(env, args[0], &value_type));
+  NODE_API_ASSERT(env, value_type == napi_number, "Argument must be a number.");
+
+  uint32_t index;
+  NODE_API_CALL(env, napi_get_value_uint32(env, args[0], &index));
+
+  std::vector<napi_ref>* strong_ref_values;
+  NODE_API_CALL(env,
+                napi_get_instance_data(
+                    env, reinterpret_cast<void**>(&strong_ref_values)));
+  NODE_API_ASSERT(
+      env, strong_ref_values != nullptr, "Cannot get instance data.");
+
+  napi_ref strong_ref = strong_ref_values->at(index);
+  uint32_t ref_count;
+  NODE_API_CALL(env, napi_reference_unref(env, strong_ref, &ref_count));
+
+  napi_value result;
+  NODE_API_CALL(env, napi_get_boolean(env, ref_count == 0, &result));
+  return result;
+}
+
+EXTERN_C_START
+napi_value Init(napi_env env, napi_value exports) {
+  napi_property_descriptor properties[] = {
+      DECLARE_NODE_API_PROPERTY("Create", Create),
+      DECLARE_NODE_API_PROPERTY("GetValue", GetValue),
+      DECLARE_NODE_API_PROPERTY("Ref", Ref),
+      DECLARE_NODE_API_PROPERTY("Unref", Unref),
+  };
+
+  NODE_API_CALL(
+      env,
+      napi_define_properties(
+          env, exports, sizeof(properties) / sizeof(*properties), properties));
+
+  return exports;
+}
+EXTERN_C_END