Addons

Addons are dynamically linked shared objects. They can provide glue to C and
C++ libraries. The API (at the moment) is rather complex, involving
knowledge of several libraries:

  • V8 JavaScript, a C++ library. Used for interfacing with JavaScript:
    creating objects, calling functions, etc. Documented mostly in the
    v8.h header file (deps/v8/include/v8.h in the Node source
    tree), which is also available
    online.

  • libuv, C event loop library.
    Anytime one needs to wait for a file descriptor to become readable,
    wait for a timer, or wait for a signal to be received one will need
    to interface with libuv. That is, if you perform any I/O, libuv will
    need to be used.

  • Internal Node libraries. Most importantly is the node::ObjectWrap
    class which you will likely want to derive from.

  • Others. Look in deps/ for what else is available.

Node statically compiles all its dependencies into the executable.
When compiling your module, you don’t need to worry about linking to
any of these libraries.

All of the following examples are available for
download and may be
used as a starting-point for your own Addon.

Hello world

To get started let’s make a small Addon which is the C++ equivalent of
the following JavaScript code:

  1. module.exports.hello = function() { return 'world'; };

First we create a file hello.cc:

  1. // hello.cc
  2. #include <node.h>
  4. using namespace v8;
  6. void Method(const FunctionCallbackInfo<Value>& args) {
  7.   Isolate* isolate = Isolate::GetCurrent();
  8.   HandleScope scope(isolate);
  9.   args.GetReturnValue().Set(String::NewFromUtf8(isolate, "world"));
  10. }
  12. void init(Handle<Object> exports) {
  13.   NODE_SET_METHOD(exports, "hello", Method);
  14. }
  16. NODE_MODULE(addon, init)

Note that all Node addons must export an initialization function:

  1. void Initialize (Handle<Object> exports);
  2. NODE_MODULE(module_name, Initialize)

There is no semi-colon after NODE_MODULE as it’s not a function (see
node.h).

The module_name needs to match the filename of the final binary (minus the
.node suffix).

The source code needs to be built into addon.node, the binary Addon. To
do this we create a file called binding.gyp which describes the configuration
to build your module in a JSON-like format. This file gets compiled by
node-gyp.

  1. {
  2.   "targets": [
  3.     {
  4.       "target_name": "addon",
  5.       "sources": [ "hello.cc" ]
  6.     }
  7.   ]
  8. }

The next step is to generate the appropriate project build files for the
current platform. Use node-gyp configure for that.

Now you will have either a Makefile (on Unix platforms) or a vcxproj file
(on Windows) in the build/ directory. Next invoke the node-gyp build
command.

Now you have your compiled .node bindings file! The compiled bindings end up
in build/Release/.

You can now use the binary addon in a Node project hello.js by pointing
require to the recently built hello.node module:

  1. // hello.js
  2. var addon = require('./build/Release/addon');
  4. console.log(addon.hello()); // 'world'

Please see patterns below for further information or
https://github.com/arturadib/node-qt for an example in production.

Addon patterns

Below are some addon patterns to help you get started. Consult the online
v8 reference for help with the various v8
calls, and v8’s Embedder’s Guide
for an explanation of several concepts used such as handles, scopes,
function templates, etc.

In order to use these examples you need to compile them using node-gyp.
Create the following binding.gyp file:

  1. {
  2.   "targets": [
  3.     {
  4.       "target_name": "addon",
  5.       "sources": [ "addon.cc" ]
  6.     }
  7.   ]
  8. }

In cases where there is more than one .cc file, simply add the file name to
the sources array, e.g.:

  1. "sources": ["addon.cc", "myexample.cc"]

Now that you have your binding.gyp ready, you can configure and build the
addon:

  1. $ node-gyp configure build

Function arguments

The following pattern illustrates how to read arguments from JavaScript
function calls and return a result. This is the main and only needed source
addon.cc:

  1. // addon.cc
  2. #include <node.h>
  4. using namespace v8;
  6. void Add(const FunctionCallbackInfo<Value>& args) {
  7.   Isolate* isolate = Isolate::GetCurrent();
  8.   HandleScope scope(isolate);
  10.   if (args.Length() < 2) {
  11.     isolate->ThrowException(Exception::TypeError(
  12.         String::NewFromUtf8(isolate, "Wrong number of arguments")));
  13.     return;
  14.   }
  16.   if (!args[0]->IsNumber() || !args[1]->IsNumber()) {
  17.     isolate->ThrowException(Exception::TypeError(
  18.         String::NewFromUtf8(isolate, "Wrong arguments")));
  19.     return;
  20.   }
  22.   double value = args[0]->NumberValue() + args[1]->NumberValue();
  23.   Local<Number> num = Number::New(isolate, value);
  25.   args.GetReturnValue().Set(num);
  26. }
  28. void Init(Handle<Object> exports) {
  29.   NODE_SET_METHOD(exports, "add", Add);
  30. }
  32. NODE_MODULE(addon, Init)

