uws-react-native 0.0.1 → 0.0.2

package/README.md

@@ -33,7 +33,7 @@ This repository does also contain the [example](https://github.com/RakaDoank/uws
 
 ## Compatibility
 
-`uws-react-native` is compatible only compatible for new architecture of React Native.
+`uws-react-native` is only compatible for new architecture of React Native.
 
 ### Platform
 
@@ -53,6 +53,8 @@ There are some new APIs in uws-react-native. The most reason is because of the d
   - `onFullData`. This is an equivalent of `res.collectBody` from uWebSockets.js, but to set the max size, provide it through route method handler options
   - `onFullDataText`. Same as the `onFullData`, but provides the body data in raw text instead of ArrayBuffer. This is useful if you are using React Native 0.84 version or older because TextDecoder is natively supported only in React Native 0.85 version
 
+---
+
 ## Development & Research
 
 uws-react-native is still in heavy development and research. All the uWebSockets instances are not fully implemented yet.
@@ -73,7 +75,11 @@ Intentionally, we make the uWebSockets runs in another thread, therefore we have
 
 We have another issue because of the uWebSockets runs in another thread. From the JSI C++ side, we have to assume any JS function as a callback especially the route method handler is asynchronous. We cannot make a sync call to the JS function from an arbitrary thread to the JS thread, and it makes JS call to the uWebSockets runner is also late.
 
-For this case especially, we have to predefined two instances in the C++ uWebSockets route method handler because of the late call, and the late call would not be tolerated by the uWebSockets internally for some instances
+There some topics you may to read regarding this threading research
+
+#### Predefined Instances
+
+For the threading case especially, we have to predefined two instances in the C++ uWebSockets route method handler because of the late call, and the late call would not be tolerated by the uWebSockets internally for some cases
 
 - `res.onAborted`
 
@@ -82,3 +88,9 @@ We have to predefined the `onAborted` callback in C++ side and prevent `res.end`
 - `res.onDataV2`
 
 For the `onData` and `onDataV2`, we have predefined it with a single `onDataV2` callback in C++ side. If this method is not predefined, uWebSockets will not collect any incoming body data. If a route method handler is sure that it doesn't expect any body data at all, a route method handler can disable the body reading through the third argument in `any`, `get`, `post`, and other route methods.
+
+#### About Worker Thread
+
+In theory, we can create another JavaScript runtime with [react-native-worklets](https://docs.swmansion.com/react-native-worklets/) and tie with our uWebSockets runner. It would solve a lot of late communication problem between uWebSockets runner and JavaScript thread that we embrace right now, but it also introduces new major issue, which is developer experience. It sounds like not a big problem, but it may bigger than you think.
+
+Think of this sample case, you want to use uws-react-native server for a simple CRUD with a local database in an app. You probably know SQLite can be used in Android, iOS, macOS, even Windows app, with your own adapter or a known library that support SQLite integration in React Native such as [op-sqlite](https://github.com/OP-Engineering/op-sqlite), and [Expo SQLite](https://docs.expo.dev/versions/latest/sdk/sqlite). If you want to use that known library, this case would not works at all, because op-sqlite and/or Expo SQLite is tied to the default JavaScript runtime. Even, you cannot use any React Native non-JS-only libraries in arbitrary JavaScript thread that has created by react-native-worklets if the library you want to use is using the default JavaScript runtime. If you really want to achieve the goal of this case, you have to create your own library for the SQLite database by yourself and tie-up with the JavaScript runtime. Probably, in the future we would still provide that worker thread with react-native-worklets.

package/cpp/app/HttpRequestObject.h

@@ -33,9 +33,9 @@ public:
       std::for_each(req->begin(),
                     req->end(),
                     [&rt_1, callback_ = std::move(callback)](const auto &item) {
-                      callback_.call(rt_1,
-                                     facebook::jsi::String::createFromUtf8(rt_1, std::string(item.first)),
-                                     facebook::jsi::String::createFromUtf8(rt_1, std::string(item.second)));
+        callback_.call(rt_1,
+                       facebook::jsi::String::createFromAscii(rt_1, std::string(item.first)),
+                       facebook::jsi::String::createFromAscii(rt_1, std::string(item.second)));
       });
       return facebook::jsi::Value::undefined();
     }));

package/cpp/app/HttpResponseObject.h

