Automatically generate RPC docs, bump version number for release

Author: Ash-L2L

Cargo.lock

@@ -10,7 +10,7 @@ members = [
 [workspace.package]
 authors = [ "Ash Manning <[email protected]>" ]
 edition = "2021"
-version = "0.7.7"
+version = "0.7.8"
 
 [workspace.dependencies.bip300301]
 git = "https://github.com/Ash-L2L/bip300301.git"

Cargo.toml

@@ -44,6 +44,7 @@ tokio-util = { version = "0.7.10", features = ["rt"] }
 tracing = "0.1.40"
 tracing-appender = "0.2.3"
 tracing-subscriber = "0.3.18"
+utoipa = "4.2.3"
 
 [dependencies.libes]
 version = "0.9.1"

app/Cargo.toml

@@ -193,6 +193,12 @@ impl RpcServer for RpcServerImpl {
         Ok(utxos)
     }
 
+    async fn openapi_schema(&self) -> RpcResult<utoipa::openapi::OpenApi> {
+        let res =
+            <plain_bitnames_app_rpc_api::RpcDoc as utoipa::OpenApi>::openapi();
+        Ok(res)
+    }
+
     async fn reserve_bitname(&self, plain_name: String) -> RpcResult<Txid> {
         let mut tx = Transaction::default();
         let () = match self.app.wallet.reserve_bitname(&mut tx, &plain_name) {

app/rpc_server.rs

@@ -13,6 +13,7 @@ plain_bitnames = { path = "../lib" }
 plain_bitnames_app_rpc_api = { path = "../rpc-api" }
 serde_json = "1.0.113"
 tokio = "1.29.1"
+utoipa = "4.2.3"
 
 [lib]
 name = "plain_bitnames_app_cli_lib"

cli/Cargo.toml

@@ -43,6 +43,9 @@ pub enum Command {
     },
     /// List owned UTXOs
     MyUtxos,
+    /// Show OpenAPI schema
+    #[command(name = "openapi-schema")]
+    OpenApiSchema,
     /// Reserve a BitName
     ReserveBitname { plaintext_name: String },
     /// Set the wallet seed from a mnemonic seed phrase
@@ -144,6 +147,11 @@ impl Cli {
                 let utxos = rpc_client.my_utxos().await?;
                 serde_json::to_string_pretty(&utxos)?
             }
+            Command::OpenApiSchema => {
+                let openapi =
+                    <plain_bitnames_app_rpc_api::RpcDoc as utoipa::OpenApi>::openapi();
+                openapi.to_pretty_json()?
+            }
             Command::ReserveBitname { plaintext_name } => {
                 let txid = rpc_client.reserve_bitname(plaintext_name).await?;
                 format!("{txid}")

cli/lib.rs

@@ -42,6 +42,7 @@ tokio = { version = "1.29.1", features = ["rt-multi-thread", "sync"] }
 tokio-stream = { version = "0.1.15", features = ["sync"] }
 tokio-util = { version = "0.7.10", features = ["rt"] }
 tracing = "0.1.40"
+utoipa = "4.2.3"
 x25519-dalek = { version = "2.0.0", features = ["serde"] }
 
 [target.'cfg(not(target_os = "windows"))'.dependencies.async_zmq]

lib/Cargo.toml

@@ -1,6 +1,7 @@
 use borsh::BorshSerialize;
 use rayon::iter::{IntoParallelRefIterator as _, ParallelIterator as _};
 use serde::{Deserialize, Serialize};
+use utoipa::ToSchema;
 
 use crate::types::{
     Address, AuthorizedTransaction, Body, GetAddress, Transaction, Verify,
@@ -49,12 +50,21 @@ where
 }
 
 #[derive(
-    BorshSerialize, Debug, Clone, Deserialize, Eq, PartialEq, Serialize,
+    BorshSerialize,
+    Debug,
+    Clone,
+    Deserialize,
+    Eq,
+    PartialEq,
+    Serialize,
+    ToSchema,
 )]
 pub struct Authorization {
     #[borsh(serialize_with = "borsh_serialize_verifying_key")]
+    #[schema(schema_with = <String as utoipa::PartialSchema>::schema)]
     pub verifying_key: VerifyingKey,
     #[borsh(serialize_with = "borsh_serialize_signature")]
+    #[schema(schema_with = <String as utoipa::PartialSchema>::schema)]
     pub signature: Signature,
 }
 

lib/authorization.rs

@@ -79,3 +79,21 @@ impl Serialize for Address {
         }
     }
 }
