rclnodejs 0.33.0 → 1.1.0

package/src/rcl_bindings.cpp

@@ -12,1460 +12,26 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "rcl_bindings.hpp"
+#include "rcl_bindings.h"
 
-#include <rcl/arguments.h>
-#include <rcl/error_handling.h>
-#include <rcl/expand_topic_name.h>
-#include <rcl/graph.h>
-#include <rcl/logging.h>
-#include <rcl/node.h>
-#include <rcl/rcl.h>
-#include <rcl/validate_topic_name.h>
-#include <rcl_action/rcl_action.h>
-#include <rcl_yaml_param_parser/parser.h>
-#include <rcl_yaml_param_parser/types.h>
-#include <rmw/error_handling.h>
-#include <rmw/rmw.h>
-#include <rmw/validate_full_topic_name.h>
-#include <rmw/validate_namespace.h>
-#include <rmw/validate_node_name.h>
+#include <node.h>
 #if ROS_VERSION >= 2006
 #include <rosidl_runtime_c/string_functions.h>
 #else
 #include <rosidl_generator_c/string_functions.h>
 #endif
 
-#if ROS_VERSION > 2205
-#include <rcl/service_introspection.h>
-#endif
-
-#include <cstdio>
-#include <iostream>
 #include <memory>
 #include <string>
-#include <vector>
-#if NODE_MAJOR_VERSION > 12
-#include <utility>
-#endif
 