You can test it with the following JavaScript snippet:

  1. // test.js
  2. var addon = require('./build/Release/addon');
  4. console.log( 'This should be eight:', addon.add(3,5) );

Callbacks

You can pass JavaScript functions to a C++ function and execute them from
there. Here’s addon.cc:

  1. // addon.cc
  2. #include <node.h>
  4. using namespace v8;
  6. void RunCallback(const FunctionCallbackInfo<Value>& args) {
  7.   Isolate* isolate = Isolate::GetCurrent();
  8.   HandleScope scope(isolate);
  10.   Local<Function> cb = Local<Function>::Cast(args[0]);
  11.   const unsigned argc = 1;
  12.   Local<Value> argv[argc] = { String::NewFromUtf8(isolate, "hello world") };
  13.   cb->Call(isolate->GetCurrentContext()->Global(), argc, argv);
  14. }
  16. void Init(Handle<Object> exports, Handle<Object> module) {
  17.   NODE_SET_METHOD(module, "exports", RunCallback);
  18. }
  20. NODE_MODULE(addon, Init)

Note that this example uses a two-argument form of Init() that receives
the full module object as the second argument. This allows the addon
to completely overwrite exports with a single function instead of
adding the function as a property of exports.

To test it run the following JavaScript snippet:

  1. // test.js
  2. var addon = require('./build/Release/addon');
  4. addon(function(msg){
  5.   console.log(msg); // 'hello world'
  6. });

Object factory

You can create and return new objects from within a C++ function with this
addon.cc pattern, which returns an object with property msg that echoes
the string passed to createObject():

  1. // addon.cc
  2. #include <node.h>
  4. using namespace v8;
  6. void CreateObject(const FunctionCallbackInfo<Value>& args) {
  7.   Isolate* isolate = Isolate::GetCurrent();
  8.   HandleScope scope(isolate);
  10.   Local<Object> obj = Object::New(isolate);
  11.   obj->Set(String::NewFromUtf8(isolate, "msg"), args[0]->ToString());
  13.   args.GetReturnValue().Set(obj);
  14. }
  16. void Init(Handle<Object> exports, Handle<Object> module) {
  17.   NODE_SET_METHOD(module, "exports", CreateObject);
  18. }
  20. NODE_MODULE(addon, Init)

To test it in JavaScript:

  1. // test.js
  2. var addon = require('./build/Release/addon');
  4. var obj1 = addon('hello');
  5. var obj2 = addon('world');
  6. console.log(obj1.msg+' '+obj2.msg); // 'hello world'

Function factory

This pattern illustrates how to create and return a JavaScript function that
wraps a C++ function:

  1. // addon.cc
  2. #include <node.h>
  4. using namespace v8;
  6. void MyFunction(const FunctionCallbackInfo<Value>& args) {
  7.   Isolate* isolate = Isolate::GetCurrent();
  8.   HandleScope scope(isolate);
  9.   args.GetReturnValue().Set(String::NewFromUtf8(isolate, "hello world"));
  10. }
  12. void CreateFunction(const FunctionCallbackInfo<Value>& args) {
  13.   Isolate* isolate = Isolate::GetCurrent();
  14.   HandleScope scope(isolate);
  16.   Local<FunctionTemplate> tpl = FunctionTemplate::New(isolate, MyFunction);
  17.   Local<Function> fn = tpl->GetFunction();
  19.   // omit this to make it anonymous
  20.   fn->SetName(String::NewFromUtf8(isolate, "theFunction"));
  22.   args.GetReturnValue().Set(fn);
  23. }
  25. void Init(Handle<Object> exports, Handle<Object> module) {
  26.   NODE_SET_METHOD(module, "exports", CreateFunction);
  27. }
  29. NODE_MODULE(addon, Init)

To test:

  1. // test.js
  2. var addon = require('./build/Release/addon');
  4. var fn = addon();
  5. console.log(fn()); // 'hello world'

Wrapping C++ objects

