rclnodejs 0.32.5 → 1.0.0

package/rostsd_gen/index.js

@@ -31,6 +31,8 @@ const fs = require('fs');
 const loader = require('../lib/interface_loader.js');
 const pkgFilters = require('../rosidl_gen/filter.js');
 
+const descriptorInterfaceNamespace = 'descriptor';
+
 async function generateAll() {
   // load pkg and interface info (msgs and srvs)
   const generatedPath = path.join(__dirname, '../generated/');
@@ -119,47 +121,30 @@ function savePkgInfoAsTSD(pkgInfos, fd) {
     for (const subfolder of pkgInfo.subfolders.keys()) {
       fs.writeSync(fd, `    namespace ${subfolder} {\n`);
 
-      for (const rosInterface of pkgInfo.subfolders.get(subfolder)) {
-        const type = rosInterface.type();
-        const fullInterfaceName = `${type.pkgName}/${type.subFolder}/${type.interfaceName}`;
-        const fullInterfacePath = `${type.pkgName}.${type.subFolder}.${type.interfaceName}`;
-        const fullInterfaceConstructor = fullInterfacePath + 'Constructor';
-
-        if (isMsgInterface(rosInterface)) {
-          // create message interface
-          saveMsgAsTSD(rosInterface, fd);
-          saveMsgConstructorAsTSD(rosInterface, fd);
-          messagesMap[fullInterfaceName] = fullInterfacePath;
-        } else if (isSrvInterface(rosInterface)) {
-          if (
-            !isValidService(rosInterface, pkgInfo.subfolders.get(subfolder))
-          ) {
-            let type = rosInterface.type();
-            console.log(
-              `Incomplete service: ${type.pkgName}.${type.subFolder}.${type.interfaceName}.`
-            );
-            continue;
-          }
-
-          // create service interface
-          saveSrvAsTSD(rosInterface, fd);
-          if (!isInternalActionSrvInterface(rosInterface)) {
-            servicesMap[fullInterfaceName] = fullInterfaceConstructor;
-          }
-        } else if (isActionInterface(rosInterface)) {
-          if (!isValidAction(rosInterface, pkgInfo.subfolders.get(subfolder))) {
-            let type = rosInterface.type();
-            console.log(
-              `Incomplete action: ${type.pkgName}.${type.subFolder}.${type.interfaceName}.`
-            );
-            continue;
-          }
-
-          // create action interface
-          saveActionAsTSD(rosInterface, fd);
-          actionsMap[fullInterfaceName] = fullInterfaceConstructor;
-        }
-      }
+      // generate real msg/srv/action interfaces
+      generateRosMsgInterfaces(
+        pkgInfo,
+        subfolder,
+        messagesMap,
+        servicesMap,
+        actionsMap,
+        fd
+      );
+
+      // generate descriptor msg/srv/action interfaces
+      fs.writeSync(fd, `      namespace ${descriptorInterfaceNamespace} {\n`);
+      const willGenerateDescriptorInterface = true;
+      generateRosMsgInterfaces(
+        pkgInfo,
+        subfolder,
+        messagesMap,
+        servicesMap,
+        actionsMap,
+        fd,
+        willGenerateDescriptorInterface
+      );
+      // close namespace descriptor declare
+      fs.writeSync(fd, '      }\n');
 
       // close namespace declare
       fs.writeSync(fd, '    }\n');
@@ -238,16 +223,96 @@ function savePkgInfoAsTSD(pkgInfos, fd) {
   fs.writeSync(fd, '}\n');
 }
 
-function saveMsgAsTSD(rosMsgInterface, fd) {
-  fs.writeSync(
-    fd,
-    `      export interface ${rosMsgInterface.type().interfaceName} {\n`
+function generateRosMsgInterfaces(
+  pkgInfo,
+  subfolder,
+  messagesMap,
+  servicesMap,
+  actionsMap,
+  fd,
+  willGenerateDescriptorInterface = false
+) {
+  const descriptorNamespaceName = willGenerateDescriptorInterface
+    ? `${descriptorInterfaceNamespace}/`
+    : '';
+  const descriptorNamespacePath = willGenerateDescriptorInterface
+    ? `${descriptorInterfaceNamespace}.`
+    : '';
+  for (const rosInterface of pkgInfo.subfolders.get(subfolder)) {
+    const type = rosInterface.type();
+    const fullInterfaceName = `${type.pkgName}/${type.subFolder}/${descriptorNamespaceName}${type.interfaceName}`;
+    const fullInterfacePath = `${type.pkgName}.${type.subFolder}.${descriptorNamespacePath}${type.interfaceName}`;
+    const fullInterfaceConstructor = fullInterfacePath + 'Constructor';
+
+    const indentStartLevel = willGenerateDescriptorInterface ? 4 : 3;
+    if (isMsgInterface(rosInterface)) {
+      // create message interface
+      saveMsgAsTSD(
+        rosInterface,
+        fd,
+        indentStartLevel,
+        willGenerateDescriptorInterface
+      );
+      saveMsgConstructorAsTSD(rosInterface, fd, indentStartLevel);
+      messagesMap[fullInterfaceName] = fullInterfacePath;
+    } else if (isSrvInterface(rosInterface)) {
+      if (!isValidService(rosInterface, pkgInfo.subfolders.get(subfolder))) {
+        let type = rosInterface.type();
+        console.log(
+          `Incomplete service: ${type.pkgName}.${type.subFolder}.${type.interfaceName}.`
+        );
+        continue;
+      }
+
+      // create service interface
+      saveSrvAsTSD(rosInterface, fd, indentStartLevel);
+      if (!isInternalActionSrvInterface(rosInterface)) {
+        servicesMap[fullInterfaceName] = fullInterfaceConstructor;
+      }
+    } else if (isActionInterface(rosInterface)) {
+      if (!isValidAction(rosInterface, pkgInfo.subfolders.get(subfolder))) {
+        let type = rosInterface.type();
+        console.log(
+          `Incomplete action: ${type.pkgName}.${type.subFolder}.${type.interfaceName}.`
+        );
+        continue;
+      }
+
+      // create action interface
+      saveActionAsTSD(rosInterface, fd, indentStartLevel);
+      actionsMap[fullInterfaceName] = fullInterfaceConstructor;
+    }
+  }
+}
+
+function saveMsgAsTSD(
+  rosMsgInterface,
+  fd,
+  indentLevel = 3,
+  willGenerateDescriptorInterface = false
+) {
+  const outerIndentSpacing = getIndentSpacing(indentLevel);
+  const tmpl = indentString(
+    `export interface ${rosMsgInterface.type().interfaceName} {\n`,
+    outerIndentSpacing
   );
+  fs.writeSync(fd, tmpl);
   const useSamePkg =
     isInternalActionMsgInterface(rosMsgInterface) ||
     isInternalServiceEventMsgInterface(rosMsgInterface);
-  saveMsgFieldsAsTSD(rosMsgInterface, fd, 8, ';', '', useSamePkg);
-  fs.writeSync(fd, '      }\n');
+  const innerIndentLevel = indentLevel + 1;
+  const innerIndentSpacing = getIndentSpacing(innerIndentLevel);
+  saveMsgFieldsAsTSD(
+    rosMsgInterface,
+    fd,
+    innerIndentSpacing,
+    ';',
+    '',
+    useSamePkg,
+    willGenerateDescriptorInterface
+  );
+  const tmplEnd = indentString('}\n', outerIndentSpacing);
+  fs.writeSync(fd, tmplEnd);
 }
 
 /**
@@ -261,6 +326,7 @@ function saveMsgAsTSD(rosMsgInterface, fd) {
  * @param {string} typePrefix The prefix to put before the type name for
  * non-primitive types
  * @param {boolean} useSamePackageSubFolder Indicates if the sub folder name should be taken from the message
+ * @param {boolean} willGenerateDescriptorInterface Indicates if descriptor interface is being generated
  * when the field type comes from the same package. This is needed for action interfaces. Defaults to false.
  * @returns {undefined}
  */
@@ -270,7 +336,8 @@ function saveMsgFieldsAsTSD(
   indent = 0,
   lineEnd = ',',
   typePrefix = '',
-  useSamePackageSubFolder = false
+  useSamePackageSubFolder = false,
+  willGenerateDescriptorInterface = false
 ) {
   let type = rosMsgInterface.type();
   let fields = rosMsgInterface.ROSMessageDef.fields;
@@ -280,49 +347,62 @@ function saveMsgFieldsAsTSD(
       useSamePackageSubFolder && field.type.pkgName === type.pkgName
         ? type.subFolder
         : 'msg';
-    let fieldType = fieldType2JSName(field, subFolder);
+    let fieldType = fieldType2JSName(
+      field,
+      subFolder,
+      willGenerateDescriptorInterface
+    );
     let tp = field.type.isPrimitiveType ? '' : typePrefix;
     if (typePrefix === 'rclnodejs.') {
       fieldType = 'any';
       tp = '';
     }
 
-    const tmpl = indentString(`${field.name}: ${tp}${fieldType}`, indent);
-    fs.writeSync(fd, tmpl);
+    let arrayString = '';
     if (field.type.isArray) {
-      fs.writeSync(fd, '[]');
+      arrayString = '[]';
+
+      if (field.type.isFixedSizeArray && willGenerateDescriptorInterface) {
+        arrayString = `[${field.type.arraySize}]`;
+      }
 
-      if (fieldType === 'number') {
+      if (fieldType === 'number' && !willGenerateDescriptorInterface) {
         // for number[] include alternate typed-array types, e.g., number[] | uint8[]
         let jsTypedArrayName = fieldTypeArray2JSTypedArrayName(field.type.type);
 
         if (jsTypedArrayName) {
-          fs.writeSync(fd, ` | ${jsTypedArrayName}`);
+          arrayString += ` | ${jsTypedArrayName}`;
         }
       }
     }
+    const fieldString = willGenerateDescriptorInterface
+      ? `${field.name}: '${tp}${fieldType}${arrayString}'`
+      : `${field.name}: ${tp}${fieldType}${arrayString}`;
+    const tmpl = indentString(fieldString, indent);
+    fs.writeSync(fd, tmpl);
 
     fs.writeSync(fd, lineEnd);
     fs.writeSync(fd, '\n');
   }
 }
 
-function saveMsgConstructorAsTSD(rosMsgInterface, fd) {
+function saveMsgConstructorAsTSD(rosMsgInterface, fd, indentLevel = 3) {
   const type = rosMsgInterface.type();
   const msgName = type.interfaceName;
-
-  fs.writeSync(fd, `      export interface ${msgName}Constructor {\n`);
+  let interfaceTmpl = [`export interface ${msgName}Constructor {`];
 
   for (const constant of rosMsgInterface.ROSMessageDef.constants) {
     const constantType = primitiveType2JSName(constant.type);
-    fs.writeSync(fd, `        readonly ${constant.name}: ${constantType};\n`);
+    interfaceTmpl.push(`  readonly ${constant.name}: ${constantType};`);
   }
-
-  fs.writeSync(fd, `        new(other?: ${msgName}): ${msgName};\n`);
-  fs.writeSync(fd, '      }\n');
+  interfaceTmpl.push(`  new(other?: ${msgName}): ${msgName};`);
+  interfaceTmpl.push('}');
+  interfaceTmpl.push('');
+  const indentSpacing = getIndentSpacing(indentLevel);
+  fs.writeSync(fd, indentLines(interfaceTmpl, indentSpacing).join('\n'));
 }
 
-function saveSrvAsTSD(rosSrvInterface, fd) {
+function saveSrvAsTSD(rosSrvInterface, fd, indentLevel = 3) {
   const serviceName = rosSrvInterface.type().interfaceName;
 
   const interfaceTemplate = [
@@ -332,11 +412,11 @@ function saveSrvAsTSD(rosSrvInterface, fd) {
     '}',
     '',
   ];
-
-  fs.writeSync(fd, indentLines(interfaceTemplate, 6).join('\n'));
+  const indentSpacing = getIndentSpacing(indentLevel);
+  fs.writeSync(fd, indentLines(interfaceTemplate, indentSpacing).join('\n'));
 }
 
-function saveActionAsTSD(rosActionInterface, fd) {
+function saveActionAsTSD(rosActionInterface, fd, indentLevel = 3) {
   const actionName = rosActionInterface.type().interfaceName;
 
   const interfaceTemplate = [
@@ -347,8 +427,19 @@ function saveActionAsTSD(rosActionInterface, fd) {
     '}',
     '',
   ];
+  const indentSpacing = getIndentSpacing(indentLevel);
+  fs.writeSync(fd, indentLines(interfaceTemplate, indentSpacing).join('\n'));
+}
 
-  fs.writeSync(fd, indentLines(interfaceTemplate, 6).join('\n'));
+/**
+ * Get number of indent spaces for given level
+ *
+ * @param {*} indentLevel Indention level
+ * @param {*} spacesPerLevel Number of spaces per level
+ * @returns Total number of space
+ */
+function getIndentSpacing(indentLevel, spacesPerLevel = 2) {
+  return indentLevel * spacesPerLevel;
 }
 
 function isMsgInterface(rosInterface) {
@@ -451,7 +542,16 @@ function isValidAction(rosActionInterface, infos) {
   return matches === SUCCESS_MATCH_COUNT;
 }
 
-function fieldType2JSName(fieldInfo, subFolder = 'msg') {
+function fieldType2JSName(
+  fieldInfo,
+  subFolder = 'msg',
+  willGenerateDescriptorInterface = false
+) {
+  if (willGenerateDescriptorInterface) {
+    return fieldInfo.type.isPrimitiveType
+      ? `${fieldInfo.type.type}`
+      : `${fieldInfo.type.pkgName}/${subFolder}/${fieldInfo.type.type}`;
+  }
   return fieldInfo.type.isPrimitiveType
     ? primitiveType2JSName(fieldInfo.type.type)
     : `${fieldInfo.type.pkgName}.${subFolder}.${fieldInfo.type.type}`;

package/scripts/config.js

@@ -29,6 +29,7 @@ const dependencies = [
   'builtin_interfaces',
   'rcl_lifecycle',
   'lifecycle_msgs',
+  'rcpputils',
   'rosidl_runtime_c',
   'rosidl_dynamic_typesupport',
   'type_description_interfaces',

package/scripts/npmjs-readme.md

@@ -43,9 +43,9 @@ npm i rclnodejs@x.y.z
 
 #### RCLNODEJS - ROS 2 Version Compatibility
 
-|                                      RCLNODEJS Version                                       |                                                             Compatible ROS 2 LTS                                                             |
-| :------------------------------------------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------: |
-| latest version (currently [v0.32.5](https://github.com/RobotWebTools/rclnodejs/tree/0.32.5)) | [Humble](https://github.com/RobotWebTools/rclnodejs/tree/humble-hawksbill)<br>[Jazzy](https://github.com/RobotWebTools/rclnodejs/tree/jazzy) |
+|                                     RCLNODEJS Version                                      |                                                             Compatible ROS 2 LTS                                                             |
+| :----------------------------------------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------: |
+| latest version (currently [v1.0.0](https://github.com/RobotWebTools/rclnodejs/tree/1.0.0)) | [Humble](https://github.com/RobotWebTools/rclnodejs/tree/humble-hawksbill)<br>[Jazzy](https://github.com/RobotWebTools/rclnodejs/tree/jazzy) |
 
 ## Documentation
 

package/src/addon.cpp

@@ -12,29 +12,39 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <nan.h>
+#include <node_api.h>
+#include <rcutils/logging.h>
 
-#include "macros.hpp"
-#include "rcl_action_bindings.hpp"
-#include "rcl_bindings.hpp"
-#include "rcl_handle.hpp"
-#include "rcl_lifecycle_bindings.hpp"
-#include "rcutils/logging.h"
-#include "rcutils/macros.h"
-#include "shadow_node.hpp"
+#include "macros.h"
+#include "rcl_action_client_bindings.h"
+#include "rcl_action_goal_bindings.h"
+#include "rcl_action_server_bindings.h"
+#include "rcl_bindings.h"
+#include "rcl_client_bindings.h"
+#include "rcl_context_bindings.h"
+#include "rcl_graph_bindings.h"
+#include "rcl_guard_condition_bindings.h"
+#include "rcl_handle.h"
+#include "rcl_lifecycle_bindings.h"
+#include "rcl_logging_bindings.h"
+#include "rcl_names_bindings.h"
+#include "rcl_node_bindings.h"
+#include "rcl_publisher_bindings.h"
+#include "rcl_service_bindings.h"
+#include "rcl_subscription_bindings.h"
+#include "rcl_time_point_bindings.h"
+#include "rcl_timer_bindings.h"
+#include "rcl_utilities.h"
+#include "shadow_node.h"
 
-bool IsRunningInElectronRenderer() {
-  auto global = Nan::GetCurrentContext()->Global();
-  auto process =
-      Nan::To<v8::Object>(Nan::Get(global, Nan::New("process").ToLocalChecked())
-                              .ToLocalChecked())
-          .ToLocalChecked();
-  auto process_type =
-      Nan::Get(process, Nan::New("type").ToLocalChecked()).ToLocalChecked();
-  return process_type->StrictEquals(Nan::New("renderer").ToLocalChecked());
+bool IsRunningInElectronRenderer(const Napi::Env& env) {
+  Napi::Object global = env.Global();
+  Napi::Object process = global.Get("process").As<Napi::Object>();
+  Napi::Value processType = process.Get("type");
+  return processType.StrictEquals(Napi::String::New(env, "renderer"));
 }
 
-void InitModule(v8::Local<v8::Object> exports) {
+Napi::Object InitModule(Napi::Env env, Napi::Object exports) {
 // workaround process name mangling by chromium
 //
 // rcl logging uses `program_invocation_name` to determine the log file,
@@ -43,7 +53,7 @@ void InitModule(v8::Local<v8::Object> exports) {
 // occurence of ' -' with the null terminator. see:
 // https://unix.stackexchange.com/questions/432419/unexpected-non-null-encoding-of-proc-pid-cmdline
 #if defined(__linux__) && defined(__GLIBC__)
-  if (IsRunningInElectronRenderer()) {
+  if (IsRunningInElectronRenderer(env)) {
     auto prog_name = program_invocation_name;
     auto end = strstr(prog_name, " -");
     assert(end);
@@ -51,44 +61,35 @@ void InitModule(v8::Local<v8::Object> exports) {
   }
 #endif
 
-  v8::Local<v8::Context> context = exports->GetIsolate()->GetCurrentContext();
-
-  for (uint32_t i = 0; i < rclnodejs::binding_methods.size(); i++) {
-    Nan::Set(
-        exports, Nan::New(rclnodejs::binding_methods[i].name).ToLocalChecked(),
-        Nan::New<v8::FunctionTemplate>(rclnodejs::binding_methods[i].function)
-            ->GetFunction(context)
-            .ToLocalChecked());
-  }
-
-  for (uint32_t i = 0; i < rclnodejs::action_binding_methods.size(); i++) {
-    Nan::Set(
-        exports,
-        Nan::New(rclnodejs::action_binding_methods[i].name).ToLocalChecked(),
-        Nan::New<v8::FunctionTemplate>(
-            rclnodejs::action_binding_methods[i].function)
-            ->GetFunction(context)
-            .ToLocalChecked());
-  }
-
-  for (uint32_t i = 0; i < rclnodejs::lifecycle_binding_methods.size(); i++) {
-    Nan::Set(
-        exports,
-        Nan::New(rclnodejs::lifecycle_binding_methods[i].name).ToLocalChecked(),
-        Nan::New<v8::FunctionTemplate>(
-            rclnodejs::lifecycle_binding_methods[i].function)
-            ->GetFunction(context)
-            .ToLocalChecked());
-  }
-
-  rclnodejs::ShadowNode::Init(exports);
-  rclnodejs::RclHandle::Init(exports);
+  rclnodejs::StoreEnv(env);
+  // Init the C++ bindings.
+  rclnodejs::InitBindings(env, exports);
+  rclnodejs::InitActionClientBindings(env, exports);
+  rclnodejs::InitActionGoalBindings(env, exports);
+  rclnodejs::InitActionServerBindings(env, exports);
+  rclnodejs::InitClientBindings(env, exports);
+  rclnodejs::InitContextBindings(env, exports);
+  rclnodejs::InitGraphBindings(env, exports);
+  rclnodejs::InitGuardConditionBindings(env, exports);
+  rclnodejs::InitLoggingBindings(env, exports);
+  rclnodejs::InitNamesBindings(env, exports);
+  rclnodejs::InitNodeBindings(env, exports);
+  rclnodejs::InitPublisherBindings(env, exports);
+  rclnodejs::InitServiceBindings(env, exports);
+  rclnodejs::InitSubscriptionBindings(env, exports);
+  rclnodejs::InitTimePointBindings(env, exports);
+  rclnodejs::InitTimerBindings(env, exports);
+  rclnodejs::InitLifecycleBindings(env, exports);
+  rclnodejs::ShadowNode::Init(env, exports);
+  rclnodejs::RclHandle::Init(env, exports);
 
 #ifdef DEBUG_ON
   int result = rcutils_logging_set_logger_level(PACKAGE_NAME,
                                                 RCUTILS_LOG_SEVERITY_DEBUG);
   RCUTILS_UNUSED(result);
 #endif
+
+  return exports;
 }
 
-NODE_MODULE(rclnodejs, InitModule);
+NODE_API_MODULE(rclnodejs, InitModule)

package/src/executor.cpp

@@ -12,16 +12,16 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "executor.hpp"
+#include "executor.h"
 
 #include <rcl/error_handling.h>
 
 #include <stdexcept>
 #include <string>
 
-#include "handle_manager.hpp"
-#include "macros.hpp"
-#include "rcl_bindings.hpp"
+#include "handle_manager.h"
+#include "macros.h"
+#include "rcl_bindings.h"
 
 #ifdef WIN32
 #define UNUSED
@@ -41,12 +41,14 @@ struct RclResult {
   std::string error_msg;
 };
 
-Executor::Executor(HandleManager* handle_manager, Delegate* delegate)
+Executor::Executor(Napi::Env env, HandleManager* handle_manager,
+                   Delegate* delegate)
     : async_(nullptr),
       main_thread_(uv_thread_self()),
       handle_manager_(handle_manager),
       delegate_(delegate),
-      context_(nullptr) {
+      context_(nullptr),
+      env_(env) {
   running_.store(false);
 }
 
@@ -74,12 +76,19 @@ void Executor::SpinOnce(rcl_context_t* context, int32_t time_out) {
   rcl_wait_set_t wait_set = rcl_get_zero_initialized_wait_set();
   rcl_ret_t ret = rcl_wait_set_init(&wait_set, 0, 0, 0, 0, 0, 0, context,
                                     rcl_get_default_allocator());
-  if (ret != RCL_RET_OK) Nan::ThrowError(rcl_get_error_string().str);
+  if (ret != RCL_RET_OK) {
+    Napi::Error::New(env_, rcl_get_error_string().str)
+        .ThrowAsJavaScriptException();
+    return;
+  }
 
   RclResult wait_result = WaitForReadyCallbacks(&wait_set, time_out);
 
-  if (wait_result.ret != RCL_RET_OK)
-    Nan::ThrowError(wait_result.error_msg.c_str());
+  if (wait_result.ret != RCL_RET_OK) {
+    Napi::Error::New(env_, wait_result.error_msg.c_str())
+        .ThrowAsJavaScriptException();
+    return;
+  }
 
   if (handle_manager_->ready_handles_count() > 0) ExecuteReadyHandles();
 
@@ -87,7 +96,7 @@ void Executor::SpinOnce(rcl_context_t* context, int32_t time_out) {
     std::string error_message =
         std::string("Failed to destroy guard waitset:") +
         std::string(rcl_get_error_string().str);
-    Nan::ThrowError(error_message.c_str());
+    Napi::Error::New(env_, error_message.c_str()).ThrowAsJavaScriptException();
   }
 }
 

package/src/{executor.hpp → executor.h}

@@ -12,9 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef SRC_EXECUTOR_HPP_
-#define SRC_EXECUTOR_HPP_
+#ifndef SRC_EXECUTOR_H_
+#define SRC_EXECUTOR_H_
 
+#include <napi.h>
 #include <rcl/wait.h>
 #include <uv.h>
 
@@ -22,7 +23,7 @@
 #include <exception>
 #include <vector>
 
-#include "rcl_handle.hpp"
+#include "rcl_handle.h"
 
 namespace rclnodejs {
 
@@ -37,7 +38,7 @@ class Executor {
     virtual void CatchException(std::exception_ptr e_ptr) = 0;
   };
 
-  Executor(HandleManager* handle_manager, Delegate* delegate);
+  Executor(Napi::Env env, HandleManager* handle_manager, Delegate* delegate);
   ~Executor();
 
   void Start(rcl_context_t* context, int32_t time_out);
@@ -68,10 +69,11 @@ class Executor {
   Delegate* delegate_;
   rcl_context_t* context_;
   int32_t time_out_;
+  Napi::Env env_;
 
   std::atomic_bool running_;
 };
 
 }  // namespace rclnodejs
 
-#endif  // SRC_EXECUTOR_HPP_
+#endif  // SRC_EXECUTOR_H_