json api work

veilid-core/src/veilid_api/api.rs

@@ -268,6 +268,7 @@ impl VeilidAPI {
     ////////////////////////////////////////////////////////////////
     // Tunnel Building
 
+    #[cfg(feature = "unstable-tunnels")]
     #[instrument(level = "debug", err, skip(self))]
     pub async fn start_tunnel(
         &self,
@@ -277,6 +278,7 @@ impl VeilidAPI {
         panic!("unimplemented");
     }
 
+    #[cfg(feature = "unstable-tunnels")]
     #[instrument(level = "debug", err, skip(self))]
     pub async fn complete_tunnel(
         &self,
@@ -287,6 +289,7 @@ impl VeilidAPI {
         panic!("unimplemented");
     }
 
+    #[cfg(feature = "unstable-tunnels")]
     #[instrument(level = "debug", err, skip(self))]
     pub async fn cancel_tunnel(&self, _tunnel_id: TunnelId) -> VeilidAPIResult<bool> {
         panic!("unimplemented");

veilid-core/src/veilid_api/error.rs

@@ -117,6 +117,7 @@ macro_rules! apibail_already_initialized {
     RkyvArchive,
     RkyvSerialize,
     RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(u8), derive(CheckBytes))]
 #[serde(tag = "kind")]
@@ -136,7 +137,10 @@ pub enum VeilidAPIError {
     #[error("No connection: {message}")]
     NoConnection { message: String },
     #[error("Key not found: {key}")]
-    KeyNotFound { key: TypedKey },
+    KeyNotFound { 
+        #[schemars(with="String")]
+        key: TypedKey 
+    },
     #[error("Internal: {message}")]
     Internal { message: String },
     #[error("Unimplemented: {message}")]

veilid-core/src/veilid_api/json_api/crypto_system.rs

@@ -0,0 +1,66 @@
+use super::*;
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub struct CryptoSystemRequest {
+    cs_id: String,
+    #[serde(flatten)]
+    cs_op: CryptoSystemRequestOp,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub struct CryptoSystemResponse {
+    cs_id: String,
+    #[serde(flatten)]
+    cs_op: CryptoSystemResponseOp,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(tag = "cs_op")]
+pub enum CryptoSystemRequestOp {
+    Release,
+    CachedDh,
+    ComputeDh,
+    RandomBytes,
+    DefaultSaltLength,
+    HashPassword,
+    VerifyPassword,
+    DeriveSharedSecret,
+    RandomNonce,
+    RandomSharedSecret,
+    GenerateKeyPair,
+    GenerateHash,
+    ValidateKeyPair,
+    ValidateHash,
+    Distance,
+    Sign,
+    Verify,
+    AeadOverhead,
+    DecryptAead,
+    EncryptAead,
+    CryptNoAuth,
+}
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(tag = "cs_op")]
+pub enum CryptoSystemResponseOp {
+    Release,
+    CachedDh,
+    ComputeDh,
+    RandomBytes,
+    DefaultSaltLength,
+    HashPassword,
+    VerifyPassword,
+    DeriveSharedSecret,
+    RandomNonce,
+    RandomSharedSecret,
+    GenerateKeyPair,
+    GenerateHash,
+    ValidateKeyPair,
+    ValidateHash,
+    Distance,
+    Sign,
+    Verify,
+    AeadOverhead,
+    DecryptAead,
+    EncryptAead,
+    CryptNoAuth,
+}

veilid-core/src/veilid_api/json_api/mod.rs

@@ -0,0 +1,203 @@
+use super::*;
+
+mod routing_context;
+pub use routing_context::*;
+
+mod table_db;
+pub use table_db::*;
+
+mod crypto_system;
+pub use crypto_system::*;
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub struct Request {
+    /// Operation Id (pairs with Response)
+    id: String,
+    /// The request operation variant
+    #[serde(flatten)]
+    op: RequestOp,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub struct Response {
+    /// Operation Id (pairs with Request)
+    id: String,
+    /// The response operation variant
+    #[serde(flatten)]
+    op: ResponseOp,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(tag = "op")]
+pub enum RequestOp {
+    GetState,
+    Attach,
+    Detach,
+    NewPrivateRoute,
+    NewCustomPrivateRoute {
+        #[schemars(with = "Vec<String>")]
+        crypto_kinds: Vec<CryptoKind>,
+        #[serde(default)]
+        stability: Stability,
+        #[serde(default)]
+        sequencing: Sequencing,
+    },
+    ImportRemotePrivateRoute {
+        #[serde(
+            serialize_with = "json_as_base64::serialize",
+            deserialize_with = "json_as_base64::deserialize"
+        )]
+        #[schemars(with = "String")]
+        blob: Vec<u8>,
+    },
+    ReleasePrivateRoute {
+        #[schemars(with = "String")]
+        route_id: RouteId,
+    },
+    AppCallReply {
+        #[schemars(with = "String")]
+        call_id: OperationId,
+        #[serde(
+            serialize_with = "json_as_base64::serialize",
+            deserialize_with = "json_as_base64::deserialize"
+        )]
+        #[schemars(with = "String")]
+        message: Vec<u8>,
+    },
+    // Routing Context
+    NewRoutingContext,
+    RoutingContext(RoutingContextRequest),
+    // TableDb
+    OpenTableDb {
+        name: String,
+        column_count: u32,
+    },
+    DeleteTableDb {
+        name: String,
+    },
+    TableDb(TableDbRequest),
+    // Crypto
+    GetCryptoSystem {
+        #[schemars(with = "String")]
+        crypto_kind: CryptoKind,
+    },
+    BestCryptoSystem,
+    CryptoSystem(CryptoSystemRequest),
+    VerifySignatures {
+        #[schemars(with = "Vec<String>")]
+        node_ids: Vec<TypedKey>,
+        #[serde(
+            serialize_with = "json_as_base64::serialize",
+            deserialize_with = "json_as_base64::deserialize"
+        )]
+        #[schemars(with = "String")]
+        data: Vec<u8>,
+        #[schemars(with = "Vec<String>")]
+        signatures: Vec<TypedSignature>,
+    },
+    GenerateSignatures {
+        #[serde(
+            serialize_with = "json_as_base64::serialize",
+            deserialize_with = "json_as_base64::deserialize"
+        )]
+        #[schemars(with = "String")]
+        data: Vec<u8>,
+        #[schemars(with = "Vec<String>")]
+        key_pairs: Vec<TypedKeyPair>,
+    },
+    GenerateKeyPair {
+        #[schemars(with = "String")]
+        crypto_kind: CryptoKind,
+    },
+    // Misc
+    Now,
+    Debug {
+        command: String,
+    },
+    VeilidVersionString,
+    VeilidVersion,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub struct NewPrivateRouteResult {
+    #[schemars(with = "String")]
+    route_id: RouteId,
+    #[serde(
+        serialize_with = "json_as_base64::serialize",
+        deserialize_with = "json_as_base64::deserialize"
+    )]
+    #[schemars(with = "String")]
+    blob: Vec<u8>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(tag = "op")]
+pub enum ResponseOp {
+    GetState {
+        #[serde(flatten)]
+        result: ApiResult<VeilidState>,
+    },
+    Attach {
+        #[serde(flatten)]
+        result: ApiResult<()>,
+    },
+    Detach {
+        #[serde(flatten)]
+        result: ApiResult<()>,
+    },
+    NewPrivateRoute {
+        #[serde(flatten)]
+        result: ApiResult<NewPrivateRouteResult>,
+    },
+    NewCustomPrivateRoute {
+        #[serde(flatten)]
+        result: ApiResult<NewPrivateRouteResult>,
+    },
+    ImportRemotePrivateRoute,
+    ReleasePrivateRoute,
+    AppCallReply,
+    // Routing Context
+    NewRoutingContext,
+    RoutingContext(RoutingContextResponse),
+    // TableDb
+    OpenTableDb,
+    DeleteTableDb,
+    TableDb(TableDbResponse),
+    // Crypto
+    GetCryptoSystem,
+    BestCryptoSystem,
+    CryptoSystem(CryptoSystemResponse),
+    VerifySignatures,
+    GenerateSignatures,
+    GenerateKeyPair,
+    // Misc
+    Now,
+    Debug,
+    VeilidVersionString,
+    VeilidVersion,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(untagged)]
+pub enum ApiResult<T>
+where
+    T: Clone + fmt::Debug + JsonSchema,
+{
+    Ok { value: T },
+    Err { error: VeilidAPIError },
+}
+
+pub fn emit_schemas(out: &mut HashMap<String, String>) {
+    let schema_request = schema_for!(Request);
+    let schema_response = schema_for!(Response);
+
+    out.insert(
+        "Request".to_owned(),
+        serde_json::to_string_pretty(&schema_request).unwrap(),
+    );
+
+    out.insert(
+        "Response".to_owned(),
+        serde_json::to_string_pretty(&schema_response).unwrap(),
+    );
+}

