From 9aeec3cfa8d34e873dafd938069448d5dfc30326 Mon Sep 17 00:00:00 2001 From: Christien Rioux Date: Thu, 31 Aug 2023 22:01:00 -0400 Subject: [PATCH] build fixes and cleanup --- Cargo.lock | 9 -- Cargo.toml | 1 - tsify-async/Cargo.toml | 14 ---- tsify-async/src/lib.rs | 30 ------- veilid-core/Cargo.toml | 5 +- .../src/crypto/types/byte_array_types.rs | 12 +-- veilid-core/src/crypto/types/crypto_typed.rs | 3 +- .../src/crypto/types/crypto_typed_group.rs | 5 +- veilid-core/src/crypto/types/mod.rs | 22 ++--- veilid-core/src/lib.rs | 5 +- veilid-core/src/veilid_api/error.rs | 18 +--- .../src/veilid_api/types/aligned_u64.rs | 22 ++--- .../src/veilid_api/types/app_message_call.rs | 10 ++- veilid-core/src/veilid_api/types/dht/mod.rs | 4 +- .../src/veilid_api/types/dht/value_data.rs | 5 +- veilid-core/src/veilid_api/types/fourcc.rs | 14 +--- .../src/veilid_api/types/veilid_log.rs | 9 +- .../src/veilid_api/types/veilid_state.rs | 36 +++++--- veilid-core/src/veilid_config.rs | 83 ++++++++++++------- veilid-core/src/wasm_helpers.rs | 21 +++++ veilid-wasm/src/lib.rs | 18 ++-- 21 files changed, 160 insertions(+), 186 deletions(-) delete mode 100644 tsify-async/Cargo.toml delete mode 100644 tsify-async/src/lib.rs create mode 100644 veilid-core/src/wasm_helpers.rs diff --git a/Cargo.lock b/Cargo.lock index 015ad59a..cdc6fc79 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -5396,15 +5396,6 @@ dependencies = [ "wasm-bindgen", ] -[[package]] -name = "tsify-async" -version = "0.1.0" -dependencies = [ - "quote", - "serde-wasm-bindgen", - "syn 1.0.109", -] - [[package]] name = "tsify-macros" version = "0.4.5" diff --git a/Cargo.toml b/Cargo.toml index eaa3bf6f..61d53ad7 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -6,7 +6,6 @@ members = [ "veilid-cli", "veilid-flutter/rust", "veilid-wasm", - "tsify-async" ] exclude = ["./external"] diff --git a/tsify-async/Cargo.toml b/tsify-async/Cargo.toml deleted file mode 100644 index 192733fc..00000000 --- a/tsify-async/Cargo.toml +++ /dev/null @@ -1,14 +0,0 @@ -[package] -name = "tsify-async" -version = "0.1.0" -edition = "2021" - -# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html - -[lib] -proc-macro = true - -[dependencies] -syn = "1.0" -quote = "1.0" -serde-wasm-bindgen = "0.5.0" diff --git a/tsify-async/src/lib.rs b/tsify-async/src/lib.rs deleted file mode 100644 index 4e4f75b7..00000000 --- a/tsify-async/src/lib.rs +++ /dev/null @@ -1,30 +0,0 @@ -// Copied from https://github.com/madonoharu/tsify/issues/24#issuecomment-1670228789 -// TODO: I think this had more to do with: -// the trait `From` is not implemented for `wasm_bindgen::JsValue` -// than it does with tsify itself... Maybe rename to something else? - -use proc_macro::TokenStream; -use quote::quote; -use syn; - -#[proc_macro_derive(TsifyAsync)] -pub fn tsify_async_macro_derive(input: TokenStream) -> TokenStream { - // Construct a representation of Rust code as a syntax tree - // that we can manipulate - let ast = syn::parse(input).unwrap(); - - // Build the trait implementation - impl_tsify_async_macro(&ast) -} - -fn impl_tsify_async_macro(ast: &syn::DeriveInput) -> TokenStream { - let name = &ast.ident; - let gen = quote! { - impl From<#name> for JsValue { - fn from(value: #name) -> Self { - serde_wasm_bindgen::to_value(&value).unwrap() - } - } - }; - gen.into() -} diff --git a/veilid-core/Cargo.toml b/veilid-core/Cargo.toml index 1a1be691..96f2d9aa 100644 --- a/veilid-core/Cargo.toml +++ b/veilid-core/Cargo.toml @@ -140,9 +140,6 @@ lz4_flex = { version = "0.11.1", default-features = false, features = [ "safe-encode", "safe-decode", ] } -tsify = { version = "0.4.5", features = ["js"] } -wasm-bindgen = "^0" -serde-wasm-bindgen = "0.5.0" # Dependencies for native builds only # Linux, Windows, Mac, iOS, Android @@ -202,6 +199,8 @@ wasm-bindgen = "0.2.87" js-sys = "0.3.64" wasm-bindgen-futures = "0.4.37" send_wrapper = { version = "0.6.0", features = ["futures"] } +tsify = { version = "0.4.5", features = ["js"] } +serde-wasm-bindgen = "0.5.0" # Network ws_stream_wasm = "0.7.4" diff --git a/veilid-core/src/crypto/types/byte_array_types.rs b/veilid-core/src/crypto/types/byte_array_types.rs index 84995829..d3bdee80 100644 --- a/veilid-core/src/crypto/types/byte_array_types.rs +++ b/veilid-core/src/crypto/types/byte_array_types.rs @@ -293,17 +293,17 @@ macro_rules! byte_array_type { byte_array_type!(CryptoKey, CRYPTO_KEY_LENGTH, CRYPTO_KEY_LENGTH_ENCODED); -#[declare] +#[cfg_attr(target_arch = "wasm32", declare)] pub type PublicKey = CryptoKey; -#[declare] +#[cfg_attr(target_arch = "wasm32", declare)] pub type SecretKey = CryptoKey; -#[declare] +#[cfg_attr(target_arch = "wasm32", declare)] pub type HashDigest = CryptoKey; -#[declare] +#[cfg_attr(target_arch = "wasm32", declare)] pub type SharedSecret = CryptoKey; -#[declare] +#[cfg_attr(target_arch = "wasm32", declare)] pub type RouteId = CryptoKey; -#[declare] +#[cfg_attr(target_arch = "wasm32", declare)] pub type CryptoKeyDistance = CryptoKey; byte_array_type!(Signature, SIGNATURE_LENGTH, SIGNATURE_LENGTH_ENCODED); diff --git a/veilid-core/src/crypto/types/crypto_typed.rs b/veilid-core/src/crypto/types/crypto_typed.rs index 4a59ae20..4717b72a 100644 --- a/veilid-core/src/crypto/types/crypto_typed.rs +++ b/veilid-core/src/crypto/types/crypto_typed.rs @@ -1,6 +1,7 @@ use super::*; -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Tsify)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct CryptoTyped where K: Clone diff --git a/veilid-core/src/crypto/types/crypto_typed_group.rs b/veilid-core/src/crypto/types/crypto_typed_group.rs index ff93df00..77d0974c 100644 --- a/veilid-core/src/crypto/types/crypto_typed_group.rs +++ b/veilid-core/src/crypto/types/crypto_typed_group.rs @@ -1,8 +1,7 @@ use super::*; -#[derive( - Clone, Debug, Serialize, Deserialize, PartialOrd, Ord, PartialEq, Eq, Hash, Default, Tsify, -)] +#[derive(Clone, Debug, Serialize, Deserialize, PartialOrd, Ord, PartialEq, Eq, Hash, Default)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] #[serde(from = "Vec>", into = "Vec>")] // TODO: figure out hot to TS type this as `string`, since it's converted to string via the JSON API. pub struct CryptoTypedGroup diff --git a/veilid-core/src/crypto/types/mod.rs b/veilid-core/src/crypto/types/mod.rs index a1f2026d..e3f24a81 100644 --- a/veilid-core/src/crypto/types/mod.rs +++ b/veilid-core/src/crypto/types/mod.rs @@ -6,7 +6,7 @@ use core::fmt; use core::hash::Hash; /// Cryptography version fourcc code -#[declare] +#[cfg_attr(target_arch = "wasm32", declare)] pub type CryptoKind = FourCC; /// Sort best crypto kinds first @@ -52,24 +52,24 @@ pub use crypto_typed::*; pub use crypto_typed_group::*; pub use keypair::*; -#[declare] +#[cfg_attr(target_arch = "wasm32", declare)] pub type TypedKey = CryptoTyped; -#[declare] +#[cfg_attr(target_arch = "wasm32", declare)] pub type TypedSecret = CryptoTyped; -#[declare] +#[cfg_attr(target_arch = "wasm32", declare)] pub type TypedKeyPair = CryptoTyped; -#[declare] +#[cfg_attr(target_arch = "wasm32", declare)] pub type TypedSignature = CryptoTyped; -#[declare] +#[cfg_attr(target_arch = "wasm32", declare)] pub type TypedSharedSecret = CryptoTyped; -#[declare] +#[cfg_attr(target_arch = "wasm32", declare)] pub type TypedKeyGroup = CryptoTypedGroup; -#[declare] +#[cfg_attr(target_arch = "wasm32", declare)] pub type TypedSecretGroup = CryptoTypedGroup; -#[declare] +#[cfg_attr(target_arch = "wasm32", declare)] pub type TypedKeyPairGroup = CryptoTypedGroup; -#[declare] +#[cfg_attr(target_arch = "wasm32", declare)] pub type TypedSignatureGroup = CryptoTypedGroup; -#[declare] +#[cfg_attr(target_arch = "wasm32", declare)] pub type TypedSharedSecretGroup = CryptoTypedGroup; diff --git a/veilid-core/src/lib.rs b/veilid-core/src/lib.rs index 1a53fd73..f2cb5df9 100644 --- a/veilid-core/src/lib.rs +++ b/veilid-core/src/lib.rs @@ -56,6 +56,7 @@ mod table_store; mod veilid_api; mod veilid_config; mod veilid_layer_filter; +mod wasm_helpers; pub use self::api_tracing_layer::ApiTracingLayer; pub use self::core_context::{api_startup, api_startup_json, UpdateCallback}; @@ -126,7 +127,5 @@ use serde::*; use stop_token::*; use thiserror::Error as ThisError; use tracing::*; -use tsify::*; -use tsify_async::*; use veilid_tools::*; -use wasm_bindgen::prelude::*; +use wasm_helpers::*; diff --git a/veilid-core/src/veilid_api/error.rs b/veilid-core/src/veilid_api/error.rs index 170a4146..d6999118 100644 --- a/veilid-core/src/veilid_api/error.rs +++ b/veilid-core/src/veilid_api/error.rs @@ -105,21 +105,10 @@ macro_rules! apibail_already_initialized { } #[derive( - ThisError, - Clone, - Debug, - PartialOrd, - PartialEq, - Eq, - Ord, - Serialize, - Deserialize, - JsonSchema, - Tsify, - TsifyAsync, + ThisError, Clone, Debug, PartialOrd, PartialEq, Eq, Ord, Serialize, Deserialize, JsonSchema, )] +#[cfg_attr(target_arch = "wasm32", derive(Tsify), tsify(into_wasm_abi))] #[serde(tag = "kind")] -#[tsify(into_wasm_abi)] pub enum VeilidAPIError { #[error("Not initialized")] NotInitialized, @@ -157,6 +146,7 @@ pub enum VeilidAPIError { #[error("Generic: {message}")] Generic { message: String }, } +from_impl_to_jsvalue!(VeilidAPIError); impl VeilidAPIError { pub fn not_initialized() -> Self { @@ -225,7 +215,7 @@ impl VeilidAPIError { } } -#[declare] +#[cfg_attr(target_arch = "wasm32", declare)] pub type VeilidAPIResult = Result; impl From for VeilidAPIError { diff --git a/veilid-core/src/veilid_api/types/aligned_u64.rs b/veilid-core/src/veilid_api/types/aligned_u64.rs index 32b5ceb1..1e2e9332 100644 --- a/veilid-core/src/veilid_api/types/aligned_u64.rs +++ b/veilid-core/src/veilid_api/types/aligned_u64.rs @@ -6,19 +6,9 @@ use super::*; /// Supports serializing to string for JSON as well, since JSON can't handle 64-bit numbers to Javascript #[derive( - Clone, - Default, - PartialEq, - Eq, - PartialOrd, - Ord, - Copy, - Hash, - Serialize, - Deserialize, - JsonSchema, - Tsify, + Clone, Default, PartialEq, Eq, PartialOrd, Ord, Copy, Hash, Serialize, Deserialize, JsonSchema, )] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] #[repr(C, align(8))] #[serde(transparent)] pub struct AlignedU64( @@ -128,17 +118,17 @@ impl AlignedU64 { ///////////////////////////////////////////////////////////////////////////////////////////////////// /// Microseconds since epoch -#[declare] +#[cfg_attr(target_arch = "wasm32", declare)] pub type Timestamp = AlignedU64; pub fn get_aligned_timestamp() -> Timestamp { get_timestamp().into() } /// Microseconds duration -#[declare] +#[cfg_attr(target_arch = "wasm32", declare)] pub type TimestampDuration = AlignedU64; /// Request/Response matching id -#[declare] +#[cfg_attr(target_arch = "wasm32", declare)] pub type OperationId = AlignedU64; /// Number of bytes -#[declare] +#[cfg_attr(target_arch = "wasm32", declare)] pub type ByteCount = AlignedU64; diff --git a/veilid-core/src/veilid_api/types/app_message_call.rs b/veilid-core/src/veilid_api/types/app_message_call.rs index 6959ad17..01ec3d76 100644 --- a/veilid-core/src/veilid_api/types/app_message_call.rs +++ b/veilid-core/src/veilid_api/types/app_message_call.rs @@ -1,11 +1,12 @@ use super::*; /// Direct statement blob passed to hosting application for processing -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)] +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct VeilidAppMessage { #[serde(with = "as_human_opt_string")] #[schemars(with = "Option")] - #[tsify(optional)] + #[cfg_attr(target_arch = "wasm32", tsify(optional))] sender: Option, #[serde(with = "as_human_base64")] @@ -30,11 +31,12 @@ impl VeilidAppMessage { } /// Direct question blob passed to hosting application for processing to send an eventual AppReply -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)] +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct VeilidAppCall { #[serde(with = "as_human_opt_string")] #[schemars(with = "Option")] - #[tsify(optional)] + #[cfg_attr(target_arch = "wasm32", tsify(optional))] sender: Option, #[serde(with = "as_human_base64")] diff --git a/veilid-core/src/veilid_api/types/dht/mod.rs b/veilid-core/src/veilid_api/types/dht/mod.rs index 9830042b..bd7b93eb 100644 --- a/veilid-core/src/veilid_api/types/dht/mod.rs +++ b/veilid-core/src/veilid_api/types/dht/mod.rs @@ -11,8 +11,8 @@ pub use value_data::*; pub use value_subkey_range_set::*; /// Value subkey -#[declare] +#[cfg_attr(target_arch = "wasm32", declare)] pub type ValueSubkey = u32; /// Value sequence number -#[declare] +#[cfg_attr(target_arch = "wasm32", declare)] pub type ValueSeqNum = u32; diff --git a/veilid-core/src/veilid_api/types/dht/value_data.rs b/veilid-core/src/veilid_api/types/dht/value_data.rs index 6a89388d..9a3d0fe7 100644 --- a/veilid-core/src/veilid_api/types/dht/value_data.rs +++ b/veilid-core/src/veilid_api/types/dht/value_data.rs @@ -1,9 +1,8 @@ use super::*; use veilid_api::VeilidAPIResult; -#[derive( - Clone, Default, PartialOrd, PartialEq, Eq, Ord, Serialize, Deserialize, JsonSchema, Tsify, -)] +#[derive(Clone, Default, PartialOrd, PartialEq, Eq, Ord, Serialize, Deserialize, JsonSchema)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct ValueData { /// An increasing sequence number to time-order the DHT record changes seq: ValueSeqNum, diff --git a/veilid-core/src/veilid_api/types/fourcc.rs b/veilid-core/src/veilid_api/types/fourcc.rs index 8325a48e..21f8db50 100644 --- a/veilid-core/src/veilid_api/types/fourcc.rs +++ b/veilid-core/src/veilid_api/types/fourcc.rs @@ -2,19 +2,9 @@ use super::*; /// FOURCC code #[derive( - Copy, - Default, - Clone, - Hash, - PartialOrd, - Ord, - PartialEq, - Eq, - Serialize, - Deserialize, - JsonSchema, - Tsify, + Copy, Default, Clone, Hash, PartialOrd, Ord, PartialEq, Eq, Serialize, Deserialize, JsonSchema, )] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] #[serde(try_from = "String")] #[serde(into = "String")] pub struct FourCC(pub [u8; 4]); diff --git a/veilid-core/src/veilid_api/types/veilid_log.rs b/veilid-core/src/veilid_api/types/veilid_log.rs index 7289e281..2e8c9bf6 100644 --- a/veilid-core/src/veilid_api/types/veilid_log.rs +++ b/veilid-core/src/veilid_api/types/veilid_log.rs @@ -2,9 +2,9 @@ use super::*; /// Log level for VeilidCore #[derive( - Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Copy, Serialize, Deserialize, JsonSchema, Tsify, + Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Copy, Serialize, Deserialize, JsonSchema, )] -#[tsify(namespace)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify), tsify(namespace))] pub enum VeilidLogLevel { Error = 1, Warn = 2, @@ -80,10 +80,11 @@ impl fmt::Display for VeilidLogLevel { } } /// A VeilidCore log message with optional backtrace -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)] +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct VeilidLog { pub log_level: VeilidLogLevel, pub message: String, - #[tsify(optional)] + #[cfg_attr(target_arch = "wasm32", tsify(optional))] pub backtrace: Option, } diff --git a/veilid-core/src/veilid_api/types/veilid_state.rs b/veilid-core/src/veilid_api/types/veilid_state.rs index 496aaeac..8443572b 100644 --- a/veilid-core/src/veilid_api/types/veilid_state.rs +++ b/veilid-core/src/veilid_api/types/veilid_state.rs @@ -1,8 +1,12 @@ use super::*; /// Attachment abstraction for network 'signal strength' -#[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize, Deserialize, JsonSchema, Tsify)] -#[tsify(namespace, from_wasm_abi, into_wasm_abi)] +#[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize, Deserialize, JsonSchema)] +#[cfg_attr( + target_arch = "wasm32", + derive(Tsify), + tsify(namespace, from_wasm_abi, into_wasm_abi) +)] pub enum AttachmentState { Detached = 0, Attaching = 1, @@ -48,14 +52,16 @@ impl TryFrom for AttachmentState { } } -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)] +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct VeilidStateAttachment { pub state: AttachmentState, pub public_internet_ready: bool, pub local_network_ready: bool, } -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)] +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct PeerTableData { #[schemars(with = "Vec")] pub node_ids: Vec, @@ -63,7 +69,8 @@ pub struct PeerTableData { pub peer_stats: PeerStats, } -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)] +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct VeilidStateNetwork { pub started: bool, pub bps_down: ByteCount, @@ -71,7 +78,8 @@ pub struct VeilidStateNetwork { pub peers: Vec, } -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)] +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct VeilidRouteChange { #[schemars(with = "Vec")] pub dead_routes: Vec, @@ -79,12 +87,14 @@ pub struct VeilidRouteChange { pub dead_remote_routes: Vec, } -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)] +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct VeilidStateConfig { pub config: VeilidConfigInner, } -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)] +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct VeilidValueChange { #[schemars(with = "String")] pub key: TypedKey, @@ -93,9 +103,9 @@ pub struct VeilidValueChange { pub value: ValueData, } -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify, TsifyAsync)] +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify), tsify(into_wasm_abi))] #[serde(tag = "kind")] -#[tsify(into_wasm_abi)] pub enum VeilidUpdate { Log(VeilidLog), AppMessage(VeilidAppMessage), @@ -107,11 +117,13 @@ pub enum VeilidUpdate { ValueChange(VeilidValueChange), Shutdown, } +from_impl_to_jsvalue!(VeilidUpdate); -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify, TsifyAsync)] -#[tsify(into_wasm_abi)] +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify), tsify(into_wasm_abi))] pub struct VeilidState { pub attachment: VeilidStateAttachment, pub network: VeilidStateNetwork, pub config: VeilidStateConfig, } +from_impl_to_jsvalue!(VeilidState); diff --git a/veilid-core/src/veilid_config.rs b/veilid-core/src/veilid_config.rs index 8aee0819..d8c6d67e 100644 --- a/veilid-core/src/veilid_config.rs +++ b/veilid-core/src/veilid_config.rs @@ -1,9 +1,9 @@ use crate::*; //////////////////////////////////////////////////////////////////////////////////////////////// -#[declare] +#[cfg_attr(target_arch = "wasm32", declare)] pub type ConfigCallbackReturn = VeilidAPIResult>; -#[declare] +#[cfg_attr(target_arch = "wasm32", declare)] pub type ConfigCallback = Arc ConfigCallbackReturn + Send + Sync>; /// Enable and configure HTTPS access to the Veilid node @@ -16,12 +16,13 @@ pub type ConfigCallback = Arc ConfigCallbackReturn + Send + Sy /// url: 'https://localhost:5150' /// ``` /// -#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)] +#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct VeilidConfigHTTPS { pub enabled: bool, pub listen_address: String, pub path: String, - #[tsify(optional)] + #[cfg_attr(target_arch = "wasm32", tsify(optional))] pub url: Option, // Fixed URL is not optional for TLS-based protocols and is dynamically validated } @@ -35,12 +36,13 @@ pub struct VeilidConfigHTTPS { /// url: 'https://localhost:5150' /// ``` /// -#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)] +#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct VeilidConfigHTTP { pub enabled: bool, pub listen_address: String, pub path: String, - #[tsify(optional)] + #[cfg_attr(target_arch = "wasm32", tsify(optional))] pub url: Option, } @@ -50,7 +52,8 @@ pub struct VeilidConfigHTTP { /// /// To be implemented... /// -#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)] +#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct VeilidConfigApplication { pub https: VeilidConfigHTTPS, pub http: VeilidConfigHTTP, @@ -66,12 +69,13 @@ pub struct VeilidConfigApplication { /// public_address: '' /// ``` /// -#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)] +#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct VeilidConfigUDP { pub enabled: bool, pub socket_pool_size: u32, pub listen_address: String, - #[tsify(optional)] + #[cfg_attr(target_arch = "wasm32", tsify(optional))] pub public_address: Option, } @@ -85,13 +89,14 @@ pub struct VeilidConfigUDP { /// listen_address: ':5150' /// public_address: '' /// -#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)] +#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct VeilidConfigTCP { pub connect: bool, pub listen: bool, pub max_connections: u32, pub listen_address: String, - #[tsify(optional)] + #[cfg_attr(target_arch = "wasm32", tsify(optional))] pub public_address: Option, } @@ -106,7 +111,8 @@ pub struct VeilidConfigTCP { /// path: 'ws' /// url: 'ws://localhost:5150/ws' /// -#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)] +#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct VeilidConfigWS { pub connect: bool, @@ -114,7 +120,7 @@ pub struct VeilidConfigWS { pub max_connections: u32, pub listen_address: String, pub path: String, - #[tsify(optional)] + #[cfg_attr(target_arch = "wasm32", tsify(optional))] pub url: Option, } @@ -129,7 +135,8 @@ pub struct VeilidConfigWS { /// path: 'ws' /// url: '' /// -#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)] +#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct VeilidConfigWSS { pub connect: bool, @@ -137,7 +144,7 @@ pub struct VeilidConfigWSS { pub max_connections: u32, pub listen_address: String, pub path: String, - #[tsify(optional)] + #[cfg_attr(target_arch = "wasm32", tsify(optional))] pub url: Option, // Fixed URL is not optional for TLS-based protocols and is dynamically validated } @@ -148,7 +155,8 @@ pub struct VeilidConfigWSS { /// All protocols are available by default, and the Veilid node will /// sort out which protocol is used for each peer connection. /// -#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)] +#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct VeilidConfigProtocol { pub udp: VeilidConfigUDP, @@ -165,7 +173,8 @@ pub struct VeilidConfigProtocol { /// private_key_path: /path/to/private/key /// connection_initial_timeout_ms: 2000 /// -#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)] +#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct VeilidConfigTLS { pub certificate_path: String, pub private_key_path: String, @@ -174,7 +183,8 @@ pub struct VeilidConfigTLS { /// Configure the Distributed Hash Table (DHT) /// -#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)] +#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct VeilidConfigDHT { pub max_find_node_count: u32, pub resolve_node_timeout_ms: u32, @@ -199,13 +209,14 @@ pub struct VeilidConfigDHT { /// Configure RPC /// -#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)] +#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct VeilidConfigRPC { pub concurrency: u32, pub queue_size: u32, - #[tsify(optional)] + #[cfg_attr(target_arch = "wasm32", tsify(optional))] pub max_timestamp_behind_ms: Option, - #[tsify(optional)] + #[cfg_attr(target_arch = "wasm32", tsify(optional))] pub max_timestamp_ahead_ms: Option, pub timeout_ms: u32, pub max_route_hop_count: u8, @@ -214,7 +225,8 @@ pub struct VeilidConfigRPC { /// Configure the network routing table /// -#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)] +#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct VeilidConfigRoutingTable { #[schemars(with = "Vec")] pub node_id: TypedKeyGroup, @@ -230,7 +242,8 @@ pub struct VeilidConfigRoutingTable { // xxx pub enable_local_network: bool, } -#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)] +#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct VeilidConfigNetwork { pub connection_initial_timeout_ms: u32, pub connection_inactivity_timeout_ms: u32, @@ -241,7 +254,7 @@ pub struct VeilidConfigNetwork { pub client_whitelist_timeout_ms: u32, pub reverse_connection_receipt_time_ms: u32, pub hole_punch_receipt_time_ms: u32, - #[tsify(optional)] + #[cfg_attr(target_arch = "wasm32", tsify(optional))] pub network_key_password: Option, pub routing_table: VeilidConfigRoutingTable, pub rpc: VeilidConfigRPC, @@ -254,36 +267,41 @@ pub struct VeilidConfigNetwork { pub protocol: VeilidConfigProtocol, } -#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)] +#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct VeilidConfigTableStore { pub directory: String, pub delete: bool, } -#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)] +#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct VeilidConfigBlockStore { pub directory: String, pub delete: bool, } -#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)] +#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct VeilidConfigProtectedStore { pub allow_insecure_fallback: bool, pub always_use_insecure_storage: bool, pub directory: String, pub delete: bool, pub device_encryption_key_password: String, - #[tsify(optional)] + #[cfg_attr(target_arch = "wasm32", tsify(optional))] pub new_device_encryption_key_password: Option, } -#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)] +#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct VeilidConfigCapabilities { pub disable: Vec, } -#[derive(Clone, Copy, PartialEq, Eq, Debug, Serialize, Deserialize, JsonSchema, Tsify)] -#[tsify(namespace, from_wasm_abi)] +#[derive(Clone, Copy, PartialEq, Eq, Debug, Serialize, Deserialize, JsonSchema)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] +#[cfg_attr(target_arch = "wasm32", tsify(namespace, from_wasm_abi))] pub enum VeilidConfigLogLevel { Off, Error, @@ -370,7 +388,8 @@ impl fmt::Display for VeilidConfigLogLevel { } } -#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Tsify)] +#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct VeilidConfigInner { pub program_name: String, pub namespace: String, diff --git a/veilid-core/src/wasm_helpers.rs b/veilid-core/src/wasm_helpers.rs new file mode 100644 index 00000000..c2f8994b --- /dev/null +++ b/veilid-core/src/wasm_helpers.rs @@ -0,0 +1,21 @@ +cfg_if::cfg_if! { + if #[cfg(target_arch = "wasm32")] { + pub use tsify::*; + pub use wasm_bindgen::prelude::*; + + macro_rules! from_impl_to_jsvalue { + ($name: ident) => { + impl From<$name> for JsValue { + fn from(value: $name) -> Self { + serde_wasm_bindgen::to_value(&value).unwrap() + } + } + } + } + } else { + macro_rules! from_impl_to_jsvalue { + ($name: ident) => {} + } + } +} +pub(crate) use from_impl_to_jsvalue; diff --git a/veilid-wasm/src/lib.rs b/veilid-wasm/src/lib.rs index ac4f4aaf..95269819 100644 --- a/veilid-wasm/src/lib.rs +++ b/veilid-wasm/src/lib.rs @@ -115,7 +115,8 @@ where ///////////////////////////////////////// // WASM-specific -#[derive(Debug, Deserialize, Serialize, Tsify)] +#[derive(Debug, Deserialize, Serialize)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct VeilidWASMConfigLoggingPerformance { pub enabled: bool, pub level: veilid_core::VeilidConfigLogLevel, @@ -123,25 +124,29 @@ pub struct VeilidWASMConfigLoggingPerformance { pub logs_in_console: bool, } -#[derive(Debug, Deserialize, Serialize, Tsify)] +#[derive(Debug, Deserialize, Serialize)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct VeilidWASMConfigLoggingAPI { pub enabled: bool, pub level: veilid_core::VeilidConfigLogLevel, } -#[derive(Debug, Deserialize, Serialize, Tsify)] +#[derive(Debug, Deserialize, Serialize)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct VeilidWASMConfigLogging { pub performance: VeilidWASMConfigLoggingPerformance, pub api: VeilidWASMConfigLoggingAPI, } -#[derive(Debug, Deserialize, Serialize, Tsify)] +#[derive(Debug, Deserialize, Serialize)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] #[tsify(from_wasm_abi)] pub struct VeilidWASMConfig { pub logging: VeilidWASMConfigLogging, } -#[derive(Debug, Deserialize, Serialize, Tsify)] +#[derive(Debug, Deserialize, Serialize)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] pub struct VeilidRouteBlob { pub route_id: veilid_core::RouteId, #[serde(with = "veilid_core::as_human_base64")] @@ -1463,7 +1468,8 @@ pub fn veilid_version_string() -> String { veilid_core::veilid_version_string() } -#[derive(Serialize, Tsify)] +#[derive(Serialize)] +#[cfg_attr(target_arch = "wasm32", derive(Tsify))] #[tsify(into_wasm_abi)] pub struct VeilidVersion { pub major: u32,