-#include "handle_manager.hpp"
-#include "macros.hpp"
-#include "rcl_handle.hpp"
-#include "rcl_utilities.hpp"
+#include "rcl_handle.h"
 
 namespace rclnodejs {
 
-static v8::Local<v8::Object> wrapParameters(
-    rcl_params_t* params);  // NOLINT(whitespace/line_length)
-
-NAN_METHOD(Init) {
-  rcl_allocator_t allocator = rcl_get_default_allocator();
-  rcl_init_options_t init_options = rcl_get_zero_initialized_init_options();
-  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
-                           rcl_init_options_init(&init_options, allocator),
-                           rcl_get_error_string().str);
-
-  // preprocess Context
-  RclHandle* context_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_context_t* context =
-      reinterpret_cast<rcl_context_t*>(context_handle->ptr());
-
-  // preprocess argc & argv
-  v8::Local<v8::Array> jsArgv = v8::Local<v8::Array>::Cast(info[1]);
-  int argc = jsArgv->Length();
-  char** argv = nullptr;
-  if (argc > 0) {
-    argv = reinterpret_cast<char**>(malloc(argc * sizeof(char*)));
-    for (int i = 0; i < argc; i++) {
-      Nan::MaybeLocal<v8::Value> jsElement = Nan::Get(jsArgv, i);
-      Nan::Utf8String utf8_arg(jsElement.ToLocalChecked());
-      int len = utf8_arg.length() + 1;
-      argv[i] = reinterpret_cast<char*>(malloc(len * sizeof(char*)));
-      snprintf(argv[i], len, "%s", *utf8_arg);
-    }
-  }
-
-  THROW_ERROR_IF_NOT_EQUAL(
-      RCL_RET_OK,
-      rcl_init(argc, argc > 0 ? argv : nullptr, &init_options, context),
-      rcl_get_error_string().str);
-
-  THROW_ERROR_IF_NOT_EQUAL(
-      RCL_RET_OK, rcl_logging_configure(&context->global_arguments, &allocator),
-      rcl_get_error_string().str);
-
-  for (int i = 0; i < argc; i++) {
-    free(argv[i]);
-  }
-  free(argv);
-}
-
-NAN_METHOD(GetParameterOverrides) {
-  RclHandle* context_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_context_t* context =
-      reinterpret_cast<rcl_context_t*>(context_handle->ptr());
-
-  rcl_arguments_t* parsed_args = &(context->global_arguments);
-  rcl_params_t* params = NULL;
-  THROW_ERROR_IF_NOT_EQUAL(
-      RCL_RET_OK, rcl_arguments_get_param_overrides(parsed_args, &params),
-      rcl_get_error_string().str);
-
-  if (params == NULL) {
-    info.GetReturnValue().Set(Nan::Undefined());
-    return;
-  }
-
-  info.GetReturnValue().Set(wrapParameters(params));
-
-  rcl_yaml_node_struct_fini(params);
-}
-
-static const int PARAMETER_NOT_SET = 0;
-static const int PARAMETER_BOOL = 1;
-static const int PARAMETER_INTEGER = 2;
-static const int PARAMETER_DOUBLE = 3;
-static const int PARAMETER_STRING = 4;
-static const int PARAMETER_BYTE_ARRAY = 5;
-static const int PARAMETER_BOOL_ARRAY = 6;
-static const int PARAMETER_INTEGER_ARRAY = 7;
-static const int PARAMETER_DOUBLE_ARRAY = 8;
-static const int PARAMETER_STRING_ARRAY = 9;
-
-/*
-Convert parsed ros arguments to parameters.
-
-type Parameter = {
-  name: string,
-  type: number,
-  value: object
-}
-
-type Node = {
-  name: string,
-  parameters: array<Parameter>
-}
-
-parameters = array<Node>;
-*/
-static v8::Local<v8::Object> wrapParameters(rcl_params_t* parsed_args) {
-  v8::Local<v8::Array> nodes = Nan::New<v8::Array>();
-
-  // iterate over nodes
-  for (size_t i = 0; i < parsed_args->num_nodes; i++) {
-    v8::Local<v8::Object> node = Nan::New<v8::Object>();
-    Nan::Set(node, Nan::New("name").ToLocalChecked(),
-             Nan::New(parsed_args->node_names[i]).ToLocalChecked());
-
-    rcl_node_params_t node_parameters = parsed_args->params[i];
-
-    // iterate over node.parameters
-    v8::Local<v8::Array> parameters = Nan::New<v8::Array>();
-    for (size_t j = 0; j < node_parameters.num_params; j++) {
-      v8::Local<v8::Object> parameter = Nan::New<v8::Object>();
-
-      Nan::Set(
-          parameter, Nan::New("name").ToLocalChecked(),
-          Nan::New(parsed_args->params[i].parameter_names[j]).ToLocalChecked());
-
-      int param_type = PARAMETER_NOT_SET;
-
-      // for each value, find type & actual value
-      rcl_variant_t value = node_parameters.parameter_values[j];
-      if (value.bool_value != NULL) {  // NOLINT()
-        param_type = PARAMETER_BOOL;
-        Nan::Set(parameter, Nan::New("value").ToLocalChecked(),
-                 (*value.bool_value ? Nan::True() : Nan::False()));
-      } else if (value.integer_value != NULL) {  // NOLINT()
-        param_type = PARAMETER_INTEGER;
-        Nan::Set(parameter, Nan::New("value").ToLocalChecked(),
-                 Nan::New<v8::Number>(*value.integer_value));
-      } else if (value.double_value != NULL) {  // NOLINT()
-        param_type = PARAMETER_DOUBLE;
-        Nan::Set(parameter, Nan::New("value").ToLocalChecked(),
-                 Nan::New<v8::Number>(*value.double_value));
-      } else if (value.string_value != NULL) {  // NOLINT()
-        param_type = PARAMETER_STRING;
-        Nan::Set(parameter, Nan::New("value").ToLocalChecked(),
-                 Nan::New(value.string_value).ToLocalChecked());
-      } else if (value.bool_array_value != NULL) {  // NOLINT()
-        param_type = PARAMETER_BOOL_ARRAY;
-        v8::Local<v8::Array> bool_array = Nan::New<v8::Array>();
-
-        for (size_t k = 0; k < value.bool_array_value->size; k++) {
-          Nan::Set(
-              bool_array, k,
-              (value.bool_array_value->values[k] ? Nan::True() : Nan::False()));
-        }
-        Nan::Set(parameter, Nan::New("value").ToLocalChecked(), bool_array);
-      } else if (value.string_array_value != NULL) {  // NOLINT()
-        param_type = PARAMETER_STRING_ARRAY;
-        v8::Local<v8::Array> string_array = Nan::New<v8::Array>();
-        for (size_t k = 0; k < value.string_array_value->size; k++) {
-          Nan::Set(string_array, k,
-                   Nan::New(value.string_array_value->data[k])
-                       .ToLocalChecked());  // NOLINT(whitespace/line_length)
-        }
-        Nan::Set(parameter, Nan::New("value").ToLocalChecked(), string_array);
-      } else if (value.byte_array_value != NULL) {  // NOLINT()
-        param_type = PARAMETER_BYTE_ARRAY;
-        v8::Local<v8::Array> byte_array = Nan::New<v8::Array>();
-        for (size_t k = 0; k < value.byte_array_value->size; k++) {
-          Nan::Set(byte_array, k, Nan::New(value.byte_array_value->values[k]));
-        }
-        Nan::Set(parameter, Nan::New("value").ToLocalChecked(), byte_array);
-      } else if (value.integer_array_value != NULL) {  // NOLINT()
-        param_type = PARAMETER_INTEGER_ARRAY;
-        v8::Local<v8::Array> int_array = Nan::New<v8::Array>();
-        for (size_t k = 0; k < value.integer_array_value->size; k++) {
-          Nan::Set(int_array, k,
-                   Nan::New<v8::Number>(value.integer_array_value->values[k]));
-        }
-        Nan::Set(parameter, Nan::New("value").ToLocalChecked(), int_array);
-      } else if (value.double_array_value != NULL) {  // NOLINT()
-        param_type = PARAMETER_DOUBLE_ARRAY;
-        v8::Local<v8::Array> dbl_array = Nan::New<v8::Array>();
-        for (size_t k = 0; k < value.double_array_value->size; k++) {
-          Nan::Set(dbl_array, k,
-                   Nan::New<v8::Number>(
-                       value.double_array_value
-                           ->values[k]));  // NOLINT(whitespace/line_length)
-        }
-        Nan::Set(parameter, Nan::New("value").ToLocalChecked(), dbl_array);
-      }
-
-      Nan::Set(parameter, Nan::New("type").ToLocalChecked(),
-               Nan::New<v8::Number>(param_type));
-      Nan::Set(parameters, j, parameter);
-    }
-
-    Nan::Set(node, Nan::New("parameters").ToLocalChecked(), parameters);
-    Nan::Set(nodes, i, node);
-  }
-
-  return nodes;
-}
-
-NAN_METHOD(CreateNode) {
-  std::string node_name(*Nan::Utf8String(info[0]));
-  std::string name_space(*Nan::Utf8String(info[1]));
-  RclHandle* context_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[2]).ToLocalChecked());
-  rcl_context_t* context =
-      reinterpret_cast<rcl_context_t*>(context_handle->ptr());
-
-  rcl_node_t* node = reinterpret_cast<rcl_node_t*>(malloc(sizeof(rcl_node_t)));
-
-  *node = rcl_get_zero_initialized_node();
-  rcl_node_options_t options = rcl_node_get_default_options();
-
-  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
-                           rcl_node_init(node, node_name.c_str(),
-                                         name_space.c_str(), context, &options),
-                           rcl_get_error_string().str);
-
-  auto handle = RclHandle::NewInstance(node, nullptr, [](void* ptr) {
-    rcl_node_t* node = reinterpret_cast<rcl_node_t*>(ptr);
-    rcl_ret_t ret = rcl_node_fini(node);
-    free(ptr);
-    THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, ret, rcl_get_error_string().str);
-  });
-  info.GetReturnValue().Set(handle);
-}
-
-NAN_METHOD(CreateGuardCondition) {
-  RclHandle* context_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_context_t* context =
-      reinterpret_cast<rcl_context_t*>(context_handle->ptr());
-
-  rcl_guard_condition_t* gc = reinterpret_cast<rcl_guard_condition_t*>(
-      malloc(sizeof(rcl_guard_condition_t)));
-
-  *gc = rcl_get_zero_initialized_guard_condition();
-  rcl_guard_condition_options_t gc_options =
-      rcl_guard_condition_get_default_options();
-
-  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
-                           rcl_guard_condition_init(gc, context, gc_options),
-                           rcl_get_error_string().str);
-
-  auto handle = RclHandle::NewInstance(gc, nullptr, [](void* ptr) {
-    rcl_guard_condition_t* gc = reinterpret_cast<rcl_guard_condition_t*>(ptr);
-    rcl_ret_t ret = rcl_guard_condition_fini(gc);
-    free(ptr);
-    THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, ret, rcl_get_error_string().str);
-  });
-  info.GetReturnValue().Set(handle);
-}
-
-NAN_METHOD(TriggerGuardCondition) {
-  RclHandle* gc_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_guard_condition_t* gc =
-      reinterpret_cast<rcl_guard_condition_t*>(gc_handle->ptr());
-
-  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, rcl_trigger_guard_condition(gc),
-                           rcl_get_error_string().str);
-}
-
-NAN_METHOD(CreateTimer) {
-  RclHandle* clock_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_clock_t* clock = reinterpret_cast<rcl_clock_t*>(clock_handle->ptr());
-  RclHandle* context_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[1]).ToLocalChecked());
-  rcl_context_t* context =
-      reinterpret_cast<rcl_context_t*>(context_handle->ptr());
-  if (!info[2]->IsBigInt()) {
-    Nan::ThrowTypeError("Timer period must be a BigInt");
-    return;
-  }
-  v8::Local<v8::BigInt> bigInt = info[2].As<v8::BigInt>();
-  int64_t period_nsec = bigInt->Int64Value();
-  rcl_timer_t* timer =
-      reinterpret_cast<rcl_timer_t*>(malloc(sizeof(rcl_timer_t)));
-  *timer = rcl_get_zero_initialized_timer();
-
-#if ROS_VERSION > 2305  // After Iron.
-  THROW_ERROR_IF_NOT_EQUAL(
-      RCL_RET_OK,
-      rcl_timer_init2(timer, clock, context, period_nsec, nullptr,
-                      rcl_get_default_allocator(), /*autostart=*/true),
-      rcl_get_error_string().str);
-#else
-  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
-                           rcl_timer_init(timer, clock, context, period_nsec,
-                                          nullptr, rcl_get_default_allocator()),
-                           rcl_get_error_string().str);
-#endif
-
-  auto js_obj = RclHandle::NewInstance(timer, clock_handle, [](void* ptr) {
-    rcl_timer_t* timer = reinterpret_cast<rcl_timer_t*>(ptr);
-    rcl_ret_t ret = rcl_timer_fini(timer);
-    free(ptr);
-    THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, ret, rcl_get_error_string().str);
-  });
-  info.GetReturnValue().Set(js_obj);
-}
-
-NAN_METHOD(IsTimerReady) {
-  RclHandle* timer_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_timer_t* timer = reinterpret_cast<rcl_timer_t*>(timer_handle->ptr());
-  bool is_ready = false;
-
-  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, rcl_timer_is_ready(timer, &is_ready),
-                           rcl_get_error_string().str);
-
-  info.GetReturnValue().Set(Nan::New(is_ready));
-}
-
-NAN_METHOD(CallTimer) {
-  RclHandle* timer_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_timer_t* timer = reinterpret_cast<rcl_timer_t*>(timer_handle->ptr());
-
-  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, rcl_timer_call(timer),
-                           rcl_get_error_string().str);
-}
-
-NAN_METHOD(CancelTimer) {
-  RclHandle* timer_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_timer_t* timer = reinterpret_cast<rcl_timer_t*>(timer_handle->ptr());
-
-  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, rcl_timer_cancel(timer),
-                           rcl_get_error_string().str);
-}
-
-NAN_METHOD(IsTimerCanceled) {
-  RclHandle* timer_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_timer_t* timer = reinterpret_cast<rcl_timer_t*>(timer_handle->ptr());
-  bool is_canceled = false;
-
-  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
-                           rcl_timer_is_canceled(timer, &is_canceled),
-                           rcl_get_error_string().str);
-
-  info.GetReturnValue().Set(Nan::New(is_canceled));
-}
-
-NAN_METHOD(ResetTimer) {
-  RclHandle* timer_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_timer_t* timer = reinterpret_cast<rcl_timer_t*>(timer_handle->ptr());
-
-  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, rcl_timer_reset(timer),
-                           rcl_get_error_string().str);
-}
-
-NAN_METHOD(TimerGetTimeUntilNextCall) {
-  RclHandle* timer_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_timer_t* timer = reinterpret_cast<rcl_timer_t*>(timer_handle->ptr());
-  int64_t remaining_time = 0;
-
-  THROW_ERROR_IF_NOT_EQUAL(
-      RCL_RET_OK, rcl_timer_get_time_until_next_call(timer, &remaining_time),
-      rcl_get_error_string().str);
-
-  v8::Local<v8::BigInt> bigInt =
-      v8::BigInt::New(v8::Isolate::GetCurrent(), remaining_time);
-  info.GetReturnValue().Set(bigInt);
-}
-
-NAN_METHOD(TimerGetTimeSinceLastCall) {
-  RclHandle* timer_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_timer_t* timer = reinterpret_cast<rcl_timer_t*>(timer_handle->ptr());
-  int64_t elapsed_time = 0;
-
-  THROW_ERROR_IF_NOT_EQUAL(
-      RCL_RET_OK, rcl_timer_get_time_since_last_call(timer, &elapsed_time),
-      rcl_get_error_string().str);
-
-  v8::Local<v8::BigInt> bigInt =
-      v8::BigInt::New(v8::Isolate::GetCurrent(), elapsed_time);
-  info.GetReturnValue().Set(bigInt);
-}
-
-NAN_METHOD(CreateTimePoint) {
-  if (!info[0]->IsBigInt()) {
-    Nan::ThrowTypeError("Timer period must be a BigInt");
-    return;
-  }
-  v8::Local<v8::BigInt> bigInt = info[0].As<v8::BigInt>();
-  const int64_t nanoseconds = bigInt->Int64Value();
-  uint32_t clock_type = Nan::To<uint32_t>(info[1]).FromJust();
-  rcl_time_point_t* time_point =
-      reinterpret_cast<rcl_time_point_t*>(malloc(sizeof(rcl_time_point_t)));
-
-  time_point->nanoseconds = nanoseconds;
-  time_point->clock_type = static_cast<rcl_clock_type_t>(clock_type);
-
-  auto js_obj =
-      RclHandle::NewInstance(time_point, nullptr, [](void* ptr) { free(ptr); });
-  info.GetReturnValue().Set(js_obj);
-}
-
-NAN_METHOD(GetNanoseconds) {
-  RclHandle* time_point_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_time_point_t* time_point =
-      reinterpret_cast<rcl_time_point_t*>(time_point_handle->ptr());
-  v8::Local<v8::BigInt> bigInt =
-      v8::BigInt::New(v8::Isolate::GetCurrent(), time_point->nanoseconds);
-  info.GetReturnValue().Set(bigInt);
-}
-
-NAN_METHOD(CreateDuration) {
-  if (!info[0]->IsBigInt()) {
-    Nan::ThrowTypeError("Timer period must be a BigInt");
-    return;
-  }
-  v8::Local<v8::BigInt> bigInt = info[0].As<v8::BigInt>();
-  const int64_t nanoseconds = bigInt->Int64Value();
-  rcl_duration_t* duration =
-      reinterpret_cast<rcl_duration_t*>(malloc(sizeof(rcl_duration_t)));
-  duration->nanoseconds = nanoseconds;
-
-  auto js_obj =
-      RclHandle::NewInstance(duration, nullptr, [](void* ptr) { free(ptr); });
-  info.GetReturnValue().Set(js_obj);
-}
-
-NAN_METHOD(GetDurationNanoseconds) {
-  RclHandle* duration_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_duration_t* duration =
-      reinterpret_cast<rcl_duration_t*>(duration_handle->ptr());
-  v8::Local<v8::BigInt> bigInt =
-      v8::BigInt::New(v8::Isolate::GetCurrent(), duration->nanoseconds);
-  info.GetReturnValue().Set(bigInt);
-}
-
-NAN_METHOD(SetRosTimeOverrideIsEnabled) {
-  RclHandle* clock_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_clock_t* clock = reinterpret_cast<rcl_clock_t*>(clock_handle->ptr());
-  bool enabled = Nan::To<bool>(info[1]).FromJust();
-
-  if (enabled) {
-    THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, rcl_enable_ros_time_override(clock),
-                             rcl_get_error_string().str);
-  } else {
-    THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, rcl_disable_ros_time_override(clock),
-                             rcl_get_error_string().str);
-  }
-  info.GetReturnValue().Set(Nan::Undefined());
-}
-
-NAN_METHOD(SetRosTimeOverride) {
-  RclHandle* clock_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_clock_t* clock = reinterpret_cast<rcl_clock_t*>(clock_handle->ptr());
-  RclHandle* time_point_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[1]).ToLocalChecked());
-  rcl_time_point_t* time_point =
-      reinterpret_cast<rcl_time_point_t*>(time_point_handle->ptr());
-
-  THROW_ERROR_IF_NOT_EQUAL(
-      RCL_RET_OK, rcl_set_ros_time_override(clock, time_point->nanoseconds),
-      rcl_get_error_string().str);
-  info.GetReturnValue().Set(Nan::Undefined());
-}
-
-NAN_METHOD(GetRosTimeOverrideIsEnabled) {
-  RclHandle* clock_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_clock_t* clock = reinterpret_cast<rcl_clock_t*>(clock_handle->ptr());
-
-  bool is_enabled;
-  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
-                           rcl_is_enabled_ros_time_override(clock, &is_enabled),
-                           rcl_get_error_string().str);
-  info.GetReturnValue().Set(Nan::New(is_enabled));
-}
-
-NAN_METHOD(CreateClock) {
-  auto clock_type =
-      static_cast<rcl_clock_type_t>(Nan::To<int32_t>(info[0]).FromJust());
-  rcl_clock_t* clock =
-      reinterpret_cast<rcl_clock_t*>(malloc(sizeof(rcl_clock_t)));
-  rcl_allocator_t allocator = rcl_get_default_allocator();
-
-  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
-                           rcl_clock_init(clock_type, clock, &allocator),
-                           rcl_get_error_string().str);
-
-  info.GetReturnValue().Set(
-      RclHandle::NewInstance(clock, nullptr, [](void* ptr) {
-        rcl_clock_t* clock = reinterpret_cast<rcl_clock_t*>(ptr);
-        rcl_ret_t ret = rcl_clock_fini(clock);
-        free(ptr);
-        THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, ret, rcl_get_error_string().str);
-      }));
-}
-
-NAN_METHOD(ClockGetNow) {
-  rcl_clock_t* clock = reinterpret_cast<rcl_clock_t*>(
-      RclHandle::Unwrap<RclHandle>(
-          Nan::To<v8::Object>(info[0]).ToLocalChecked())
-          ->ptr());
-  rcl_time_point_t time_point;
-  time_point.clock_type = clock->type;
-
-  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
-                           rcl_clock_get_now(clock, &time_point.nanoseconds),
-                           rcl_get_error_string().str);
-  v8::Local<v8::BigInt> bigInt =
-      v8::BigInt::New(v8::Isolate::GetCurrent(), time_point.nanoseconds);
-  info.GetReturnValue().Set(bigInt);
-}
-
-NAN_METHOD(RclTake) {
-  RclHandle* subscription_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_subscription_t* subscription =
-      reinterpret_cast<rcl_subscription_t*>(subscription_handle->ptr());
-  void* msg_taken =
-      node::Buffer::Data(Nan::To<v8::Object>(info[1]).ToLocalChecked());
-  rcl_ret_t ret = rcl_take(subscription, msg_taken, nullptr, nullptr);
-
-  if (ret != RCL_RET_OK && ret != RCL_RET_SUBSCRIPTION_TAKE_FAILED) {
-    Nan::ThrowError(rcl_get_error_string().str);
-    rcl_reset_error();
-    info.GetReturnValue().Set(Nan::False());
-    return;
-  }
-
-  if (ret != RCL_RET_SUBSCRIPTION_TAKE_FAILED) {
-    info.GetReturnValue().Set(Nan::True());
-    return;
-  }
-  info.GetReturnValue().Set(Nan::Undefined());
-}
-
-NAN_METHOD(CreateSubscription) {
-  v8::Local<v8::Context> currentContent = Nan::GetCurrentContext();
-  RclHandle* node_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_node_t* node = reinterpret_cast<rcl_node_t*>(node_handle->ptr());
-  std::string package_name(
-      *Nan::Utf8String(info[1]->ToString(currentContent).ToLocalChecked()));
-  std::string message_sub_folder(
-      *Nan::Utf8String(info[2]->ToString(currentContent).ToLocalChecked()));
-  std::string message_name(
-      *Nan::Utf8String(info[3]->ToString(currentContent).ToLocalChecked()));
-  std::string topic(
-      *Nan::Utf8String(info[4]->ToString(currentContent).ToLocalChecked()));
-  v8::Local<v8::Object> options =
-      info[5]->ToObject(currentContent).ToLocalChecked();
-
-  rcl_subscription_t* subscription =
-      reinterpret_cast<rcl_subscription_t*>(malloc(sizeof(rcl_subscription_t)));
-  *subscription = rcl_get_zero_initialized_subscription();
-
-  rcl_subscription_options_t subscription_ops =
-      rcl_subscription_get_default_options();
-
-  v8::Local<v8::Value> qos =
-      Nan::Get(options, Nan::New("qos").ToLocalChecked()).ToLocalChecked();
-  auto qos_profile = GetQoSProfile(qos);
-  if (qos_profile) {
-    subscription_ops.qos = *qos_profile;
-  }
-
-#if ROS_VERSION >= 2205  // 2205 => Humble+
-  if (Nan::Has(options, Nan::New("contentFilter").ToLocalChecked())
-          .FromMaybe(false)) {
-    // configure content-filter
-    v8::MaybeLocal<v8::Value> contentFilterVal =
-        Nan::Get(options, Nan::New("contentFilter").ToLocalChecked());
-
-    if (!Nan::Equals(contentFilterVal.ToLocalChecked(), Nan::Undefined())
-             .ToChecked()) {
-      v8::Local<v8::Object> contentFilter = contentFilterVal.ToLocalChecked()
-                                                ->ToObject(currentContent)
-                                                .ToLocalChecked();
-
-      // expression property is required
-      std::string expression(*Nan::Utf8String(
-          Nan::Get(contentFilter, Nan::New("expression").ToLocalChecked())
-              .ToLocalChecked()
-              ->ToString(currentContent)
-              .ToLocalChecked()));
-
-      // parameters property (string[]) is optional
-      int argc = 0;
-      char** argv = nullptr;
-
-      if (Nan::Has(contentFilter, Nan::New("parameters").ToLocalChecked())
-              .FromMaybe(false)) {
-        v8::Local<v8::Array> jsArgv = v8::Local<v8::Array>::Cast(
-            Nan::Get(contentFilter, Nan::New("parameters").ToLocalChecked())
-                .ToLocalChecked());
-        argc = jsArgv->Length();
-        if (argc > 0) {
-          argv = reinterpret_cast<char**>(malloc(argc * sizeof(char*)));
-          for (int i = 0; i < argc; i++) {
-            Nan::MaybeLocal<v8::Value> jsElement = Nan::Get(jsArgv, i);
-            Nan::Utf8String utf8_arg(jsElement.ToLocalChecked());
-            int len = utf8_arg.length() + 1;
-            argv[i] = reinterpret_cast<char*>(malloc(len * sizeof(char*)));
-            snprintf(argv[i], len, "%s", *utf8_arg);
-          }
-        }
-      }
-
-      rcl_ret_t ret = rcl_subscription_options_set_content_filter_options(
-          expression.c_str(), argc, (const char**)argv, &subscription_ops);
-
-      if (ret != RCL_RET_OK) {
-        Nan::ThrowError(rcl_get_error_string().str);
-        rcl_reset_error();
-      }
-
-      if (argc) {
-        for (int i = 0; i < argc; i++) {
-          free(argv[i]);
-        }
-        free(argv);
-      }
-    }
-  }
-
-#endif
-
-  const rosidl_message_type_support_t* ts =
-      GetMessageTypeSupport(package_name, message_sub_folder, message_name);
-
-  if (ts) {
-    THROW_ERROR_IF_NOT_EQUAL(
-        RCL_RET_OK,
-        rcl_subscription_init(subscription, node, ts, topic.c_str(),
-                              &subscription_ops),
-        rcl_get_error_string().str);
-
-    auto js_obj =
-        RclHandle::NewInstance(subscription, node_handle, [node](void* ptr) {
-          rcl_subscription_t* subscription =
-              reinterpret_cast<rcl_subscription_t*>(ptr);
-          rcl_ret_t ret = rcl_subscription_fini(subscription, node);
-          free(ptr);
-          THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, ret, rcl_get_error_string().str);
-        });
-    info.GetReturnValue().Set(js_obj);
-  } else {
-    Nan::ThrowError(GetErrorMessageAndClear().c_str());
-  }
-}
-
-NAN_METHOD(HasContentFilter) {
-#if ROS_VERSION < 2205  // 2205 => Humble+
-  info.GetReturnValue().Set(Nan::False());
-  return;
-#else
-  RclHandle* subscription_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_subscription_t* subscription =
-      reinterpret_cast<rcl_subscription_t*>(subscription_handle->ptr());
-
-  bool is_valid = rcl_subscription_is_cft_enabled(subscription);
-  info.GetReturnValue().Set(Nan::New(is_valid));
-#endif
-}
-
-NAN_METHOD(SetContentFilter) {
-#if ROS_VERSION < 2205  // 2205 => Humble+
-  info.GetReturnValue().Set(Nan::False());
-  return;
-#else
-  v8::Local<v8::Context> currentContext = Nan::GetCurrentContext();
-  RclHandle* subscription_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_subscription_t* subscription =
-      reinterpret_cast<rcl_subscription_t*>(subscription_handle->ptr());
-
-  v8::Local<v8::Object> contentFilter =
-      info[1]->ToObject(currentContext).ToLocalChecked();
-
-  Nan::MaybeLocal<v8::Value> jsExpression =
-      Nan::Get(contentFilter, Nan::New("expression").ToLocalChecked());
-  Nan::Utf8String utf8_arg(jsExpression.ToLocalChecked());
-  int len = utf8_arg.length() + 1;
-  char* expression = reinterpret_cast<char*>(malloc(len * sizeof(char*)));
-  snprintf(expression, len, "%s", *utf8_arg);
-
-  // parameters property (string[]) is optional
-  int argc = 0;
-  char** argv = nullptr;
-
-  if (Nan::Has(contentFilter, Nan::New("parameters").ToLocalChecked())
-          .FromMaybe(false)) {
-    v8::Local<v8::Array> jsArgv = v8::Local<v8::Array>::Cast(
-        Nan::Get(contentFilter, Nan::New("parameters").ToLocalChecked())
-            .ToLocalChecked());
-    argc = jsArgv->Length();
-    if (argc > 0) {
-      argv = reinterpret_cast<char**>(malloc(argc * sizeof(char*)));
-      for (int i = 0; i < argc; i++) {
-        Nan::MaybeLocal<v8::Value> jsElement = Nan::Get(jsArgv, i);
-        Nan::Utf8String utf8_arg(jsElement.ToLocalChecked());
-        int len = utf8_arg.length() + 1;
-        argv[i] = reinterpret_cast<char*>(malloc(len * sizeof(char*)));
-        snprintf(argv[i], len, "%s", *utf8_arg);
-      }
-    }
-  }
-
-  // create ctf options
-  rcl_subscription_content_filter_options_t options =
-      rcl_get_zero_initialized_subscription_content_filter_options();
-
-  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
-                           rcl_subscription_content_filter_options_set(
-                               subscription,
-                               expression,  // expression.c_str(),
-                               argc, (const char**)argv, &options),
-                           rcl_get_error_string().str);
-
-  THROW_ERROR_IF_NOT_EQUAL(
-      RCL_RET_OK, rcl_subscription_set_content_filter(subscription, &options),
-      rcl_get_error_string().str);
-
-  if (argc) {
-    free(expression);
-
-    for (int i = 0; i < argc; i++) {
-      free(argv[i]);
-    }
-    free(argv);
-  }
-
-  info.GetReturnValue().Set(Nan::True());
-#endif
-}
-
-NAN_METHOD(ClearContentFilter) {
-#if ROS_VERSION < 2205  // 2205 => Humble+
-  info.GetReturnValue().Set(Nan::False());
-  return;
-#else
-  RclHandle* subscription_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_subscription_t* subscription =
-      reinterpret_cast<rcl_subscription_t*>(subscription_handle->ptr());
-
-  // create ctf options
-  rcl_subscription_content_filter_options_t options =
-      rcl_get_zero_initialized_subscription_content_filter_options();
-
-  THROW_ERROR_IF_NOT_EQUAL(
-      RCL_RET_OK,
-      rcl_subscription_content_filter_options_init(
-          subscription, "", 0, (const char**)nullptr, &options),
-      rcl_get_error_string().str);
-
-  THROW_ERROR_IF_NOT_EQUAL(
-      RCL_RET_OK, rcl_subscription_set_content_filter(subscription, &options),
-      rcl_get_error_string().str);
-
-  info.GetReturnValue().Set(Nan::True());
-#endif
-}
-
-NAN_METHOD(CreatePublisher) {
-  v8::Local<v8::Context> currentContent = Nan::GetCurrentContext();
-  // Extract arguments
-  RclHandle* node_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_node_t* node = reinterpret_cast<rcl_node_t*>(node_handle->ptr());
-  std::string package_name(
-      *Nan::Utf8String(info[1]->ToString(currentContent).ToLocalChecked()));
-  std::string message_sub_folder(
-      *Nan::Utf8String(info[2]->ToString(currentContent).ToLocalChecked()));
-  std::string message_name(
-      *Nan::Utf8String(info[3]->ToString(currentContent).ToLocalChecked()));
-  std::string topic(
-      *Nan::Utf8String(info[4]->ToString(currentContent).ToLocalChecked()));
-
-  // Prepare publisher object
-  rcl_publisher_t* publisher =
-      reinterpret_cast<rcl_publisher_t*>(malloc(sizeof(rcl_publisher_t)));
-  *publisher = rcl_get_zero_initialized_publisher();
-
-  // Get type support object dynamically
-  const rosidl_message_type_support_t* ts =
-      GetMessageTypeSupport(package_name, message_sub_folder, message_name);
-
-  if (ts) {
-    // Using default options
-    rcl_publisher_options_t publisher_ops = rcl_publisher_get_default_options();
-    auto qos_profile = GetQoSProfile(info[5]);
-
-    if (qos_profile) {
-      publisher_ops.qos = *qos_profile;
-    }
-
-    // Initialize the publisher
-    THROW_ERROR_IF_NOT_EQUAL(
-        rcl_publisher_init(publisher, node, ts, topic.c_str(), &publisher_ops),
-        RCL_RET_OK, rcl_get_error_string().str);
-
-    // Wrap the handle into JS object
-    auto js_obj =
-        RclHandle::NewInstance(publisher, node_handle, [node](void* ptr) {
-          rcl_publisher_t* publisher = reinterpret_cast<rcl_publisher_t*>(ptr);
-          rcl_ret_t ret = rcl_publisher_fini(publisher, node);
-          free(ptr);
-          THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, ret, rcl_get_error_string().str);
-        });
-
-    // Everything is done
-    info.GetReturnValue().Set(js_obj);
-  } else {
-    Nan::ThrowError(GetErrorMessageAndClear().c_str());
-  }
-}
-
-NAN_METHOD(Publish) {
-  rcl_publisher_t* publisher = reinterpret_cast<rcl_publisher_t*>(
-      RclHandle::Unwrap<RclHandle>(
-          Nan::To<v8::Object>(info[0]).ToLocalChecked())
-          ->ptr());
-
-  void* buffer =
-      node::Buffer::Data(Nan::To<v8::Object>(info[1]).ToLocalChecked());
-  THROW_ERROR_IF_NOT_EQUAL(rcl_publish(publisher, buffer, nullptr), RCL_RET_OK,
-                           rcl_get_error_string().str);
-
-  info.GetReturnValue().Set(Nan::Undefined());
-}
-
-NAN_METHOD(GetPublisherTopic) {
-  rcl_publisher_t* publisher = reinterpret_cast<rcl_publisher_t*>(
-      RclHandle::Unwrap<RclHandle>(
-          Nan::To<v8::Object>(info[0]).ToLocalChecked())
-          ->ptr());
-
-  const char* topic = rcl_publisher_get_topic_name(publisher);
-  info.GetReturnValue().Set(Nan::New(topic).ToLocalChecked());
-}
-
-NAN_METHOD(GetSubscriptionTopic) {
-  rcl_subscription_t* subscription = reinterpret_cast<rcl_subscription_t*>(
-      RclHandle::Unwrap<RclHandle>(
-          Nan::To<v8::Object>(info[0]).ToLocalChecked())
-          ->ptr());
-
-  const char* topic = rcl_subscription_get_topic_name(subscription);
-  info.GetReturnValue().Set(Nan::New(topic).ToLocalChecked());
-}
-
-NAN_METHOD(CreateClient) {
-  v8::Local<v8::Context> currentContent = Nan::GetCurrentContext();
-  RclHandle* node_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_node_t* node = reinterpret_cast<rcl_node_t*>(node_handle->ptr());
-  std::string service_name(
-      *Nan::Utf8String(info[1]->ToString(currentContent).ToLocalChecked()));
-  std::string interface_name(
-      *Nan::Utf8String(info[2]->ToString(currentContent).ToLocalChecked()));
-  std::string package_name(
-      *Nan::Utf8String(info[3]->ToString(currentContent).ToLocalChecked()));
-
-  const rosidl_service_type_support_t* ts =
-      GetServiceTypeSupport(package_name, interface_name);
-
-  if (ts) {
-    rcl_client_t* client =
-        reinterpret_cast<rcl_client_t*>(malloc(sizeof(rcl_client_t)));
-    *client = rcl_get_zero_initialized_client();
-    rcl_client_options_t client_ops = rcl_client_get_default_options();
-    auto qos_profile = GetQoSProfile(info[4]);
-
-    if (qos_profile) {
-      client_ops.qos = *qos_profile;
-    }
-
-    THROW_ERROR_IF_NOT_EQUAL(
-        rcl_client_init(client, node, ts, service_name.c_str(), &client_ops),
-        RCL_RET_OK, rcl_get_error_string().str);
-
-    auto js_obj =
-        RclHandle::NewInstance(client, node_handle, [node](void* ptr) {
-          rcl_client_t* client = reinterpret_cast<rcl_client_t*>(ptr);
-          rcl_ret_t ret = rcl_client_fini(client, node);
-          free(ptr);
-          THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, ret, rcl_get_error_string().str);
-        });
-
-    info.GetReturnValue().Set(js_obj);
-  } else {
-    Nan::ThrowError(GetErrorMessageAndClear().c_str());
-  }
-}
-
-NAN_METHOD(SendRequest) {
-  rcl_client_t* client = reinterpret_cast<rcl_client_t*>(
-      RclHandle::Unwrap<RclHandle>(
-          Nan::To<v8::Object>(info[0]).ToLocalChecked())
-          ->ptr());
-  void* buffer =
-      node::Buffer::Data(Nan::To<v8::Object>(info[1]).ToLocalChecked());
-  int64_t sequence_number;
-
-  THROW_ERROR_IF_NOT_EQUAL(rcl_send_request(client, buffer, &sequence_number),
-                           RCL_RET_OK, rcl_get_error_string().str);
-
-  info.GetReturnValue().Set(Nan::New(static_cast<uint32_t>(sequence_number)));
-}
-
-NAN_METHOD(RclTakeResponse) {
-  rcl_client_t* client = reinterpret_cast<rcl_client_t*>(
-      RclHandle::Unwrap<RclHandle>(
-          Nan::To<v8::Object>(info[0]).ToLocalChecked())
-          ->ptr());
+Napi::Value InitString(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
 
-  rmw_service_info_t header;
-
-  void* taken_response =
-      node::Buffer::Data(Nan::To<v8::Object>(info[1]).ToLocalChecked());
-  rcl_ret_t ret = rcl_take_response_with_info(client, &header, taken_response);
-  int64_t sequence_number = header.request_id.sequence_number;
-
-  if (ret == RCL_RET_OK) {
-    info.GetReturnValue().Set(Nan::New(static_cast<uint32_t>(sequence_number)));
-    return;
-  }
-
-  rcl_reset_error();
-  info.GetReturnValue().Set(Nan::Undefined());
-}
-
-NAN_METHOD(CreateService) {
-  v8::Local<v8::Context> currentContent = Nan::GetCurrentContext();
-  RclHandle* node_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_node_t* node = reinterpret_cast<rcl_node_t*>(node_handle->ptr());
-  std::string service_name(
-      *Nan::Utf8String(info[1]->ToString(currentContent).ToLocalChecked()));
-  std::string interface_name(
-      *Nan::Utf8String(info[2]->ToString(currentContent).ToLocalChecked()));
-  std::string package_name(
-      *Nan::Utf8String(info[3]->ToString(currentContent).ToLocalChecked()));
-
-  const rosidl_service_type_support_t* ts =
-      GetServiceTypeSupport(package_name, interface_name);
-
-  if (ts) {
-    rcl_service_t* service =
-        reinterpret_cast<rcl_service_t*>(malloc(sizeof(rcl_service_t)));
-    *service = rcl_get_zero_initialized_service();
-    rcl_service_options_t service_ops = rcl_service_get_default_options();
-    auto qos_profile = GetQoSProfile(info[4]);
-
-    if (qos_profile) {
-      service_ops.qos = *qos_profile;
-    }
-
-    THROW_ERROR_IF_NOT_EQUAL(
-        rcl_service_init(service, node, ts, service_name.c_str(), &service_ops),
-        RCL_RET_OK, rcl_get_error_string().str);
-    auto js_obj =
-        RclHandle::NewInstance(service, node_handle, [node](void* ptr) {
-          rcl_service_t* service = reinterpret_cast<rcl_service_t*>(ptr);
-          rcl_ret_t ret = rcl_service_fini(service, node);
-          free(ptr);
-          THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, ret, rcl_get_error_string().str);
-        });
-
-    info.GetReturnValue().Set(js_obj);
-  } else {
-    Nan::ThrowError(GetErrorMessageAndClear().c_str());
-  }
-}
-
-NAN_METHOD(RclTakeRequest) {
-  rcl_service_t* service = reinterpret_cast<rcl_service_t*>(
-      RclHandle::Unwrap<RclHandle>(
-          Nan::To<v8::Object>(info[0]).ToLocalChecked())
-          ->ptr());
-  rmw_request_id_t* header =
-      reinterpret_cast<rmw_request_id_t*>(malloc(sizeof(rmw_request_id_t)));
-
-  void* taken_request =
-      node::Buffer::Data(Nan::To<v8::Object>(info[2]).ToLocalChecked());
-  rcl_ret_t ret = rcl_take_request(service, header, taken_request);
-  if (ret != RCL_RET_SERVICE_TAKE_FAILED) {
-    auto js_obj =
-        RclHandle::NewInstance(header, nullptr, [](void* ptr) { free(ptr); });
-    info.GetReturnValue().Set(js_obj);
-    return;
-  }
-
-  info.GetReturnValue().Set(Nan::Undefined());
-}
-
-NAN_METHOD(SendResponse) {
-  rcl_service_t* service = reinterpret_cast<rcl_service_t*>(
-      RclHandle::Unwrap<RclHandle>(
-          Nan::To<v8::Object>(info[0]).ToLocalChecked())
-          ->ptr());
-  void* buffer =
-      node::Buffer::Data(Nan::To<v8::Object>(info[1]).ToLocalChecked());
-
-  rmw_request_id_t* header = reinterpret_cast<rmw_request_id_t*>(
-      RclHandle::Unwrap<RclHandle>(
-          Nan::To<v8::Object>(info[2]).ToLocalChecked())
-          ->ptr());
-
-  THROW_ERROR_IF_NOT_EQUAL(rcl_send_response(service, header, buffer),
-                           RCL_RET_OK, rcl_get_error_string().str);
-}
-
-#if ROS_VERSION > 2205  // 2205 == Humble
-NAN_METHOD(ConfigureServiceIntrospection) {
-  v8::Local<v8::Context> currentContent = Nan::GetCurrentContext();
-
-  RclHandle* node_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[1]).ToLocalChecked());
-  rcl_node_t* node = reinterpret_cast<rcl_node_t*>(node_handle->ptr());
-
-  rcl_clock_t* clock = reinterpret_cast<rcl_clock_t*>(
-      RclHandle::Unwrap<RclHandle>(
-          Nan::To<v8::Object>(info[2]).ToLocalChecked())
-          ->ptr());
-
-  std::string interface_name(
-      *Nan::Utf8String(info[3]->ToString(currentContent).ToLocalChecked()));
-  std::string package_name(
-      *Nan::Utf8String(info[4]->ToString(currentContent).ToLocalChecked()));
-  const rosidl_service_type_support_t* ts =
-      GetServiceTypeSupport(package_name, interface_name);
-
-  if (ts) {
-    rcl_publisher_options_t publisher_ops = rcl_publisher_get_default_options();
-    auto qos_profile = GetQoSProfile(info[5]);
-    if (qos_profile) {
-      publisher_ops.qos = *qos_profile;
-    }
-
-    rcl_service_introspection_state_t state =
-        static_cast<rcl_service_introspection_state_t>(
-            Nan::To<uint32_t>(info[6]).ToChecked());
-
-    bool configureForService = Nan::To<bool>(info[7]).FromJust();
-
-    if (configureForService) {
-      RclHandle* service_handle = RclHandle::Unwrap<RclHandle>(
-          Nan::To<v8::Object>(info[0]).ToLocalChecked());
-      rcl_service_t* service =
-          reinterpret_cast<rcl_service_t*>(service_handle->ptr());
-
-      THROW_ERROR_IF_NOT_EQUAL(
-          rcl_service_configure_service_introspection(service, node, clock, ts,
-                                                      publisher_ops, state),
-          RCL_RET_OK, rcl_get_error_string().str);
-
-    } else {
-      RclHandle* client_handle = RclHandle::Unwrap<RclHandle>(
-          Nan::To<v8::Object>(info[0]).ToLocalChecked());
-      rcl_client_t* client =
-          reinterpret_cast<rcl_client_t*>(client_handle->ptr());
-
-      THROW_ERROR_IF_NOT_EQUAL(
-          rcl_client_configure_service_introspection(client, node, clock, ts,
-                                                     publisher_ops, state),
-          RCL_RET_OK, rcl_get_error_string().str);
-    }
-
-  } else {
-    Nan::ThrowError(GetErrorMessageAndClear().c_str());
-  }
-}
-#endif
-
-NAN_METHOD(ValidateFullTopicName) {
-  v8::Local<v8::Context> currentContent = Nan::GetCurrentContext();
-  int validation_result;
-  size_t invalid_index;
-  std::string topic_name(
-      *Nan::Utf8String(info[0]->ToString(currentContent).ToLocalChecked()));
-  rmw_ret_t ret = rmw_validate_full_topic_name(
-      topic_name.c_str(), &validation_result, &invalid_index);
-
-  if (ret != RMW_RET_OK) {
-    if (ret == RMW_RET_BAD_ALLOC) {
-      Nan::ThrowError(rmw_get_error_string().str);
-    }
-    rmw_reset_error();
-    return info.GetReturnValue().Set(Nan::Undefined());
-  }
-
-  if (validation_result == RMW_NAMESPACE_VALID) {
-    info.GetReturnValue().Set(Nan::Null());
-    return;
-  }
-  const char* validation_message =
-      rmw_full_topic_name_validation_result_string(validation_result);
-  THROW_ERROR_IF_EQUAL(nullptr, validation_message,
-                       "Unable to get validation error message");
-
-  v8::Local<v8::Array> result_list = Nan::New<v8::Array>(2);
-  Nan::Set(
-      result_list, 0,
-      Nan::New<v8::String>(std::string(validation_message)).ToLocalChecked());
-  Nan::Set(result_list, 1, Nan::New(static_cast<int32_t>(invalid_index)));
-
-  info.GetReturnValue().Set(result_list);
-}
-
-NAN_METHOD(ValidateNodeName) {
-  v8::Local<v8::Context> currentContent = Nan::GetCurrentContext();
-  int validation_result;
-  size_t invalid_index;
-  std::string node_name(
-      *Nan::Utf8String(info[0]->ToString(currentContent).ToLocalChecked()));
-  rmw_ret_t ret = rmw_validate_node_name(node_name.c_str(), &validation_result,
-                                         &invalid_index);
-
-  if (ret != RMW_RET_OK) {
-    if (ret == RMW_RET_BAD_ALLOC) {
-      Nan::ThrowError(rmw_get_error_string().str);
-    }
-    rmw_reset_error();
-    return info.GetReturnValue().Set(Nan::Undefined());
-  }
-
-  if (validation_result == RMW_NODE_NAME_VALID) {
-    info.GetReturnValue().Set(Nan::Null());
-    return;
-  }
-  const char* validation_message =
-      rmw_node_name_validation_result_string(validation_result);
-  THROW_ERROR_IF_EQUAL(nullptr, validation_message,
-                       "Unable to get validation error message");
-
-  v8::Local<v8::Array> result_list = Nan::New<v8::Array>(2);
-  Nan::Set(
-      result_list, 0,
-      Nan::New<v8::String>(std::string(validation_message)).ToLocalChecked());
-  Nan::Set(result_list, 1, Nan::New(static_cast<int32_t>(invalid_index)));
-
-  info.GetReturnValue().Set(result_list);
-}
-
-NAN_METHOD(ValidateTopicName) {
-  v8::Local<v8::Context> currentContent = Nan::GetCurrentContext();
-  int validation_result;
-  size_t invalid_index;
-  std::string topic_name(
-      *Nan::Utf8String(info[0]->ToString(currentContent).ToLocalChecked()));
-  rmw_ret_t ret = rcl_validate_topic_name(topic_name.c_str(),
-                                          &validation_result, &invalid_index);
-
-  if (ret != RMW_RET_OK) {
-    if (ret == RMW_RET_BAD_ALLOC) {
-      Nan::ThrowError(rmw_get_error_string().str);
-    }
-    rmw_reset_error();
-    return info.GetReturnValue().Set(Nan::Undefined());
-  }
-
-  if (validation_result == RMW_NODE_NAME_VALID) {
-    info.GetReturnValue().Set(Nan::Null());
-    return;
-  }
-  const char* validation_message =
-      rcl_topic_name_validation_result_string(validation_result);
-  THROW_ERROR_IF_EQUAL(nullptr, validation_message,
-                       "Unable to get validation error message");
-
-  v8::Local<v8::Array> result_list = Nan::New<v8::Array>(2);
-  Nan::Set(
-      result_list, 0,
-      Nan::New<v8::String>(std::string(validation_message)).ToLocalChecked());
-  Nan::Set(result_list, 1, Nan::New(static_cast<int32_t>(invalid_index)));
-
-  info.GetReturnValue().Set(result_list);
-}
-
-NAN_METHOD(ValidateNamespace) {
-  v8::Local<v8::Context> currentContent = Nan::GetCurrentContext();
-  int validation_result;
-  size_t invalid_index;
-  std::string namespace_name(
-      *Nan::Utf8String(info[0]->ToString(currentContent).ToLocalChecked()));
-  rmw_ret_t ret = rmw_validate_namespace(namespace_name.c_str(),
-                                         &validation_result, &invalid_index);
-
-  if (ret != RMW_RET_OK) {
-    if (ret == RMW_RET_BAD_ALLOC) {
-      Nan::ThrowError(rmw_get_error_string().str);
-    }
-    rmw_reset_error();
-    return info.GetReturnValue().Set(Nan::Undefined());
-  }
-
-  if (validation_result == RMW_NODE_NAME_VALID) {
-    info.GetReturnValue().Set(Nan::Null());
-    return;
-  }
-  const char* validation_message =
-      rmw_namespace_validation_result_string(validation_result);
-  THROW_ERROR_IF_EQUAL(nullptr, validation_message,
-                       "Unable to get validation error message");
-
-  v8::Local<v8::Array> result_list = Nan::New<v8::Array>(2);
-  Nan::Set(
-      result_list, 0,
-      Nan::New<v8::String>(std::string(validation_message)).ToLocalChecked());
-  Nan::Set(result_list, 1, Nan::New(static_cast<int32_t>(invalid_index)));
-
-  info.GetReturnValue().Set(result_list);
-}
-
-NAN_METHOD(ExpandTopicName) {
-  v8::Local<v8::Context> currentContent = Nan::GetCurrentContext();
-  std::string topic_name(
-      *Nan::Utf8String(info[0]->ToString(currentContent).ToLocalChecked()));
-  std::string node_name(
-      *Nan::Utf8String(info[1]->ToString(currentContent).ToLocalChecked()));
-  std::string node_namespace(
-      *Nan::Utf8String(info[2]->ToString(currentContent).ToLocalChecked()));
-
-  char* expanded_topic = nullptr;
-  rcl_allocator_t allocator = rcl_get_default_allocator();
-  rcutils_allocator_t rcutils_allocator = rcutils_get_default_allocator();
-  rcutils_string_map_t substitutions_map =
-      rcutils_get_zero_initialized_string_map();
-
-  rcutils_ret_t rcutils_ret =
-      rcutils_string_map_init(&substitutions_map, 0, rcutils_allocator);
-  if (rcutils_ret != RCUTILS_RET_OK) {
-    if (rcutils_ret == RCUTILS_RET_BAD_ALLOC) {
-      Nan::ThrowError(rcutils_get_error_string().str);
-    }
-    rcutils_reset_error();
-    info.GetReturnValue().Set(Nan::Undefined());
-    return;
-  }
-  rcl_ret_t ret = rcl_get_default_topic_name_substitutions(&substitutions_map);
-  if (ret != RCL_RET_OK) {
-    if (ret == RCL_RET_BAD_ALLOC) {
-      Nan::ThrowError(rcl_get_error_string().str);
-    }
-    rcl_reset_error();
-
-    rcutils_ret = rcutils_string_map_fini(&substitutions_map);
-    if (rcutils_ret != RCUTILS_RET_OK) {
-      Nan::ThrowError(rcutils_get_error_string().str);
-      rcutils_reset_error();
-    }
-    info.GetReturnValue().Set(Nan::Undefined());
-    return;
-  }
-
-  ret = rcl_expand_topic_name(topic_name.c_str(), node_name.c_str(),
-                              node_namespace.c_str(), &substitutions_map,
-                              allocator, &expanded_topic);
-
-  rcutils_ret = rcutils_string_map_fini(&substitutions_map);
-  if (rcutils_ret != RCUTILS_RET_OK) {
-    Nan::ThrowError(rcutils_get_error_string().str);
-    rcutils_reset_error();
-    allocator.deallocate(expanded_topic, allocator.state);
-    info.GetReturnValue().Set(Nan::Undefined());
-    return;
-  }
-  if (ret != RCL_RET_OK) {
-    Nan::ThrowError(rcl_get_error_string().str);
-    rcl_reset_error();
-    info.GetReturnValue().Set(Nan::Undefined());
-    return;
-  }
-
-  if (!expanded_topic) {
-    info.GetReturnValue().Set(Nan::Undefined());
-    return;
-  }
-
-  rcl_allocator_t topic_allocator = rcl_get_default_allocator();
-  std::string topic(expanded_topic);
-  allocator.deallocate(expanded_topic, topic_allocator.state);
-  info.GetReturnValue().Set(Nan::New<v8::String>(topic).ToLocalChecked());
-}
-
-NAN_METHOD(GetNodeName) {
-  RclHandle* node_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_node_t* node = reinterpret_cast<rcl_node_t*>(node_handle->ptr());
-  const char* node_name = rcl_node_get_name(node);
-  if (!node_name) {
-    info.GetReturnValue().Set(Nan::Undefined());
-  } else {
-    info.GetReturnValue().Set(Nan::New<v8::String>(node_name).ToLocalChecked());
-  }
-}
-
-NAN_METHOD(GetNamespace) {
-  RclHandle* node_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_node_t* node = reinterpret_cast<rcl_node_t*>(node_handle->ptr());
-  const char* node_namespace = rcl_node_get_namespace(node);
-  if (!node_namespace) {
-    info.GetReturnValue().Set(Nan::Undefined());
-  } else {
-    info.GetReturnValue().Set(
-        Nan::New<v8::String>(node_namespace).ToLocalChecked());
-  }
-}
-
-const rmw_qos_profile_t* GetQoSProfileFromString(const std::string& profile) {
-  const rmw_qos_profile_t* qos_profile = nullptr;
-  if (profile == "qos_profile_sensor_data") {
-    qos_profile = &rmw_qos_profile_sensor_data;
-  } else if (profile == "qos_profile_system_default") {
-    qos_profile = &rmw_qos_profile_system_default;
-  } else if (profile == "qos_profile_services_default") {
-    qos_profile = &rmw_qos_profile_services_default;
-  } else if (profile == "qos_profile_parameters") {
-    qos_profile = &rmw_qos_profile_parameters;
-  } else if (profile == "qos_profile_parameter_events") {
-    qos_profile = &rmw_qos_profile_parameter_events;
-  } else if (profile == "qos_profile_action_status_default") {
-    qos_profile = &rcl_action_qos_profile_status_default;
-  } else {
-    return &rmw_qos_profile_default;
-  }
-
-  return qos_profile;
-}
-
-std::unique_ptr<rmw_qos_profile_t> GetQosProfileFromObject(
-    v8::Local<v8::Object> object) {
-  std::unique_ptr<rmw_qos_profile_t> qos_profile =
-      std::make_unique<rmw_qos_profile_t>();
-
-  auto history =
-      Nan::Get(object, Nan::New("history").ToLocalChecked()).ToLocalChecked();
-  auto depth =
-      Nan::Get(object, Nan::New("depth").ToLocalChecked()).ToLocalChecked();
-  auto reliability = Nan::Get(object, Nan::New("reliability").ToLocalChecked())
-                         .ToLocalChecked();
-  auto durability = Nan::Get(object, Nan::New("durability").ToLocalChecked())
-                        .ToLocalChecked();
-  auto avoid_ros_namespace_conventions =
-      Nan::Get(object,
-               Nan::New("avoidRosNameSpaceConventions").ToLocalChecked())
-          .ToLocalChecked();
-
-  qos_profile->history = static_cast<rmw_qos_history_policy_t>(
-      Nan::To<uint32_t>(history).FromJust());
-  qos_profile->depth = Nan::To<uint32_t>(depth).FromJust();
-  qos_profile->reliability = static_cast<rmw_qos_reliability_policy_t>(
-      Nan::To<uint32_t>(reliability).FromJust());
-  qos_profile->durability = static_cast<rmw_qos_durability_policy_t>(
-      Nan::To<uint32_t>(durability).FromJust());
-  qos_profile->avoid_ros_namespace_conventions =
-      Nan::To<bool>(avoid_ros_namespace_conventions).FromJust();
-
-  return qos_profile;
-}
-
-std::unique_ptr<rmw_qos_profile_t> GetQoSProfile(v8::Local<v8::Value> qos) {
-  v8::Local<v8::Context> currentContent = Nan::GetCurrentContext();
-  std::unique_ptr<rmw_qos_profile_t> qos_profile =
-      std::make_unique<rmw_qos_profile_t>();
-
-  if (qos->IsString()) {
-    *qos_profile = *GetQoSProfileFromString(std::string(
-        *Nan::Utf8String(qos->ToString(currentContent).ToLocalChecked())));
-  } else if (qos->IsObject()) {
-    qos_profile =
-        GetQosProfileFromObject(Nan::To<v8::Object>(qos).ToLocalChecked());
-  } else {
-    return qos_profile;
-  }
-  return qos_profile;
-}
-
-int DestroyContext(rcl_context_t* context) {
-  rcl_ret_t ret = RCL_RET_OK;
-  if (context->impl) {
-    if (rcl_context_is_valid(context)) {
-      if (RCL_RET_OK != rcl_shutdown(context)) {
-        Nan::ThrowError(rcl_get_error_string().str);
-      }
-      ret = rcl_context_fini(context);
-    }
-  }
-  return ret;
-}
-
-NAN_METHOD(Shutdown) {
-  RclHandle* context_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_context_t* context =
-      reinterpret_cast<rcl_context_t*>(context_handle->ptr());
-  THROW_ERROR_IF_NOT_EQUAL(rcl_shutdown(context), RCL_RET_OK,
-                           rcl_get_error_string().str);
-  THROW_ERROR_IF_NOT_EQUAL(rcl_logging_fini(), RCL_RET_OK,
-                           rcl_get_error_string().str);
-
-  info.GetReturnValue().Set(Nan::Undefined());
-}
-
-NAN_METHOD(InitString) {
-  void* buffer =
-      node::Buffer::Data(Nan::To<v8::Object>(info[0]).ToLocalChecked());
+  void* buffer = info[0].As<Napi::Buffer<char>>().Data();
 #if ROS_VERSION >= 2006
   rosidl_runtime_c__String* ptr =
       reinterpret_cast<rosidl_runtime_c__String*>(buffer);
@@ -1477,608 +43,74 @@ NAN_METHOD(InitString) {
 
   rosidl_generator_c__String__init(ptr);
 #endif
-  info.GetReturnValue().Set(Nan::Undefined());
+  return env.Undefined();
 }
 
-inline char* GetBufAddr(v8::Local<v8::Value> buf) {
-  return node::Buffer::Data(buf.As<v8::Object>());
+inline char* GetBufAddr(Napi::Value buf) {
+  return buf.As<Napi::Buffer<char>>().Data();
 }
 
-NAN_METHOD(FreeMemeoryAtOffset) {
-  v8::Local<v8::Context> currentContent = Nan::GetCurrentContext();
-  std::string addr_str(
-      *Nan::Utf8String(info[0]->ToString(currentContent).ToLocalChecked()));
+Napi::Value FreeMemeoryAtOffset(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  std::string addr_str = info[0].As<Napi::String>().Utf8Value();
   int64_t result = std::stoull(addr_str, 0, 16);
   char* addr = reinterpret_cast<char*>(result);
   int64_t offset =
-      info[1]->IsNumber() ? Nan::To<int64_t>(info[1]).FromJust() : 0;
+      info[1].IsNumber() ? info[1].As<Napi::Number>().Int64Value() : 0;
   auto ptr = addr + offset;
 
   char* val = *reinterpret_cast<char**>(ptr);
   free(val);
-  info.GetReturnValue().Set(Nan::Undefined());
+  return env.Undefined();
 }
 
-NAN_METHOD(CreateArrayBufferFromAddress) {
-  v8::Local<v8::Context> currentContent = Nan::GetCurrentContext();
-  std::string addr_str(
-      *Nan::Utf8String(info[0]->ToString(currentContent).ToLocalChecked()));
+Napi::Value CreateArrayBufferFromAddress(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  std::string addr_str = info[0].As<Napi::String>().Utf8Value();
   int64_t result = std::stoull(addr_str, 0, 16);
   char* addr = reinterpret_cast<char*>(result);
-  int32_t length = Nan::To<int32_t>(info[1]).FromJust();
+  int32_t length = info[1].As<Napi::Number>().Int32Value();
 
   static_assert(NODE_MAJOR_VERSION > 12, "nodejs version must > 12");
 #if (NODE_RUNTIME_ELECTRON && NODE_MODULE_VERSION >= 109)
   // Because V8 sandboxed pointers was enabled since Electron 21, we have to
   // make a deep copy for Electron 21 and up.
   // See more details: https://www.electronjs.org/blog/v8-memory-cage
-  v8::Local<v8::ArrayBuffer> array_buffer =
-      v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), length);
-  memcpy(array_buffer->Data(), addr, length);
+  Napi::ArrayBuffer array_buffer = Napi::ArrayBuffer::New(env, length);
+  memcpy(array_buffer.Data(), addr, length);
   free(addr);
 #else
-  // For nodejs > 12 or electron < 21, we will create a new `BackingStore` and
-  // take over the ownership of `addr`.
-  std::unique_ptr<v8::BackingStore> backing = v8::ArrayBuffer::NewBackingStore(
-      addr, length,
-      [](void* data, size_t length, void* deleter_data) { free(data); },
-      nullptr);
-  auto array_buffer =
-      v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), std::move(backing));
+  // For nodejs > 12 or electron < 21, we will take over the ownership of
+  // `addr`.
+  auto array_buffer = Napi::ArrayBuffer::New(
+      env, addr, length, [](Napi::Env /*env*/, void* data) { free(data); });
 #endif
 
-  info.GetReturnValue().Set(array_buffer);
+  return array_buffer;
 }
 