veilid-core/src/veilid_api/json_api/routing_context.rs

@@ -0,0 +1,52 @@
+use super::*;
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub struct RoutingContextRequest {
+    rc_id: String,
+    #[serde(flatten)]
+    rc_op: RoutingContextRequestOp,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub struct RoutingContextResponse {
+    rc_id: String,
+    #[serde(flatten)]
+    rc_op: RoutingContextResponseOp,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(tag = "rc_op")]
+pub enum RoutingContextRequestOp {
+    Release,
+    WithPrivacy,
+    WithCustomPrivacy,
+    WithSequencing,
+    AppCall,
+    AppMessage,
+    CreateDhtRecord,
+    OpenDhtRecord,
+    CloseDhtRecord,
+    DeleteDhtRecord,
+    GetDhtValue,
+    SetDhtValue,
+    WatchDhtValues,
+    CancelDhtWatch,
+}
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(tag = "rc_op")]
+pub enum RoutingContextResponseOp {
+    Release,
+    WithPrivacy,
+    WithCustomPrivacy,
+    WithSequencing,
+    AppCall,
+    AppMessage,
+    CreateDhtRecord,
+    OpenDhtRecord,
+    CloseDhtRecord,
+    DeleteDhtRecord,
+    GetDhtValue,
+    SetDhtValue,
+    WatchDhtValues,
+    CancelDhtWatch,
+}

