fix: use the Napi::Addon interface for the module

src/context.cc

@@ -9,7 +9,7 @@
 
 namespace zmq {
 Context::Context(const Napi::CallbackInfo& info)
-    : Napi::ObjectWrap<Context>(info), module(*reinterpret_cast<Module*>(info.Data())) {
+    : Napi::ObjectWrap<Context>(info), module(*static_cast<Module*>(info.Data())) {
     /* If this module has no global context, then create one with a process
        wide context pointer that is shared between threads/agents. */
     if (module.GlobalContext.IsEmpty()) {

src/incoming_msg.cc

@@ -27,7 +27,7 @@ Napi::Value IncomingMsg::IntoBuffer(const Napi::Env& env) {
             return env.Undefined();
         }
     }
-    auto* data = reinterpret_cast<uint8_t*>(zmq_msg_data(ref->get()));
+    auto* data = static_cast<uint8_t*>(zmq_msg_data(ref->get()));
     auto length = zmq_msg_size(ref->get());
 
     if (noElectronMemoryCage) {

src/module.cc

@@ -102,10 +102,10 @@ Module::Global::Shared Module::Global::Instance() {
     return instance;
 }
 
-Module::Module(Napi::Object exports) : MsgTrash(exports.Env()) {
-    exports.Set("version", zmq::Version(exports.Env()));
-    exports.Set("capability", zmq::Capabilities(exports.Env()));
-    exports.Set("curveKeyPair", Napi::Function::New(exports.Env(), zmq::CurveKeyPair));
+Module::Module(Napi::Env env, Napi::Object exports) : MsgTrash(env) {
+    exports.Set("version", zmq::Version(env));
+    exports.Set("capability", zmq::Capabilities(env));
+    exports.Set("curveKeyPair", Napi::Function::New(env, zmq::CurveKeyPair));
 
     Context::Initialize(*this, exports);
     Socket::Initialize(*this, exports);
@@ -117,13 +117,5 @@ Module::Module(Napi::Object exports) : MsgTrash(exports.Env()) {
 }
 }  // namespace zmq
 
-/* This initializer can be called in multiple contexts, like worker threads. */
-NAPI_MODULE_INIT(/* env, exports */) {
-    auto* module = new zmq::Module(Napi::Object(env, exports));
-    auto terminate = [](void* data) { delete reinterpret_cast<zmq::Module*>(data); };
-
-    /* Tear down the module class when the env/agent/thread is closed.*/
-    [[maybe_unused]] auto status = napi_add_env_cleanup_hook(env, terminate, module);
-    assert(status == napi_ok);
-    return exports;
-}
+using Module = zmq::Module;
+NODE_API_ADDON(Module)

src/module.h

@@ -46,7 +46,7 @@ struct Terminator {
     }
 };
 
-class Module {
+class Module : public Napi::Addon<Module> {
     /* Contains shared global state that will be accessible by all
        agents/threads. */
     class Global {
@@ -67,7 +67,7 @@ class Module {
     };
 
 public:
-    explicit Module(Napi::Object exports);
+    explicit Module(Napi::Env env, Napi::Object exports);
 
     class Global& Global() {
         return *global;

src/observer.cc

@@ -130,7 +130,7 @@ std::pair<const char*, const char*> ProtoError(uint32_t val) {
 
 Observer::Observer(const Napi::CallbackInfo& info)
     : Napi::ObjectWrap<Observer>(info), async_context(Env(), "Observer"), poller(*this),
-      module(*reinterpret_cast<Module*>(info.Data())) {
+      module(*static_cast<Module*>(info.Data())) {
     Arg::Validator const args{
         Arg::Required<Arg::Object>("Socket must be a socket object"),
     };
@@ -263,7 +263,7 @@ void Observer::Receive(const Napi::Promise::Deferred& res) {
         }
     }
 
-    auto* data2 = reinterpret_cast<char*>(zmq_msg_data(&msg2));
+    auto* data2 = static_cast<char*>(zmq_msg_data(&msg2));
     auto length = zmq_msg_size(&msg2);
 
     auto event = Napi::Object::New(Env());

src/outgoing_msg.cc

@@ -48,9 +48,7 @@ OutgoingMsg::OutgoingMsg(Napi::Value value, std::reference_wrapper<Module> modul
         auto length = str->size();
         auto* data = str->data();
 
-        auto release = [](void*, void* str) {
-            delete reinterpret_cast<std::string*>(str);
-        };
+        auto release = [](void*, void* str) { delete static_cast<std::string*>(str); };
 
         if (zmq_msg_init_data(&msg, data, length, release, str) < 0) {
             delete str;

src/poller.h

@@ -75,7 +75,7 @@ class Poller {
                 readable_timer.get(),
                 [](uv_timer_t* timer) {
                     // NOLINTNEXTLINE(*-pro-type-reinterpret-cast)
-                    auto& poller = *reinterpret_cast<Poller*>(timer->data);
+                    auto& poller = *static_cast<Poller*>(timer->data);
                     poller.Trigger(UV_READABLE);
                 },
                 static_cast<uint64_t>(timeout), 0);
@@ -100,7 +100,7 @@ class Poller {
                 writable_timer.get(),
                 [](uv_timer_t* timer) {
                     // NOLINTNEXTLINE(*-pro-type-reinterpret-cast)
-                    auto& poller = *reinterpret_cast<Poller*>(timer->data);
+                    auto& poller = *static_cast<Poller*>(timer->data);
                     poller.Trigger(UV_WRITABLE);
                 },
                 static_cast<uint64_t>(timeout), 0);
@@ -167,7 +167,7 @@ class Poller {
     static void Callback(uv_poll_t* poll, int32_t status, int32_t /*events*/) {
         if (status == 0) {
             // NOLINTNEXTLINE(*-pro-type-reinterpret-cast)
-            auto& poller = *reinterpret_cast<Poller*>(poll->data);
+            auto& poller = *static_cast<Poller*>(poll->data);
             poller.TriggerReadable();
             poller.TriggerWritable();
         }

src/proxy.cc

@@ -23,7 +23,7 @@ struct ProxyContext {
 
 Proxy::Proxy(const Napi::CallbackInfo& info)
     : Napi::ObjectWrap<Proxy>(info), async_context(Env(), "Proxy"),
-      module(*reinterpret_cast<Module*>(info.Data())) {
+      module(*static_cast<Module*>(info.Data())) {
     Arg::Validator const args{
         Arg::Required<Arg::Object>("Front-end must be a socket object"),
         Arg::Required<Arg::Object>("Back-end must be a socket object"),

src/socket.cc

@@ -67,7 +67,7 @@ struct AddressContext {
 
 Socket::Socket(const Napi::CallbackInfo& info)
     : Napi::ObjectWrap<Socket>(info), async_context(Env(), "Socket"), poller(*this),
-      module(*reinterpret_cast<Module*>(info.Data())) {
+      module(*static_cast<Module*>(info.Data())) {
     Arg::Validator const args{
         Arg::Required<Arg::Number>("Socket type must be a number"),
         Arg::Optional<Arg::Object>("Options must be an object"),
@@ -392,7 +392,7 @@ Napi::Value Socket::Bind(const Napi::CallbackInfo& info) {
             if (run_ctx->error != 0) {
                 res.Reject(ErrnoException(
                     Env(), static_cast<int32_t>(run_ctx->error), run_ctx->address)
-                               .Value());
+                        .Value());
                 return;
             }
 
@@ -448,7 +448,7 @@ Napi::Value Socket::Unbind(const Napi::CallbackInfo& info) {
             if (run_ctx->error != 0) {
                 res.Reject(ErrnoException(
                     Env(), static_cast<int32_t>(run_ctx->error), run_ctx->address)
-                               .Value());
+                        .Value());
                 return;
             }
 

src/util/trash.h

@@ -25,9 +25,7 @@ class Trash {
 
         async->data = this;
 
-        auto clear = [](uv_async_t* async) {
-            reinterpret_cast<Trash*>(async->data)->Clear();
-        };
+        auto clear = [](uv_async_t* async) { static_cast<Trash*>(async->data)->Clear(); };
 
         [[maybe_unused]] auto err = uv_async_init(loop, async.get(), clear);
         assert(err == 0);

src/util/uvdelayed.h

@@ -33,7 +33,7 @@ class UvDelayed {
         assert(err == 0);
 
         err = uv_check_start(check.get(), [](uv_check_t* check) {
-            auto& immediate = *reinterpret_cast<UvDelayed*>(check->data);
+            auto& immediate = *static_cast<UvDelayed*>(check->data);
             immediate.check.reset();
             immediate.idle.reset();
             immediate.delayed_callback();

src/util/uvwork.h

@@ -23,11 +23,11 @@ class UvWork {
         auto err = uv_queue_work(
             loop, work.get(),
             [](uv_work_t* req) {
-                auto& work = *reinterpret_cast<UvWork*>(req->data);
+                auto& work = *static_cast<UvWork*>(req->data);
                 work.execute_callback();
             },
             [](uv_work_t* req, int /*status*/) {
-                auto& work = *reinterpret_cast<UvWork*>(req->data);
+                auto& work = *static_cast<UvWork*>(req->data);
                 work.complete_callback();
                 delete &work;
             });