Here we will create a wrapper for a C++ object/class MyObject that can be
instantiated in JavaScript through the new operator. First prepare the main
module addon.cc:

  1. // addon.cc
  2. #include <node.h>
  3. #include "myobject.h"
  5. using namespace v8;
  7. void InitAll(Handle<Object> exports) {
  8.   MyObject::Init(exports);
  9. }
  11. NODE_MODULE(addon, InitAll)

Then in myobject.h make your wrapper inherit from node::ObjectWrap:

  1. // myobject.h
  2. #ifndef MYOBJECT_H
  3. #define MYOBJECT_H
  5. #include <node.h>
  6. #include <node_object_wrap.h>
  8. class MyObject : public node::ObjectWrap {
  9.  public:
  10.   static void Init(v8::Handle<v8::Object> exports);
  12.  private:
  13.   explicit MyObject(double value = 0);
  14.   ~MyObject();
  16.   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
  17.   static void PlusOne(const v8::FunctionCallbackInfo<v8::Value>& args);
  18.   static v8::Persistent<v8::Function> constructor;
  19.   double value_;
  20. };
  22. #endif

And in myobject.cc implement the various methods that you want to expose.
Here we expose the method plusOne by adding it to the constructor’s
prototype:

  1. // myobject.cc
  2. #include "myobject.h"
  4. using namespace v8;
  6. Persistent<Function> MyObject::constructor;
  8. MyObject::MyObject(double value) : value_(value) {
  9. }
  11. MyObject::~MyObject() {
  12. }
  14. void MyObject::Init(Handle<Object> exports) {
  15.   Isolate* isolate = Isolate::GetCurrent();
  17.   // Prepare constructor template
  18.   Local<FunctionTemplate> tpl = FunctionTemplate::New(isolate, New);
  19.   tpl->SetClassName(String::NewFromUtf8(isolate, "MyObject"));
  20.   tpl->InstanceTemplate()->SetInternalFieldCount(1);
  22.   // Prototype
  23.   NODE_SET_PROTOTYPE_METHOD(tpl, "plusOne", PlusOne);
  25.   constructor.Reset(isolate, tpl->GetFunction());
  26.   exports->Set(String::NewFromUtf8(isolate, "MyObject"),
  27.                tpl->GetFunction());
  28. }
  30. void MyObject::New(const FunctionCallbackInfo<Value>& args) {
  31.   Isolate* isolate = Isolate::GetCurrent();
  32.   HandleScope scope(isolate);
  34.   if (args.IsConstructCall()) {
  35.     // Invoked as constructor: `new MyObject(...)`
  36.     double value = args[0]->IsUndefined() ? 0 : args[0]->NumberValue();
  37.     MyObject* obj = new MyObject(value);
  38.     obj->Wrap(args.This());
  39.     args.GetReturnValue().Set(args.This());
  40.   } else {
  41.     // Invoked as plain function `MyObject(...)`, turn into construct call.
  42.     const int argc = 1;
  43.     Local<Value> argv[argc] = { args[0] };
  44.     Local<Function> cons = Local<Function>::New(isolate, constructor);
  45.     args.GetReturnValue().Set(cons->NewInstance(argc, argv));
  46.   }
  47. }
  49. void MyObject::PlusOne(const FunctionCallbackInfo<Value>& args) {
  50.   Isolate* isolate = Isolate::GetCurrent();
  51.   HandleScope scope(isolate);
  53.   MyObject* obj = ObjectWrap::Unwrap<MyObject>(args.Holder());
  54.   obj->value_ += 1;
  56.   args.GetReturnValue().Set(Number::New(isolate, obj->value_));
  57. }

Test it with:

  1. // test.js
  2. var addon = require('./build/Release/addon');
  4. var obj = new addon.MyObject(10);
  5. console.log( obj.plusOne() ); // 11
  6. console.log( obj.plusOne() ); // 12
  7. console.log( obj.plusOne() ); // 13

Factory of wrapped objects

This is useful when you want to be able to create native objects without
explicitly instantiating them with the new operator in JavaScript, e.g.

  1. var obj = addon.createObject();
  2. // instead of:
  3. // var obj = new addon.Object();

Let’s register our createObject method in addon.cc:

  1. // addon.cc
  2. #include <node.h>
  3. #include "myobject.h"
  5. using namespace v8;
  7. void CreateObject(const FunctionCallbackInfo<Value>& args) {
  8.   Isolate* isolate = Isolate::GetCurrent();
  9.   HandleScope scope(isolate);
  10.   MyObject::NewInstance(args);
  11. }
  13. void InitAll(Handle<Object> exports, Handle<Object> module) {
  14.   MyObject::Init();
  16.   NODE_SET_METHOD(module, "exports", CreateObject);
  17. }
  19. NODE_MODULE(addon, InitAll)

