@rspack/binding 0.0.2

package/Cargo.toml

@@ -0,0 +1,44 @@
+[package]
+edition = "2021"
+name = "rspack_node"
+publish = false
+version = "0.1.0"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+anyhow = {version = "1", features = ["backtrace"]}
+async-trait = "0.1.53"
+backtrace = "0.3"
+dashmap = "5.0.0"
+futures = "0.3"
+napi = {git = "https://github.com/speedy-js/napi-rs", branch = "speedy-release", default-features = false, features = [
+  "async",
+  "tokio_rt",
+  "serde-json",
+]}
+napi-derive = {git = "https://github.com/speedy-js/napi-rs", branch = "speedy-release"}
+napi-sys = {git = "https://github.com/speedy-js/napi-rs", branch = "speedy-release"}
+once_cell = "1"
+regex = "1.6.0"
+rspack = {path = "../rspack"}
+rspack_binding_options = {path = "../rspack_binding_options", features = ["node-api"]}
+rspack_core = {path = "../rspack_core"}
+rspack_error = {path = "../rspack_error"}
+rspack_plugin_html = {path = "../rspack_plugin_html"}
+serde = {version = "1", features = ["derive"]}
+serde_json = "1"
+tokio = {version = "1.17.0", features = ["full"]}
+tracing = "0.1.34"
+
+[target.'cfg(all(not(all(target_os = "linux", target_arch = "aarch64", target_env = "musl"))))'.dependencies]
+mimalloc-rust = {version = "0.1"}
+
+[build-dependencies]
+napi-build = {git = "https://github.com/speedy-js/napi-rs", branch = "speedy-release"}
+
+[dev-dependencies]
+testing_macros = {version = "0.2.5"}

package/binding.js