@@ -8,10 +8,10 @@
 
 namespace uws_react_native {
 
-struct HttpResponseObjectOptions {
-  bool disableBodyRead;
-  unsigned long maxBodySize;
-};
+// struct HttpResponseObjectOptions {
+//   bool disableBodyRead;
+//   unsigned long maxBodySize;
+// };
 
 class HttpResponseObject : public facebook::jsi::Object {
 
@@ -52,63 +52,6 @@ private:
     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
@@ -124,8 +67,8 @@ private:
 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) {
+                     std::shared_ptr<facebook::react::CallInvoker> &jsInvoker
+                     /* std::optional<HttpResponseObjectOptions> &&options = HttpResponseObjectOptions{ .disableBodyRead = false, .maxBodySize = 0 } */) : facebook::jsi::Object(rt) {
 
     this->setProperty(rt,
                       "close",
@@ -377,7 +320,6 @@ public:
         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))));
@@ -558,65 +500,83 @@ public:
       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
+
+  void invokeOnAbortedHandler() {
+    this->OnAbortedAssignee.alreadyAborted = true;
+
+    if(this->OnAbortedAssignee.callback) {
+      this->OnAbortedAssignee.callback->call(facebook::jsi::Value::undefined());
     }
+  }
 
-  } // HttpResponseObject
+  bool isStopCollectingData() const {
+    return this->OnDataV2Assignee.isStopCollecting;
+  }
+
+  void stopCollectingData() {
+    this->OnDataV2Assignee.isStopCollecting = true;
+  }
+
+  void updateBuffer(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.maxRemainingBodyLength = maxRemainingBodyLength;
+  }
+
+  size_t getBufferSize() const {
+    return this->OnDataV2Assignee.buffer->size();
+  }
+
+  /**
+   * 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));
+        });
+      }
+    }
+  }
 
 };
 

package/cpp/app/TemplatedAppObject.h

@@ -90,11 +90,10 @@ private:
       }
     }
 
-    std::function<void (uWS::HttpResponse<false> *res, uWS::HttpRequest *req)> uwsRouteHandler = [pattern, disableBodyRead, maxBodySize, &rt, &jsInvoker, asyncCallback = facebook::react::AsyncCallback(rt, std::move(callback), jsInvoker)](uWS::HttpResponse<false> *res, uWS::HttpRequest *req) {
+    std::function<void (uWS::HttpResponse<false> *res, uWS::HttpRequest *req)> uwsRouteHandler = [disableBodyRead, maxBodySize, &rt, &jsInvoker, asyncCallback = facebook::react::AsyncCallback(rt, std::move(callback), jsInvoker)](uWS::HttpResponse<false> *res, uWS::HttpRequest *req) {
       auto httpResponseObject = std::make_shared<HttpResponseObject>(rt,
                                                                      res,
-                                                                     jsInvoker,
-                                                                     HttpResponseObjectOptions{ .disableBodyRead = disableBodyRead, .maxBodySize = maxBodySize });
+                                                                     jsInvoker);
 
       auto httpRequestObject = std::make_shared<HttpRequestObject>(rt, req);
 
@@ -103,6 +102,62 @@ private:
                 *httpResponseObject,
                 *httpRequestObject);
       });
+
+      /// We have to make JS call asynchronously because the uWebSockets app run at different thread.
+      /// See the `react_native_uws::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([httpResponseObject]() {
+        httpResponseObject->invokeOnAbortedHandler();
+      });
+
+      /// 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(!disableBodyRead) {
+        res->onDataV2([httpResponseObject, maxBodySize](auto chunk, auto maxRemainingBodyLength) {
+          if(httpResponseObject->isStopCollectingData()) {
+            return;
+          }
+
+          if(maxBodySize > 0) {
+            auto chunkSize = chunk.size();
+            auto currentChunkSize = httpResponseObject->getBufferSize();
+
+            /// First and possibly only chunk
+            if(currentChunkSize == 0 && chunkSize > maxBodySize) {
+              httpResponseObject->stopCollectingData();
+              /// set the first chunk
+              httpResponseObject->updateBuffer(chunk, maxRemainingBodyLength);
+              httpResponseObject->invokeOnDataHandler();
+              /// Don't worry,
+              /// JS call may late
+              /// it will invokes the handler once when user pass the handler.
+              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
+              httpResponseObject->stopCollectingData();
+              httpResponseObject->invokeOnDataHandler();
+              /// Don't worry,
+              /// JS call may late
+              /// it will invokes the handler once when user pass the handler.
+              return;
+            }
+          }
+
+          httpResponseObject->updateBuffer(chunk, maxRemainingBodyLength);
+          httpResponseObject->invokeOnDataHandler();
+        });
+      }
     };
 
     if(method == UwsRouteMethod::ANY) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uws-react-native",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "The port of uWebSockets library for React Native",
   "license": "MIT",
   "author": "RakaDoank <rakaaudira@gmail.com> (https://github.com/RakaDoank)",