node-addon-api 1.6.1 → 1.7.1

package/doc/creating_a_release.md

@@ -1,30 +1,51 @@
 # Creating a release
 
-Only collaborators in npm for node-addon-api can create releases.
+Only collaborators in npm for **node-addon-api** can create releases.
 If you want to be able to do releases ask one of the existing
-collaborators to add you.  If necessary you can ask the build
+collaborators to add you. If necessary you can ask the build
 Working Group who manages the Node.js npm user to add you if
 there are no other active collaborators.
 
+## Prerequisites
+
+Before to start creating a new release check if you have installed the following
+tools:
+
+* [Changelog maker](https://www.npmjs.com/package/changelog-maker)
+
+If not please follow the instruction reported in the tool's documentation to 
+install it.
+
+## Publish new release
+
 These are the steps to follow to create a new release:
 
-* Open an issue in the node-addon-api repo documenting
-  the intent to create a new release.  Give people some
-  time to comment or suggest PRs that should land first.
+* Open an issue in the **node-addon-api** repo documenting the intent to create a
+new release. Give people some time to comment or suggest PRs that should land first.
 
 * Validate all tests pass by running npm test on master.
 
-* Use https://ci.nodejs.org/view/x%20-%20Abi%20stable%20module%20API/job/node-test-node-addon-api/
-  to validate tests pass for latest 9, 8, 6, 4 releases
-  (note there are still some issues on SmartOS and
-   Windows in the testing).
+* Update the version in **package.json** appropriately.
 
-* Update the version in package.json appropriately.
+* Update the [README.md](https://github.com/nodejs/node-addon-api/blob/master/README.md) 
+to show the new version as the latest.
 
-* Update the README.md to show the new version as the latest.
+* Generate the changelog for the new version using **changelog maker** tool. From
+the route folder of the repo launch the following command:
+
+    ```bash 
+    > changelog-maker
+    ```
+* Use the output generated by **changelog maker** to pdate the [CHANGELOG.md](https://github.com/nodejs/node-addon-api/blob/master/CHANGELOG.md)
+following the style used in publishing the previous release.
+
+* Add any new contributors to the "contributors" section in the package.json
+
+* Validate all tests pass by running npm test on master.
 
-* Add any new contributors to the "contributors" section in
-  the package.json
+* Use **[CI](https://ci.nodejs.org/view/x%20-%20Abi%20stable%20module%20API/job/node-test-node-addon-api/)**
+to validate tests pass for latest 11, 10, 8, 6 releases (note there are still some issues on SmartOS and
+Windows in the testing).
 
 * Do a clean checkout of node-addon-api.
 
@@ -33,9 +54,9 @@ These are the steps to follow to create a new release:
 * Create a release in Github (look at existing releases for an example).
 
 * Validate that you can run `npm install node-addon-api` successfully
-  and that the correct version is installed.
+and that the correct version is installed.
 
-* Comment on the issue opened in the first step that the
-  release has been created and close the issue.
+* Comment on the issue opened in the first step that the release has been created
+and close the issue.
 
 * Tweet that the release has been created.

package/doc/error_handling.md

@@ -153,3 +153,34 @@ if (env.IsExceptionPending()) {
 
 Since the exception was cleared here, it will not be propagated as a JavaScript
 exception after the native callback returns.
+
+## Calling N-API directly from a **node-addon-api** addon
+
+**node-addon-api** provides macros for throwing errors in response to non-OK
+`napi_status` results when calling [N-API](https://nodejs.org/docs/latest/api/n-api.html)
+functions from within a native addon. These macros are defined differently
+depending on whether C++ exceptions are enabled or not, but are available for
+use in either case.
+
+### `NAPI_THROW(e, ...)`
+
+This macro accepts a `Napi::Error`, throws it, and returns the value given as
+the last parameter. If C++ exceptions are enabled (by defining
+`NAPI_CPP_EXCEPTIONS` during the build), the return value will be ignored.
+
+### `NAPI_THROW_IF_FAILED(env, status, ...)`
+
+This macro accepts a `Napi::Env` and a `napi_status`. It constructs an error
+from the `napi_status`, throws it, and returns the value given as the last
+parameter. If C++ exceptions are enabled (by defining `NAPI_CPP_EXCEPTIONS`
+during the build), the return value will be ignored.
+
+### `NAPI_THROW_IF_FAILED_VOID(env, status)`
+
+This macro accepts a `Napi::Env` and a `napi_status`. It constructs an error
+from the `napi_status`, throws it, and returns.
+
+### `NAPI_FATAL_IF_FAILED(status, location, message)`
+
+This macro accepts a `napi_status`, a C string indicating the location where the
+error occurred, and a second C string for the message to display.

package/doc/function_reference.md

@@ -23,7 +23,7 @@ Creates a "weak" reference to the value, in that the initial reference count is
 set to 0.
 
 ```cpp
-static Napi::FunctionReference Napi::FunctionReference::Weak(const Napi::Function& value);
+static Napi::FunctionReference Napi::Weak(const Napi::Function& value);
 ```
 
 - `[in] value`: The value which is to be referenced.
@@ -36,7 +36,7 @@ Creates a "persistent" reference to the value, in that the initial reference
 count is set to 1.
 
 ```cpp
-static Napi::FunctionReference Napi::FunctionReference::Persistent(const Napi::Function& value);
+static Napi::FunctionReference Napi::Persistent(const Napi::Function& value);
 ```
 
 - `[in] value`: The value which is to be referenced.

package/doc/number.md

@@ -24,8 +24,8 @@ Creates a new instance of a `Napi::Number` object.
 Napi::Number(napi_env env, napi_value value);
 ```
 
- - `[in] env`: The `napi_env` environment in which to construct the `Napi::Nuber` object.
- - `[in] value`: The `napi_value` which is a handle for a JavaScript `Number`.
+ - `[in] env`: The `napi_env` environment in which to construct the `Napi::Number` object.
+ - `[in] value`: The JavaScript value holding a number.
 
  Returns a non-empty `Napi::Number` object.
 
@@ -36,14 +36,14 @@ Napi::Number(napi_env env, napi_value value);
 ```cpp
 Napi::Number Napi::Number::New(napi_env env, double value);
 ```
- - `[in] env`: The `napi_env` environment in which to construct the `Napi::Nuber` object.
- - `[in] value`: The `napi_value` which is a handle for a JavaScript `Number`.
+ - `[in] env`: The `napi_env` environment in which to construct the `Napi::Number` object.
+ - `[in] value`: The C++ primitive from which to instantiate the `Napi::Number`.
 
 Creates a new instance of a `Napi::Number` object.
 
 ### Int32Value
 
-Converts a `Napi::Number` value to a `uint32_t` primitive type.
+Converts a `Napi::Number` value to a `int32_t` primitive type.
 
 ```cpp
 Napi::Number::Int32Value() const;

package/doc/object.md

@@ -23,12 +23,12 @@ Void Init(Env env) {
 
   // Assign values to properties
   obj.Set("hello", "world");
-  obj.Set(42, "The Answer to Life, the Universe, and Everything");
+  obj.Set(uint32_t(42), "The Answer to Life, the Universe, and Everything");
   obj.Set("Douglas Adams", true);
 
   // Get properties
   Value val1 = obj.Get("hello");
-  Value val2 = obj.Get(42);
+  Value val2 = obj.Get(uint32_t(42));
   Value val3 = obj.Get("Douglas Adams");
 
   // Test if objects have properties.
@@ -108,7 +108,7 @@ Napi::Value Napi::Object::Get(____ key);
 ```
 - `[in] key`: The name of the property to return the value for.
 
-Returns the [`Napi::Value`](value.md) associated with the key property. Returns NULL if no such key exists.
+Returns the [`Napi::Value`](value.md) associated with the key property. Returns the value *undefined* if the key does not exist.
 
 The `key` can be any of the following types:
 - `napi_value`
@@ -142,7 +142,7 @@ Note: This is equivalent to the JavaScript instanceof operator.
 ```cpp
 void Napi::Object::DefineProperty (const Napi::PropertyDescriptor& property);
 ```
-- `[in] property`: A [`Napi::PropertyDescriptor`](propertydescriptor.md).
+- `[in] property`: A [`Napi::PropertyDescriptor`](property_descriptor.md).
 
 Define a property on the object.
 
@@ -151,7 +151,7 @@ Define a property on the object.
 ```cpp
 void Napi::Object::DefineProperties (____ properties)
 ```
-- `[in] properties`: A list of [`Napi::PropertyDescriptor`](propertydescriptor.md). Can be one of the following types:
+- `[in] properties`: A list of [`Napi::PropertyDescriptor`](property_descriptor.md). Can be one of the following types:
 	- const std::initializer_list<Napi::PropertyDescriptor>&
 	- const std::vector<Napi::PropertyDescriptor>&
 

package/doc/object_reference.md

@@ -40,7 +40,7 @@ static Napi::ObjectReference Napi::ObjectReference::New(const Napi::Object& valu
 Returns the newly created reference.
 
 ```cpp
-static Napi::ObjectReference Napi::ObjectReference::Weak(const Napi::Object& value);
+static Napi::ObjectReference Napi::Weak(const Napi::Object& value);
 ```
 
 Creates a "weak" reference to the value, in that the initial count of number of references is set to 0.
@@ -50,7 +50,7 @@ Creates a "weak" reference to the value, in that the initial count of number of
 Returns the newly created reference.
 
 ```cpp
-static Napi::ObjectReference Napi::ObjectReference::Persistent(const Napi::Object& value);
+static Napi::ObjectReference Napi::Persistent(const Napi::Object& value);
 ```
 
 Creates a "persistent" reference to the value, in that the initial count of number of references is set to 1.

package/doc/object_wrap.md

@@ -78,7 +78,7 @@ Napi::Object Init (Napi::Env env, Napi::Object exports) {
     return exports;
 }
 
-// Regisgter and initialize native add-on
+// Register and initialize native add-on
 NODE_API_MODULE(NODE_GYP_MODULE_NAME, Init)
 ```
 
@@ -116,7 +116,7 @@ against the class constructor.
 
 ## Methods
 
-### Contructor
+### Constructor
 
 Creates a new instance of a JavaScript object that wraps native instance.
 

package/doc/prebuild_tools.md

@@ -2,7 +2,7 @@
 
 The distribution of a native add-on is just as important as its implementation.
 In order to install a native add-on it's important to have all the necessary
-dependencies installed and well configured (see the [setup](doc/setum.md) section).
+dependencies installed and well configured (see the [setup](setup.md) section).
 The end-user will need to compile the add-on when they will do an `npm install`
 and in some cases this could create problems. To avoid the compilation process it's
 possible to ditribute the native add-on in pre-built form for different platform

package/doc/property_descriptor.md

@@ -192,7 +192,7 @@ static Napi::PropertyDescriptor Napi::PropertyDescriptor::Function (
 		            void *data = nullptr);
 ```
 
-* `[in] env`: The environemnt in which to create this accessor.
+* `[in] env`: The environment in which to create this accessor.
 * `[in] name`: The name of the Callable function.
 * `[in] cb`: The function
 * `[in] attributes`: Potential attributes for the getter function.

package/doc/setup.md

@@ -55,8 +55,19 @@ To use **N-API** in a native module:
 ```gyp
   'defines': [ 'NAPI_DISABLE_CPP_EXCEPTIONS' ],
 ```
-
-  4. Include `napi.h` in the native module code.
+  4. If you would like your native addon to support OSX, please also add the
+  following settings in the `binding.gyp` file:
+
+  ```gyp
+  ['OS=="mac"', {
+      'cflags+': ['-fvisibility=hidden'],
+      'xcode_settings': {
+        'GCC_SYMBOLS_PRIVATE_EXTERN': 'YES', # -fvisibility=hidden
+      }
+  }]
+  ```
+
+  5. Include `napi.h` in the native module code.
      To ensure only ABI-stable APIs are used, DO NOT include
      `node.h`, `nan.h`, or `v8.h`.
 

package/doc/string.md

@@ -56,6 +56,8 @@ Napi::String::New(napi_env env, const std::string& value);
 Napi::String::New(napi_env env, const std::u16::string& value);
 Napi::String::New(napi_env env, const char* value);
 Napi::String::New(napi_env env, const char16_t* value);
+Napi::String::New(napi_env env, const char* value, size_t length);
+Napi::String::New(napi_env env, const char16_t* value, size_t length);
 ```
 
 - `[in] env`: The `napi_env` environment in which to construct the `Napi::Value` object.
@@ -64,6 +66,7 @@ Napi::String::New(napi_env env, const char16_t* value);
   - `std::u16string&` - represents a UTF16-LE string.
   - `const char*` - represents a UTF8 string.
   - `const char16_t*` - represents a UTF16-LE string.
+- `[in] length`: The length of the string (not necessarily null-terminated) in code units.
 
 Returns a new `Napi::String` that represents the passed in C++ string.
 

package/doc/threadsafe_function.md

@@ -0,0 +1,303 @@
+# ThreadSafeFunction
+
+JavaScript functions can normally only be called from a native addon's main
+thread. If an addon creates additional threads, then node-addon-api functions
+that require a `Napi::Env`, `Napi::Value`, or `Napi::Reference` must not be
+called from those threads.
+
+When an addon has additional threads and JavaScript functions need to be invoked
+based on the processing completed by those threads, those threads must
+communicate with the addon's main thread so that the main thread can invoke the
+JavaScript function on their behalf. The thread-safe function APIs provide an
+easy way to do this.
+
+These APIs provide the type `Napi::ThreadSafeFunction` as well as APIs to
+create, destroy, and call objects of this type.
+`Napi::ThreadSafeFunction::New()` creates a persistent reference that holds a
+JavaScript function which can be called from multiple threads. The calls happen
+asynchronously. This means that values with which the JavaScript callback is to
+be called will be placed in a queue, and, for each value in the queue, a call
+will eventually be made to the JavaScript function.
+
+`Napi::ThreadSafeFunction` objects are destroyed when every thread which uses
+the object has called `Release()` or has received a return status of
+`napi_closing` in response to a call to `BlockingCall()` or `NonBlockingCall()`.
+The queue is emptied before the `Napi::ThreadSafeFunction` is destroyed. It is
+important that `Release()` be the last API call made in conjunction with a given
+`Napi::ThreadSafeFunction`, because after the call completes, there is no
+guarantee that the `Napi::ThreadSafeFunction` is still allocated. For the same
+reason it is also important that no more use be made of a thread-safe function
+after receiving a return value of `napi_closing` in response to a call to
+`BlockingCall()` or `NonBlockingCall()`. Data associated with the
+`Napi::ThreadSafeFunction` can be freed in its `Finalizer` callback which was
+passed to `ThreadSafeFunction::New()`.
+
+Once the number of threads making use of a `Napi::ThreadSafeFunction` reaches
+zero, no further threads can start making use of it by calling `Acquire()`. In
+fact, all subsequent API calls associated with it, except `Release()`, will
+return an error value of `napi_closing`.
+
+## Methods
+
+### Constructor
+
+Creates a new empty instance of `Napi::ThreadSafeFunction`.
+
+```cpp
+Napi::Function::ThreadSafeFunction();
+```
+
+### Constructor
+
+Creates a new instance of the `Napi::ThreadSafeFunction` object.
+
+```cpp
+Napi::ThreadSafeFunction::ThreadSafeFunction(napi_threadsafe_function tsfn);
+```
+
+- `tsfn`: The `napi_threadsafe_function` which is a handle for an existing
+  thread-safe function.
+
+Returns a non-empty `Napi::ThreadSafeFunction` instance.
+
+### New
+
+Creates a new instance of the `Napi::ThreadSafeFunction` object. The `New`
+function has several overloads for the various optional parameters: skip the
+optional parameter for that specific overload.
+
+```cpp
+New(napi_env env,
+    const Function& callback,
+    const Object& resource,
+    ResourceString resourceName,
+    size_t maxQueueSize,
+    size_t initialThreadCount,
+    ContextType* context,
+    Finalizer finalizeCallback,
+    FinalizerDataType* data);
+```
+
+- `env`: The `napi_env` environment in which to construct the
+  `Napi::ThreadSafeFunction` object.
+- `callback`: The `Function` to call from another thread.
+- `[optional] resource`: An object associated with the async work that will be
+  passed to possible async_hooks init hooks.
+- `resourceName`: A JavaScript string to provide an identifier for the kind of
+  resource that is being provided for diagnostic information exposed by the
+  async_hooks API.
+- `maxQueueSize`: Maximum size of the queue. `0` for no limit.
+- `initialThreadCount`: The initial number of threads, including the main
+  thread, which will be making use of this function.
+- `[optional] context`: Data to attach to the resulting `ThreadSafeFunction`.
+- `[optional] finalizeCallback`: Function to call when the `ThreadSafeFunction`
+  is being destroyed.  This callback will be invoked on the main thread when the
+  thread-safe function is about to be destroyed. It receives the context and the
+  finalize data given during construction (if given), and provides an
+  opportunity for cleaning up after the threads e.g. by calling
+  `uv_thread_join()`. It is important that, aside from the main loop thread,
+  there be no threads left using the thread-safe function after the finalize
+  callback completes. Must implement `void operator()(Env env, DataType* data,
+  Context* hint)`, skipping `data` or `hint` if they are not provided.
+  Can be retreived via `GetContext()`.
+- `[optional] data`: Data to be passed to `finalizeCallback`.
+
+Returns a non-empty `Napi::ThreadSafeFunction` instance.
+
+### Acquire
+
+Add a thread to this thread-safe function object, indicating that a new thread
+will start making use of the thread-safe function. 
+
+```cpp
+napi_status Napi::ThreadSafeFunction::Acquire()
+```
+
+Returns one of:
+- `napi_ok`: The thread has successfully acquired the thread-safe function
+for its use. 
+- `napi_closing`: The thread-safe function has been marked as closing via a
+previous call to `Abort()`.
+
+### Release
+
+Indicate that an existing thread will stop making use of the thread-safe
+function. A thread should call this API when it stops making use of this
+thread-safe function. Using any thread-safe APIs after having called this API
+has undefined results in the current thread, as it may have been destroyed.
+
+```cpp
+napi_status Napi::ThreadSafeFunction::Release()
+```
+
+Returns one of:
+- `napi_ok`: The thread-safe function has been successfully released.
+- `napi_invalid_arg`: The thread-safe function's thread-count is zero.
+- `napi_generic_failure`: A generic error occurred when attemping to release
+the thread-safe function.
+
+### Abort
+
+"Abort" the thread-safe function. This will cause all subsequent APIs associated
+with the thread-safe function except `Release()` to return `napi_closing` even
+before its reference count reaches zero. In particular, `BlockingCall` and
+`NonBlockingCall()` will return `napi_closing`, thus informing the threads that
+it is no longer possible to make asynchronous calls to the thread-safe function.
+This can be used as a criterion for terminating the thread. Upon receiving a
+return value of `napi_closing` from a thread-safe function call a thread must
+make no further use of the thread-safe function because it is no longer
+guaranteed to be allocated.
+
+```cpp
+napi_status Napi::ThreadSafeFunction::Abort()
+```
+
+Returns one of:
+- `napi_ok`: The thread-safe function has been successfully aborted.
+- `napi_invalid_arg`: The thread-safe function's thread-count is zero.
+- `napi_generic_failure`: A generic error occurred when attemping to abort
+the thread-safe function.
+
+### BlockingCall / NonBlockingCall
+
+Calls the Javascript function in either a blocking or non-blocking fashion.
+- `BlockingCall()`: the API blocks until space becomes available in the queue.
+  Will never block if the thread-safe function was created with a maximum queue
+  size of `0`.
+- `NonBlockingCall()`: will return `napi_queue_full` if the queue was full,
+  preventing data from being successfully added to the queue.
+
+There are several overloaded implementations of `BlockingCall()` and
+`NonBlockingCall()` for use with optional parameters: skip the optional
+parameter for that specific overload.
+
+```cpp
+napi_status Napi::ThreadSafeFunction::BlockingCall(DataType* data, Callback callback) const
+
+napi_status Napi::ThreadSafeFunction::NonBlockingCall(DataType* data, Callback callback) const
+```
+
+- `[optional] data`: Data to pass to `callback`.
+- `[optional] callback`: C++ function that is invoked on the main thread. The
+  callback receives the `ThreadSafeFunction`'s JavaScript callback function to
+  call as an `Napi::Function` in its parameters and the `DataType*` data pointer
+  (if provided). Must implement `void operator()(Napi::Env env, Function
+  jsCallback, DataType* data)`, skipping `data` if not provided. It is not
+  necessary to call into JavaScript via `MakeCallback()` because N-API runs
+  `callback` in a context appropriate for callbacks.
+
+Returns one of:
+- `napi_ok`: The call was successfully added to the queue.
+- `napi_queue_full`: The queue was full when trying to call in a non-blocking
+  method.
+- `napi_closing`: The thread-safe function is aborted and cannot accept more
+  calls.
+- `napi_invalid_arg`: The thread-safe function is closed.
+- `napi_generic_failure`: A generic error occurred when attemping to add to the
+  queue.
+
+## Example
+
+```cpp
+#include <chrono>
+#include <thread>
+#include <napi.h>
+
+using namespace Napi;
+
+std::thread nativeThread;
+ThreadSafeFunction tsfn;
+
+Value Start( const CallbackInfo& info )
+{
+  Napi::Env env = info.Env();
+
+  if ( info.Length() < 2 )
+  {
+    throw TypeError::New( env, "Expected two arguments" );
+  }
+  else if ( !info[0].IsFunction() )
+  {
+    throw TypeError::New( env, "Expected first arg to be function" );
+  }
+  else if ( !info[1].IsNumber() )
+  {
+    throw TypeError::New( env, "Expected second arg to be number" );
+  }
+
+  int count = info[1].As<Number>().Int32Value();
+
+  // Create a ThreadSafeFunction
+  tsfn = ThreadSafeFunction::New(
+      env,
+      info[0].As<Function>(),  // JavaScript function called asynchronously
+      "Resource Name",         // Name
+      0,                       // Unlimited queue
+      1,                       // Only one thread will use this initially
+      []( Napi::Env ) {        // Finalizer used to clean threads up
+        nativeThread.join();
+      } );
+
+  // Create a native thread
+  nativeThread = std::thread( [count] {
+    auto callback = []( Napi::Env env, Function jsCallback, int* value ) {
+      // Transform native data into JS data, passing it to the provided 
+      // `jsCallback` -- the TSFN's JavaScript function.
+      jsCallback.Call( {Number::New( env, *value )} );
+      
+      // We're finished with the data.
+      delete value;
+    };
+
+    for ( int i = 0; i < count; i++ )
+    {
+      // Create new data
+      int* value = new int( clock() );
+
+      // Perform a blocking call
+      napi_status status = tsfn.BlockingCall( value, callback );
+      if ( status != napi_ok )
+      {
+        // Handle error
+        break;
+      }
+
+      std::this_thread::sleep_for( std::chrono::seconds( 1 ) );
+    }
+
+    // Release the thread-safe function
+    tsfn.Release();
+  } );
+
+  return Boolean::New(env, true);
+}
+
+Napi::Object Init( Napi::Env env, Object exports )
+{
+  exports.Set( "start", Function::New( env, Start ) );
+  return exports;
+}
+
+NODE_API_MODULE( clock, Init )
+```
+
+The above code can be used from JavaScript as follows:
+
+```js
+const { start } = require('bindings')('clock');
+
+start(function () {
+    console.log("JavaScript callback called with arguments", Array.from(arguments));
+}, 5);
+```
+
+When executed, the output will show the value of `clock()` five times at one
+second intervals:
+
+```
+JavaScript callback called with arguments [ 84745 ]
+JavaScript callback called with arguments [ 103211 ]
+JavaScript callback called with arguments [ 104516 ]
+JavaScript callback called with arguments [ 105104 ]
+JavaScript callback called with arguments [ 105691 ]
+```

package/index.js

@@ -17,6 +17,7 @@ var versionArray = process.version
 var isNodeApiBuiltin = (
   versionArray[0] > 8 ||
   (versionArray[0] == 8 && versionArray[1] >= 6) ||
+  (versionArray[0] == 6 && versionArray[1] >= 15) ||
   (versionArray[0] == 6 && versionArray[1] >= 14 && versionArray[2] >= 2));
 
 // The flag is not needed when the Node version is not 8, nor if the API is

package/napi-inl.deprecated.h

@@ -73,7 +73,7 @@ inline PropertyDescriptor PropertyDescriptor::Accessor(const char* utf8name,
                                                        void* /*data*/) {
   typedef details::AccessorCallbackData<Getter, Setter> CbData;
   // TODO: Delete when the function is destroyed
-  auto callbackData = new CbData({ getter, setter });
+  auto callbackData = new CbData({ getter, setter, nullptr });
 
   return PropertyDescriptor({
     utf8name,
@@ -104,7 +104,7 @@ inline PropertyDescriptor PropertyDescriptor::Accessor(napi_value name,
                                                        void* /*data*/) {
   typedef details::AccessorCallbackData<Getter, Setter> CbData;
   // TODO: Delete when the function is destroyed
-  auto callbackData = new CbData({ getter, setter });
+  auto callbackData = new CbData({ getter, setter, nullptr });
 
   return PropertyDescriptor({
     nullptr,