In myobject.h we now introduce the static method NewInstance that takes
care of instantiating the object (i.e. it does the job of new in JavaScript):

  1. // myobject.h
  2. #ifndef MYOBJECT_H
  3. #define MYOBJECT_H
  5. #include <node.h>
  6. #include <node_object_wrap.h>
  8. class MyObject : public node::ObjectWrap {
  9.  public:
  10.   static void Init();
  11.   static void NewInstance(const v8::FunctionCallbackInfo<v8::Value>& args);
  13.  private:
  14.   explicit MyObject(double value = 0);
  15.   ~MyObject();
  17.   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
  18.   static void PlusOne(const v8::FunctionCallbackInfo<v8::Value>& args);
  19.   static v8::Persistent<v8::Function> constructor;
  20.   double value_;
  21. };
  23. #endif

The implementation is similar to the above in myobject.cc:

  1. // myobject.cc
  2. #include <node.h>
  3. #include "myobject.h"
  5. using namespace v8;
  7. Persistent<Function> MyObject::constructor;
  9. MyObject::MyObject(double value) : value_(value) {
  10. }
  12. MyObject::~MyObject() {
  13. }
  15. void MyObject::Init() {
  16.   Isolate* isolate = Isolate::GetCurrent();
  17.   // Prepare constructor template
  18.   Local<FunctionTemplate> tpl = FunctionTemplate::New(isolate, New);
  19.   tpl->SetClassName(String::NewFromUtf8(isolate, "MyObject"));
  20.   tpl->InstanceTemplate()->SetInternalFieldCount(1);
  22.   // Prototype
  23.   NODE_SET_PROTOTYPE_METHOD(tpl, "plusOne", PlusOne);
  25.   constructor.Reset(isolate, tpl->GetFunction());
  26. }
  28. void MyObject::New(const FunctionCallbackInfo<Value>& args) {
  29.   Isolate* isolate = Isolate::GetCurrent();
  30.   HandleScope scope(isolate);
  32.   if (args.IsConstructCall()) {
  33.     // Invoked as constructor: `new MyObject(...)`
  34.     double value = args[0]->IsUndefined() ? 0 : args[0]->NumberValue();
  35.     MyObject* obj = new MyObject(value);
  36.     obj->Wrap(args.This());
  37.     args.GetReturnValue().Set(args.This());
  38.   } else {
  39.     // Invoked as plain function `MyObject(...)`, turn into construct call.
  40.     const int argc = 1;
  41.     Local<Value> argv[argc] = { args[0] };
  42.     Local<Function> cons = Local<Function>::New(isolate, constructor);
  43.     args.GetReturnValue().Set(cons->NewInstance(argc, argv));
  44.   }
  45. }
  47. void MyObject::NewInstance(const FunctionCallbackInfo<Value>& args) {
  48.   Isolate* isolate = Isolate::GetCurrent();
  49.   HandleScope scope(isolate);
  51.   const unsigned argc = 1;
  52.   Handle<Value> argv[argc] = { args[0] };
  53.   Local<Function> cons = Local<Function>::New(isolate, constructor);
  54.   Local<Object> instance = cons->NewInstance(argc, argv);
  56.   args.GetReturnValue().Set(instance);
  57. }
  59. void MyObject::PlusOne(const FunctionCallbackInfo<Value>& args) {
  60.   Isolate* isolate = Isolate::GetCurrent();
  61.   HandleScope scope(isolate);
  63.   MyObject* obj = ObjectWrap::Unwrap<MyObject>(args.Holder());
  64.   obj->value_ += 1;
  66.   args.GetReturnValue().Set(Number::New(isolate, obj->value_));
  67. }

Test it with:

  1. // test.js
  2. var createObject = require('./build/Release/addon');
  4. var obj = createObject(10);
  5. console.log( obj.plusOne() ); // 11
  6. console.log( obj.plusOne() ); // 12
  7. console.log( obj.plusOne() ); // 13
  9. var obj2 = createObject(20);
  10. console.log( obj2.plusOne() ); // 21
  11. console.log( obj2.plusOne() ); // 22
  12. console.log( obj2.plusOne() ); // 23

Passing wrapped objects around