veilid-core/src/veilid_api/json_api/table_db.rs

@@ -0,0 +1,26 @@
+use super::*;
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub struct TableDbRequest {
+    db_id: String,
+    #[serde(flatten)]
+    db_op: TableDbRequestOp,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub struct TableDbResponse {
+    db_id: String,
+    #[serde(flatten)]
+    db_op: TableDbResponseOp,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(tag = "db_op")]
+pub enum TableDbRequestOp {
+    Release,
+}
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(tag = "db_op")]
+pub enum TableDbResponseOp {
+    Release,
+}

veilid-core/src/veilid_api/mod.rs

@@ -3,6 +3,7 @@
 mod api;
 mod debug;
 mod error;
+mod json_api;
 mod routing_context;
 mod serialize_helpers;
 mod types;
@@ -12,6 +13,7 @@ pub mod tests;
 pub use api::*;
 pub use debug::*;
 pub use error::*;
+pub use json_api::*;
 pub use routing_context::*;
 pub use serialize_helpers::*;
 pub use types::*;

veilid-core/src/veilid_api/serialize_helpers/serialize_range_set_blaze.rs

@@ -9,11 +9,10 @@ pub fn serialize<T: Integer + Serialize, S: Serializer>(
     v: &RangeSetBlaze<T>,
     s: S,
 ) -> Result<S::Ok, S::Error> {
-    let cnt = v.ranges_len() * 2;
+    let cnt = v.ranges_len();
     let mut seq = s.serialize_seq(Some(cnt))?;
     for range in v.ranges() {
-        seq.serialize_element(range.start())?;
-        seq.serialize_element(range.end())?;
+        seq.serialize_element(&(range.start(), range.end()))?;
     }
     seq.end()
 }