@@ -0,0 +1,221 @@
+const { existsSync, readFileSync } = require('fs')
+const { join } = require('path')
+
+const { platform, arch } = process
+
+let nativeBinding = null
+let localFileExisted = false
+let loadError = null
+
+function isMusl() {
+  // For Node 10
+  if (!process.report || typeof process.report.getReport !== 'function') {
+    try {
+      return readFileSync('/usr/bin/ldd', 'utf8').includes('musl')
+    } catch (e) {
+      return true
+    }
+  } else {
+    const { glibcVersionRuntime } = process.report.getReport().header
+    return !glibcVersionRuntime
+  }
+}
+
+switch (platform) {
+  case 'android':
+    switch (arch) {
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, 'rspack.android-arm64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rspack.android-arm64.node')
+          } else {
+            nativeBinding = require('@rspack/binding-android-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm':
+        localFileExisted = existsSync(join(__dirname, 'rspack.android-arm-eabi.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rspack.android-arm-eabi.node')
+          } else {
+            nativeBinding = require('@rspack/binding-android-arm-eabi')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Android ${arch}`)
+    }
+    break
+  case 'win32':
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, 'rspack.win32-x64-msvc.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rspack.win32-x64-msvc.node')
+          } else {
+            nativeBinding = require('@rspack/binding-win32-x64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'ia32':
+        localFileExisted = existsSync(join(__dirname, 'rspack.win32-ia32-msvc.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rspack.win32-ia32-msvc.node')
+          } else {
+            nativeBinding = require('@rspack/binding-win32-ia32-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, 'rspack.win32-arm64-msvc.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rspack.win32-arm64-msvc.node')
+          } else {
+            nativeBinding = require('@rspack/binding-win32-arm64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Windows: ${arch}`)
+    }
+    break
+  case 'darwin':
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, 'rspack.darwin-x64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rspack.darwin-x64.node')
+          } else {
+            nativeBinding = require('@rspack/binding-darwin-x64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, 'rspack.darwin-arm64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rspack.darwin-arm64.node')
+          } else {
+            nativeBinding = require('@rspack/binding-darwin-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on macOS: ${arch}`)
+    }
+    break
+  case 'freebsd':
+    if (arch !== 'x64') {
+      throw new Error(`Unsupported architecture on FreeBSD: ${arch}`)
+    }
+    localFileExisted = existsSync(join(__dirname, 'rspack.freebsd-x64.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./rspack.freebsd-x64.node')
+      } else {
+        nativeBinding = require('@rspack/binding-freebsd-x64')
+      }
+    } catch (e) {
+      loadError = e
+    }
+    break
+  case 'linux':
+    switch (arch) {
+      case 'x64':
+        if (isMusl()) {
+          localFileExisted = existsSync(join(__dirname, 'rspack.linux-x64-musl.node'))
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rspack.linux-x64-musl.node')
+            } else {
+              nativeBinding = require('@rspack/binding-linux-x64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(join(__dirname, 'rspack.linux-x64-gnu.node'))
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rspack.linux-x64-gnu.node')
+            } else {
+              nativeBinding = require('@rspack/binding-linux-x64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm64':
+        if (isMusl()) {
+          localFileExisted = existsSync(join(__dirname, 'rspack.linux-arm64-musl.node'))
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rspack.linux-arm64-musl.node')
+            } else {
+              nativeBinding = require('@rspack/binding-linux-arm64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(join(__dirname, 'rspack.linux-arm64-gnu.node'))
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rspack.linux-arm64-gnu.node')
+            } else {
+              nativeBinding = require('@rspack/binding-linux-arm64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm':
+        localFileExisted = existsSync(join(__dirname, 'rspack.linux-arm-gnueabihf.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rspack.linux-arm-gnueabihf.node')
+          } else {
+            nativeBinding = require('@rspack/binding-linux-arm-gnueabihf')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Linux: ${arch}`)
+    }
+    break
+  default:
+    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
+}
+
+if (!nativeBinding) {
+  if (loadError) {
+    throw loadError
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+module.exports.default = module.exports = nativeBinding

package/build.rs

@@ -0,0 +1,5 @@
+extern crate napi_build;
+
+fn main() {
+  napi_build::setup();
+}

package/napirs.rc.json

@@ -0,0 +1,20 @@
+{
+  "napi": {
+    "name": "rspack",
+    "triples": {
+      "defaults": true,
+      "additional": [
+        "x86_64-unknown-linux-musl",
+        "aarch64-unknown-linux-gnu",
+        "i686-pc-windows-msvc",
+        "armv7-unknown-linux-gnueabihf",
+        "aarch64-apple-darwin",
+        "x86_64-unknown-freebsd",
+        "aarch64-unknown-linux-musl",
+        "aarch64-pc-windows-msvc",
+        "aarch64-linux-android",
+        "armv7-linux-androideabi"
+      ]
+    }
+  }
+}

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@rspack/binding",
+  "version": "0.0.2",
+  "description": "Node binding for rspack",
+  "main": "binding.js",
+  "types": "binding.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@napi-rs/cli": "^2.6.2",
+    "why-is-node-running": "2.2.1"
+  },
+  "scripts": {
+    "build": "napi build --platform --js false --dts binding.d.ts --config napirs.rc.json",
+    "build:release": "napi build --release --platform --js false --dts binding.d.ts --config napirs.rc.json"
+  }
+}

package/src/adapter/common.rs

@@ -0,0 +1,11 @@
+use std::sync::Arc;
+
+use dashmap::DashMap;
+use napi::threadsafe_function::{ErrorStrategy, ThreadsafeFunction};
+use once_cell::sync::Lazy;
+use tokio::sync::oneshot::Sender;
+
+pub type ThreadsafeRspackCallback = ThreadsafeFunction<String, ErrorStrategy::CalleeHandled>;
+
+pub static REGISTERED_DONE_SENDERS: Lazy<Arc<DashMap<usize, Sender<()>>>> =
+  Lazy::new(Default::default);

package/src/adapter/mod.rs

@@ -0,0 +1,124 @@
+use std::fmt::Debug;
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+use rspack_core::{Plugin, PluginBuildEndHookOutput};
+
+use anyhow::Context;
+use async_trait::async_trait;
+use napi::threadsafe_function::ThreadsafeFunctionCallMode;
+use napi::Error;
+use napi_derive::napi;
+use once_cell::sync::Lazy;
+use serde::{Deserialize, Serialize};
+use tokio::sync::oneshot;
+
+mod common;
+pub mod utils;
+pub use utils::create_node_adapter_from_plugin_callbacks;
+
+use common::ThreadsafeRspackCallback;
+use common::REGISTERED_DONE_SENDERS;
+
+pub static CALL_ID: Lazy<AtomicUsize> = Lazy::new(|| AtomicUsize::new(1));
+
+pub struct RspackPluginNodeAdapter {
+  pub done_tsfn: ThreadsafeRspackCallback,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct RspackThreadsafeContext<T: Debug> {
+  id: usize,
+  inner: T,
+}
+
+impl<T: Debug> RspackThreadsafeContext<T> {
+  pub fn new(payload: T) -> Self {
+    Self {
+      id: CALL_ID.fetch_add(1, Ordering::SeqCst),
+      inner: payload,
+    }
+  }
+
+  #[inline(always)]
+  pub fn get_call_id(&self) -> usize {
+    self.id
+  }
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct RspackThreadsafeResult<T: Debug> {
+  id: usize,
+  inner: T,
+}
+
+impl<T: Debug> RspackThreadsafeResult<T> {
+  #[inline(always)]
+  pub fn get_call_id(&self) -> usize {
+    self.id
+  }
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[napi(object)]
+pub struct OnLoadContext {
+  pub id: String,
+}
+
+impl Debug for RspackPluginNodeAdapter {
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    f.debug_struct("RspackPluginNodeAdapter").finish()
+  }
+}
+
+#[async_trait]
+impl Plugin for RspackPluginNodeAdapter {
+  fn name(&self) -> &'static str {
+    "rspack_plugin_node_adapter"
+  }
+  #[tracing::instrument(skip_all)]
+  async fn done(&self) -> PluginBuildEndHookOutput {
+    let context = RspackThreadsafeContext::new(());
+
+    let (tx, rx) = oneshot::channel::<()>();
+
+    match REGISTERED_DONE_SENDERS.entry(context.get_call_id()) {
+      dashmap::mapref::entry::Entry::Vacant(v) => {
+        v.insert(tx);
+      }
+      dashmap::mapref::entry::Entry::Occupied(_) => {
+        let err = Error::new(
+          napi::Status::Unknown,
+          format!(
+            "duplicated call id encountered {}, please file an issue.",
+            context.get_call_id(),
+          ),
+        );
+        self
+          .done_tsfn
+          .call(Err(err.clone()), ThreadsafeFunctionCallMode::Blocking);
+
+        let any_error = anyhow::Error::from(err);
+        return Err(any_error.into());
+      }
+    }
+
+    let value = serde_json::to_string(&context).map_err(|_| {
+      Error::new(
+        napi::Status::Unknown,
+        "unable to convert context".to_owned(),
+      )
+    });
+
+    self
+      .done_tsfn
+      .call(value, ThreadsafeFunctionCallMode::Blocking);
+
+    let t = rx
+      .await
+      .context("failed to receive done result")
+      .map_err(|err| err.into());
+    return t;
+  }
+}

package/src/adapter/utils.rs

@@ -0,0 +1,62 @@
+use napi::bindgen_prelude::*;
+use napi::{
+  threadsafe_function::{ErrorStrategy, ThreadSafeResultContext, ThreadsafeFunction},
+  Env,
+};
+
+use super::common::REGISTERED_DONE_SENDERS;
+use crate::PluginCallbacks;
+
+pub fn create_node_adapter_from_plugin_callbacks(
+  env: &Env,
+  plugin_callbacks: Option<PluginCallbacks>,
+) -> Result<Option<super::RspackPluginNodeAdapter>> {
+  plugin_callbacks
+    .map(|PluginCallbacks { done_callback }| {
+      let mut done_tsfn: ThreadsafeFunction<String, ErrorStrategy::CalleeHandled> = done_callback
+        .create_threadsafe_function(
+        0,
+        |ctx| ctx.env.create_string_from_std(ctx.value).map(|v| vec![v]),
+        |ctx: ThreadSafeResultContext<Promise<String>>| {
+          let return_value = ctx.return_value;
+
+          ctx
+            .env
+            .execute_tokio_future(
+              async move {
+                let result = return_value.await?;
+
+                let result: super::RspackThreadsafeResult<()> =
+                  serde_json::from_str(&result).expect("failed to evaluate done result");
+
+                tracing::debug!("build end result {:?}", result);
+
+                let sender = REGISTERED_DONE_SENDERS.remove(&result.get_call_id());
+
+                if let Some((_, sender)) = sender {
+                  sender.send(()).map_err(|m| {
+                    Error::new(
+                      napi::Status::GenericFailure,
+                      format!("failed to send result {:#?}", m),
+                    )
+                  })?;
+                } else {
+                  return Err(Error::new(
+                    napi::Status::GenericFailure,
+                    "failed to get sender for plugin".to_owned(),
+                  ));
+                }
+
+                Ok(())
+              },
+              |_, ret| Ok(ret),
+            )
+            .expect("failed to execute tokio future");
+        },
+      )?;
+      done_tsfn.unref(env)?;
+
+      Ok(super::RspackPluginNodeAdapter { done_tsfn })
+    })
+    .transpose()
+}