In addition to wrapping and returning C++ objects, you can pass them around
by unwrapping them with Node’s node::ObjectWrap::Unwrap helper function.
In the following addon.cc we introduce a function add() that can take on two
MyObject objects:

  1. // addon.cc
  2. #include <node.h>
  3. #include <node_object_wrap.h>
  4. #include "myobject.h"
  6. using namespace v8;
  8. void CreateObject(const FunctionCallbackInfo<Value>& args) {
  9.   Isolate* isolate = Isolate::GetCurrent();
  10.   HandleScope scope(isolate);
  11.   MyObject::NewInstance(args);
  12. }
  14. void Add(const FunctionCallbackInfo<Value>& args) {
  15.   Isolate* isolate = Isolate::GetCurrent();
  16.   HandleScope scope(isolate);
  18.   MyObject* obj1 = node::ObjectWrap::Unwrap<MyObject>(
  19.       args[0]->ToObject());
  20.   MyObject* obj2 = node::ObjectWrap::Unwrap<MyObject>(
  21.       args[1]->ToObject());
  23.   double sum = obj1->value() + obj2->value();
  24.   args.GetReturnValue().Set(Number::New(isolate, sum));
  25. }
  27. void InitAll(Handle<Object> exports) {
  28.   MyObject::Init();
  30.   NODE_SET_METHOD(exports, "createObject", CreateObject);
  31.   NODE_SET_METHOD(exports, "add", Add);
  32. }
  34. NODE_MODULE(addon, InitAll)

To make things interesting we introduce a public method in myobject.h so we
can probe private values after unwrapping the object:

  1. // myobject.h
  2. #ifndef MYOBJECT_H
  3. #define MYOBJECT_H
  5. #include <node.h>
  6. #include <node_object_wrap.h>
  8. class MyObject : public node::ObjectWrap {
  9.  public:
  10.   static void Init();
  11.   static void NewInstance(const v8::FunctionCallbackInfo<v8::Value>& args);
  12.   inline double value() const { return value_; }
  14.  private:
  15.   explicit MyObject(double value = 0);
  16.   ~MyObject();
  18.   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
  19.   static v8::Persistent<v8::Function> constructor;
  20.   double value_;
  21. };
  23. #endif

The implementation of myobject.cc is similar as before:

  1. // myobject.cc
  2. #include <node.h>
  3. #include "myobject.h"
  5. using namespace v8;
  7. Persistent<Function> MyObject::constructor;
  9. MyObject::MyObject(double value) : value_(value) {
  10. }
  12. MyObject::~MyObject() {
  13. }
  15. void MyObject::Init() {
  16.   Isolate* isolate = Isolate::GetCurrent();
  18.   // Prepare constructor template
  19.   Local<FunctionTemplate> tpl = FunctionTemplate::New(isolate, New);
  20.   tpl->SetClassName(String::NewFromUtf8(isolate, "MyObject"));
  21.   tpl->InstanceTemplate()->SetInternalFieldCount(1);
  23.   constructor.Reset(isolate, tpl->GetFunction());
  24. }
  26. void MyObject::New(const FunctionCallbackInfo<Value>& args) {
  27.   Isolate* isolate = Isolate::GetCurrent();
  28.   HandleScope scope(isolate);
  30.   if (args.IsConstructCall()) {
  31.     // Invoked as constructor: `new MyObject(...)`
  32.     double value = args[0]->IsUndefined() ? 0 : args[0]->NumberValue();
  33.     MyObject* obj = new MyObject(value);
  34.     obj->Wrap(args.This());
  35.     args.GetReturnValue().Set(args.This());
  36.   } else {
  37.     // Invoked as plain function `MyObject(...)`, turn into construct call.
  38.     const int argc = 1;
  39.     Local<Value> argv[argc] = { args[0] };
  40.     Local<Function> cons = Local<Function>::New(isolate, constructor);
  41.     args.GetReturnValue().Set(cons->NewInstance(argc, argv));
  42.   }
  43. }
  45. void MyObject::NewInstance(const FunctionCallbackInfo<Value>& args) {
  46.   Isolate* isolate = Isolate::GetCurrent();
  47.   HandleScope scope(isolate);
  49.   const unsigned argc = 1;
  50.   Handle<Value> argv[argc] = { args[0] };
  51.   Local<Function> cons = Local<Function>::New(isolate, constructor);
  52.   Local<Object> instance = cons->NewInstance(argc, argv);
  54.   args.GetReturnValue().Set(instance);
  55. }

Test it with:

  1. // test.js
  2. var addon = require('./build/Release/addon');
  4. var obj1 = addon.createObject(10);
  5. var obj2 = addon.createObject(20);
  6. var result = addon.add(obj1, obj2);
  8. console.log(result); // 30