@@ -41,10 +40,7 @@ pub fn deserialize<'de, T: Integer + Deserialize<'de>, D: Deserializer<'de>>(
         {
             let mut values = RangeSetBlaze::<T>::new();
 
-            while let Some(start) = seq.next_element()? {
-                let Some(end) = seq.next_element()? else {
-                    break;
-                };
+            while let Some((start, end)) = seq.next_element()? {
                 values.ranges_insert(start..=end);
             }
 

veilid-core/src/veilid_api/types/aligned_u64.rs

@@ -18,10 +18,19 @@ use super::*;
     RkyvArchive,
     RkyvSerialize,
     RkyvDeserialize,
+    JsonSchema,
 )]
 #[repr(C, align(8))]
 #[archive_attr(repr(C, align(8)), derive(CheckBytes))]
-pub struct AlignedU64(u64);
+#[serde(transparent)]
+pub struct AlignedU64(
+    #[serde(
+        serialize_with = "json_as_string::serialize",
+        deserialize_with = "json_as_string::deserialize"
+    )]
+    #[schemars(with = "String")]
+    u64,
+);
 
 impl From<u64> for AlignedU64 {
     fn from(v: u64) -> Self {

veilid-core/src/veilid_api/types/app_message_call.rs

@@ -2,15 +2,33 @@ use super::*;
 
 /// Direct statement blob passed to hosting application for processing
 #[derive(
-    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, RkyvArchive, RkyvSerialize, RkyvDeserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    Serialize,
+    Deserialize,
+    RkyvArchive,
+    RkyvSerialize,
+    RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(C), derive(CheckBytes))]
 pub struct VeilidAppMessage {
     /// Some(sender) if the message was sent directly, None if received via a private/safety route
-    #[serde(with = "opt_json_as_string")]
+    #[serde(
+        serialize_with = "opt_json_as_string::serialize",
+        deserialize_with = "opt_json_as_string::deserialize"
+    )]
+    #[schemars(with = "Option<String>")]
     sender: Option<TypedKey>,
+
     /// The content of the message to deliver to the application
-    #[serde(with = "json_as_base64")]
+    #[serde(
+        serialize_with = "json_as_base64::serialize",
+        deserialize_with = "json_as_base64::deserialize"
+    )]
+    #[schemars(with = "String")]
     message: Vec<u8>,
 }
 
@@ -29,18 +47,41 @@ impl VeilidAppMessage {
 
 /// Direct question blob passed to hosting application for processing to send an eventual AppReply
 #[derive(
-    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, RkyvArchive, RkyvSerialize, RkyvDeserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    Serialize,
+    Deserialize,
+    RkyvArchive,
+    RkyvSerialize,
+    RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(C), derive(CheckBytes))]
 pub struct VeilidAppCall {
     /// Some(sender) if the request was sent directly, None if received via a private/safety route
-    #[serde(with = "opt_json_as_string")]
+    #[serde(
+        serialize_with = "opt_json_as_string::serialize",
+        deserialize_with = "opt_json_as_string::deserialize"
+    )]
+    #[schemars(with = "Option<String>")]
     sender: Option<TypedKey>,
+
     /// The content of the request to deliver to the application
-    #[serde(with = "json_as_base64")]
+    #[serde(
+        serialize_with = "json_as_base64::serialize",
+        deserialize_with = "json_as_base64::deserialize"
+    )]
+    #[schemars(with = "String")]
     message: Vec<u8>,
+
     /// The id to reply to
-    #[serde(with = "json_as_string")]
+    #[serde(
+        serialize_with = "json_as_string::serialize",
+        deserialize_with = "json_as_string::deserialize"
+    )]
+    #[schemars(with = "String")]
     id: OperationId,
 }
 

veilid-core/src/veilid_api/types/dht/dht_record_descriptor.rs

@@ -13,15 +13,19 @@ use super::*;
     RkyvArchive,
     RkyvSerialize,
     RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(C), derive(CheckBytes))]
 pub struct DHTRecordDescriptor {
     /// DHT Key = Hash(ownerKeyKind) of: [ ownerKeyValue, schema ]
+    #[schemars(with = "String")]
     key: TypedKey,
     /// The public key of the owner
+    #[schemars(with = "String")]
     owner: PublicKey,
     /// If this key is being created: Some(the secret key of the owner)
     /// If this key is just being opened: None
+    #[schemars(with = "Option<String>")]
     owner_secret: Option<SecretKey>,
     /// The schema in use associated with the key
     schema: DHTSchema,

veilid-core/src/veilid_api/types/dht/schema/dflt.rs

@@ -13,6 +13,7 @@ use super::*;
     RkyvArchive,
     RkyvSerialize,
     RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(C), derive(CheckBytes))]
 pub struct DHTSchemaDFLT {

veilid-core/src/veilid_api/types/dht/schema/mod.rs

@@ -19,6 +19,7 @@ pub use smpl::*;
     RkyvArchive,
     RkyvSerialize,
     RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(u8), derive(CheckBytes))]
 #[serde(tag = "kind")]

