Add BigInt support and more nj-core support for N-API v7.

CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## Unreleased
+- Support for converting to/from [Rust BigInt][rust-bigint] to/from [JavaScript BigInt][js-bigint] ([#97][]).
+- Support for converting Rust `u64` to BigInt in JavaScript. ([#97][])
+- Updated to N-API v7 in `js-sys`. ([#97][])
+
+[rust-bigint]: https://crates.io/crates/num-bigint
+[js-bigint]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt
+[#97]: https://github.com/infinyon/node-bindgen/pull/97
+
 ## [3.0.0] - 2020-10-14-2000
 - Support for Passing Buffer to Rust
 - Support for Env cleanup
@@ -11,7 +20,7 @@
 - Support for Array [#26](https://github.com/infinyon/node-bindgen/pull/26)
 
 ## Fixed
-- Fixed conversion of () [#31](https://github.com/infinyon/node-bindgen/pull/31)
+- Fixed conversion of `()` [#31](https://github.com/infinyon/node-bindgen/pull/31)
 
 # [2.0.0] - 2020-05-011
 
@@ -21,4 +30,4 @@
 
 ## Fixed
 
-- Proper support for boolean [#19](https://github.com/infinyon/node-bindgen/pull/19)
+- Proper support for boolean [#19](https://github.com/infinyon/node-bindgen/pull/19)

examples/Cargo.toml

@@ -14,8 +14,9 @@ members = [
     "buffer",
     "array",
     "electron",
-    "cleanup"
+    "cleanup",
+    "bigint",
 ]
 
 #[patch.crates-io]
-#flv-future-aio = { path = "../../flv-future/src/future-aio"}
+#flv-future-aio = { path = "../../flv-future/src/future-aio"}

examples/Makefile

@@ -11,11 +11,13 @@ clean:
 	make -C class-async clean
 	make -C param clean
 	make -C electron clean
+	make -C bigint clean
 	make -C cleanup clean
 
 
 test: test-function test-cb test-async-cb test-promise test-json test-class-simple \
-	test-class-wrapper test-class-async test-stream test-buffer test-array test-cleanup
+	test-class-wrapper test-class-async test-stream test-buffer test-array test-bigint \
+	test-cleanup
 
 test-function:
 	make -C function test
@@ -56,5 +58,8 @@ test-array:
 test-electron:
 	make -C electron test
 
+test-bigint:
+	make -C bigint test
+
 test-cleanup:
-	make -C cleanup test
+	make -C cleanup test

examples/bigint/.gitignore

@@ -0,0 +1 @@
+dist

examples/bigint/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "nj-example-bigint"
+version = "0.1.0"
+authors = ["fluvio.io"]
+edition = "2018"
+
+
+[lib]
+crate-type = ["cdylib"]
+
+
+[dependencies]
+node-bindgen = { path = "../.."}
+
+
+[build-dependencies]
+node-bindgen = { path = "../../", features = ["build"] }

examples/bigint/Makefile

@@ -0,0 +1,12 @@
+all:	build
+
+build:
+	nj-cli build
+
+test:	build
+	node test.js
+
+
+clean:
+	rm -rf dist
+

examples/bigint/README.md

@@ -0,0 +1 @@
+manual JS callback

examples/bigint/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+    node_bindgen::build::configure();
+}

examples/bigint/src/lib.rs

@@ -0,0 +1,30 @@
+use node_bindgen::derive::node_bindgen;
+use node_bindgen::core::bigint::BigInt;
+
+// example where we multiply a big_int.
+#[node_bindgen]
+fn multiply_big_int(arg: BigInt) -> BigInt {
+    println!("bigint arg: {}", arg);
+    arg*2
+}
+
+// Test that we can go across the FFI without screwing up the bits.
+#[node_bindgen]
+fn do_nothing(arg: BigInt) -> BigInt {
+    println!("bigint arg: {}", arg);
+    arg
+}
+
+// Test out the signage conversion
+#[node_bindgen]
+fn go_negative(arg: BigInt) -> BigInt {
+    println!("bigint arg: {}", arg);
+    -1*arg
+}
+
+// Test out that we can return a u64 which is automatically converted to a bigint.
+#[node_bindgen]
+fn return_u64(arg: u32) -> u64 {
+    println!("bigint arg: {}", arg);
+    arg as u64
+}

examples/bigint/test.js

@@ -0,0 +1,22 @@
+const assert = require('assert');
+
+let addon = require('./dist');
+
+const hugeBin = BigInt("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")
+
+// Test that we can go back and forth through the FFI
+assert.equal(addon.doNothing(hugeBin), hugeBin);
+
+// Test out some signage
+assert.equal(addon.goNegative(hugeBin), hugeBin*BigInt(-1));
+
+// How about multiplication?
+assert.equal(addon.multiplyBigInt(hugeBin), hugeBin*(BigInt(2)));
+
+// Basic tests from js-env
+assert.equal(addon.multiplyBigInt(BigInt(-5)), BigInt(-10));
+assert.equal(addon.multiplyBigInt(BigInt(5)), BigInt(10));
+assert.equal(addon.multiplyBigInt(BigInt(5)), BigInt(10));
+
+// Rust's u64s turn into JS BigInts.
+assert.equal(addon.returnU64(5), BigInt(5));

examples/js-env/src/lib.rs

@@ -9,8 +9,8 @@ use node_bindgen::core::val::JsEnv;
 /// JsEnv argument does not manipulate JsCb arguments
 #[node_bindgen]
 fn multiply(env: JsEnv, arg: f64) -> Result<napi_value, NjError> {
-    
+
     println!("arg: {}",arg);
     env.create_double(arg * 2.0)
-} 
+}
 

examples/js-env/test.js

@@ -2,4 +2,4 @@ const assert = require('assert');
 
 let addon = require('./dist');
 
-assert.equal(addon.multiply(5),10);
+assert.equal(addon.multiply(5), 10);

nj-core/Cargo.toml

@@ -21,3 +21,4 @@ futures-lite = "1.7.0"
 nj-sys = { version = "1.0.0", path = "../nj-sys" }
 fluvio-future = { version = "0.1.0", default-features=false, features=["task","subscriber"]}
 pin-utils = "0.1.0"
+num-bigint = "0.3.0"

nj-core/src/basic.rs

@@ -154,6 +154,18 @@ impl JsEnv {
         Ok(result)
     }
 
+    pub fn create_bigint_uint64(&self, value: u64) -> Result<napi_value,NjError> {
+        let mut result = ptr::null_mut();
+        napi_call_result!(
+            crate::sys::napi_create_bigint_uint64(
+                self.0,
+                value,
+                &mut result
+            )
+        )?;
+        Ok(result)
+    }
+
     pub fn create_object(&self) -> Result<napi_value,NjError>  {
 
         let mut result = ptr::null_mut();
@@ -725,6 +737,27 @@ impl JsEnv {
 
     }
 
+    /// Detach ArrayBuffer
+    pub fn detach_arraybuffer(&self, napi_value: napi_value) -> Result<(),NjError> {
+        napi_call_result!(
+            crate::sys::napi_detach_arraybuffer(self.inner(), napi_value)
+        )?;
+        Ok(())
+    }
+
+    /// Is this ArrayBuffer Detached?
+    pub fn is_detached_arraybuffer(&self, napi_value: napi_value) -> Result<bool,NjError> {
+        let mut is_detached = false;
+        napi_call_result!(
+            crate::sys::napi_is_detached_arraybuffer(
+                self.inner(),
+                napi_value,
+                &mut is_detached,
+                )
+        )?;
+        Ok(is_detached)
+    }
+
     #[allow(unused_unsafe)]
     #[allow(clippy::missing_safety_doc)]
     pub unsafe fn add_env_clean_up_hook(

nj-core/src/bigint.rs

@@ -0,0 +1,111 @@
+use std::ptr;
+use log::trace;
+
+use crate::TryIntoJs;
+use crate::JSValue;
+use crate::sys::napi_value;
+use crate::val::JsEnv;
+use crate::NjError;
+
+pub use num_bigint::*;
+
+impl<'a> JSValue<'a> for BigInt {
+    fn convert_to_rust(env: &'a JsEnv, js_value: napi_value) -> Result<Self, NjError> {
+        trace!("Converting JS BigInt to Rust!");
+
+        env.assert_type(js_value, crate::sys::napi_valuetype_napi_bigint)?;
+        let mut word_count: usize = 0;
+
+        // https://nodejs.org/api/n-api.html#n_api_napi_get_value_bigint_words
+        // Frist call is to figure out how long of a vec to make.
+        crate::napi_call_result!(crate::sys::napi_get_value_bigint_words(
+            env.inner(),
+            js_value,
+            ptr::null_mut(),
+            &mut word_count,
+            ptr::null_mut(),
+        ))?;
+
+        // Now we actually get the sign and the vector.
+        let mut napi_buffer: Vec<u64> = vec![0; word_count];
+        let mut sign = 0;
+
+        crate::napi_call_result!(crate::sys::napi_get_value_bigint_words(
+            env.inner(),
+            js_value,
+            &mut sign,
+            &mut word_count,
+            napi_buffer.as_mut_ptr(),
+        ))?;
+
+        // BigInt is initialized via a little endian &[u8] so we need to build the u8s from the
+        // u64s
+        let mut bytes: Vec<u8> = Vec::new();
+        for i in &napi_buffer {
+            bytes.extend_from_slice(&i.to_le_bytes());
+        }
+
+        // The N-API documentation on the signs is lacking.
+        let sign = match sign {
+            0 => Sign::Plus,
+            1 => Sign::Minus,
+            _ => unreachable!(),
+        };
+        let res = BigInt::from_bytes_le(sign, &bytes);
+        trace!(
+            "Converted JS BigInt to Rust! words: {:#X?}, bytes: {:#?}, len: {:?}, bigint: {:#?}",
+            napi_buffer,
+            bytes,
+            bytes.len(),
+            res
+        );
+        Ok(res)
+    }
+}
+
+impl TryIntoJs for BigInt {
+    fn try_to_js(self, env: &JsEnv) -> Result<napi_value, NjError> {
+        let (sign, bytes) = self.to_bytes_le();
+        let mut words: Vec<u64> = Vec::new();
+        use std::cmp::min;
+
+        // bytes can be non-multiples of 8.
+        for i in 0..(bytes.len()/8 + 1) {
+            let mut slice : [u8; 8] = [0;8];
+
+            // https://stackoverflow.com/a/29784723 seems to be the least bad way to convert a Vec
+            // slice into an array :/
+            for (place, element) in slice.iter_mut().zip(bytes[i*8..min((i+1)*8, bytes.len())].iter()) {
+                *place = *element;
+            }
+            words.push(u64::from_le_bytes(slice));
+        }
+        let sign = match sign {
+            Sign::Minus => 1,
+            Sign::Plus | Sign::NoSign => 0,
+        };
+        let word_count = words.len();
+
+        trace!(
+            "Converted Rust BigInt to JS Bigint: {:#?}!, bytes: {:#?}, len: {:?}, words: {:#?}, word_count {:#?}, sign: {:#?}",
+            self,
+            bytes,
+            bytes.len(),
+            words,
+            word_count,
+            sign,
+        );
+
+        let mut napi_buffer = ptr::null_mut();
+
+        // https://nodejs.org/api/n-api.html#n_api_napi_create_bigint_words
+        crate::napi_call_result!(crate::sys::napi_create_bigint_words(
+            env.inner(),
+            sign,
+            word_count,
+            words.as_ptr(),
+            &mut napi_buffer
+        ))?;
+        Ok(napi_buffer)
+    }
+}

nj-core/src/convert.rs

@@ -40,6 +40,11 @@ impl TryIntoJs for i32 {
         js_env.create_int32(self)
     }
 }
+impl TryIntoJs for u64 {
+    fn try_to_js(self, js_env: &JsEnv) -> Result<napi_value,NjError> {
+        js_env.create_bigint_uint64(self)
+    }
+}
 
 
 impl TryIntoJs for String {

nj-core/src/lib.rs

@@ -7,6 +7,7 @@ mod worker;
 mod convert;
 mod module;
 pub mod buffer;
+pub mod bigint;
 pub mod stream;
 
 pub use thread_fn::ThreadSafeFunction;