node-datachannel 0.29.0 → 0.30.0

package/src/cpp/web-socket-wrapper.cpp

@@ -7,763 +7,790 @@ std::unordered_set<WebSocketWrapper *> WebSocketWrapper::instances;
 
 void WebSocketWrapper::CloseAll()
 {
-    PLOG_DEBUG << "CloseAll() called";
-    auto copy(instances);
-    for (auto inst : copy)
-        inst->doClose();
+  PLOG_DEBUG << "CloseAll() called";
+  auto copy(instances);
+  for (auto inst : copy)
+    inst->doClose();
 }
 
 void WebSocketWrapper::CleanupAll()
 {
-    PLOG_DEBUG << "CleanupAll() called";
-    auto copy(instances);
-    for (auto inst : copy)
-        inst->doCleanup();
+  PLOG_DEBUG << "CleanupAll() called";
+  auto copy(instances);
+  for (auto inst : copy)
+    inst->doCleanup();
 }
 
 Napi::Object WebSocketWrapper::Init(Napi::Env env, Napi::Object exports)
 {
-    Napi::HandleScope scope(env);
-
-    Napi::Function func = DefineClass(
-        env,
-        "WebSocket",
-        {
-            InstanceMethod("open", &WebSocketWrapper::open),
-            InstanceMethod("close", &WebSocketWrapper::close),
-            InstanceMethod("forceClose", &WebSocketWrapper::forceClose),
-            InstanceMethod("sendMessage", &WebSocketWrapper::sendMessage),
-            InstanceMethod("sendMessageBinary", &WebSocketWrapper::sendMessageBinary),
-            InstanceMethod("isOpen", &WebSocketWrapper::isOpen),
-            InstanceMethod("bufferedAmount", &WebSocketWrapper::bufferedAmount),
-            InstanceMethod("maxMessageSize", &WebSocketWrapper::maxMessageSize),
-            InstanceMethod("setBufferedAmountLowThreshold", &WebSocketWrapper::setBufferedAmountLowThreshold),
-            InstanceMethod("onOpen", &WebSocketWrapper::onOpen),
-            InstanceMethod("onClosed", &WebSocketWrapper::onClosed),
-            InstanceMethod("onError", &WebSocketWrapper::onError),
-            InstanceMethod("onBufferedAmountLow", &WebSocketWrapper::onBufferedAmountLow),
-            InstanceMethod("onMessage", &WebSocketWrapper::onMessage),
-            InstanceMethod("remoteAddress", &WebSocketWrapper::remoteAddress),
-            InstanceMethod("path", &WebSocketWrapper::path),
-        });
-
-    // If this is not the first call, we don't want to reassign the constructor (hot-reload problem)
-    if(constructor.IsEmpty())
-    {
-        constructor = Napi::Persistent(func);
-        constructor.SuppressDestruct();
-    }
-
-    exports.Set("WebSocket", func);
-    return exports;
+  Napi::HandleScope scope(env);
+
+  Napi::Function func =
+      DefineClass(env, "WebSocket",
+                  {
+                      InstanceMethod("open", &WebSocketWrapper::open),
+                      InstanceMethod("close", &WebSocketWrapper::close),
+                      InstanceMethod("forceClose", &WebSocketWrapper::forceClose),
+                      InstanceMethod("sendMessage", &WebSocketWrapper::sendMessage),
+                      InstanceMethod("sendMessageBinary", &WebSocketWrapper::sendMessageBinary),
+                      InstanceMethod("isOpen", &WebSocketWrapper::isOpen),
+                      InstanceMethod("bufferedAmount", &WebSocketWrapper::bufferedAmount),
+                      InstanceMethod("maxMessageSize", &WebSocketWrapper::maxMessageSize),
+                      InstanceMethod("setBufferedAmountLowThreshold", &WebSocketWrapper::setBufferedAmountLowThreshold),
+                      InstanceMethod("onOpen", &WebSocketWrapper::onOpen),
+                      InstanceMethod("onClosed", &WebSocketWrapper::onClosed),
+                      InstanceMethod("onError", &WebSocketWrapper::onError),
+                      InstanceMethod("onBufferedAmountLow", &WebSocketWrapper::onBufferedAmountLow),
+                      InstanceMethod("onMessage", &WebSocketWrapper::onMessage),
+                      InstanceMethod("remoteAddress", &WebSocketWrapper::remoteAddress),
+                      InstanceMethod("path", &WebSocketWrapper::path),
+                  });
+
+  // If this is not the first call, we don't want to reassign the constructor (hot-reload problem)
+  if (constructor.IsEmpty())
+  {
+    constructor = Napi::Persistent(func);
+    constructor.SuppressDestruct();
+  }
+
+  exports.Set("WebSocket", func);
+  return exports;
 }
 
 WebSocketWrapper::WebSocketWrapper(const Napi::CallbackInfo &info) : Napi::ObjectWrap<WebSocketWrapper>(info)
 {
-    PLOG_DEBUG << "Constructor called";
-    Napi::Env env = info.Env();
+  PLOG_DEBUG << "Constructor called";
+  Napi::Env env = info.Env();
+
+  // Create WebSocket using rtc::WebSocket provided by WebSocketServer
+  if (info.Length() > 1)
+  {
+    mWebSocketPtr = *(info[1].As<Napi::External<std::shared_ptr<rtc::WebSocket>>>().Data());
+    PLOG_DEBUG << "Using WebSocket got from WebSocketServer";
+    instances.insert(this);
 
-    // Create WebSocket using rtc::WebSocket provided by WebSocketServer
-    if (info.Length() > 1)
-    {
-        mWebSocketPtr = *(info[1].As<Napi::External<std::shared_ptr<rtc::WebSocket>>>().Data());
-        PLOG_DEBUG << "Using WebSocket got from WebSocketServer";
-        instances.insert(this);
+    // Closed callback must be set to trigger cleanup
+    mOnClosedCallback =
+        std::make_unique<ThreadSafeCallback>(Napi::Function::New(info.Env(), [](const Napi::CallbackInfo &) {}));
+    return;
+  }
 
-        // Closed callback must be set to trigger cleanup
-        mOnClosedCallback = std::make_unique<ThreadSafeCallback>(Napi::Function::New(info.Env(), [](const Napi::CallbackInfo &) {}));
-        return;
+  // Create WebSocket without config
+  if (info.Length() == 0)
+  {
+    try
+    {
+      PLOG_DEBUG << "Creating a new WebSocket without config";
+      mWebSocketPtr = std::make_unique<rtc::WebSocket>();
     }
-
-    // Create WebSocket without config
-    if (info.Length() == 0)
+    catch (std::exception &ex)
     {
-        try
-        {
-            PLOG_DEBUG << "Creating a new WebSocket without config";
-            mWebSocketPtr = std::make_unique<rtc::WebSocket>();
-        }
-        catch (std::exception &ex)
-        {
-            Napi::Error::New(env, std::string("libdatachannel error while creating WebSocket without config: ") + ex.what()).ThrowAsJavaScriptException();
-            return;
-        }
-        instances.insert(this);
-
-        // Closed callback must be set to trigger cleanup
-        mOnClosedCallback = std::make_unique<ThreadSafeCallback>(Napi::Function::New(info.Env(), [](const Napi::CallbackInfo &) {}));
-        return;
+      Napi::Error::New(env, std::string("libdatachannel error while creating WebSocket without config: ") + ex.what())
+          .ThrowAsJavaScriptException();
+      return;
     }
+    instances.insert(this);
 
-    // Create WebSocket with config
-    PLOG_DEBUG << "Creating a new WebSocket with config";
+    // Closed callback must be set to trigger cleanup
+    mOnClosedCallback =
+        std::make_unique<ThreadSafeCallback>(Napi::Function::New(info.Env(), [](const Napi::CallbackInfo &) {}));
+    return;
+  }
 
-    Napi::Object config = info[0].As<Napi::Object>();
-    rtc::WebSocketConfiguration webSocketConfig;
+  // Create WebSocket with config
+  PLOG_DEBUG << "Creating a new WebSocket with config";
 
-    if (config.Has("disableTlsVerification"))
+  Napi::Object config = info[0].As<Napi::Object>();
+  rtc::WebSocketConfiguration webSocketConfig;
+
+  if (config.Has("disableTlsVerification"))
+  {
+    if (!config.Get("disableTlsVerification").IsBoolean())
     {
-        if (!config.Get("disableTlsVerification").IsBoolean())
-        {
-            Napi::TypeError::New(info.Env(), "disableTlsVerification must be boolean").ThrowAsJavaScriptException();
-            return;
-        }
-        webSocketConfig.disableTlsVerification = config.Get("disableTlsVerification").ToBoolean();
+      Napi::TypeError::New(info.Env(), "disableTlsVerification must be boolean").ThrowAsJavaScriptException();
+      return;
     }
+    webSocketConfig.disableTlsVerification = config.Get("disableTlsVerification").ToBoolean();
+  }
 
-    // Proxy Server
-    if (config.Has("proxyServer") && config.Get("proxyServer").IsObject())
-    {
-        Napi::Object proxyServer = config.Get("proxyServer").As<Napi::Object>();
+  // Proxy Server
+  if (config.Has("proxyServer") && config.Get("proxyServer").IsObject())
+  {
+    Napi::Object proxyServer = config.Get("proxyServer").As<Napi::Object>();
 
-        // IP
-        std::string ip = proxyServer.Get("ip").As<Napi::String>();
+    // IP
+    std::string ip = proxyServer.Get("ip").As<Napi::String>();
 
-        // Port
-        uint16_t port = proxyServer.Get("port").As<Napi::Number>().Uint32Value();
+    // Port
+    uint16_t port = proxyServer.Get("port").As<Napi::Number>().Uint32Value();
 
-        // Type
-        std::string strType = proxyServer.Get("type").As<Napi::String>().ToString();
-        rtc::ProxyServer::Type type = rtc::ProxyServer::Type::Http;
+    // Type
+    std::string strType = proxyServer.Get("type").As<Napi::String>().ToString();
+    rtc::ProxyServer::Type type = rtc::ProxyServer::Type::Http;
 
-        if (strType == "Socks5")
-            type = rtc::ProxyServer::Type::Socks5;
+    if (strType == "Socks5")
+      type = rtc::ProxyServer::Type::Socks5;
 
-        // Username & Password
-        std::string username = "";
-        std::string password = "";
+    // Username & Password
+    std::string username = "";
+    std::string password = "";
 
-        if (proxyServer.Get("username").IsString())
-            username = proxyServer.Get("username").As<Napi::String>().ToString();
-        if (proxyServer.Get("password").IsString())
-            password = proxyServer.Get("password").As<Napi::String>().ToString();
+    if (proxyServer.Get("username").IsString())
+      username = proxyServer.Get("username").As<Napi::String>().ToString();
+    if (proxyServer.Get("password").IsString())
+      password = proxyServer.Get("password").As<Napi::String>().ToString();
 
-        webSocketConfig.proxyServer = rtc::ProxyServer(type, ip, port, username, password);
-    }
+    webSocketConfig.proxyServer = rtc::ProxyServer(type, ip, port, username, password);
+  }
 
-    if (config.Has("protocols"))
+  if (config.Has("protocols"))
+  {
+    if (!config.Get("protocols").IsArray())
     {
-        if (!config.Get("protocols").IsArray())
-        {
-            Napi::TypeError::New(info.Env(), "protocols must be an array").ThrowAsJavaScriptException();
-            return;
-        }
-        Napi::Array protocols = config.Get("protocols").As<Napi::Array>();
-        for (uint32_t i = 0; i < protocols.Length(); i++)
-        {
-            webSocketConfig.protocols.push_back(protocols.Get(i).ToString());
-        }
+      Napi::TypeError::New(info.Env(), "protocols must be an array").ThrowAsJavaScriptException();
+      return;
     }
-
-    if (config.Has("connectionTimeout"))
+    Napi::Array protocols = config.Get("protocols").As<Napi::Array>();
+    for (uint32_t i = 0; i < protocols.Length(); i++)
     {
-        if (!config.Get("connectionTimeout").IsNumber())
-        {
-            Napi::TypeError::New(info.Env(), "connectionTimeout must be a number").ThrowAsJavaScriptException();
-            return;
-        }
-        webSocketConfig.connectionTimeout = std::chrono::milliseconds(config.Get("connectionTimeout").ToNumber().Int64Value());
+      webSocketConfig.protocols.push_back(protocols.Get(i).ToString());
     }
+  }
 
-    if (config.Has("pingInterval"))
+  if (config.Has("connectionTimeout"))
+  {
+    if (!config.Get("connectionTimeout").IsNumber())
     {
-        if (!config.Get("pingInterval").IsNumber())
-        {
-            Napi::TypeError::New(info.Env(), "pingInterval must be a number").ThrowAsJavaScriptException();
-            return;
-        }
-        webSocketConfig.pingInterval = std::chrono::milliseconds(config.Get("pingInterval").ToNumber().Int64Value());
+      Napi::TypeError::New(info.Env(), "connectionTimeout must be a number").ThrowAsJavaScriptException();
+      return;
     }
+    webSocketConfig.connectionTimeout =
+        std::chrono::milliseconds(config.Get("connectionTimeout").ToNumber().Int64Value());
+  }
 
-    if (config.Has("maxOutstandingPings"))
+  if (config.Has("pingInterval"))
+  {
+    if (!config.Get("pingInterval").IsNumber())
     {
-        if (!config.Get("maxOutstandingPings").IsNumber())
-        {
-            Napi::TypeError::New(info.Env(), "maxOutstandingPings must be a number").ThrowAsJavaScriptException();
-            return;
-        }
-        webSocketConfig.maxOutstandingPings = config.Get("maxOutstandingPings").ToNumber().Int32Value();
+      Napi::TypeError::New(info.Env(), "pingInterval must be a number").ThrowAsJavaScriptException();
+      return;
     }
+    webSocketConfig.pingInterval = std::chrono::milliseconds(config.Get("pingInterval").ToNumber().Int64Value());
+  }
 
-    if (config.Has("caCertificatePemFile"))
+  if (config.Has("maxOutstandingPings"))
+  {
+    if (!config.Get("maxOutstandingPings").IsNumber())
     {
-        if (!config.Get("caCertificatePemFile").IsString())
-        {
-            Napi::TypeError::New(info.Env(), "caCertificatePemFile must be a string").ThrowAsJavaScriptException();
-            return;
-        }
-        webSocketConfig.caCertificatePemFile = config.Get("caCertificatePemFile").ToString();
+      Napi::TypeError::New(info.Env(), "maxOutstandingPings must be a number").ThrowAsJavaScriptException();
+      return;
     }
+    webSocketConfig.maxOutstandingPings = config.Get("maxOutstandingPings").ToNumber().Int32Value();
+  }
 
-    if (config.Has("certificatePemFile"))
+  if (config.Has("caCertificatePemFile"))
+  {
+    if (!config.Get("caCertificatePemFile").IsString())
     {
-        if (!config.Get("certificatePemFile").IsString())
-        {
-            Napi::TypeError::New(info.Env(), "certificatePemFile must be a string").ThrowAsJavaScriptException();
-            return;
-        }
-        webSocketConfig.certificatePemFile = config.Get("certificatePemFile").ToString();
+      Napi::TypeError::New(info.Env(), "caCertificatePemFile must be a string").ThrowAsJavaScriptException();
+      return;
     }
+    webSocketConfig.caCertificatePemFile = config.Get("caCertificatePemFile").ToString();
+  }
 
-    if (config.Has("keyPemFile"))
+  if (config.Has("certificatePemFile"))
+  {
+    if (!config.Get("certificatePemFile").IsString())
     {
-        if (!config.Get("keyPemFile").IsString())
-        {
-            Napi::TypeError::New(info.Env(), "keyPemFile must be a string").ThrowAsJavaScriptException();
-            return;
-        }
-        webSocketConfig.keyPemFile = config.Get("keyPemFile").ToString();
+      Napi::TypeError::New(info.Env(), "certificatePemFile must be a string").ThrowAsJavaScriptException();
+      return;
     }
+    webSocketConfig.certificatePemFile = config.Get("certificatePemFile").ToString();
+  }
 
-    if (config.Has("keyPemPass"))
+  if (config.Has("keyPemFile"))
+  {
+    if (!config.Get("keyPemFile").IsString())
     {
-        if (!config.Get("keyPemPass").IsString())
-        {
-            Napi::TypeError::New(info.Env(), "keyPemPass must be a string").ThrowAsJavaScriptException();
-            return;
-        }
-        webSocketConfig.keyPemPass = config.Get("keyPemPass").ToString();
+      Napi::TypeError::New(info.Env(), "keyPemFile must be a string").ThrowAsJavaScriptException();
+      return;
     }
+    webSocketConfig.keyPemFile = config.Get("keyPemFile").ToString();
+  }
 
-    if (config.Has("maxMessageSize"))
+  if (config.Has("keyPemPass"))
+  {
+    if (!config.Get("keyPemPass").IsString())
     {
-        if (!config.Get("maxMessageSize").IsNumber())
-        {
-            Napi::TypeError::New(info.Env(), "maxMessageSize must be a number").ThrowAsJavaScriptException();
-            return;
-        }
-        webSocketConfig.maxMessageSize = config.Get("maxMessageSize").ToNumber().Int32Value();
+      Napi::TypeError::New(info.Env(), "keyPemPass must be a string").ThrowAsJavaScriptException();
+      return;
     }
+    webSocketConfig.keyPemPass = config.Get("keyPemPass").ToString();
+  }
 
-    // Create WebSocket
-    try
+  if (config.Has("maxMessageSize"))
+  {
+    if (!config.Get("maxMessageSize").IsNumber())
     {
-        PLOG_DEBUG << "Creating a new WebSocket";
-        mWebSocketPtr = std::make_unique<rtc::WebSocket>(webSocketConfig);
-    }
-    catch (std::exception &ex)
-    {
-        Napi::Error::New(env, std::string("libdatachannel error while creating WebSocket: ") + ex.what()).ThrowAsJavaScriptException();
-        return;
+      Napi::TypeError::New(info.Env(), "maxMessageSize must be a number").ThrowAsJavaScriptException();
+      return;
     }
+    webSocketConfig.maxMessageSize = config.Get("maxMessageSize").ToNumber().Int32Value();
+  }
 
-    PLOG_DEBUG << "WebSocket created";
+  // Create WebSocket
+  try
+  {
+    PLOG_DEBUG << "Creating a new WebSocket";
+    mWebSocketPtr = std::make_unique<rtc::WebSocket>(webSocketConfig);
+  }
+  catch (std::exception &ex)
+  {
+    Napi::Error::New(env, std::string("libdatachannel error while creating WebSocket: ") + ex.what())
+        .ThrowAsJavaScriptException();
+    return;
+  }
 
-    // Closed callback must set to trigger cleanup
-    mOnClosedCallback = std::make_unique<ThreadSafeCallback>(Napi::Function::New(info.Env(), [](const Napi::CallbackInfo &) {}));
+  PLOG_DEBUG << "WebSocket created";
 
-    instances.insert(this);
+  // Closed callback must set to trigger cleanup
+  mOnClosedCallback =
+      std::make_unique<ThreadSafeCallback>(Napi::Function::New(info.Env(), [](const Napi::CallbackInfo &) {}));
+
+  instances.insert(this);
 }
 
 WebSocketWrapper::~WebSocketWrapper()
 {
-    PLOG_DEBUG << "Destructor called";
-    doClose();
+  PLOG_DEBUG << "Destructor called";
+  doClose();
 }
 
 void WebSocketWrapper::doClose()
 {
-    PLOG_DEBUG << "doClose() called";
-    if (mWebSocketPtr)
+  PLOG_DEBUG << "doClose() called";
+  if (mWebSocketPtr)
+  {
+    PLOG_DEBUG << "Closing...";
+    try
     {
-        PLOG_DEBUG << "Closing...";
-        try
-        {
-            mWebSocketPtr->close();
-            mWebSocketPtr.reset();
-        }
-        catch (std::exception &ex)
-        {
-            std::cerr << std::string("libdatachannel error while closing WebSocket: ") + ex.what() << std::endl;
-            return;
-        }
+      mWebSocketPtr->close();
+      mWebSocketPtr.reset();
     }
+    catch (std::exception &ex)
+    {
+      std::cerr << std::string("libdatachannel error while closing WebSocket: ") + ex.what() << std::endl;
+      return;
+    }
+  }
 
-    mOnOpenCallback.reset();
-    mOnErrorCallback.reset();
-    mOnBufferedAmountLowCallback.reset();
-    mOnMessageCallback.reset();
+  mOnOpenCallback.reset();
+  mOnErrorCallback.reset();
+  mOnBufferedAmountLowCallback.reset();
+  mOnMessageCallback.reset();
 }
 
 void WebSocketWrapper::doForceClose()
 {
-    PLOG_DEBUG << "doForceClose() called";
-    if (mWebSocketPtr)
+  PLOG_DEBUG << "doForceClose() called";
+  if (mWebSocketPtr)
+  {
+    PLOG_DEBUG << "Force closing...";
+    try
     {
-        PLOG_DEBUG << "Force closing...";
-        try
-        {
-            mWebSocketPtr->forceClose();
-            mWebSocketPtr.reset();
-        }
-        catch (std::exception &ex)
-        {
-            std::cerr << std::string("libdatachannel error while force closing WebSocket: ") + ex.what() << std::endl;
-            return;
-        }
+      mWebSocketPtr->forceClose();
+      mWebSocketPtr.reset();
+    }
+    catch (std::exception &ex)
+    {
+      std::cerr << std::string("libdatachannel error while force closing WebSocket: ") + ex.what() << std::endl;
+      return;
     }
+  }
 
-    mOnOpenCallback.reset();
-    mOnErrorCallback.reset();
-    mOnBufferedAmountLowCallback.reset();
-    mOnMessageCallback.reset();
+  mOnOpenCallback.reset();
+  mOnErrorCallback.reset();
+  mOnBufferedAmountLowCallback.reset();
+  mOnMessageCallback.reset();
 }
 
 void WebSocketWrapper::doCleanup()
 {
-    PLOG_DEBUG << "doCleanup() called";
-    mOnClosedCallback.reset();
-    instances.erase(this);
+  PLOG_DEBUG << "doCleanup() called";
+  mOnClosedCallback.reset();
+  instances.erase(this);
 }
 
 void WebSocketWrapper::open(const Napi::CallbackInfo &info)
 {
-    PLOG_DEBUG << "open() called";
-    Napi::Env env = info.Env();
-
-    if (!mWebSocketPtr)
-    {
-        Napi::Error::New(env, "open() called on destroyed WebSocket").ThrowAsJavaScriptException();
-        return;
-    }
-    if (info.Length() < 1 || !info[0].IsString())
-    {
-        Napi::TypeError::New(env, "url must be string").ThrowAsJavaScriptException();
-        return;
-    }
-
-    try
-    {
-        mWebSocketPtr->open(info[0].As<Napi::String>().ToString());
-    }
-    catch (std::exception &ex)
-    {
-        Napi::Error::New(env, std::string("libdatachannel error while opening WebSocket: ") + ex.what()).ThrowAsJavaScriptException();
-        return;
-    }
+  PLOG_DEBUG << "open() called";
+  Napi::Env env = info.Env();
+
+  if (!mWebSocketPtr)
+  {
+    Napi::Error::New(env, "open() called on destroyed WebSocket").ThrowAsJavaScriptException();
+    return;
+  }
+  if (info.Length() < 1 || !info[0].IsString())
+  {
+    Napi::TypeError::New(env, "url must be string").ThrowAsJavaScriptException();
+    return;
+  }
+
+  try
+  {
+    mWebSocketPtr->open(info[0].As<Napi::String>().ToString());
+  }
+  catch (std::exception &ex)
+  {
+    Napi::Error::New(env, std::string("libdatachannel error while opening WebSocket: ") + ex.what())
+        .ThrowAsJavaScriptException();
+    return;
+  }
 }
 
 void WebSocketWrapper::close(const Napi::CallbackInfo &info)
 {
-    PLOG_DEBUG << "close() called";
-    doClose();
+  PLOG_DEBUG << "close() called";
+  doClose();
 }
 
 void WebSocketWrapper::forceClose(const Napi::CallbackInfo &info)
 {
-    PLOG_DEBUG << "forceClose() called";
-    doForceClose();
+  PLOG_DEBUG << "forceClose() called";
+  doForceClose();
 }
 
 Napi::Value WebSocketWrapper::sendMessage(const Napi::CallbackInfo &info)
 {
-    PLOG_DEBUG << "sendMessage() called";
-    if (!mWebSocketPtr)
-    {
-        Napi::Error::New(info.Env(), "sendMessage() called on destroyed channel").ThrowAsJavaScriptException();
-        return info.Env().Null();
-    }
-
-    Napi::Env env = info.Env();
-    int length = info.Length();
-
-    // Allow call with NULL
-    if (length < 1 || (!info[0].IsString() && !info[0].IsNull()))
-    {
-        Napi::TypeError::New(env, "String or Null expected").ThrowAsJavaScriptException();
-        return info.Env().Null();
-    }
-
-    try
-    {
-        return Napi::Boolean::New(info.Env(), mWebSocketPtr->send(info[0].As<Napi::String>().ToString()));
-    }
-    catch (std::exception &ex)
-    {
-        Napi::Error::New(env, std::string("libdatachannel error while sending data channel message: ") + ex.what()).ThrowAsJavaScriptException();
-        return Napi::Boolean::New(info.Env(), false);
-    }
+  PLOG_DEBUG << "sendMessage() called";
+  if (!mWebSocketPtr)
+  {
+    Napi::Error::New(info.Env(), "sendMessage() called on destroyed channel").ThrowAsJavaScriptException();
+    return info.Env().Null();
+  }
+
+  Napi::Env env = info.Env();
+  int length = info.Length();
+
+  // Allow call with NULL
+  if (length < 1 || (!info[0].IsString() && !info[0].IsNull()))
+  {
+    Napi::TypeError::New(env, "String or Null expected").ThrowAsJavaScriptException();
+    return info.Env().Null();
+  }
+
+  try
+  {
+    return Napi::Boolean::New(info.Env(), mWebSocketPtr->send(info[0].As<Napi::String>().ToString()));
+  }
+  catch (std::exception &ex)
+  {
+    Napi::Error::New(env, std::string("libdatachannel error while sending data channel message: ") + ex.what())
+        .ThrowAsJavaScriptException();
+    return Napi::Boolean::New(info.Env(), false);
+  }
 }
 
 Napi::Value WebSocketWrapper::sendMessageBinary(const Napi::CallbackInfo &info)
 {
-    PLOG_DEBUG << "sendMessageBinary() called";
-    if (!mWebSocketPtr)
-    {
-        Napi::Error::New(info.Env(), "sendMessagBinary() called on destroyed channel").ThrowAsJavaScriptException();
-        return info.Env().Null();
-    }
-
-    Napi::Env env = info.Env();
-    int length = info.Length();
-
-    if (length < 1 || !info[0].IsBuffer())
-    {
-        Napi::TypeError::New(env, "Buffer expected").ThrowAsJavaScriptException();
-        return info.Env().Null();
-    }
-
-    try
-    {
-        Napi::Uint8Array buffer = info[0].As<Napi::Uint8Array>();
-        return Napi::Boolean::New(info.Env(), mWebSocketPtr->send((std::byte *)buffer.Data(), buffer.ByteLength()));
-    }
-    catch (std::exception &ex)
-    {
-        Napi::Error::New(env, std::string("libdatachannel error while sending data channel message: ") + ex.what()).ThrowAsJavaScriptException();
-        return Napi::Boolean::New(info.Env(), false);
-    }
+  PLOG_DEBUG << "sendMessageBinary() called";
+  if (!mWebSocketPtr)
+  {
+    Napi::Error::New(info.Env(), "sendMessagBinary() called on destroyed channel").ThrowAsJavaScriptException();
+    return info.Env().Null();
+  }
+
+  Napi::Env env = info.Env();
+  int length = info.Length();
+
+  if (length < 1 || !info[0].IsBuffer())
+  {
+    Napi::TypeError::New(env, "Buffer expected").ThrowAsJavaScriptException();
+    return info.Env().Null();
+  }
+
+  try
+  {
+    Napi::Uint8Array buffer = info[0].As<Napi::Uint8Array>();
+    return Napi::Boolean::New(info.Env(), mWebSocketPtr->send((std::byte *)buffer.Data(), buffer.ByteLength()));
+  }
+  catch (std::exception &ex)
+  {
+    Napi::Error::New(env, std::string("libdatachannel error while sending data channel message: ") + ex.what())
+        .ThrowAsJavaScriptException();
+    return Napi::Boolean::New(info.Env(), false);
+  }
 }
 
 Napi::Value WebSocketWrapper::isOpen(const Napi::CallbackInfo &info)
 {
-    PLOG_DEBUG << "isOpen() called";
-    Napi::Env env = info.Env();
-
-    if (!mWebSocketPtr)
-    {
-        return Napi::Boolean::New(info.Env(), false);
-    }
-
-    try
-    {
-        return Napi::Boolean::New(info.Env(), mWebSocketPtr->isOpen());
-    }
-    catch (std::exception &ex)
-    {
-        Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException();
-        return Napi::Boolean::New(info.Env(), false);
-    }
+  PLOG_DEBUG << "isOpen() called";
+  Napi::Env env = info.Env();
+
+  if (!mWebSocketPtr)
+  {
+    return Napi::Boolean::New(info.Env(), false);
+  }
+
+  try
+  {
+    return Napi::Boolean::New(info.Env(), mWebSocketPtr->isOpen());
+  }
+  catch (std::exception &ex)
+  {
+    Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException();
+    return Napi::Boolean::New(info.Env(), false);
+  }
 }
 
 Napi::Value WebSocketWrapper::bufferedAmount(const Napi::CallbackInfo &info)
 {
-    PLOG_DEBUG << "bufferedAmount() called";
-    Napi::Env env = info.Env();
-
-    if (!mWebSocketPtr)
-    {
-        return Napi::Number::New(info.Env(), 0);
-    }
-
-    try
-    {
-        return Napi::Number::New(info.Env(), mWebSocketPtr->bufferedAmount());
-    }
-    catch (std::exception &ex)
-    {
-        Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException();
-        return Napi::Number::New(info.Env(), 0);
-    }
+  PLOG_DEBUG << "bufferedAmount() called";
+  Napi::Env env = info.Env();
+
+  if (!mWebSocketPtr)
+  {
+    return Napi::Number::New(info.Env(), 0);
+  }
+
+  try
+  {
+    return Napi::Number::New(info.Env(), mWebSocketPtr->bufferedAmount());
+  }
+  catch (std::exception &ex)
+  {
+    Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException();
+    return Napi::Number::New(info.Env(), 0);
+  }
 }
 
 Napi::Value WebSocketWrapper::maxMessageSize(const Napi::CallbackInfo &info)
 {
-    PLOG_DEBUG << "maxMessageSize() called";
-    Napi::Env env = info.Env();
-
-    if (!mWebSocketPtr)
-    {
-        return Napi::Number::New(info.Env(), 0);
-    }
-
-    try
-    {
-        return Napi::Number::New(info.Env(), mWebSocketPtr->maxMessageSize());
-    }
-    catch (std::exception &ex)
-    {
-        Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException();
-        return Napi::Number::New(info.Env(), 0);
-    }
+  PLOG_DEBUG << "maxMessageSize() called";
+  Napi::Env env = info.Env();
+
+  if (!mWebSocketPtr)
+  {
+    return Napi::Number::New(info.Env(), 0);
+  }
+
+  try
+  {
+    return Napi::Number::New(info.Env(), mWebSocketPtr->maxMessageSize());
+  }
+  catch (std::exception &ex)
+  {
+    Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException();
+    return Napi::Number::New(info.Env(), 0);
+  }
 }
 
 Napi::Value WebSocketWrapper::remoteAddress(const Napi::CallbackInfo &info)
 {
-    PLOG_DEBUG << "remoteAddress() called";
-    Napi::Env env = info.Env();
+  PLOG_DEBUG << "remoteAddress() called";
+  Napi::Env env = info.Env();
 
-    if (!mWebSocketPtr)
-    {
-        return env.Undefined();
-    }
+  if (!mWebSocketPtr)
+  {
+    return env.Undefined();
+  }
 
-    try
+  try
+  {
+    auto address = mWebSocketPtr->remoteAddress();
+    if (address.has_value())
     {
-        auto address = mWebSocketPtr->remoteAddress();
-        if (address.has_value())
-        {
-            return Napi::String::New(info.Env(), address.value());
-        }
-        else
-        {
-            return env.Undefined();
-        }
+      return Napi::String::New(info.Env(), address.value());
     }
-    catch (std::exception &ex)
+    else
     {
-        Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException();
-        return env.Undefined();
+      return env.Undefined();
     }
+  }
+  catch (std::exception &ex)
+  {
+    Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
 }
 
 Napi::Value WebSocketWrapper::path(const Napi::CallbackInfo &info)
 {
-    PLOG_DEBUG << "path() called";
-    Napi::Env env = info.Env();
+  PLOG_DEBUG << "path() called";
+  Napi::Env env = info.Env();
 
-    if (!mWebSocketPtr)
-    {
-        return env.Undefined();
-    }
+  if (!mWebSocketPtr)
+  {
+    return env.Undefined();
+  }
 
-    try
+  try
+  {
+    auto path = mWebSocketPtr->path();
+    if (path.has_value())
     {
-        auto path = mWebSocketPtr->path();
-        if (path.has_value())
-        {
-            return Napi::String::New(info.Env(), path.value());
-        }
-        else
-        {
-            return env.Undefined();
-        }
+      return Napi::String::New(info.Env(), path.value());
     }
-    catch (std::exception &ex)
+    else
     {
-        Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException();
-        return env.Undefined();
+      return env.Undefined();
     }
+  }
+  catch (std::exception &ex)
+  {
+    Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
 }
 
 void WebSocketWrapper::setBufferedAmountLowThreshold(const Napi::CallbackInfo &info)
 {
-    PLOG_DEBUG << "setBufferedAmountLowThreshold() called";
-    if (!mWebSocketPtr)
-    {
-        Napi::Error::New(info.Env(), "setBufferedAmountLowThreshold() called on destroyed channel").ThrowAsJavaScriptException();
-        return;
-    }
-
-    Napi::Env env = info.Env();
-    int length = info.Length();
-
-    if (length < 1 || !info[0].IsNumber())
-    {
-        Napi::TypeError::New(env, "Number expected").ThrowAsJavaScriptException();
-        return;
-    }
-
-    try
-    {
-        mWebSocketPtr->setBufferedAmountLowThreshold(info[0].ToNumber().Uint32Value());
-    }
-    catch (std::exception &ex)
-    {
-        Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException();
-        return;
-    }
+  PLOG_DEBUG << "setBufferedAmountLowThreshold() called";
+  if (!mWebSocketPtr)
+  {
+    Napi::Error::New(info.Env(), "setBufferedAmountLowThreshold() called on destroyed channel")
+        .ThrowAsJavaScriptException();
+    return;
+  }
+
+  Napi::Env env = info.Env();
+  int length = info.Length();
+
+  if (length < 1 || !info[0].IsNumber())
+  {
+    Napi::TypeError::New(env, "Number expected").ThrowAsJavaScriptException();
+    return;
+  }
+
+  try
+  {
+    mWebSocketPtr->setBufferedAmountLowThreshold(info[0].ToNumber().Uint32Value());
+  }
+  catch (std::exception &ex)
+  {
+    Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException();
+    return;
+  }
 }
 
 void WebSocketWrapper::onOpen(const Napi::CallbackInfo &info)
 {
-    PLOG_DEBUG << "new onOpen() called";
-    if (!mWebSocketPtr)
-    {
-        Napi::Error::New(info.Env(), "onOpen() called on destroyed channel").ThrowAsJavaScriptException();
-        return;
-    }
-
-    Napi::Env env = info.Env();
-    int length = info.Length();
-
-    if (length < 1 || !info[0].IsFunction())
-    {
-        Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
-        return;
-    }
+  PLOG_DEBUG << "new onOpen() called";
+  if (!mWebSocketPtr)
+  {
+    Napi::Error::New(info.Env(), "onOpen() called on destroyed channel").ThrowAsJavaScriptException();
+    return;
+  }
+
+  Napi::Env env = info.Env();
+  int length = info.Length();
+
+  if (length < 1 || !info[0].IsFunction())
+  {
+    Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
+    return;
+  }
+
+  // Callback
+  mOnOpenCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
+
+  mWebSocketPtr->onOpen(
+      [&]()
+      {
+    PLOG_DEBUG << "onOpen cb received from rtc";
+
+    if (mOnOpenCallback)
+      mOnOpenCallback->call(
+          [this](Napi::Env env, std::vector<napi_value> &args)
+          {
+        PLOG_DEBUG << "mOnOpenCallback call(1)";
+        // Check the WebSocket is not closed
+        if (instances.find(this) == instances.end())
+        {
+          PLOG_DEBUG << "WebSocket not found in instances";
+          throw ThreadSafeCallback::CancelException();
+        }
 
-    // Callback
-    mOnOpenCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
-
-    mWebSocketPtr->onOpen([&]()
-                          {
-                              PLOG_DEBUG << "onOpen cb received from rtc";
-
-                              if (mOnOpenCallback)
-                                  mOnOpenCallback->call([this](Napi::Env env, std::vector<napi_value> &args)
-                                                        {
-                    PLOG_DEBUG << "mOnOpenCallback call(1)";
-                    // Check the WebSocket is not closed
-                    if(instances.find(this) == instances.end())
-                        {
-                            PLOG_DEBUG << "WebSocket not found in instances";
-                            throw ThreadSafeCallback::CancelException();
-                        }
-
-
-                    // This will run in main thread and needs to construct the
-                    // arguments for the call
-                    args = {};
-                    PLOG_DEBUG << "mOnOpenCallback call(2)"; }); });
+        // This will run in main thread and needs to construct the
+        // arguments for the call
+        args = {};
+        PLOG_DEBUG << "mOnOpenCallback call(2)";
+      });
+  });
 }
 
 void WebSocketWrapper::onClosed(const Napi::CallbackInfo &info)
 {
-    PLOG_DEBUG << "onClosed() called";
-    if (!mWebSocketPtr)
-    {
-        Napi::Error::New(info.Env(), "onClosed() called on destroyed WebSocket").ThrowAsJavaScriptException();
-        return;
-    }
-
-    Napi::Env env = info.Env();
-    int length = info.Length();
-
-    if (length < 1 || !info[0].IsFunction())
-    {
-        Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
-        return;
-    }
-
-    // Callback
-    mOnClosedCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
-
-    mWebSocketPtr->onClosed([&]()
-                            {
-        PLOG_DEBUG << "onClosed cb received from rtc";
-        if (mOnClosedCallback)
-            mOnClosedCallback->call([this](Napi::Env env, std::vector<napi_value> &args) {
-                PLOG_DEBUG << "mOnClosedCallback call";
-                // Do not check if the data channel has been closed here
-
-                // This will run in main thread and needs to construct the
-                // arguments for the call
-                args = {};
-            },[this]{
-                doCleanup();
-            }); });
+  PLOG_DEBUG << "onClosed() called";
+  if (!mWebSocketPtr)
+  {
+    Napi::Error::New(info.Env(), "onClosed() called on destroyed WebSocket").ThrowAsJavaScriptException();
+    return;
+  }
+
+  Napi::Env env = info.Env();
+  int length = info.Length();
+
+  if (length < 1 || !info[0].IsFunction())
+  {
+    Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
+    return;
+  }
+
+  // Callback
+  mOnClosedCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
+
+  mWebSocketPtr->onClosed(
+      [&]()
+      {
+    PLOG_DEBUG << "onClosed cb received from rtc";
+    if (mOnClosedCallback)
+      mOnClosedCallback->call(
+          [this](Napi::Env env, std::vector<napi_value> &args)
+          {
+        PLOG_DEBUG << "mOnClosedCallback call";
+        // Do not check if the data channel has been closed here
+
+        // This will run in main thread and needs to construct the
+        // arguments for the call
+        args = {};
+          },
+          [this] { doCleanup(); });
+  });
 }
 
 void WebSocketWrapper::onError(const Napi::CallbackInfo &info)
 {
-    PLOG_DEBUG << "onError() called";
-    if (!mWebSocketPtr)
-    {
-        Napi::Error::New(info.Env(), "onError() called on destroyed channel").ThrowAsJavaScriptException();
-        return;
-    }
-
-    Napi::Env env = info.Env();
-    int length = info.Length();
-
-    if (length < 1 || !info[0].IsFunction())
-    {
-        Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
-        return;
-    }
-
-    // Callback
-    mOnErrorCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
-
-    mWebSocketPtr->onError([&](std::string error)
-                           {
-        PLOG_DEBUG << "onError cb received from rtc";
-        if (mOnErrorCallback)
-            mOnErrorCallback->call([this, error = std::move(error)](Napi::Env env, std::vector<napi_value> &args) {
-                PLOG_DEBUG << "mOnErrorCallback call(1)";
-                // Check the data channel is not closed
-                if(instances.find(this) == instances.end())
-                    throw ThreadSafeCallback::CancelException();
-
-                // This will run in main thread and needs to construct the
-                // arguments for the call
-                args = {Napi::String::New(env, error)};
-                PLOG_DEBUG << "mOnErrorCallback call(2)";
-            }); });
+  PLOG_DEBUG << "onError() called";
+  if (!mWebSocketPtr)
+  {
+    Napi::Error::New(info.Env(), "onError() called on destroyed channel").ThrowAsJavaScriptException();
+    return;
+  }
+
+  Napi::Env env = info.Env();
+  int length = info.Length();
+
+  if (length < 1 || !info[0].IsFunction())
+  {
+    Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
+    return;
+  }
+
+  // Callback
+  mOnErrorCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
+
+  mWebSocketPtr->onError(
+      [&](std::string error)
+      {
+    PLOG_DEBUG << "onError cb received from rtc";
+    if (mOnErrorCallback)
+      mOnErrorCallback->call(
+          [this, error = std::move(error)](Napi::Env env, std::vector<napi_value> &args)
+          {
+        PLOG_DEBUG << "mOnErrorCallback call(1)";
+        // Check the data channel is not closed
+        if (instances.find(this) == instances.end())
+          throw ThreadSafeCallback::CancelException();
+
+        // This will run in main thread and needs to construct the
+        // arguments for the call
+        args = {Napi::String::New(env, error)};
+        PLOG_DEBUG << "mOnErrorCallback call(2)";
+      });
+  });
 }
 
 void WebSocketWrapper::onBufferedAmountLow(const Napi::CallbackInfo &info)
 {
-    PLOG_DEBUG << "onBufferedAmountLow() called";
-    if (!mWebSocketPtr)
-    {
-        Napi::Error::New(info.Env(), "onBufferedAmountLow() called on destroyed channel").ThrowAsJavaScriptException();
-        return;
-    }
-
-    Napi::Env env = info.Env();
-    int length = info.Length();
-
-    if (length < 1 || !info[0].IsFunction())
-    {
-        Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
-        return;
-    }
-
-    // Callback
-    mOnBufferedAmountLowCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
-
-    mWebSocketPtr->onBufferedAmountLow([&]()
-                                       {
-        PLOG_DEBUG << "onBufferedAmountLow cb received from rtc";
-        if (mOnBufferedAmountLowCallback)
-            mOnBufferedAmountLowCallback->call([this](Napi::Env env, std::vector<napi_value> &args) {
-                PLOG_DEBUG << "mOnBufferedAmountLowCallback call(1)";
-                // Check the data channel is not closed
-                if(instances.find(this) == instances.end())
-                    throw ThreadSafeCallback::CancelException();
-
-                // This will run in main thread and needs to construct the
-                // arguments for the call
-                args = {};
-                PLOG_DEBUG << "mOnBufferedAmountLowCallback call(2)";
-            }); });
+  PLOG_DEBUG << "onBufferedAmountLow() called";
+  if (!mWebSocketPtr)
+  {
+    Napi::Error::New(info.Env(), "onBufferedAmountLow() called on destroyed channel").ThrowAsJavaScriptException();
+    return;
+  }
+
+  Napi::Env env = info.Env();
+  int length = info.Length();
+
+  if (length < 1 || !info[0].IsFunction())
+  {
+    Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
+    return;
+  }
+
+  // Callback
+  mOnBufferedAmountLowCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
+
+  mWebSocketPtr->onBufferedAmountLow(
+      [&]()
+      {
+    PLOG_DEBUG << "onBufferedAmountLow cb received from rtc";
+    if (mOnBufferedAmountLowCallback)
+      mOnBufferedAmountLowCallback->call(
+          [this](Napi::Env env, std::vector<napi_value> &args)
+          {
+        PLOG_DEBUG << "mOnBufferedAmountLowCallback call(1)";
+        // Check the data channel is not closed
+        if (instances.find(this) == instances.end())
+          throw ThreadSafeCallback::CancelException();
+
+        // This will run in main thread and needs to construct the
+        // arguments for the call
+        args = {};
+        PLOG_DEBUG << "mOnBufferedAmountLowCallback call(2)";
+      });
+  });
 }
 
 void WebSocketWrapper::onMessage(const Napi::CallbackInfo &info)
 {
-    PLOG_DEBUG << "onMessage() called";
-    if (!mWebSocketPtr)
-    {
-        Napi::Error::New(info.Env(), "onMessage() called on destroyed channel").ThrowAsJavaScriptException();
-        return;
-    }
-
-    Napi::Env env = info.Env();
-    int length = info.Length();
-
-    if (length < 1 || !info[0].IsFunction())
-    {
-        Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
-        return;
-    }
-
-    // Callback
-    mOnMessageCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
-
-    PLOG_DEBUG << "setting onMessage cb on mWebSocketPtr";
-    mWebSocketPtr->onMessage([&](std::variant<rtc::binary, std::string> message)
-                             {
-        PLOG_DEBUG << "onMessage cb received from rtc";
-        if (mOnMessageCallback)
-            mOnMessageCallback->call([this, message = std::move(message)](Napi::Env env, std::vector<napi_value> &args) {
-                PLOG_DEBUG << "mOnMessageCallback call(1)";
-                // Check the data channel is not closed
-                if(instances.find(this) == instances.end())
-                    throw ThreadSafeCallback::CancelException();
-
-                // This will run in main thread and needs to construct the
-                // arguments for the call
-                if (std::holds_alternative<std::string>(message))
-                {
-                    args = {Napi::String::New(env, std::get<std::string>(message))};
-                }
-                else
-                {
-                    auto bin = std::get<rtc::binary>(std::move(message));
-                    args = {Napi::Buffer<std::byte>::Copy(env, bin.data(), bin.size())};
-                }
-                PLOG_DEBUG << "mOnMessageCallback call(2)";
-            }); });
+  PLOG_DEBUG << "onMessage() called";
+  if (!mWebSocketPtr)
+  {
+    Napi::Error::New(info.Env(), "onMessage() called on destroyed channel").ThrowAsJavaScriptException();
+    return;
+  }
+
+  Napi::Env env = info.Env();
+  int length = info.Length();
+
+  if (length < 1 || !info[0].IsFunction())
+  {
+    Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
+    return;
+  }
+
+  // Callback
+  mOnMessageCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
+
+  PLOG_DEBUG << "setting onMessage cb on mWebSocketPtr";
+  mWebSocketPtr->onMessage(
+      [&](std::variant<rtc::binary, std::string> message)
+      {
+    PLOG_DEBUG << "onMessage cb received from rtc";
+    if (mOnMessageCallback)
+      mOnMessageCallback->call(
+          [this, message = std::move(message)](Napi::Env env, std::vector<napi_value> &args)
+          {
+        PLOG_DEBUG << "mOnMessageCallback call(1)";
+        // Check the data channel is not closed
+        if (instances.find(this) == instances.end())
+          throw ThreadSafeCallback::CancelException();
+
+        // This will run in main thread and needs to construct the
+        // arguments for the call
+        if (std::holds_alternative<std::string>(message))
+        {
+          args = {Napi::String::New(env, std::get<std::string>(message))};
+        }
+        else
+        {
+          auto bin = std::get<rtc::binary>(std::move(message));
+          args = {Napi::Buffer<std::byte>::Copy(env, bin.data(), bin.size())};
+        }
+        PLOG_DEBUG << "mOnMessageCallback call(2)";
+      });
+  });
 }