chore(refactor): extract cookies into separate module (#306)

Refactors `impit-node` by splitting the `request.rs` module into
multiple separate ones.

Author: barjin

impit-node/src/cookies.rs

@@ -0,0 +1,101 @@
+use napi::bindgen_prelude::{Function, JsObjectValue, Object};
+
+use napi::Env;
+
+use crate::utils::await_promise;
+
+use reqwest::Url;
+
+use reqwest::cookie::CookieStore;
+use reqwest::header::HeaderValue;
+
+use napi::Status;
+
+use napi::bindgen_prelude::Promise;
+
+use napi::threadsafe_function::ThreadsafeFunction;
+
+pub struct NodeCookieJar {
+  pub(crate) set_cookie_tsfn:
+    ThreadsafeFunction<(String, String), Promise<()>, (String, String), Status, false>,
+  pub(crate) get_cookies_tsfn: ThreadsafeFunction<String, Promise<String>, String, Status, false>,
+}
+
+impl CookieStore for NodeCookieJar {
+  fn set_cookies(
+    &self,
+    cookie_headers: &mut dyn Iterator<Item = &reqwest::header::HeaderValue>,
+    url: &Url,
+  ) {
+    for header in cookie_headers {
+      let header = header.to_str().unwrap_or_default().to_string();
+      let url = url.as_str().to_string();
+
+      let _ = await_promise(&self.set_cookie_tsfn, (header.clone(), url.clone()));
+    }
+  }
+
+  fn cookies(&self, url: &Url) -> Option<reqwest::header::HeaderValue> {
+    let url = url.as_str().to_string();
+
+    await_promise(&self.get_cookies_tsfn, url.clone())
+      .ok()
+      .and_then(|header| {
+        if header.is_empty() {
+          return None;
+        }
+
+        HeaderValue::from_str(&header).ok()
+      })
+  }
+}
+
+impl NodeCookieJar {
+  pub fn new(env: &Env, tough_cookie: Object) -> Result<Self, napi::Error> {
+    let set_cookie_js_method = match tough_cookie
+      .get_named_property::<Function<'_, (String, String), Promise<()>>>("setCookie")
+    {
+      Ok(method) => method,
+      Err(e) => {
+        return Err(napi::Error::new(
+          napi::Status::GenericFailure,
+          format!("[impit] Couldn't find `setCookie` method on the external cookie store: {e}"),
+        ));
+      }
+    };
+
+    let get_cookie_js_method = match tough_cookie
+      .get_named_property::<Function<'_, String, Promise<String>>>("getCookieString")
+    {
+      Ok(method) => method,
+      Err(e) => {
+        return Err(napi::Error::new(
+          napi::Status::GenericFailure,
+          format!(
+            "[impit] Couldn't find `getCookieString` method on the external cookie store: {e}"
+          ),
+        ));
+      }
+    };
+
+    let mut set_cookie = set_cookie_js_method
+      .build_threadsafe_function::<(std::string::String, std::string::String)>()
+      .build_callback(|ctx| Ok(ctx.value))?;
+
+    let mut get_cookies = get_cookie_js_method
+      .build_threadsafe_function::<std::string::String>()
+      .build_callback(|ctx| Ok(ctx.value))?;
+
+    // Unless the `ThreadsafeFunction` is unreferenced, the Node.JS application will hang on exit
+    // https://nodejs.github.io/node-addon-examples/special-topics/thread-safe-functions/#q-my-application-isnt-exiting-correctly-it-just-hangs
+    #[allow(deprecated)]
+    let _ = set_cookie.unref(env);
+    #[allow(deprecated)]
+    let _ = get_cookies.unref(env);
+
+    Ok(Self {
+      set_cookie_tsfn: set_cookie,
+      get_cookies_tsfn: get_cookies,
+    })
+  }
+}

impit-node/src/impit_builder.rs

@@ -7,7 +7,7 @@ use impit::{
 use napi::{bindgen_prelude::Object, Env};
 use napi_derive::napi;
 
-use crate::request::NodeCookieJar;
+use crate::cookies::NodeCookieJar;
 
 /// Supported browsers for emulation.
 ///

impit-node/src/lib.rs

@@ -8,13 +8,15 @@ use impit::{
 use napi::Env;
 use napi_derive::napi;
 
+mod cookies;
 mod impit_builder;
 mod request;
 mod response;
+mod utils;
 
 use self::response::ImpitResponse;
 use impit_builder::ImpitOptions;
-use request::{HttpMethod, NodeCookieJar, RequestInit};
+use request::{HttpMethod, RequestInit};
 
 /// The main class of the `impit` package
 ///
@@ -36,7 +38,7 @@ use request::{HttpMethod, NodeCookieJar, RequestInit};
 /// resources (e.g. cookie jar and connection pool), and other settings.
 #[napi(js_name = "Impit")]
 pub struct ImpitWrapper {
-  inner: Impit<NodeCookieJar>,
+  inner: Impit<cookies::NodeCookieJar>,
 }
 
 #[napi]
@@ -60,7 +62,7 @@ impl ImpitWrapper {
   /// ```
   #[napi(constructor)]
   pub fn new(env: &Env, options: Option<ImpitOptions>) -> Result<Self, napi::Error> {
-    let config: Result<ImpitBuilder<NodeCookieJar>, napi::Error> =
+    let config: Result<ImpitBuilder<cookies::NodeCookieJar>, napi::Error> =
       options.unwrap_or_default().into_builder(env);
 
     // `quinn` for h3 requires existing async runtime.

impit-node/src/request.rs

@@ -1,19 +1,6 @@
-use std::{
-  thread::{self, sleep},
-  time::Duration,
-};
-
-use napi::{
-  bindgen_prelude::{
-    FromNapiValue, Function, JsObjectValue, JsValuesTupleIntoVec, Object, Promise, Uint8Array,
-  },
-  threadsafe_function::ThreadsafeFunction,
-  Env, Status,
-};
+use napi::bindgen_prelude::Uint8Array;
 
 use napi_derive::napi;
-use reqwest::{cookie::CookieStore, header::HeaderValue, Url};
-use tokio::sync::oneshot;
 
 #[derive(Default, Clone)]
 #[napi(string_enum = "UPPERCASE")]
@@ -59,145 +46,3 @@ pub struct RequestInit {
   /// Force the request to use HTTP/3. If the server doesn't expect HTTP/3 or the Impit instance doesn't have HTTP/3 enabled (via the {@link ImpitOptions.http3} option), the request will fail.
   pub force_http3: Option<bool>,
 }
-
-fn await_promise<
-  T: Send,
-  CallbackArgs: JsValuesTupleIntoVec,
-  RustReturn: FromNapiValue + std::fmt::Debug + Sync + Send,
->(
-  tsfn: &ThreadsafeFunction<T, Promise<RustReturn>, CallbackArgs, Status, false>,
-  args: T,
-) -> Result<RustReturn, napi::Error> {
-  thread::scope(|scope| {
-    let (tx, mut rx) = oneshot::channel();
-
-    scope.spawn(move || match tokio::runtime::Runtime::new() {
-      Ok(runtime) => {
-        runtime.block_on(async {
-          match tsfn.call_async(args).await {
-            Ok(result) => {
-              let _ = tx.send(result.await);
-            }
-            Err(e) => {
-              let _ = tx.send(Err(napi::Error::new(
-                napi::Status::GenericFailure,
-                format!("[impit] failed to retrieve cookies from the external cookie store: {e}"),
-              )));
-            }
-          }
-        });
-      }
-      Err(e) => {
-        let _ = tx.send(Err(napi::Error::new(
-          napi::Status::GenericFailure,
-          format!("[impit] failed to retrieve cookies from the external cookie store: {e}"),
-        )));
-      }
-    });
-
-    let mut result = rx.try_recv();
-
-    let max_retries = 5;
-    let mut retries = 0;
-
-    while result.is_err() && retries < max_retries {
-      sleep(Duration::from_millis(5));
-      result = rx.try_recv();
-      retries += 1;
-    }
-
-    match result {
-      Ok(Ok(result)) => Ok(result),
-      Ok(Err(e)) => Err(e),
-      Err(_) => Err(napi::Error::new(
-        napi::Status::GenericFailure,
-        "[impit] failed to retrieve cookies from the external cookie store".to_string(),
-      )),
-    }
-  })
-}
-
-pub struct NodeCookieJar {
-  set_cookie_tsfn:
-    ThreadsafeFunction<(String, String), Promise<()>, (String, String), Status, false>,
-  get_cookies_tsfn: ThreadsafeFunction<String, Promise<String>, String, Status, false>,
-}
-
-impl CookieStore for NodeCookieJar {
-  fn set_cookies(
-    &self,
-    cookie_headers: &mut dyn Iterator<Item = &reqwest::header::HeaderValue>,
-    url: &Url,
-  ) {
-    for header in cookie_headers {
-      let header = header.to_str().unwrap_or_default().to_string();
-      let url = url.as_str().to_string();
-
-      let _ = await_promise(&self.set_cookie_tsfn, (header.clone(), url.clone()));
-    }
-  }
-
-  fn cookies(&self, url: &Url) -> Option<reqwest::header::HeaderValue> {
-    let url = url.as_str().to_string();
-
-    await_promise(&self.get_cookies_tsfn, url.clone())
-      .ok()
-      .and_then(|header| {
-        if header.is_empty() {
-          return None;
-        }
-
-        HeaderValue::from_str(&header).ok()
-      })
-  }
-}
-
-impl NodeCookieJar {
-  pub fn new(env: &Env, tough_cookie: Object) -> Result<Self, napi::Error> {
-    let set_cookie_js_method = match tough_cookie
-      .get_named_property::<Function<'_, (String, String), Promise<()>>>("setCookie")
-    {
-      Ok(method) => method,
-      Err(e) => {
-        return Err(napi::Error::new(
-          napi::Status::GenericFailure,
-          format!("[impit] Couldn't find `setCookie` method on the external cookie store: {e}"),
-        ));
-      }
-    };
-
-    let get_cookie_js_method = match tough_cookie
-      .get_named_property::<Function<'_, String, Promise<String>>>("getCookieString")
-    {
-      Ok(method) => method,
-      Err(e) => {
-        return Err(napi::Error::new(
-          napi::Status::GenericFailure,
-          format!(
-            "[impit] Couldn't find `getCookieString` method on the external cookie store: {e}"
-          ),
-        ));
-      }
-    };
-
-    let mut set_cookie = set_cookie_js_method
-      .build_threadsafe_function::<(std::string::String, std::string::String)>()
-      .build_callback(|ctx| Ok(ctx.value))?;
-
-    let mut get_cookies = get_cookie_js_method
-      .build_threadsafe_function::<std::string::String>()
-      .build_callback(|ctx| Ok(ctx.value))?;
-
-    // Unless the `ThreadsafeFunction` is unreferenced, the Node.JS application will hang on exit
-    // https://nodejs.github.io/node-addon-examples/special-topics/thread-safe-functions/#q-my-application-isnt-exiting-correctly-it-just-hangs
-    #[allow(deprecated)]
-    let _ = set_cookie.unref(env);
-    #[allow(deprecated)]
-    let _ = get_cookies.unref(env);
-
-    Ok(Self {
-      set_cookie_tsfn: set_cookie,
-      get_cookies_tsfn: get_cookies,
-    })
-  }
-}

impit-node/src/utils.rs

@@ -0,0 +1,72 @@
+use napi::threadsafe_function::ThreadsafeFunction;
+use tokio::sync::oneshot;
+
+use std::thread;
+use std::time::Duration;
+
+use std::thread::sleep;
+
+use napi::Status;
+
+use napi::bindgen_prelude::Promise;
+
+use napi::bindgen_prelude::FromNapiValue;
+
+use napi::bindgen_prelude::JsValuesTupleIntoVec;
+
+pub(crate) fn await_promise<
+  T: Send,
+  CallbackArgs: JsValuesTupleIntoVec,
+  RustReturn: FromNapiValue + std::fmt::Debug + Sync + Send,
+>(
+  tsfn: &ThreadsafeFunction<T, Promise<RustReturn>, CallbackArgs, Status, false>,
+  args: T,
+) -> Result<RustReturn, napi::Error> {
+  thread::scope(|scope| {
+    let (tx, mut rx) = oneshot::channel();
+
+    scope.spawn(move || match tokio::runtime::Runtime::new() {
+      Ok(runtime) => {
+        runtime.block_on(async {
+          match tsfn.call_async(args).await {
+            Ok(result) => {
+              let _ = tx.send(result.await);
+            }
+            Err(e) => {
+              let _ = tx.send(Err(napi::Error::new(
+                napi::Status::GenericFailure,
+                format!("[impit] failed to retrieve cookies from the external cookie store: {e}"),
+              )));
+            }
+          }
+        });
+      }
+      Err(e) => {
+        let _ = tx.send(Err(napi::Error::new(
+          napi::Status::GenericFailure,
+          format!("[impit] failed to retrieve cookies from the external cookie store: {e}"),
+        )));
+      }
+    });
+
+    let mut result = rx.try_recv();
+
+    let max_retries = 5;
+    let mut retries = 0;
+
+    while result.is_err() && retries < max_retries {
+      sleep(Duration::from_millis(5));
+      result = rx.try_recv();
+      retries += 1;
+    }
+
+    match result {
+      Ok(Ok(result)) => Ok(result),
+      Ok(Err(e)) => Err(e),
+      Err(_) => Err(napi::Error::new(
+        napi::Status::GenericFailure,
+        "[impit] failed to retrieve cookies from the external cookie store".to_string(),
+      )),
+    }
+  })
+}