uws-react-native 0.0.1-alpha.1

package/cpp/app/HttpResponseObject.h

@@ -0,0 +1,623 @@
+#pragma once
+
+#include <jsi/Buffer.h>
+#include <jsi/jsi.h>
+#include <utility>
+#include "RecognizedString.h"
+#include "uWebSockets/HttpResponse.h"
+
+namespace uws_react_native {
+
+struct HttpResponseObjectOptions {
+  bool disableBodyRead;
+  unsigned long maxBodySize;
+};
+
+class HttpResponseObject : public facebook::jsi::Object {
+
+private:
+  struct {
+    std::shared_ptr<facebook::react::AsyncCallback<facebook::jsi::Value>> callback = nullptr;
+    bool alreadyAborted = false;
+  } OnAbortedAssignee;
+
+  struct {
+    /**
+     * For passing ArrayBuffer
+     * - onData
+     * - onDataV2
+     * - onFullData
+     */
+    std::unique_ptr<facebook::react::AsyncCallback<facebook::jsi::Value, facebook::jsi::Value>> callback = nullptr;
+
+    /**
+     * For passing string, only for onFullDataText
+     */
+    std::unique_ptr<facebook::react::AsyncCallback<facebook::jsi::Value, facebook::jsi::Value>> callbackStr = nullptr;
+
+    std::shared_ptr<std::vector<char>> buffer = nullptr;
+
+    unsigned long maxRemainingBodyLength = 0;
+
+    bool isCallbackForFullChunk = false;
+
+    /**
+     * It's marked from TemplatedAppObject that predefined res->onDataV2 there
+     * want to stop collecting for certain condition.
+     *
+     * At the time, this boolean belong to the TemplatedAppObject only,
+     * but if the JS handler assignment for the onData, onDataText, onDataV2, onFullData, and onFullDataText is late,
+     * we invoke the handler immediately from the `this->setProperty`.
+     */
+    bool isStopCollecting = false;
+  } OnDataV2Assignee;
+
+  void setChunk(std::string_view chunk,
+                unsigned long maxRemainingBodyLength) {
+    if(!this->OnDataV2Assignee.buffer) {
+      this->OnDataV2Assignee.buffer = std::make_shared<std::vector<char>>();
+      this->OnDataV2Assignee.buffer->reserve(maxRemainingBodyLength + chunk.size()); // preallocate with hint
+    }
+    this->OnDataV2Assignee.buffer->insert(this->OnDataV2Assignee.buffer->end(), chunk.begin(), chunk.end());
+//    this->OnDataV2Assignee.chunk.append(chunk.data(), chunk.size());
+    this->OnDataV2Assignee.maxRemainingBodyLength = maxRemainingBodyLength;
+  }
+
+  /**
+   * Probably bad name,
+   * it's used either for "onData", "onDataV2", or "onFullData", and combined for "onFullDataText"
+   */
+  void invokeOnDataHandler() {
+    if(
+      !this->OnDataV2Assignee.isCallbackForFullChunk ||
+      this->OnDataV2Assignee.maxRemainingBodyLength == 0
+    ) {
+      /// HELP me the better way to pass JSI ArrayBuffer here.
+      /// with faster buffer or anything
+
+      /// I have tested that,
+      /// when we captured the buffer by reference into the lambda,
+      /// in the middle of stream, it is often giving inaccuracy of
+      /// JS ArrayBuffer.byteLength in the `onDataV2` argument
+      /// when it's compared to the maxRemainingBodyLength differentiation that captured by value.
+      /// It's still accurate when it's finished.
+
+      /// While capturing the buffer by value is often accurate.
+      /// but is it slower?
+
+      if(this->OnDataV2Assignee.callback) {
+        this->OnDataV2Assignee.callback
+          ->callWithPriority(facebook::react::SchedulerPriority::ImmediatePriority,
+                             [buffer = this->OnDataV2Assignee.buffer, maxRemainingBodyLength = this->OnDataV2Assignee.maxRemainingBodyLength](facebook::jsi::Runtime &rt, facebook::jsi::Function &cb) {
+          auto mutableBuffer = CharsMutableBuffer(buffer);
+
+          cb.call(rt,
+                  facebook::jsi::ArrayBuffer(rt, std::make_shared<CharsMutableBuffer>(std::move(mutableBuffer))),
+                  facebook::jsi::BigInt::fromUint64(rt, maxRemainingBodyLength));
+        });
+      }
+
+      if(this->OnDataV2Assignee.callbackStr) {
+        this->OnDataV2Assignee.callbackStr
+          ->callWithPriority(facebook::react::SchedulerPriority::ImmediatePriority,
+                             [buffer = this->OnDataV2Assignee.buffer, maxRemainingBodyLength = this->OnDataV2Assignee.maxRemainingBodyLength](facebook::jsi::Runtime &rt, facebook::jsi::Function &cb) {
+          cb.call(rt,
+                  std::string(buffer->begin(), buffer->end()),
+                  facebook::jsi::BigInt::fromUint64(rt, maxRemainingBodyLength));
+        });
+      }
+    }
+  }
+
+//  void preEnd(facebook::jsi::Runtime &rt) const {
+//    if(this->OnAbortedAssignee.alreadyAborted) {
+//      /// Stated from uWebSockets
+//      /// Every HttpResponse MUST have an attached abort handler.
+//      /// If you do not respond to it immediately inside of the callback.
+//      /// Returning from an Http request handler without attaching
+//      /// (by calling onAborted) an abort handler is ill-use and will terminate.
+//      /// When this event emits, the response has been aborted and may not be used.
+//      throw facebook::jsi::JSError(rt, "Cannot send response to aborted request");
+//    }
+//  }
+
+public:
+  HttpResponseObject(facebook::jsi::Runtime &rt,
+                     uWS::HttpResponse<false> *res,
+                     std::shared_ptr<facebook::react::CallInvoker> &jsInvoker,
+                     std::optional<HttpResponseObjectOptions> &&options = HttpResponseObjectOptions{ .disableBodyRead = false, .maxBodySize = 0 }) : facebook::jsi::Object(rt) {
+
+    this->setProperty(rt,
+                      "close",
+                      facebook::jsi::Function::createFromHostFunction(rt,
+                                                                      facebook::jsi::PropNameID::forUtf8(rt, "close"),
+                                                                      1,
+                                                                      [res](facebook::jsi::Runtime &rt_1,
+                                                                            const facebook::jsi::Value &thisValue,
+                                                                            const facebook::jsi::Value *arguments,
+                                                                            size_t count) -> facebook::jsi::Value {
+      res->close();
+      return {rt_1, thisValue};
+    }));
+
+    this->setProperty(rt,
+                      "cork",
+                      facebook::jsi::Function::createFromHostFunction(rt,
+                                                                      facebook::jsi::PropNameID::forUtf8(rt, "cork"),
+                                                                      1,
+                                                                      [res, &jsInvoker](facebook::jsi::Runtime &rt_1,
+                                                                                        const facebook::jsi::Value &thisValue,
+                                                                                        const facebook::jsi::Value *arguments,
+                                                                                        size_t count) -> facebook::jsi::Value {
+      auto callback = arguments[0].asObject(rt_1).asFunction(rt_1);
+
+      res->cork([asyncCallback = facebook::react::AsyncCallback(rt_1, std::move(callback), jsInvoker)]() {
+        asyncCallback.call();
+      });
+
+      return {rt_1, thisValue};
+    }));
+
+    this->setProperty(rt,
+                      "end", facebook::jsi::Function::createFromHostFunction(rt,
+                                                                             facebook::jsi::PropNameID::forUtf8(rt, "end"),
+                                                                             1,
+                                                                             [this, res](facebook::jsi::Runtime &rt_1,
+                                                                                         const facebook::jsi::Value &thisValue,
+                                                                                         const facebook::jsi::Value *arguments,
+                                                                                         size_t count) -> facebook::jsi::Value {
+      /// Due to JS run at different thread
+      /// The race condition event is not avoidable under stress test
+      /// Our predefined `res->onAborted` call earlier than JS callback
+      /// This below makes JS side can call the "res.end" without attaching `onAborted` handler at all.
+      /// If we know how to make a sync call across the thread, please update this.
+      if(this->OnAbortedAssignee.alreadyAborted) {
+        return {rt_1, thisValue};
+      }
+
+      auto body = RecognizedString(rt_1, arguments[0]).getStringView();
+      res->end(body);
+
+      return {rt_1, thisValue};
+    }));
+
+    this->setProperty(rt,
+                      "endWithoutBody",
+                      facebook::jsi::Function::createFromHostFunction(rt,
+                                                                      facebook::jsi::PropNameID::forUtf8(rt, "endWithoutBody"),
+                                                                      2,
+                                                                      [this, res](facebook::jsi::Runtime &rt_1,
+                                                                                  const facebook::jsi::Value &thisValue,
+                                                                                  const facebook::jsi::Value *arguments,
+                                                                                  size_t count) -> facebook::jsi::Value {
+      /// Due to JS run at different thread
+      /// The race condition event is not avoidable under stress test
+      /// Our predefined `res->onAborted` call earlier than JS callback
+      /// This below makes JS side can call the "res.end" without attaching `onAborted` handler at all.
+      /// If we know how to make a sync call across the thread, please update this.
+      if(this->OnAbortedAssignee.alreadyAborted) {
+        return {rt_1, thisValue};
+      }
+
+      if(!arguments) {
+        res->endWithoutBody();
+        return {rt_1, thisValue};
+      }
+
+      std::optional<double> reportedContentLength = std::nullopt;
+      bool closeConnection = false;
+
+      if(arguments[0].isNumber()) {
+        reportedContentLength = arguments[0].asNumber();
+      }
+
+      if(arguments[1].isBool()) {
+        closeConnection = arguments[1].asBool();
+      }
+
+      res->endWithoutBody(reportedContentLength, closeConnection);
+
+      return {rt_1, thisValue};
+    }));
+
+    this->setProperty(rt,
+                      "getRemoteAddressAsText",
+                      facebook::jsi::Function::createFromHostFunction(rt,
+                                                                      facebook::jsi::PropNameID::forUtf8(rt, "getRemoteAddressAsText"),
+                                                                      0,
+                                                                      [res](facebook::jsi::Runtime &rt_1,
+                                                                            const facebook::jsi::Value &thisValue,
+                                                                            const facebook::jsi::Value *arguments,
+                                                                            size_t count) -> facebook::jsi::Value {
+      auto remoteAddress = res->getRemoteAddressAsText();
+      return facebook::jsi::String::createFromUtf8(rt_1, std::string(remoteAddress));
+    }));
+    
+    this->setProperty(rt,
+                      "getRemotePort",
+                      facebook::jsi::Function::createFromHostFunction(rt,
+                                                                      facebook::jsi::PropNameID::forUtf8(rt, "getRemotePort"),
+                                                                      0,
+                                                                      [res](facebook::jsi::Runtime &rt_1,
+                                                                            const facebook::jsi::Value &thisValue,
+                                                                            const facebook::jsi::Value *arguments,
+                                                                            size_t count) -> facebook::jsi::Value {
+      return facebook::jsi::BigInt::fromUint64(rt_1, res->getRemotePort());
+    }));
+
+    this->setProperty(rt,
+                      "getWriteOffset",
+                      facebook::jsi::Function::createFromHostFunction(rt,
+                                                                      facebook::jsi::PropNameID::forUtf8(rt, "getWriteOffset"),
+                                                                      0,
+                                                                      [res](facebook::jsi::Runtime &rt_1,
+                                                                            const facebook::jsi::Value &thisValue,
+                                                                            const facebook::jsi::Value *arguments,
+                                                                            size_t count) -> facebook::jsi::Value {
+      return facebook::jsi::BigInt::fromUint64(rt_1, res->getWriteOffset());
+    }));
+
+    this->setProperty(rt,
+                      "onAborted",
+                      facebook::jsi::Function::createFromHostFunction(rt,
+                                                                      facebook::jsi::PropNameID::forUtf8(rt, "onAborted"),
+                                                                      1,
+                                                                      [this, &jsInvoker](facebook::jsi::Runtime &rt_1,
+                                                                            const facebook::jsi::Value &thisValue,
+                                                                            const facebook::jsi::Value *arguments,
+                                                                            size_t count) -> facebook::jsi::Value {
+      auto callback = arguments[0].asObject(rt_1).asFunction(rt_1);
+
+      if(this->OnAbortedAssignee.alreadyAborted) {
+        facebook::react::AsyncCallback(rt_1, std::move(callback), jsInvoker).call();
+      } else {
+        this->OnAbortedAssignee.callback = std::make_shared<facebook::react::AsyncCallback<facebook::jsi::Value>>(rt_1, std::move(callback), jsInvoker);
+      }
+
+      return {rt_1, thisValue};
+    }));
+
+    this->setProperty(rt,
+                      "onData",
+                      facebook::jsi::Function::createFromHostFunction(rt,
+                                                                      facebook::jsi::PropNameID::forUtf8(rt, "onData"),
+                                                                      1,
+                                                                      [this, &jsInvoker](facebook::jsi::Runtime &rt_1,
+                                                                                        const facebook::jsi::Value &thisValue,
+                                                                                        const facebook::jsi::Value *arguments,
+                                                                                        size_t count) -> facebook::jsi::Value {
+      if(this->OnDataV2Assignee.callback) {
+        throw facebook::jsi::JSError(rt_1, "Cannot reassign onData or assign it with existing onDataV2 and/or onFullData handler");
+      }
+
+      /// Same usage as the onDataV2
+      /// except the second parameter to the JS handler is the boolean `isLast`
+      auto callback = arguments[0].asObject(rt_1).asFunction(rt_1);
+      this->OnDataV2Assignee.callback = std::make_unique<facebook::react::AsyncCallback<facebook::jsi::Value, facebook::jsi::Value>>(rt_1, std::move(callback), jsInvoker);
+
+      /// This a late call
+      if(
+        this->OnDataV2Assignee.isStopCollecting ||
+        this->OnDataV2Assignee.maxRemainingBodyLength == 0
+      ) {
+        this->OnDataV2Assignee.callback->callWithPriority(facebook::react::SchedulerPriority::ImmediatePriority,
+                                                          [this](facebook::jsi::Runtime &rt, facebook::jsi::Function &cb) {
+//          auto stringMutableBuffer = facebook::jsi::StringMutableBuffer(&this->OnDataV2Assignee.chunk);
+          auto mutableBuffer = CharsMutableBuffer(this->OnDataV2Assignee.buffer.get());
+          cb.call(rt,
+                  facebook::jsi::ArrayBuffer(rt, std::make_shared<CharsMutableBuffer>(std::move(mutableBuffer))),
+                  this->OnDataV2Assignee.maxRemainingBodyLength == 0);
+        });
+      }
+
+      return facebook::jsi::Value::undefined();
+    }));
+
+    this->setProperty(rt,
+                      "onDataV2",
+                      facebook::jsi::Function::createFromHostFunction(rt,
+                                                                      facebook::jsi::PropNameID::forUtf8(rt, "onDataV2"),
+                                                                      1,
+                                                                      [this, &jsInvoker](facebook::jsi::Runtime &rt_1,
+                                                                                          const facebook::jsi::Value &thisValue,
+                                                                                          const facebook::jsi::Value *arguments,
+                                                                                          size_t count) -> facebook::jsi::Value {
+      if(this->OnDataV2Assignee.callback) {
+        throw facebook::jsi::JSError(rt_1, "Cannot reassign onDataV2 or assign it with existing onData and/or onFullData handler");
+      }
+
+      auto callback = arguments[0].asObject(rt_1).asFunction(rt_1);
+      this->OnDataV2Assignee.callback = std::make_unique<facebook::react::AsyncCallback<facebook::jsi::Value, facebook::jsi::Value>>(rt_1, std::move(callback), jsInvoker);
+
+      /// This is a late call to the onDataV2 callback
+      /// due to the onDataV2 predefined lambda has finished earlier
+      /// or isStopCollecting is already marked
+      if(
+        this->OnDataV2Assignee.buffer &&
+        (this->OnDataV2Assignee.isStopCollecting || this->OnDataV2Assignee.maxRemainingBodyLength == 0)
+      ) {
+        this->OnDataV2Assignee.callback
+          ->callWithPriority(facebook::react::SchedulerPriority::ImmediatePriority,
+                             [this](facebook::jsi::Runtime &rt, facebook::jsi::Function &cb) {
+//          auto stringMutableBuffer = facebook::jsi::StringMutableBuffer(&this->OnDataV2Assignee.chunk);
+          auto mutableBuffer = CharsMutableBuffer(this->OnDataV2Assignee.buffer.get());
+          cb.call(rt,
+                 facebook::jsi::ArrayBuffer(rt, std::make_shared<CharsMutableBuffer>(std::move(mutableBuffer))),
+                 facebook::jsi::BigInt::fromUint64(rt, this->OnDataV2Assignee.maxRemainingBodyLength));
+        });
+      }
+
+      return facebook::jsi::Value::undefined();
+    }));
+
+    this->setProperty(rt,
+                      "onFullData",
+                      facebook::jsi::Function::createFromHostFunction(rt,
+                                                                      facebook::jsi::PropNameID::forUtf8(rt, "onFullData"),
+                                                                      1,
+                                                                      [this, &jsInvoker](facebook::jsi::Runtime &rt_1,
+                                                                                          const facebook::jsi::Value &thisValue,
+                                                                                          const facebook::jsi::Value *arguments,
+                                                                                          size_t count) -> facebook::jsi::Value {
+      if(this->OnDataV2Assignee.callback) {
+        throw facebook::jsi::JSError(rt_1, "Cannot reassign onFullData or assign it with existing onData and/or onDataV2 handler");
+      }
+
+      auto callback = arguments[0].asObject(rt_1).asFunction(rt_1);
+      this->OnDataV2Assignee.isCallbackForFullChunk = true;
+      this->OnDataV2Assignee.callback = std::make_unique<facebook::react::AsyncCallback<facebook::jsi::Value, facebook::jsi::Value>>(rt_1, std::move(callback), jsInvoker);
+
+      /// This is a late call to the onFullData callback
+      /// due to the onDataV2 predefined lambda has finished earlier
+      /// or isStopCollecting is already marked
+      if(
+        this->OnDataV2Assignee.buffer &&
+        (this->OnDataV2Assignee.isStopCollecting || this->OnDataV2Assignee.maxRemainingBodyLength == 0)
+      ) {
+        this->OnDataV2Assignee.callback
+          ->callWithPriority(facebook::react::SchedulerPriority::ImmediatePriority,
+                             [this](facebook::jsi::Runtime &rt, facebook::jsi::Function &cb) {
+//          auto stringMutableBuffer = facebook::jsi::StringMutableBuffer(&this->OnDataV2Assignee.chunk);
+          auto mutableBuffer = CharsMutableBuffer(this->OnDataV2Assignee.buffer.get());
+          cb.call(rt,
+                  facebook::jsi::ArrayBuffer(rt, std::make_shared<CharsMutableBuffer>(std::move(mutableBuffer))));
+        });
+      }
+
+      return facebook::jsi::Value::undefined();
+    }));
+
+    this->setProperty(rt,
+                      "onFullDataText",
+                      facebook::jsi::Function::createFromHostFunction(rt,
+                                                                      facebook::jsi::PropNameID::forUtf8(rt, "onFullDataText"),
+                                                                      1,
+                                                                      [this, &jsInvoker](facebook::jsi::Runtime &rt_1,
+                                                                                          const facebook::jsi::Value &thisValue,
+                                                                                          const facebook::jsi::Value *arguments,
+                                                                                          size_t count) -> facebook::jsi::Value {
+      if(this->OnDataV2Assignee.callbackStr) {
+        throw facebook::jsi::JSError(rt_1, "Cannot reassign onFullDataText handler");
+      }
+
+      auto callback = arguments[0].asObject(rt_1).asFunction(rt_1);
+      this->OnDataV2Assignee.isCallbackForFullChunk = true;
+      this->OnDataV2Assignee.callbackStr = std::make_unique<facebook::react::AsyncCallback<facebook::jsi::Value, facebook::jsi::Value>>(rt_1, std::move(callback), jsInvoker);
+
+      /// This is a late call to the onFullDataText callback
+      /// due to the onDataV2 predefined lambda has finished earlier
+      /// or isStopCollecting is already marked
+      if(
+        this->OnDataV2Assignee.buffer &&
+        (this->OnDataV2Assignee.isStopCollecting || this->OnDataV2Assignee.maxRemainingBodyLength == 0)
+      ) {
+        this->OnDataV2Assignee.callbackStr
+          ->callWithPriority(facebook::react::SchedulerPriority::ImmediatePriority,
+                             [this](facebook::jsi::Runtime &rt, facebook::jsi::Function &cb) {
+          cb.call(rt,
+                  std::string(this->OnDataV2Assignee.buffer->begin(), this->OnDataV2Assignee.buffer->end()));
+        });
+      }
+
+      return facebook::jsi::Value::undefined();
+    }));
+
+    this->setProperty(rt,
+                      "pause",
+                      facebook::jsi::Function::createFromHostFunction(rt,
+                                                                      facebook::jsi::PropNameID::forUtf8(rt, "pause"),
+                                                                      0,
+                                                                      [res](facebook::jsi::Runtime &rt_1,
+                                                                            const facebook::jsi::Value &thisValue,
+                                                                            const facebook::jsi::Value *arguments,
+                                                                            size_t count) -> facebook::jsi::Value {
+      res->pause();
+      return facebook::jsi::Value::undefined();
+    }));
+
+    this->setProperty(rt,
+                      "resume",
+                      facebook::jsi::Function::createFromHostFunction(rt,
+                                                                      facebook::jsi::PropNameID::forUtf8(rt, "resume"),
+                                                                      0,
+                                                                      [res](facebook::jsi::Runtime &rt_1,
+                                                                            const facebook::jsi::Value &thisValue,
+                                                                            const facebook::jsi::Value *arguments,
+                                                                            size_t count) -> facebook::jsi::Value {
+      res->resume();
+      return facebook::jsi::Value::undefined();
+    }));
+
+    this->setProperty(rt,
+                      "tryEnd",
+                      facebook::jsi::Function::createFromHostFunction(rt,
+                                                                      facebook::jsi::PropNameID::forUtf8(rt, "tryEnd"),
+                                                                      2,
+                                                                      [this, res](facebook::jsi::Runtime &rt_1,
+                                                                            const facebook::jsi::Value &thisValue,
+                                                                            const facebook::jsi::Value *arguments,
+                                                                            size_t count) -> facebook::jsi::Value {
+      /// Due to JS run at different thread
+      /// The race condition event is not avoidable under stress test
+      /// Our predefined `res->onAborted` call earlier than JS callback
+      /// This below makes JS side can call the "res.end" without attaching `onAborted` handler at all.
+      /// If we know how to make a JS sync call across the thread, please update this.
+      if(this->OnAbortedAssignee.alreadyAborted) {
+        return {rt_1, thisValue};
+      }
+
+      auto fullBodyOrChunk = RecognizedString(rt_1, arguments[0]).getStringView();
+      auto totalSize = arguments[1].asNumber();
+
+      auto tryEndResult = res->tryEnd(fullBodyOrChunk, static_cast<uintmax_t>(totalSize));
+
+      return facebook::jsi::Array::createWithElements(rt_1, {tryEndResult.first, tryEndResult.second});
+    }));
+
+    /// TODO
+    /// Implement this method later
+    /// It looks like we need to persist/save the us_socket_context_t from the ws.
+//    this->setProperty(rt, "upgrade", facebook::jsi::Function::createFromHostFunction(rt,
+//                                                                                         facebook::jsi::PropNameID::forUtf8(rt, "upgrade"),
+//                                                                                         5,
+//                                                                                         [res](facebook::jsi::Runtime &rt_1,
+//                                                                                               const facebook::jsi::Value &thisValue,
+//                                                                                               const facebook::jsi::Value *arguments,
+//                                                                                               size_t count) -> facebook::jsi::Value {
+//      if(!arguments ||
+//         count != 5 ||
+//         !arguments[0].isString() ||
+//         !arguments[1].isString() ||
+//         !arguments[2].isString() ||
+//         !arguments[3].isString() ||
+//         !arguments[4].isNumber()) {
+//        return facebook::jsi::Value::undefined();
+//      }
+//
+//      auto userData = arguments[0].asString(rt_1).utf8(rt_1);
+//      auto secWebSocketKey = arguments[1].asString(rt_1).utf8(rt_1);
+//      auto secWebSocketProtocol = arguments[2].asString(rt_1).utf8(rt_1);
+//      auto secWebSocketExtensions = arguments[3].asString(rt_1).utf8(rt_1);
+//      auto context = arguments[4].asNumber();
+//
+//      // TODO give user a warning if this method has been called outside of cork handler
+//      // assumeCorked()
+//
+//      auto *usSocketContext = reinterpret_cast<us_socket_context_t *>(static_cast<u_long>(context));
+//
+//      res->upgrade(std::string_view(userData),
+//                   std::string_view(secWebSocketKey),
+//                   std::string_view(secWebSocketProtocol),
+//                   std::string_view(secWebSocketExtensions),
+//                   usSocketContext);
+//
+//      return facebook::jsi::Value::undefined();
+//    }));
+
+    this->setProperty(rt,
+                      "write",
+                      facebook::jsi::Function::createFromHostFunction(rt,
+                                                                      facebook::jsi::PropNameID::forUtf8(rt, "write"),
+                                                                      2,
+                                                                      [res](facebook::jsi::Runtime &rt_1,
+                                                                            const facebook::jsi::Value &thisValue,
+                                                                            const facebook::jsi::Value *arguments,
+                                                                            size_t count) -> facebook::jsi::Value {
+      auto chunk = RecognizedString(rt_1, arguments[0]).getStringView();
+      return res->write(std::string_view(chunk));
+    }));
+
+    this->setProperty(rt,
+                      "writeHeader",
+                      facebook::jsi::Function::createFromHostFunction(rt,
+                                                                      facebook::jsi::PropNameID::forUtf8(rt, "writeHeader"),
+                                                                      2,
+                                                                      [res](facebook::jsi::Runtime &rt_1,
+                                                                            const facebook::jsi::Value &thisValue,
+                                                                            const facebook::jsi::Value *arguments,
+                                                                            size_t count) -> facebook::jsi::Value {
+      auto headerKey = RecognizedString(rt_1, arguments[0]).getStringView();
+      auto headerVal = RecognizedString(rt_1, arguments[1]).getStringView();
+      res->writeHeader(headerKey, headerVal);
+
+      return {rt_1, thisValue};
+    }));
+
+    this->setProperty(rt,
+                      "writeStatus",
+                      facebook::jsi::Function::createFromHostFunction(rt,
+                                                                      facebook::jsi::PropNameID::forUtf8(rt, "writeStatus"),
+                                                                      1,
+                                                                      [res](facebook::jsi::Runtime &rt_1,
+                                                                            const facebook::jsi::Value &thisValue,
+                                                                            const facebook::jsi::Value *arguments,
+                                                                            size_t count) -> facebook::jsi::Value {
+      auto status = RecognizedString(rt_1, arguments[0]).getStringView();
+      res->writeStatus(status);
+
+      return {rt_1, thisValue};
+    }));
+
+    /// We have to make JS call asynchronously because the uWebSockets app run at different thread.
+    /// See the `uws_react_native::AppRunner`, and `facebook::react::AsyncCallback`.
+    /// So this predefined `onAborted` assignment below is to tell that
+    /// uWebSockets has to wait until JS call finished with the `res.end() or res.tryEnd()`.
+    ///
+    /// Stated from uWebSockets
+    /// `Returning from a request handler without responding or attaching an onAborted handler is ill-use`
+    ///
+    /// I thought `onAborted` is just a callback or event listener.
+    res->onAborted([this]() {
+      this->OnAbortedAssignee.alreadyAborted = true;
+
+      if(this->OnAbortedAssignee.callback) {
+        this->OnAbortedAssignee.callback->call(facebook::jsi::Value::undefined());
+      }
+    });
+
+    /// Sadly, we can't do late assignment to the onDataV2 and onData.
+    /// uWebSockets will do nothing to our handler if we assign the lambda so late.
+    /// So we have to predefined onDataV2 handler here, and save the chunk.
+    if(!options->disableBodyRead) {
+      res->onDataV2([this, maxBodySize = options->maxBodySize](auto chunk, auto maxRemainingBodyLength) {
+        if(this->OnDataV2Assignee.isStopCollecting) {
+          return;
+        }
+
+        if(maxBodySize > 0) {
+          auto chunkSize = chunk.size();
+          auto currentChunkSize = this->OnDataV2Assignee.buffer ? this->OnDataV2Assignee.buffer->size() : 0;
+
+          /// First and possibly only chunk
+          if(currentChunkSize == 0 && chunkSize > maxBodySize) {
+            this->OnDataV2Assignee.isStopCollecting = true;
+            /// set the first chunk
+            this->setChunk(chunk, maxRemainingBodyLength);
+            this->invokeOnDataHandler();
+            return;
+          }
+
+          /// subsequent chunks overflow
+          if(currentChunkSize > 0 && chunkSize > maxBodySize - currentChunkSize) {
+            /// tell to JS that we already stop collecting chunk
+            /// and invoke the JSI onData / onDataText / onDataV2 / onFullData / onFullDataText handler immediately
+            this->OnDataV2Assignee.isStopCollecting = true;
+            this->invokeOnDataHandler();
+            return;
+          }
+        }
+
+        this->setChunk(chunk, maxRemainingBodyLength);
+        this->invokeOnDataHandler();
+
+        /// About the invokeOnDataHandler,
+        /// JS call may late
+        /// it will invokes the handler once when user pass the handler.
+      });
+    }
+
+  } // HttpResponseObject
+
+};
+
+}