veilid-core/src/veilid_api/types/dht/schema/smpl.rs

@@ -13,10 +13,12 @@ use super::*;
     RkyvArchive,
     RkyvSerialize,
     RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(C), derive(CheckBytes))]
 pub struct DHTSchemaSMPLMember {
     /// Member key
+    #[schemars(with = "String")]
     pub m_key: PublicKey,
     /// Member subkey count
     pub m_cnt: u16,
@@ -35,6 +37,7 @@ pub struct DHTSchemaSMPLMember {
     RkyvArchive,
     RkyvSerialize,
     RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(C), derive(CheckBytes))]
 pub struct DHTSchemaSMPL {

veilid-core/src/veilid_api/types/dht/value_data.rs

@@ -13,11 +13,23 @@ use super::*;
     RkyvArchive,
     RkyvSerialize,
     RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(C), derive(CheckBytes))]
 pub struct ValueData {
+    /// An increasing sequence number to time-order the DHT record changes
     seq: ValueSeqNum,
+
+    /// The contents of a DHT Record
+    #[serde(
+        serialize_with = "json_as_base64::serialize",
+        deserialize_with = "json_as_base64::deserialize"
+    )]
+    #[schemars(with = "String")]
     data: Vec<u8>,
+
+    /// The public identity key of the writer of the data
+    #[schemars(with = "String")]
     writer: PublicKey,
 }
 impl ValueData {

veilid-core/src/veilid_api/types/dht/value_subkey_range_set.rs

@@ -15,11 +15,16 @@ use range_set_blaze::*;
     RkyvArchive,
     RkyvSerialize,
     RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(C), derive(CheckBytes))]
 pub struct ValueSubkeyRangeSet {
     #[with(RkyvRangeSetBlaze)]
-    #[serde(with = "serialize_range_set_blaze")]
+    #[serde(
+        serialize_with = "serialize_range_set_blaze::serialize",
+        deserialize_with = "serialize_range_set_blaze::deserialize"
+    )]
+    #[schemars(with = "Vec<(u32,u32)>")]
     data: RangeSetBlaze<ValueSubkey>,
 }
 

veilid-core/src/veilid_api/types/fourcc.rs

@@ -15,8 +15,11 @@ use super::*;
     RkyvArchive,
     RkyvSerialize,
     RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(C), derive(CheckBytes, PartialOrd, Ord, PartialEq, Eq, Hash))]
+#[serde(try_from = "String")]
+#[serde(into = "String")]
 pub struct FourCC(pub [u8; 4]);
 
 impl From<[u8; 4]> for FourCC {
@@ -37,6 +40,12 @@ impl From<FourCC> for u32 {
     }
 }
 