-NAN_METHOD(CreateArrayBufferCleaner) {
+Napi::Value CreateArrayBufferCleaner(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
   auto address = GetBufAddr(info[0]);
-  int32_t offset = Nan::To<int32_t>(info[1]).FromJust();
+  int32_t offset = info[1].As<Napi::Number>().Int32Value();
 
   char* target = *reinterpret_cast<char**>(address + offset);
-  info.GetReturnValue().Set(
-      RclHandle::NewInstance(target, nullptr, [](void* ptr) { free(ptr); }));
-}
-
-NAN_METHOD(setLoggerLevel) {
-  v8::Local<v8::Context> currentContent = Nan::GetCurrentContext();
-  std::string name(
-      *Nan::Utf8String(info[0]->ToString(currentContent).ToLocalChecked()));
-  int level = Nan::To<int64_t>(info[1]).FromJust();
-
-  rcutils_ret_t ret = rcutils_logging_set_logger_level(name.c_str(), level);
-  if (ret != RCUTILS_RET_OK) {
-    Nan::ThrowError(rcutils_get_error_string().str);
-    rcutils_reset_error();
-  }
-  info.GetReturnValue().Set(Nan::Undefined());
-}
-
-NAN_METHOD(GetLoggerEffectiveLevel) {
-  v8::Local<v8::Context> currentContent = Nan::GetCurrentContext();
-  std::string name(
-      *Nan::Utf8String(info[0]->ToString(currentContent).ToLocalChecked()));
-  int logger_level = rcutils_logging_get_logger_effective_level(name.c_str());
-
-  if (logger_level < 0) {
-    Nan::ThrowError(rcutils_get_error_string().str);
-    rcutils_reset_error();
-    info.GetReturnValue().Set(Nan::Undefined());
-    return;
-  }
-  info.GetReturnValue().Set(Nan::New(logger_level));
-}
-
-NAN_METHOD(GetNodeLoggerName) {
-  RclHandle* node_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_node_t* node = reinterpret_cast<rcl_node_t*>(node_handle->ptr());
-
-  const char* node_logger_name = rcl_node_get_logger_name(node);
-  if (!node_logger_name) {
-    info.GetReturnValue().Set(Nan::Undefined());
-    return;
-  }
-
-  info.GetReturnValue().Set(
-      Nan::New<v8::String>(node_logger_name).ToLocalChecked());
-}
-
-NAN_METHOD(Log) {
-  v8::Local<v8::Context> currentContent = Nan::GetCurrentContext();
-  std::string name(
-      *Nan::Utf8String(info[0]->ToString(currentContent).ToLocalChecked()));
-  int severity = Nan::To<int64_t>(info[1]).FromJust();
-  std::string message(
-      *Nan::Utf8String(info[2]->ToString(currentContent).ToLocalChecked()));
-  std::string function_name(
-      *Nan::Utf8String(info[3]->ToString(currentContent).ToLocalChecked()));
-  size_t line_number = Nan::To<int64_t>(info[4]).FromJust();
-  std::string file_name(
-      *Nan::Utf8String(info[5]->ToString(currentContent).ToLocalChecked()));
-  bool enabled = rcutils_logging_logger_is_enabled_for(name.c_str(), severity);
-
-  if (enabled) {
-    rcutils_log_location_t logging_location = {function_name.c_str(),
-                                               file_name.c_str(), line_number};
-    rcutils_log(&logging_location, severity, name.c_str(), "%s",
-                message.c_str());
-  }
-
-  info.GetReturnValue().Set(Nan::New(enabled));
-}
-
-NAN_METHOD(IsEnableFor) {
-  v8::Local<v8::Context> currentContent = Nan::GetCurrentContext();
-  std::string name(
-      *Nan::Utf8String(info[0]->ToString(currentContent).ToLocalChecked()));
-  int severity = Nan::To<int64_t>(info[1]).FromJust();
-  bool enabled = rcutils_logging_logger_is_enabled_for(name.c_str(), severity);
-  info.GetReturnValue().Set(Nan::New(enabled));
-}
-
-NAN_METHOD(CreateContext) {
-  rcl_context_t* context =
-      reinterpret_cast<rcl_context_t*>(malloc(sizeof(rcl_context_t)));
-  *context = rcl_get_zero_initialized_context();
-  auto js_obj = RclHandle::NewInstance(context, nullptr, [](void* ptr) {
-    rcl_context_t* context = reinterpret_cast<rcl_context_t*>(ptr);
-    rcl_ret_t ret = DestroyContext(context);
-    free(ptr);
-    THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, ret, rcl_get_error_string().str);
-  });
-
-  info.GetReturnValue().Set(js_obj);
-}
-
-NAN_METHOD(IsContextValid) {
-  RclHandle* context_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_context_t* context =
-      reinterpret_cast<rcl_context_t*>(context_handle->ptr());
-  bool is_valid = rcl_context_is_valid(context);
-  info.GetReturnValue().Set(Nan::New(is_valid));
-}
-
-void ExtractNamesAndTypes(rcl_names_and_types_t names_and_types,
-                          v8::Local<v8::Array>* result_list) {
-  for (size_t i = 0; i < names_and_types.names.size; ++i) {
-    auto item = v8::Object::New(v8::Isolate::GetCurrent());
-    std::string topic_name = names_and_types.names.data[i];
-    Nan::Set(item, Nan::New("name").ToLocalChecked(),
-             Nan::New(names_and_types.names.data[i]).ToLocalChecked());
-
-    v8::Local<v8::Array> type_list =
-        Nan::New<v8::Array>(names_and_types.types[i].size);
-    for (size_t j = 0; j < names_and_types.types[i].size; ++j) {
-      Nan::Set(type_list, j,
-               Nan::New(names_and_types.types[i].data[j]).ToLocalChecked());
-    }
-    Nan::Set(item, Nan::New("types").ToLocalChecked(), type_list);
-    Nan::Set(*result_list, i, item);
-  }
-}
-
-NAN_METHOD(GetPublisherNamesAndTypesByNode) {
-  v8::Local<v8::Context> currentContent = Nan::GetCurrentContext();
-  RclHandle* node_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_node_t* node = reinterpret_cast<rcl_node_t*>(node_handle->ptr());
-  std::string node_name =
-      *Nan::Utf8String(info[1]->ToString(currentContent).ToLocalChecked());
-  std::string node_namespace =
-      *Nan::Utf8String(info[2]->ToString(currentContent).ToLocalChecked());
-  bool no_demangle = Nan::To<bool>(info[3]).FromJust();
-
-  rcl_names_and_types_t topic_names_and_types =
-      rcl_get_zero_initialized_names_and_types();
-  rcl_allocator_t allocator = rcl_get_default_allocator();
-  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
-                           rcl_get_publisher_names_and_types_by_node(
-                               node, &allocator, no_demangle, node_name.c_str(),
-                               node_namespace.c_str(), &topic_names_and_types),
-                           "Failed to get_publisher_names_and_types.");
-
-  v8::Local<v8::Array> result_list =
-      Nan::New<v8::Array>(topic_names_and_types.names.size);
-  ExtractNamesAndTypes(topic_names_and_types, &result_list);
-
-  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
-                           rcl_names_and_types_fini(&topic_names_and_types),
-                           "Failed to destroy topic_names_and_types");
-
-  info.GetReturnValue().Set(result_list);
-}
-
-NAN_METHOD(GetSubscriptionNamesAndTypesByNode) {
-  v8::Local<v8::Context> currentContent = Nan::GetCurrentContext();
-  RclHandle* node_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_node_t* node = reinterpret_cast<rcl_node_t*>(node_handle->ptr());
-  std::string node_name =
-      *Nan::Utf8String(info[1]->ToString(currentContent).ToLocalChecked());
-  std::string node_namespace =
-      *Nan::Utf8String(info[2]->ToString(currentContent).ToLocalChecked());
-  bool no_demangle = Nan::To<bool>(info[3]).FromJust();
-
-  rcl_names_and_types_t topic_names_and_types =
-      rcl_get_zero_initialized_names_and_types();
-  rcl_allocator_t allocator = rcl_get_default_allocator();
-  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
-                           rcl_get_subscriber_names_and_types_by_node(
-                               node, &allocator, no_demangle, node_name.c_str(),
-                               node_namespace.c_str(), &topic_names_and_types),
-                           "Failed to get_publisher_names_and_types.");
-
-  v8::Local<v8::Array> result_list =
-      Nan::New<v8::Array>(topic_names_and_types.names.size);
-  ExtractNamesAndTypes(topic_names_and_types, &result_list);
-
-  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
-                           rcl_names_and_types_fini(&topic_names_and_types),
-                           "Failed to destroy topic_names_and_types");
-
-  info.GetReturnValue().Set(result_list);
-}
-
-NAN_METHOD(GetServiceNamesAndTypesByNode) {
-  v8::Local<v8::Context> currentContent = Nan::GetCurrentContext();
-  RclHandle* node_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_node_t* node = reinterpret_cast<rcl_node_t*>(node_handle->ptr());
-  std::string node_name =
-      *Nan::Utf8String(info[1]->ToString(currentContent).ToLocalChecked());
-  std::string node_namespace =
-      *Nan::Utf8String(info[2]->ToString(currentContent).ToLocalChecked());
-
-  rcl_names_and_types_t service_names_and_types =
-      rcl_get_zero_initialized_names_and_types();
-  rcl_allocator_t allocator = rcl_get_default_allocator();
-  THROW_ERROR_IF_NOT_EQUAL(
-      RCL_RET_OK,
-      rcl_get_service_names_and_types_by_node(
-          node, &allocator, node_name.c_str(), node_namespace.c_str(),
-          &service_names_and_types),
-      "Failed to get_service_names_and_types.");
-
-  v8::Local<v8::Array> result_list =
-      Nan::New<v8::Array>(service_names_and_types.names.size);
-  ExtractNamesAndTypes(service_names_and_types, &result_list);
-
-  THROW_ERROR_IF_NOT_EQUAL(
-      RCL_RET_OK, rcl_names_and_types_fini(&service_names_and_types),
-      "Failed to destroy rcl_get_zero_initialized_names_and_types");
-
-  info.GetReturnValue().Set(result_list);
-}
-
-NAN_METHOD(GetClientNamesAndTypesByNode) {
-  v8::Local<v8::Context> currentContent = Nan::GetCurrentContext();
-  RclHandle* node_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_node_t* node = reinterpret_cast<rcl_node_t*>(node_handle->ptr());
-  std::string node_name =
-      *Nan::Utf8String(info[1]->ToString(currentContent).ToLocalChecked());
-  std::string node_namespace =
-      *Nan::Utf8String(info[2]->ToString(currentContent).ToLocalChecked());
-
-  rcl_names_and_types_t client_names_and_types =
-      rcl_get_zero_initialized_names_and_types();
-  rcl_allocator_t allocator = rcl_get_default_allocator();
-  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
-                           rcl_get_client_names_and_types_by_node(
-                               node, &allocator, node_name.c_str(),
-                               node_namespace.c_str(), &client_names_and_types),
-                           "Failed to get_client_names_and_types.");
-
-  v8::Local<v8::Array> result_list =
-      Nan::New<v8::Array>(client_names_and_types.names.size);
-  ExtractNamesAndTypes(client_names_and_types, &result_list);
-
-  THROW_ERROR_IF_NOT_EQUAL(
-      RCL_RET_OK, rcl_names_and_types_fini(&client_names_and_types),
-      "Failed to destroy rcl_get_zero_initialized_names_and_types");
-
-  info.GetReturnValue().Set(result_list);
-}
-
-NAN_METHOD(GetTopicNamesAndTypes) {
-  RclHandle* node_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_node_t* node = reinterpret_cast<rcl_node_t*>(node_handle->ptr());
-  bool no_demangle = Nan::To<bool>(info[1]).FromJust();
-  rcl_names_and_types_t topic_names_and_types =
-      rcl_get_zero_initialized_names_and_types();
-  rcl_allocator_t allocator = rcl_get_default_allocator();
-
-  THROW_ERROR_IF_NOT_EQUAL(
-      RCL_RET_OK,
-      rcl_get_topic_names_and_types(node, &allocator, no_demangle,
-                                    &topic_names_and_types),
-      "Failed to get_publisher_names_and_types.");
-
-  v8::Local<v8::Array> result_list =
-      Nan::New<v8::Array>(topic_names_and_types.names.size);
-  ExtractNamesAndTypes(topic_names_and_types, &result_list);
-
-  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
-                           rcl_names_and_types_fini(&topic_names_and_types),
-                           "Failed to destroy topic_names_and_types");
-
-  info.GetReturnValue().Set(result_list);
-}
-
-NAN_METHOD(GetServiceNamesAndTypes) {
-  RclHandle* node_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_node_t* node = reinterpret_cast<rcl_node_t*>(node_handle->ptr());
-  rcl_names_and_types_t service_names_and_types =
-      rcl_get_zero_initialized_names_and_types();
-  rcl_allocator_t allocator = rcl_get_default_allocator();
-
-  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
-                           rcl_get_service_names_and_types(
-                               node, &allocator, &service_names_and_types),
-                           "Failed to get_publisher_names_and_types.");
-
-  v8::Local<v8::Array> result_list =
-      Nan::New<v8::Array>(service_names_and_types.names.size);
-  ExtractNamesAndTypes(service_names_and_types, &result_list);
-
-  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
-                           rcl_names_and_types_fini(&service_names_and_types),
-                           "Failed to destroy topic_names_and_types");
-
-  info.GetReturnValue().Set(result_list);
-}
-
-NAN_METHOD(GetNodeNames) {
-  RclHandle* node_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_node_t* node = reinterpret_cast<rcl_node_t*>(node_handle->ptr());
-  rcutils_string_array_t node_names =
-      rcutils_get_zero_initialized_string_array();
-  rcutils_string_array_t node_namespaces =
-      rcutils_get_zero_initialized_string_array();
-  rcl_allocator_t allocator = rcl_get_default_allocator();
-
-  THROW_ERROR_IF_NOT_EQUAL(
-      RCL_RET_OK,
-      rcl_get_node_names(node, allocator, &node_names, &node_namespaces),
-      "Failed to get_node_names.");
-
-  v8::Local<v8::Array> result_list = Nan::New<v8::Array>(node_names.size);
-
-  for (size_t i = 0; i < node_names.size; ++i) {
-    auto item = v8::Object::New(v8::Isolate::GetCurrent());
-
-    Nan::Set(item, Nan::New("name").ToLocalChecked(),
-             Nan::New(node_names.data[i]).ToLocalChecked());
-    Nan::Set(item, Nan::New("namespace").ToLocalChecked(),
-             Nan::New(node_namespaces.data[i]).ToLocalChecked());
-
-    Nan::Set(result_list, i, item);
-  }
-
-  rcutils_ret_t fini_names_ret = rcutils_string_array_fini(&node_names);
-  rcutils_ret_t fini_namespaces_ret =
-      rcutils_string_array_fini(&node_namespaces);
-
-  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, fini_names_ret,
-                           "Failed to destroy node_names");
-  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, fini_namespaces_ret,
-                           "Failed to destroy node_namespaces");
-
-  info.GetReturnValue().Set(result_list);
+  return RclHandle::NewInstance(env, target, nullptr,
+                                [](void* ptr) { free(ptr); });
 }
 