+
+impl utoipa::PartialSchema for Address {
+    fn schema() -> utoipa::openapi::RefOr<utoipa::openapi::schema::Schema> {
+        let obj = utoipa::openapi::Object::with_type(
+            utoipa::openapi::SchemaType::String,
+        );
+        utoipa::openapi::RefOr::T(utoipa::openapi::Schema::Object(obj))
+    }
+}
+
+impl utoipa::ToSchema<'static> for Address {
+    fn schema() -> (
+        &'static str,
+        utoipa::openapi::RefOr<utoipa::openapi::schema::Schema>,
+    ) {
+        ("Address", <Address as utoipa::PartialSchema>::schema())
+    }
+}

lib/types/address.rs

@@ -79,6 +79,24 @@ impl FromStr for BlockHash {
     }
 }
 
+impl utoipa::PartialSchema for BlockHash {
+    fn schema() -> utoipa::openapi::RefOr<utoipa::openapi::schema::Schema> {
+        let obj = utoipa::openapi::Object::with_type(
+            utoipa::openapi::SchemaType::String,
+        );
+        utoipa::openapi::RefOr::T(utoipa::openapi::Schema::Object(obj))
+    }
+}
+
+impl utoipa::ToSchema<'static> for BlockHash {
+    fn schema() -> (
+        &'static str,
+        utoipa::openapi::RefOr<utoipa::openapi::schema::Schema>,
+    ) {
+        ("BlockHash", <Self as utoipa::PartialSchema>::schema())
+    }
+}
+
 #[derive(
     BorshSerialize,
     Clone,
@@ -120,6 +138,24 @@ impl std::fmt::Debug for MerkleRoot {
     }
 }
 
+impl utoipa::PartialSchema for MerkleRoot {
+    fn schema() -> utoipa::openapi::RefOr<utoipa::openapi::schema::Schema> {
+        let obj = utoipa::openapi::Object::with_type(
+            utoipa::openapi::SchemaType::String,
+        );
+        utoipa::openapi::RefOr::T(utoipa::openapi::Schema::Object(obj))
+    }
+}
+
+impl utoipa::ToSchema<'static> for MerkleRoot {
+    fn schema() -> (
+        &'static str,
+        utoipa::openapi::RefOr<utoipa::openapi::schema::Schema>,
+    ) {
+        ("MerkleRoot", <Self as utoipa::PartialSchema>::schema())
+    }
+}
+
 #[derive(
     BorshSerialize,
     Clone,
@@ -180,6 +216,24 @@ impl FromStr for Txid {
     }
 }
 
+impl utoipa::PartialSchema for Txid {
+    fn schema() -> utoipa::openapi::RefOr<utoipa::openapi::schema::Schema> {
+        let obj = utoipa::openapi::Object::with_type(
+            utoipa::openapi::SchemaType::String,
+        );
+        utoipa::openapi::RefOr::T(utoipa::openapi::Schema::Object(obj))
+    }
+}
+
+impl utoipa::ToSchema<'static> for Txid {
+    fn schema() -> (
+        &'static str,
+        utoipa::openapi::RefOr<utoipa::openapi::schema::Schema>,
+    ) {
+        ("Txid", <Self as utoipa::PartialSchema>::schema())
+    }
+}
+
 /// Identifier for a BitName
 #[derive(
     BorshDeserialize,
@@ -213,6 +267,24 @@ impl FromHex for BitName {
     }
 }
 
+impl utoipa::PartialSchema for BitName {
+    fn schema() -> utoipa::openapi::RefOr<utoipa::openapi::schema::Schema> {
+        let obj = utoipa::openapi::Object::with_type(
+            utoipa::openapi::SchemaType::String,
+        );
+        utoipa::openapi::RefOr::T(utoipa::openapi::Schema::Object(obj))
+    }
+}
+
+impl utoipa::ToSchema<'static> for BitName {
+    fn schema() -> (
+        &'static str,
+        utoipa::openapi::RefOr<utoipa::openapi::schema::Schema>,
+    ) {
+        ("BitName", <Self as utoipa::PartialSchema>::schema())
+    }
+}
+
 pub fn hash<T>(data: &T) -> Hash
 where
     T: BorshSerialize,