fix: support arrays in C++ join/leave

Author: aminya

src/draft.ts

@@ -41,27 +41,28 @@ interface RadioGroupOptions {
 export interface Radio extends Writable<MessageLike, [RadioGroupOptions]> {}
 allowMethods(Radio.prototype, ["send"])
 
-const join = (Socket.prototype as any).join
-const leave = (Socket.prototype as any).leave
+const join = (
+  Socket.prototype as Socket & {
+    join: (value: Array<string | Buffer>) => void
+  }
+).join
+const leave = (
+  Socket.prototype as Socket & {
+    leave: (value: Array<string | Buffer>) => void
+  }
+).leave
 
 export class Dish extends Socket {
   constructor(options?: SocketOptions<Dish>) {
     super(SocketType.Dish, options)
   }
 
-  /* TODO: These methods might accept arrays in their C++ implementation for
-     the sake of simplicity. */
-
   join(...values: Array<Buffer | string>): void {
-    for (const value of values) {
-      join(value)
-    }
+    join(values)
   }
 
   leave(...values: Array<Buffer | string>): void {
-    for (const value of values) {
-      leave(value)
-    }
+    leave(values)
   }
 }
 

src/outgoing_msg.cc

@@ -5,6 +5,7 @@
 
 #include "./module.h"
 #include "util/error.h"
+#include "util/string_or_buffer.h"
 
 namespace zmq {
 OutgoingMsg::OutgoingMsg(Napi::Value value, std::reference_wrapper<Module> module) {
@@ -116,18 +117,7 @@ bool OutgoingMsg::Parts::SetGroup(Napi::Value value) {
         return false;
     }
 
-    auto group = [&]() {
-        if (value.IsString()) {
-            return std::string(value.As<Napi::String>());
-        }
-        if (value.IsBuffer()) {
-            auto buf = value.As<Napi::Object>();
-            auto length = buf.As<Napi::Buffer<char>>().Length();
-            auto* value = buf.As<Napi::Buffer<char>>().Data();
-            return std::string(value, length);
-        }
-        return std::string();
-    }();
+    const auto group = convert_string_or_buffer(value);
 
     for (auto& part : parts) {
         if (zmq_msg_set_group(part.get(), group.c_str()) < 0) {

src/socket.cc

@@ -14,6 +14,7 @@
 #include "util/async_scope.h"
 #include "util/error.h"
 #include "util/object.h"
+#include "util/string_or_buffer.h"
 #include "util/take.h"
 #include "util/uvdelayed.h"
 #include "util/uvwork.h"
@@ -102,7 +103,7 @@ Socket::Socket(const Napi::CallbackInfo& info)
         return;
     }
 
-    uv_os_sock_t file_descriptor = 0;
+    auto file_descriptor = uv_os_sock_t{};
 
     const auto error = [this]() {
         [[maybe_unused]] auto err = zmq_close(socket);
@@ -751,27 +752,20 @@ Napi::Value Socket::Receive(const Napi::CallbackInfo& info) {
 
 void Socket::Join([[maybe_unused]] const Napi::CallbackInfo& info) {
 #ifdef ZMQ_HAS_POLLABLE_THREAD_SAFE
-    Arg::Validator args{
-        Arg::Required<Arg::String, Arg::Buffer>("Group must be a string or buffer"),
-    };
-
-    if (args.ThrowIfInvalid(info)) {
-        return;
+    for (size_t i_value = 0; i_value < info.Length(); ++i_value) {
+        const auto& value = info[i_value];
+        this->JoinElement(value);
     }
+#endif
+}
 
+void Socket::JoinElement([[maybe_unused]] const Napi::Value& value) {
+#ifdef ZMQ_HAS_POLLABLE_THREAD_SAFE
     if (!ValidateOpen()) {
         return;
     }
 
-    auto str = [&]() {
-        if (info[0].IsString()) {
-            return std::string(info[0].As<Napi::String>());
-        }
-        auto buf = info[0].As<Napi::Object>();
-        auto length = buf.As<Napi::Buffer<char>>().Length();
-        auto* value = buf.As<Napi::Buffer<char>>().Data();
-        return std::string(value, length);
-    }();
+    const auto str = convert_string_or_buffer(value);
 
     if (zmq_join(socket, str.c_str()) < 0) {
         ErrnoException(Env(), zmq_errno()).ThrowAsJavaScriptException();
@@ -782,27 +776,20 @@ void Socket::Join([[maybe_unused]] const Napi::CallbackInfo& info) {
 
 void Socket::Leave([[maybe_unused]] const Napi::CallbackInfo& info) {
 #ifdef ZMQ_HAS_POLLABLE_THREAD_SAFE
-    Arg::Validator args{
-        Arg::Required<Arg::String, Arg::Buffer>("Group must be a string or buffer"),
-    };
-
-    if (args.ThrowIfInvalid(info)) {
-        return;
+    for (size_t i_value = 0; i_value < info.Length(); ++i_value) {
+        const auto& value = info[i_value];
+        this->LeaveElement(value);
     }
+#endif
+}
 
+void Socket::LeaveElement([[maybe_unused]] const Napi::Value& value) {
+#ifdef ZMQ_HAS_POLLABLE_THREAD_SAFE
     if (!ValidateOpen()) {
         return;
     }
 
-    auto str = [&]() {
-        if (info[0].IsString()) {
-            return std::string(info[0].As<Napi::String>());
-        }
-        auto buf = info[0].As<Napi::Object>();
-        auto length = buf.As<Napi::Buffer<char>>().Length();
-        auto* value = buf.As<Napi::Buffer<char>>().Data();
-        return std::string(value, length);
-    }();
+    const auto str = convert_string_or_buffer(value);
 
     if (zmq_leave(socket, str.c_str()) < 0) {
         ErrnoException(Env(), zmq_errno()).ThrowAsJavaScriptException();

src/socket.h

@@ -73,6 +73,9 @@ class Socket : public Napi::ObjectWrap<Socket>, public Closable {
     force_inline void Send(const Napi::Promise::Deferred& res, OutgoingMsg::Parts& parts);
     force_inline void Receive(const Napi::Promise::Deferred& res);
 
+    inline void JoinElement(const Napi::Value& value);
+    inline void LeaveElement(const Napi::Value& value);
+
     class Poller : public zmq::Poller<Poller> {
         std::reference_wrapper<Socket> socket;
         std::optional<Napi::Promise::Deferred> read_deferred;

src/util/arguments.h

@@ -88,7 +88,8 @@ class Validator {
         if constexpr (I == NumArgs) {
             if (info.Length() > NumArgs) {
                 auto msg = "Expected " + std::to_string(NumArgs) + " argument"
-                    + (NumArgs != 1 ? "s" : "");
+                    + (NumArgs != 1 ? "s" : "") + " but received "
+                    + std::to_string(info.Length());
                 return Napi::TypeError::New(info.Env(), msg);
             }
 

src/util/string_or_buffer.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <napi.h>
+
+#include <string>
+
+namespace zmq {
+
+inline std::string convert_string_or_buffer(const Napi::Value& value) {
+    if (value.IsString()) {
+        return std::string(value.As<Napi::String>());
+    }
+    if (value.IsBuffer()) {
+        auto buf = value.As<Napi::Object>();
+        auto length = buf.As<Napi::Buffer<char>>().Length();
+        auto* value = buf.As<Napi::Buffer<char>>().Data();
+        return {value, length};
+    }
+    throw Napi::TypeError::New(value.Env(), "Value must be a string or buffer");
+}
+
+}  // namespace zmq