-NAN_METHOD(CountPublishers) {
-  v8::Local<v8::Context> currentContent = Nan::GetCurrentContext();
-  RclHandle* node_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_node_t* node = reinterpret_cast<rcl_node_t*>(node_handle->ptr());
-  std::string topic_name =
-      *Nan::Utf8String(info[1]->ToString(currentContent).ToLocalChecked());
-
-  size_t count = 0;
-  THROW_ERROR_IF_NOT_EQUAL(
-      RCL_RET_OK, rcl_count_publishers(node, topic_name.c_str(), &count),
-      "Failed to count publishers.");
-
-  v8::Local<v8::Integer> result =
-      Nan::New<v8::Integer>(static_cast<int32_t>(count));
-  info.GetReturnValue().Set(result);
+Napi::Object InitBindings(Napi::Env env, Napi::Object exports) {
+  exports.Set("initString", Napi::Function::New(env, InitString));
+  exports.Set("freeMemeoryAtOffset",
+              Napi::Function::New(env, FreeMemeoryAtOffset));
+  exports.Set("createArrayBufferFromAddress",
+              Napi::Function::New(env, CreateArrayBufferFromAddress));
+  exports.Set("createArrayBufferCleaner",
+              Napi::Function::New(env, CreateArrayBufferCleaner));
+  return exports;
 }
 
-NAN_METHOD(CountSubscribers) {
-  v8::Local<v8::Context> currentContent = Nan::GetCurrentContext();
-  RclHandle* node_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_node_t* node = reinterpret_cast<rcl_node_t*>(node_handle->ptr());
-  std::string topic_name =
-      *Nan::Utf8String(info[1]->ToString(currentContent).ToLocalChecked());
-
-  size_t count = 0;
-  THROW_ERROR_IF_NOT_EQUAL(
-      RCL_RET_OK, rcl_count_subscribers(node, topic_name.c_str(), &count),
-      "Failed to count subscribers.");
-
-  v8::Local<v8::Integer> result =
-      Nan::New<v8::Integer>(static_cast<int32_t>(count));
-  info.GetReturnValue().Set(result);
-}
-
-NAN_METHOD(ServiceServerIsAvailable) {
-  RclHandle* node_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_node_t* node = reinterpret_cast<rcl_node_t*>(node_handle->ptr());
-  RclHandle* client_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[1]).ToLocalChecked());
-  rcl_client_t* client = reinterpret_cast<rcl_client_t*>(client_handle->ptr());
-
-  bool is_available;
-  THROW_ERROR_IF_NOT_EQUAL(
-      RCL_RET_OK, rcl_service_server_is_available(node, client, &is_available),
-      "Failed to get service state.");
-
-  v8::Local<v8::Boolean> result = Nan::New<v8::Boolean>(is_available);
-  info.GetReturnValue().Set(result);
-}
-
-NAN_METHOD(PublishRawMessage) {
-  rcl_publisher_t* publisher = reinterpret_cast<rcl_publisher_t*>(
-      RclHandle::Unwrap<RclHandle>(
-          Nan::To<v8::Object>(info[0]).ToLocalChecked())
-          ->ptr());
-
-  auto object = Nan::To<v8::Object>(info[1]).ToLocalChecked();
-  rcl_serialized_message_t serialized_msg =
-      rmw_get_zero_initialized_serialized_message();
-  serialized_msg.buffer_capacity = node::Buffer::Length(object);
-  serialized_msg.buffer_length = serialized_msg.buffer_capacity;
-  serialized_msg.buffer =
-      reinterpret_cast<uint8_t*>(node::Buffer::Data(object));
-
-  THROW_ERROR_IF_NOT_EQUAL(
-      rcl_publish_serialized_message(publisher, &serialized_msg, nullptr),
-      RCL_RET_OK, rcl_get_error_string().str);
-
-  info.GetReturnValue().Set(Nan::Undefined());
-}
-
-NAN_METHOD(RclTakeRaw) {
-  RclHandle* subscription_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  rcl_subscription_t* subscription =
-      reinterpret_cast<rcl_subscription_t*>(subscription_handle->ptr());
-
-  rcl_serialized_message_t msg = rmw_get_zero_initialized_serialized_message();
-  rcutils_allocator_t allocator = rcutils_get_default_allocator();
-  rcl_ret_t ret = rmw_serialized_message_init(&msg, 0u, &allocator);
-  if (ret != RCL_RET_OK) {
-    THROW_ERROR_IF_NOT_EQUAL(rmw_serialized_message_fini(&msg), RCL_RET_OK,
-                             "Failed to deallocate message buffer.");
-    info.GetReturnValue().Set(Nan::Undefined());
-    return;
-  }
-  ret = rcl_take_serialized_message(subscription, &msg, nullptr, nullptr);
-  if (ret != RCL_RET_OK && ret != RCL_RET_SUBSCRIPTION_TAKE_FAILED) {
-    rcl_reset_error();
-    THROW_ERROR_IF_NOT_EQUAL(rmw_serialized_message_fini(&msg), RCL_RET_OK,
-                             "Failed to deallocate message buffer.");
-    info.GetReturnValue().Set(Nan::Undefined());
-    return;
-  }
-
-  if (ret == RCL_RET_SUBSCRIPTION_TAKE_FAILED) {
-    THROW_ERROR_IF_NOT_EQUAL(rmw_serialized_message_fini(&msg), RCL_RET_OK,
-                             "Failed to deallocate message buffer.");
-    info.GetReturnValue().Set(Nan::Undefined());
-    return;
-  }
-
-  info.GetReturnValue().Set(
-      Nan::CopyBuffer(reinterpret_cast<char*>(msg.buffer), msg.buffer_length)
-          .ToLocalChecked());
-  THROW_ERROR_IF_NOT_EQUAL(rmw_serialized_message_fini(&msg), RCL_RET_OK,
-                           "Failed to deallocate message buffer");
-}
-
-NAN_METHOD(GetClientServiceName) {
-  rcl_client_t* client = reinterpret_cast<rcl_client_t*>(
-      RclHandle::Unwrap<RclHandle>(
-          Nan::To<v8::Object>(info[0]).ToLocalChecked())
-          ->ptr());
-
-  const char* service_name = rcl_client_get_service_name(client);
-  info.GetReturnValue().Set(Nan::New(service_name).ToLocalChecked());
-}
-
-NAN_METHOD(GetServiceServiceName) {
-  rcl_service_t* service = reinterpret_cast<rcl_service_t*>(
-      RclHandle::Unwrap<RclHandle>(
-          Nan::To<v8::Object>(info[0]).ToLocalChecked())
-          ->ptr());
-
-  const char* service_name = rcl_service_get_service_name(service);
-  info.GetReturnValue().Set(Nan::New(service_name).ToLocalChecked());
-}
-
-std::vector<BindingMethod> binding_methods = {
-    {"init", Init},
-    {"createNode", CreateNode},
-    {"getParameterOverrides", GetParameterOverrides},
-    {"createGuardCondition", CreateGuardCondition},
-    {"triggerGuardCondition", TriggerGuardCondition},
-    {"createTimer", CreateTimer},
-    {"isTimerReady", IsTimerReady},
-    {"callTimer", CallTimer},
-    {"cancelTimer", CancelTimer},
-    {"isTimerCanceled", IsTimerCanceled},
-    {"resetTimer", ResetTimer},
-    {"timerGetTimeSinceLastCall", TimerGetTimeSinceLastCall},
-    {"timerGetTimeUntilNextCall", TimerGetTimeUntilNextCall},
-    {"createClock", CreateClock},
-    {"clockGetNow", ClockGetNow},
-    {"createTimePoint", CreateTimePoint},
-    {"getNanoseconds", GetNanoseconds},
-    {"createDuration", CreateDuration},
-    {"getDurationNanoseconds", GetDurationNanoseconds},
-    {"setRosTimeOverrideIsEnabled", SetRosTimeOverrideIsEnabled},
-    {"setRosTimeOverride", SetRosTimeOverride},
-    {"getRosTimeOverrideIsEnabled", GetRosTimeOverrideIsEnabled},
-    {"rclTake", RclTake},
-    {"createSubscription", CreateSubscription},
-    {"hasContentFilter", HasContentFilter},
-    {"setContentFilter", SetContentFilter},
-    {"clearContentFilter", ClearContentFilter},
-    {"createPublisher", CreatePublisher},
-    {"publish", Publish},
-    {"getPublisherTopic", GetPublisherTopic},
-    {"getSubscriptionTopic", GetSubscriptionTopic},
-    {"createClient", CreateClient},
-    {"rclTakeResponse", RclTakeResponse},
-    {"sendRequest", SendRequest},
-    {"createService", CreateService},
-    {"rclTakeRequest", RclTakeRequest},
-    {"sendResponse", SendResponse},
-    {"shutdown", Shutdown},
-    {"validateFullTopicName", ValidateFullTopicName},
-    {"validateNodeName", ValidateNodeName},
-    {"validateTopicName", ValidateTopicName},
-    {"validateNamespace", ValidateNamespace},
-    {"expandTopicName", ExpandTopicName},
-    {"getNodeName", GetNodeName},
-    {"getNamespace", GetNamespace},
-    {"initString", InitString},
-    {"freeMemeoryAtOffset", FreeMemeoryAtOffset},
-    {"createArrayBufferFromAddress", CreateArrayBufferFromAddress},
-    {"createArrayBufferCleaner", CreateArrayBufferCleaner},
-    {"setLoggerLevel", setLoggerLevel},
-    {"getLoggerEffectiveLevel", GetLoggerEffectiveLevel},
-    {"getNodeLoggerName", GetNodeLoggerName},
-    {"log", Log},
-    {"isEnableFor", IsEnableFor},
-    {"createContext", CreateContext},
-    {"isContextValid", IsContextValid},
-    {"getPublisherNamesAndTypesByNode", GetPublisherNamesAndTypesByNode},
-    {"getSubscriptionNamesAndTypesByNode", GetSubscriptionNamesAndTypesByNode},
-    {"getServiceNamesAndTypesByNode", GetServiceNamesAndTypesByNode},
-    {"getClientNamesAndTypesByNode", GetClientNamesAndTypesByNode},
-    {"getTopicNamesAndTypes", GetTopicNamesAndTypes},
-    {"getServiceNamesAndTypes", GetServiceNamesAndTypes},
-    {"getNodeNames", GetNodeNames},
-    {"countPublishers", CountPublishers},
-    {"countSubscribers", CountSubscribers},
-    {"serviceServerIsAvailable", ServiceServerIsAvailable},
-    {"publishRawMessage", PublishRawMessage},
-    {"rclTakeRaw", RclTakeRaw},
-    {"getClientServiceName", GetClientServiceName},
-    {"getServiceServiceName", GetServiceServiceName},
-    {"", nullptr}
-#if ROS_VERSION > 2205  // 2205 == Humble
-    ,
-    {"configureServiceIntrospection", ConfigureServiceIntrospection}
-#endif
-};
-
 }  // namespace rclnodejs