+impl From<FourCC> for String {
+    fn from(u: FourCC) -> Self {
+        String::from_utf8_lossy(&u.0).to_string()
+    }
+}
+
 impl TryFrom<&[u8]> for FourCC {
     type Error = VeilidAPIError;
     fn try_from(b: &[u8]) -> Result<Self, Self::Error> {
@@ -44,6 +53,13 @@ impl TryFrom<&[u8]> for FourCC {
     }
 }
 
+impl TryFrom<String> for FourCC {
+    type Error = VeilidAPIError;
+    fn try_from(s: String) -> Result<Self, Self::Error> {
+        Self::from_str(s.as_str())
+    }
+}
+
 impl fmt::Display for FourCC {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
         write!(f, "{}", String::from_utf8_lossy(&self.0))

veilid-core/src/veilid_api/types/mod.rs

@@ -4,6 +4,7 @@ mod dht;
 mod fourcc;
 mod safety;
 mod stats;
+#[cfg(feature = "unstable-tunnels")]
 mod tunnel;
 mod veilid_log;
 mod veilid_state;
@@ -16,6 +17,7 @@ pub use dht::*;
 pub use fourcc::*;
 pub use safety::*;
 pub use stats::*;
+#[cfg(feature = "unstable-tunnels")]
 pub use tunnel::*;
 pub use veilid_log::*;
 pub use veilid_state::*;

veilid-core/src/veilid_api/types/safety.rs

@@ -15,6 +15,7 @@ use super::*;
     RkyvArchive,
     RkyvSerialize,
     RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(u8), derive(CheckBytes))]
 pub enum Sequencing {
@@ -44,6 +45,7 @@ impl Default for Sequencing {
     RkyvArchive,
     RkyvSerialize,
     RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(u8), derive(CheckBytes))]
 pub enum Stability {
@@ -72,6 +74,7 @@ impl Default for Stability {
     RkyvArchive,
     RkyvSerialize,
     RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(u8), derive(CheckBytes))]
 pub enum SafetySelection {
@@ -111,10 +114,12 @@ impl Default for SafetySelection {
     RkyvArchive,
     RkyvSerialize,
     RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(C), derive(CheckBytes))]
 pub struct SafetySpec {
     /// preferred safety route set id if it still exists
+    #[schemars(with = "Option<String>")]
     pub preferred_route: Option<RouteId>,
     /// must be greater than 0
     pub hop_count: usize,

veilid-core/src/veilid_api/types/stats.rs

@@ -11,14 +11,12 @@ use super::*;
     RkyvArchive,
     RkyvSerialize,
     RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(C), derive(CheckBytes))]
 pub struct LatencyStats {
-    #[serde(with = "json_as_string")]
     pub fastest: TimestampDuration, // fastest latency in the ROLLING_LATENCIES_SIZE last latencies
-    #[serde(with = "json_as_string")]
     pub average: TimestampDuration, // average latency over the ROLLING_LATENCIES_SIZE last latencies
-    #[serde(with = "json_as_string")]
     pub slowest: TimestampDuration, // slowest latency in the ROLLING_LATENCIES_SIZE last latencies
 }
 
@@ -33,16 +31,13 @@ pub struct LatencyStats {
     RkyvArchive,
     RkyvSerialize,
     RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(C), derive(CheckBytes))]
 pub struct TransferStats {
-    #[serde(with = "json_as_string")]
-    pub total: ByteCount, // total amount transferred ever
-    #[serde(with = "json_as_string")]
+    pub total: ByteCount,   // total amount transferred ever
     pub maximum: ByteCount, // maximum rate over the ROLLING_TRANSFERS_SIZE last amounts
-    #[serde(with = "json_as_string")]
     pub average: ByteCount, // average rate over the ROLLING_TRANSFERS_SIZE last amounts
-    #[serde(with = "json_as_string")]
     pub minimum: ByteCount, // minimum rate over the ROLLING_TRANSFERS_SIZE last amounts
 }
 
@@ -57,6 +52,7 @@ pub struct TransferStats {
     RkyvArchive,
     RkyvSerialize,
     RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(C), derive(CheckBytes))]
 pub struct TransferStatsDownUp {
@@ -75,17 +71,15 @@ pub struct TransferStatsDownUp {
     RkyvArchive,
     RkyvSerialize,
     RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(C), derive(CheckBytes))]
 pub struct RPCStats {
     pub messages_sent: u32, // number of rpcs that have been sent in the total_time range
     pub messages_rcvd: u32, // number of rpcs that have been received in the total_time range
     pub questions_in_flight: u32, // number of questions issued that have yet to be answered
-    #[serde(with = "opt_json_as_string")]
     pub last_question_ts: Option<Timestamp>, // when the peer was last questioned (either successfully or not) and we wanted an answer
-    #[serde(with = "opt_json_as_string")]
     pub last_seen_ts: Option<Timestamp>, // when the peer was last seen for any reason, including when we first attempted to reach out to it
-    #[serde(with = "opt_json_as_string")]
     pub first_consecutive_seen_ts: Option<Timestamp>, // the timestamp of the first consecutive proof-of-life for this node (an answer or received question)
     pub recent_lost_answers: u32, // number of answers that have been lost since we lost reliability
     pub failed_to_send: u32, // number of messages that have failed to send since we last successfully sent one
@@ -102,12 +96,12 @@ pub struct RPCStats {
     RkyvArchive,
     RkyvSerialize,
     RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(C), derive(CheckBytes))]
 pub struct PeerStats {
-    #[serde(with = "json_as_string")]
     pub time_added: Timestamp, // when the peer was added to the routing table
-    pub rpc_stats: RPCStats,           // information about RPCs
+    pub rpc_stats: RPCStats,   // information about RPCs
     pub latency: Option<LatencyStats>, // latencies for communications with the peer
     pub transfer: TransferStatsDownUp, // Stats for communications with the peer
 }

