feat: Add Qt bindings

yerpc-derive/src/ts.rs → yerpc-derive/src/bindings.rs

@@ -2,9 +2,10 @@ use crate::{util::extract_result_ty, Inputs, RpcInfo};
 use convert_case::{Case, Casing};
 use proc_macro2::TokenStream;
 use quote::quote;
-pub(crate) fn generate_typescript_generator(info: &RpcInfo) -> TokenStream {
+pub(crate) fn generate_bindings_impl(info: &RpcInfo) -> TokenStream {
     let mut gen_types = vec![];
-    let mut gen_methods = vec![];
+    let mut gen_methods_ts = vec![];
+    let mut gen_methods_qt = vec![];
     for method in &info.methods {
         let (is_positional, gen_args) = match &method.input {
             Inputs::Positional(ref inputs) => {
@@ -41,23 +42,26 @@ pub(crate) fn generate_typescript_generator(info: &RpcInfo) -> TokenStream {
                 quote!(Some(&<#ty as TypeDef>::INFO))
             }
         };
-        let ts_name = method.name.to_case(Case::Camel);
+        let rpc_name_camel = method.name.to_case(Case::Camel);
         let rpc_name = &method.name;
         let is_notification = method.is_notification;
         let docs = if let Some(docs) = &method.docs {
             quote!(Some(#docs))
         } else {
             quote!(None)
         };
-        gen_methods.push(quote!(
+        gen_methods_ts.push(quote!(
                 let args = vec![#(#gen_args),*];
-                let method = Method::new(#ts_name, #rpc_name, args, #gen_output, #is_notification, #is_positional, #docs);
-                out.push_str(&method.to_string(root_namespace));
+                let method = Method::new(#rpc_name_camel, #rpc_name, args, #gen_output, #is_notification, #is_positional, #docs);
+                out.push_str(&method.to_string_ts(root_namespace));
+        ));
+        gen_methods_qt.push(quote!(
+                let args = vec![#(#gen_args),*];
+                let method = Method::new(#rpc_name_camel, #rpc_name, args, #gen_output, #is_notification, #is_positional, #docs);
+                out.push_str(&method.to_string_qt());
         ));
     }
 
-    let ts_base = include_str!("client.ts");
-
     let mut all_types: Vec<String> = gen_types
         .clone()
         .into_iter()
@@ -67,11 +71,22 @@ pub(crate) fn generate_typescript_generator(info: &RpcInfo) -> TokenStream {
     all_types.dedup();
     let all_types: Vec<TokenStream> = all_types.into_iter().map(|s| s.parse().unwrap()).collect();
 
+    let ts = ts_impl(&all_types, &gen_methods_ts);
+    let qt = qt_impl(&all_types, &gen_methods_qt);
+    quote! {
+        #ts
+        #qt
+    }
+}
+
+fn ts_impl(all_types: &[TokenStream], gen_methods: &[TokenStream]) -> TokenStream {
+    let ts_base = include_str!("client.ts");
+
     quote! {
         /// Write typescript bindings for the JSON-RPC API.
         pub fn write_ts_bindings(outdir: &::std::path::Path) {
             use ::yerpc::typescript::type_def::{TypeDef, type_expr::TypeInfo, DefinitionFileOptions};
-            use ::yerpc::typescript::{typedef_to_expr_string, export_types_to_file, Method};
+            use ::yerpc::{method::Method, typescript::{typedef_to_expr_string, export_types_to_file}};
             use ::std::{fs, path::Path};
             use ::std::io::Write;
 
@@ -84,7 +99,7 @@ pub(crate) fn generate_typescript_generator(info: &RpcInfo) -> TokenStream {
             // Write typescript types to file.
             export_types_to_file::<__AllTyps>(&outdir.join("types.ts"), None).expect("Failed to write TS out");
             // remove __AllTyps ts type from output,
-            // it's only used as a woraround to export all types and is not needed anymore now
+            // it's only used as a workaround to export all types and is not needed anymore now
             let new_content = {
                 let string =
                     ::std::fs::read_to_string(&outdir.join("types.ts")).expect("Failed to find TS out");
@@ -100,7 +115,7 @@ pub(crate) fn generate_typescript_generator(info: &RpcInfo) -> TokenStream {
                 .expect("removing __AllTyps from TS failed");
             export_types_to_file::<::yerpc::Message>(&outdir.join("jsonrpc.ts"), None).expect("Failed to write TS out");
 
-            // // Generate a raw client.
+            // Generate a raw client.
             let root_namespace = Some("T");
             let mut out = String::new();
             #(#gen_methods)*
@@ -109,3 +124,44 @@ pub(crate) fn generate_typescript_generator(info: &RpcInfo) -> TokenStream {
         }
     }
 }
+
+fn qt_impl(all_types: &[TokenStream], gen_methods: &[TokenStream]) -> TokenStream {
+    let qt_base = include_str!("client.hpp");
+    quote! {
+        /// Generate qt bindings for the JSON-RPC API.
+        pub fn write_qt_bindings(outdir: &::std::path::Path, root_namespace: &str) {
+            use ::yerpc::typescript::type_def::{TypeDef, type_expr::TypeInfo, DefinitionFileOptions};
+            use ::yerpc::{method::Method, qt::export_types_to_file};
+            use ::std::{fs, path::Path};
+            use ::std::io::Write;
+
+            // Create helper type with all exported types.
+            // #(#gen_definitions)*
+            #[derive(TypeDef)]
+            struct __AllTyps(#(#all_types),*);
+            // Write qt types to file.
+            export_types_to_file::<__AllTyps>(&outdir.join("types.hpp"), root_namespace).expect("Failed to write Qt out");
+            // remove __AllTyps type from output,
+            // it's only used as a workaround to export all types and is not needed anymore now
+            let new_content = {
+                let string =
+                    ::std::fs::read_to_string(&outdir.join("types.hpp")).expect("Failed to find Qt out");
+                if let Some(index) = string.find("using __AllTyps = ") {
+                    string[..index].to_string() + "\n}\n"
+                } else {
+                    panic!("did not find __AllTyps in Qt out");
+                }
+            };
+            ::std::fs::File::create(&outdir.join("types.hpp"))
+                .expect("failed to open Qt out")
+                .write_all(new_content.as_bytes())
+                .expect("removing __AllTyps from Qt failed");
+
+            // Generate a raw client.
+            let mut out = String::new();
+            #(#gen_methods)*
+            let qt_header = #qt_base.replace("#root_namespace", root_namespace).replace("#methods", &out);
+            fs::write(&outdir.join("client.hpp"), &qt_header).expect("Failed to write Qt bindings");
+        }
+    }
+}

yerpc-derive/src/client.hpp

@@ -0,0 +1,108 @@
+#pragma once
+
+#include "types.hpp"
+
+#include <QString>
+#include <QJsonValue>
+#include <QJsonObject>
+#include <QJsonArray>
+#include <QJsonDocument>
+
+#include <future>
+#include <memory>
+
+namespace #root_namespace {
+
+template<typename T>
+struct [[nodiscard]] Result {
+    T result();
+    QString error_message();
+    int32_t error_code = 0;
+
+    /**
+     * Returns the result value. If the result is an error, logs a warning
+     * with the error details and the caller's source location, and returns
+     * a default-constructed T.
+     */
+    T valueOrDefault(const char* file = __builtin_FILE(), int line = __builtin_LINE()) {
+      if (error_code) {
+        qWarning() << file << ":" << line
+          << "Error " << error_code << error_message;
+      }
+      return result;
+    }
+};
+
+template<>
+struct [[nodiscard]] Result<void> {
+    QString error_message();
+    int32_t error_code = 0;
+
+    /**
+     * If the result is an error, logs a warning with the error details and the
+     * caller's source location
+     */
+    void logError(const char* file = __builtin_FILE(), int line = __builtin_LINE()) {
+      if (error_code) {
+        qWarning() << file << ":" << line
+          << "Error " << error_code << error_message;
+      }
+    }
+};
+
+static Result<QJsonValue> parseResult(const QJsonObject& val) {
+  if (val.contains("error")) {
+    QJsonObject err = val["error"].toObject();
+    QJsonValue error_message = err["message"];
+    int error_code = err["code"].toInt();
+    if (!error_message.isString() || error_code == 0)
+      return {{}, "Invalid error in response: " + QJsonDocument(val).toJson(QJsonDocument::Compact), -32700};
+    return {{}, error_message.toString(), error_code};
+  }
+  if (!val.contains("result"))
+    return {{}, "Neither error nor result in response: " + QJsonDocument(val).toJson(QJsonDocument::Compact), -32700};
+  return {val["result"], {}, 0};
+}
+
+class Transport {
+public:
+    virtual std::future<Result<QJsonValue>> send(const QString method, const QJsonValue request) = 0;
+};
+
+class RawClient {
+  std::unique_ptr<Transport> transport_;
+
+  template <typename T>
+  std::future<Result<T>> request(const QString method,
+                                 const QJsonArray params) {
+    std::future<Result<QJsonValue>> inner = transport_->send(method, params);
+    return std::async(
+        std::launch::deferred,
+        [method, inner = std::move(inner)]() mutable -> Result<T> {
+          auto val = inner.get();
+          if constexpr (std::is_void_v<T>) {
+            if (val.error_code)
+              return {method + ": " + val.error_message, val.error_code};
+            return {{}, 0};
+          } else {
+            if (val.error_code)
+              return {{}, method + ": " + val.error_message, val.error_code};
+            T out;
+            if (!tryFromJson(val.result, out)) {
+              return {{},
+                      method + ": Could not parse result " +
+                          QJsonDocument(QJsonArray{val.result})
+                              .toJson(QJsonDocument::Compact),
+                      -32700};
+            }
+            return {out, {}, 0};
+          }
+        });
+  }
+public:
+  RawClient(std::unique_ptr<Transport> t) : transport_{std::move(t)} {}
+
+#methods
+};
+
+}

yerpc-derive/src/lib.rs

@@ -11,14 +11,14 @@ use proc_macro::TokenStream;
 use quote::quote;
 use syn::{parse_macro_input, Item};
 
+mod bindings;
 #[cfg(feature = "openrpc")]
 mod openrpc;
 mod parse;
 mod rpc;
-mod ts;
+pub(crate) use bindings::generate_bindings_impl;
 pub(crate) use parse::{Inputs, RpcInfo};
 pub(crate) use rpc::generate_rpc_impl;
-pub(crate) use ts::generate_typescript_generator;
 pub(crate) mod util;
 
 /// Generates the jsonrpc handler and types.
@@ -49,7 +49,7 @@ pub fn rpc(attr: TokenStream, tokens: TokenStream) -> TokenStream {
             };
 
             let info = RpcInfo::from_impl(&attr_args, input);
-            let ts_impl = generate_typescript_generator(&info);
+            let bindings_impl = generate_bindings_impl(&info);
             let rpc_impl = generate_rpc_impl(&info);
 
             #[cfg(feature = "openrpc")]
@@ -61,7 +61,7 @@ pub fn rpc(attr: TokenStream, tokens: TokenStream) -> TokenStream {
             quote! {
                 #item
                 #rpc_impl
-                #ts_impl
+                #bindings_impl
                 #openrpc_impl
             }
         }

yerpc/Cargo.toml

@@ -49,3 +49,4 @@ axum = { version = "0.8.1", features = ["ws"] }
 tokio-tungstenite = { version = "0.26.1" }
 tokio = { version = "1.43.0", features = ["rt", "macros"] }
 url = "2.5.4"
+insta = "1.47.2"