veilid-core/src/veilid_api/types/tunnel.rs

@@ -1,8 +1,11 @@
+#[cfg(feature = "unstable-tunnels")]
 use super::*;
 
 /// Tunnel identifier
+#[cfg(feature = "unstable-tunnels")]
 pub type TunnelId = AlignedU64;
 
+#[cfg(feature = "unstable-tunnels")]
 #[derive(
     Copy,
     Clone,
@@ -16,6 +19,7 @@ pub type TunnelId = AlignedU64;
     RkyvArchive,
     RkyvSerialize,
     RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(u8), derive(CheckBytes))]
 pub enum TunnelMode {
@@ -23,6 +27,7 @@ pub enum TunnelMode {
     Turn,
 }
 
+#[cfg(feature = "unstable-tunnels")]
 #[derive(
     Copy,
     Clone,
@@ -36,6 +41,7 @@ pub enum TunnelMode {
     RkyvArchive,
     RkyvSerialize,
     RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(u8), derive(CheckBytes))]
 pub enum TunnelError {
@@ -45,13 +51,17 @@ pub enum TunnelError {
     NoCapacity,   // Endpoint is full
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, RkyvArchive, RkyvSerialize, RkyvDeserialize)]
+#[cfg(feature = "unstable-tunnels")]
+#[derive(
+    Clone, Debug, Serialize, Deserialize, RkyvArchive, RkyvSerialize, RkyvDeserialize, JsonSchema,
+)]
 #[archive_attr(repr(C), derive(CheckBytes))]
 pub struct TunnelEndpoint {
     pub mode: TunnelMode,
     pub description: String, // XXX: TODO
 }
 
+#[cfg(feature = "unstable-tunnels")]
 impl Default for TunnelEndpoint {
     fn default() -> Self {
         Self {
@@ -61,8 +71,17 @@ impl Default for TunnelEndpoint {
     }
 }
 
+#[cfg(feature = "unstable-tunnels")]
 #[derive(
-    Clone, Debug, Default, Serialize, Deserialize, RkyvArchive, RkyvSerialize, RkyvDeserialize,
+    Clone,
+    Debug,
+    Default,
+    Serialize,
+    Deserialize,
+    RkyvArchive,
+    RkyvSerialize,
+    RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(C), derive(CheckBytes))]
 pub struct FullTunnel {
@@ -72,8 +91,17 @@ pub struct FullTunnel {
     pub remote: TunnelEndpoint,
 }
 
+#[cfg(feature = "unstable-tunnels")]
 #[derive(
-    Clone, Debug, Default, Serialize, Deserialize, RkyvArchive, RkyvSerialize, RkyvDeserialize,
+    Clone,
+    Debug,
+    Default,
+    Serialize,
+    Deserialize,
+    RkyvArchive,
+    RkyvSerialize,
+    RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(C), derive(CheckBytes))]
 pub struct PartialTunnel {

veilid-core/src/veilid_api/types/veilid_log.rs

@@ -14,6 +14,7 @@ use super::*;
     RkyvArchive,
     RkyvSerialize,
     RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(u8), derive(CheckBytes))]
 pub enum VeilidLogLevel {
@@ -78,7 +79,16 @@ impl fmt::Display for VeilidLogLevel {
 
 /// A VeilidCore log message with optional backtrace
 #[derive(
-    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, RkyvArchive, RkyvSerialize, RkyvDeserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    Serialize,
+    Deserialize,
+    RkyvArchive,
+    RkyvSerialize,
+    RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(C), derive(CheckBytes))]
 pub struct VeilidLog {

veilid-core/src/veilid_api/types/veilid_state.rs

@@ -12,6 +12,7 @@ use super::*;
     RkyvArchive,
     RkyvSerialize,
     RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(u8), derive(CheckBytes))]
 pub enum AttachmentState {
@@ -60,7 +61,16 @@ impl TryFrom<String> for AttachmentState {
 }
 
 #[derive(
-    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, RkyvArchive, RkyvSerialize, RkyvDeserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    Serialize,
+    Deserialize,
+    RkyvArchive,
+    RkyvSerialize,
+    RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(C), derive(CheckBytes))]
 pub struct VeilidStateAttachment {
@@ -70,39 +80,76 @@ pub struct VeilidStateAttachment {
 }
 
 #[derive(
-    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, RkyvArchive, RkyvSerialize, RkyvDeserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    Serialize,
+    Deserialize,
+    RkyvArchive,
+    RkyvSerialize,
+    RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(C), derive(CheckBytes))]
 pub struct PeerTableData {
+    #[schemars(with = "Vec<String>")]
     pub node_ids: Vec<TypedKey>,
     pub peer_address: String,
     pub peer_stats: PeerStats,
 }
 
 #[derive(
-    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, RkyvArchive, RkyvSerialize, RkyvDeserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    Serialize,
+    Deserialize,
+    RkyvArchive,
+    RkyvSerialize,
+    RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(C), derive(CheckBytes))]
 pub struct VeilidStateNetwork {
     pub started: bool,
-    #[serde(with = "json_as_string")]
     pub bps_down: ByteCount,
-    #[serde(with = "json_as_string")]
     pub bps_up: ByteCount,
     pub peers: Vec<PeerTableData>,
 }
 
 #[derive(
-    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, RkyvArchive, RkyvSerialize, RkyvDeserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    Serialize,
+    Deserialize,
+    RkyvArchive,
+    RkyvSerialize,
+    RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(C), derive(CheckBytes))]
 pub struct VeilidRouteChange {
+    #[schemars(with = "Vec<String>")]
     pub dead_routes: Vec<RouteId>,
+    #[schemars(with = "Vec<String>")]
     pub dead_remote_routes: Vec<RouteId>,
 }
 
 #[derive(
-    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, RkyvArchive, RkyvSerialize, RkyvDeserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    Serialize,
+    Deserialize,
+    RkyvArchive,
+    RkyvSerialize,
+    RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(C), derive(CheckBytes))]
 pub struct VeilidStateConfig {
@@ -110,17 +157,29 @@ pub struct VeilidStateConfig {
 }
 
 #[derive(
-    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, RkyvArchive, RkyvSerialize, RkyvDeserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    Serialize,
+    Deserialize,
+    RkyvArchive,
+    RkyvSerialize,
+    RkyvDeserialize,
+    JsonSchema,
 )]
 #[archive_attr(repr(C), derive(CheckBytes))]
 pub struct VeilidValueChange {
+    #[schemars(with = "String")]
     key: TypedKey,
     subkeys: Vec<ValueSubkey>,
     count: u32,
     value: ValueData,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, RkyvArchive, RkyvSerialize, RkyvDeserialize)]
+#[derive(
+    Debug, Clone, Serialize, Deserialize, RkyvArchive, RkyvSerialize, RkyvDeserialize, JsonSchema,
+)]
 #[archive_attr(repr(u8), derive(CheckBytes))]
 #[serde(tag = "kind")]
 pub enum VeilidUpdate {
@@ -135,7 +194,9 @@ pub enum VeilidUpdate {
     Shutdown,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, RkyvArchive, RkyvSerialize, RkyvDeserialize)]
+#[derive(
+    Debug, Clone, Serialize, Deserialize, RkyvArchive, RkyvSerialize, RkyvDeserialize, JsonSchema,
+)]
 #[archive_attr(repr(C), derive(CheckBytes))]
 pub struct VeilidState {
     pub attachment: VeilidStateAttachment,