Add C# implementation

makes the output more stable for putting it into a versioning system
like git

Cargo.lock

@@ -561,7 +561,7 @@ checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
 
 [[package]]
 name = "jrpc-cli"
-version = "0.1.0"
+version = "0.1.2"
 dependencies = [
  "anyhow",
  "clap",

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 edition = "2021"
 name = "jrpc-cli"
-version = "0.1.0"
+version = "0.1.2"
 
 [workspace]
 resolver = "2"
@@ -12,6 +12,7 @@ anyhow = "1"
 clap = { version = "4", features = ["derive"] }
 libjrpc = { path = "libjrpc" }
 log = "0.4"
-simple_logger = { version = "5.0.0", features = ["threads"] }
+simple_logger = { version = "5", features = ["threads"] }
+
 [dev-dependencies]
 walkdir = "2"

libjrpc/Cargo.toml

@@ -8,9 +8,9 @@ default = ["http"]
 http = ["dep:reqwest", "dep:url"]
 
 [dependencies]
-anyhow = "1.0.89"
+anyhow = "1"
-lazy_static = "1.5.0"
+lazy_static = "1"
-log = "0.4.22"
+log = "0.4"
-regex = "1.10.6"
+regex = "1"
-reqwest = { version = "0.12.7", optional = true, features = ["blocking"] }
+reqwest = { version = "0.12", optional = true, features = ["blocking"] }
-url = { version = "2.5.2", optional = true }
+url = { version = "2", optional = true }

libjrpc/src/compile.rs

@@ -1,4 +1,4 @@
-use std::{collections::HashMap, path::PathBuf};
+use std::{collections::BTreeMap, path::PathBuf};
 
 use anyhow::{Context, Result};
 
@@ -8,7 +8,7 @@ use crate::{
 };
 
 pub trait Compile {
-    fn new(options: &HashMap<String, String>) -> Result<Self>
+    fn new(options: &BTreeMap<String, String>) -> Result<Self>
     where
         Self: Sized;
 

libjrpc/src/ir.rs

@@ -1,5 +1,5 @@
 use std::{
-    collections::{HashMap, HashSet},
+    collections::{BTreeMap, BTreeSet},
     error::Error,
     fmt::{Debug, Display},
     hash::{Hash, Hasher},
@@ -20,7 +20,7 @@ pub trait Definition: Debug {
 
 #[derive(Debug, Clone)]
 pub struct IR {
-    pub options: HashMap<String, String>,
+    pub options: BTreeMap<String, String>,
     pub steps: Vec<Step>,
 }
 
@@ -58,7 +58,12 @@ impl ToString for BaseType {
 
 impl Hash for BaseType {
     fn hash<H: Hasher>(&self, state: &mut H) {
-        self.to_string().hash(state);
+        // Hash the enum variant itself
+        std::mem::discriminant(self).hash(state);
+        // If the variant has data, hash that too
+        if let BaseType::Custom(name) = self {
+            name.hash(state);
+        }
     }
 }
 
@@ -178,7 +183,7 @@ impl Type {
 #[derive(Debug, Clone)]
 pub struct TypeDefinition {
     pub name: String,
-    pub depends: HashSet<BaseType>,
+    pub depends: BTreeSet<BaseType>,
     pub fields: Vec<Field>,
     pub position: ParserPosition,
 }
@@ -223,7 +228,7 @@ pub struct EnumField {
 #[derive(Debug, Clone)]
 pub struct ServiceDefinition {
     pub name: String,
-    pub depends: HashSet<BaseType>,
+    pub depends: BTreeSet<BaseType>,
     pub methods: Vec<Method>,
     pub position: ParserPosition,
 }
@@ -259,7 +264,7 @@ pub struct MethodOutput {
 #[derive(Debug, Clone)]
 pub struct MethodDecorators {
     pub description: Option<String>,
-    pub parameter_descriptions: HashMap<String, String>,
+    pub parameter_descriptions: BTreeMap<String, String>,
     pub return_description: Option<String>,
 }
 
@@ -267,7 +272,7 @@ fn build_type(stmt: &TypeStatement) -> Result<TypeDefinition> {
     let mut typedef = TypeDefinition {
         position: stmt.position.clone(),
         name: stmt.name.clone(),
-        depends: HashSet::new(),
+        depends: BTreeSet::new(),
         fields: Vec::new(),
     };
 
@@ -332,7 +337,7 @@ fn build_service(stmt: &ServiceStatement) -> Result<ServiceDefinition> {
     let mut servdef = ServiceDefinition {
         position: stmt.position.clone(),
         name: stmt.name.clone(),
-        depends: HashSet::new(),
+        depends: BTreeSet::new(),
         methods: Vec::new(),
     };
 
@@ -349,7 +354,7 @@ fn build_service(stmt: &ServiceStatement) -> Result<ServiceDefinition> {
             }),
             decorators: MethodDecorators {
                 description: None,
-                parameter_descriptions: HashMap::new(),
+                parameter_descriptions: BTreeMap::new(),
                 return_description: None,
             },
         };
@@ -450,7 +455,7 @@ fn build_service(stmt: &ServiceStatement) -> Result<ServiceDefinition> {
 }
 
 pub fn build_ir(root: &Vec<RootNode>) -> Result<IR> {
-    let mut options = HashMap::<String, String>::new();
+    let mut options = BTreeMap::<String, String>::new();
     let mut steps = Vec::new();
 
     for node in root {
@@ -476,8 +481,8 @@ pub fn build_ir(root: &Vec<RootNode>) -> Result<IR> {
         }
     }
 
-    let mut all_types = HashSet::<String>::new();
+    let mut all_types = BTreeSet::<String>::new();
-    let mut serv_types = HashSet::<String>::new();
+    let mut serv_types = BTreeSet::<String>::new();
 
     for bi in &BUILT_INS {
         all_types.insert(bi.to_string());
@@ -577,3 +582,36 @@ impl Display for IRError {
         write!(f, "ParserError: {} at {:?}", self.message, self.position)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn btreeset_order_is_consistent() {
+        let mut set1 = BTreeSet::new();
+        let mut set2 = BTreeSet::new();
+
+        let elements = vec![
+            BaseType::Custom("CustomType".to_string()),
+            BaseType::Void,
+            BaseType::Bytes,
+            BaseType::Float,
+        ];
+
+        // Insert in normal order
+        for elem in &elements {
+            set1.insert(elem.clone());
+        }
+
+        // Insert in reverse order
+        for elem in elements.iter().rev() {
+            set2.insert(elem.clone());
+        }
+
+        let iter1: Vec<_> = set1.iter().cloned().collect();
+        let iter2: Vec<_> = set2.iter().cloned().collect();
+
+        assert_eq!(iter1, iter2); // Order must be the same
+    }
+}

libjrpc/src/targets/csharp.rs

@@ -0,0 +1,404 @@
+use anyhow::Result;
+use log::warn;
+use std::collections::{BTreeMap, BTreeSet};
+use std::fmt::format;
+
+use crate::compile::{Compile, CompileContext, FileGenerator};
+use crate::ir::{BaseType, EnumDefinition, ServiceDefinition, Step, Type, TypeDefinition};
+use crate::shared::Keywords;
+use crate::IR;
+
+pub struct CSharpCompiler {
+    namespace: String,
+}
+
+static CSHARP_KEYWORDS: [&'static str; 5] = ["event", "internal", "public", "private", "static"];
+
+impl CSharpCompiler {
+    fn type_to_csharp(typ: &BaseType) -> String {
+        match typ {
+            BaseType::String => "string".to_string(),
+            BaseType::Int => "long".to_string(),
+            BaseType::Float => "double".to_string(),
+            BaseType::Bool => "bool".to_string(),
+            BaseType::Bytes => todo!("Bytes are not implemented for C#"),
+            BaseType::Void => "void".to_string(),
+            BaseType::Custom(name) => name.clone(),
+        }
+    }
+
+    fn type_to_csharp_ext(typ: &Type) -> String {
+        let mut result = Self::type_to_csharp(&typ.0);
+
+        let (optional, array, map) = typ.1.get_flags();
+
+        if array {
+            result = format!("IList<{}>", result);
+        }
+        if let Some(map) = &map {
+            result = format!("Dictionary<{}, {}>", Self::type_to_csharp(&map), result);
+        }
+        if optional {
+            result = format!("{}?", result);
+        }
+        result
+    }
+
+    fn fix_keyword_name(name: &str) -> String {
+        if CSHARP_KEYWORDS.contains(&name) {
+            format!("{}_", name)
+        } else {
+            name.to_string()
+        }
+    }
+
+    fn generate_service_server(
+        &mut self,
+        ctx: &mut CompileContext,
+        definition: &ServiceDefinition,
+    ) -> anyhow::Result<()> {
+        let mut f = FileGenerator::new();
+
+        f.a0("using System;");
+        f.a0("using System.Text.Json;");
+        f.a0("using System.Text.Json.Serialization;");
+        f.a0("using System.Text.Json.Nodes;");
+        f.a0("using System.Threading.Tasks;");
+        f.a0("using System.Collections.Generic;");
+
+        f.a0("");
+        f.a0(format!("namespace {};", self.namespace));
+        f.a0("");
+
+        f.a0(format!(
+            "public abstract class {}Server<TContext> : JRpcService<TContext> {{",
+            definition.name
+        ));
+        f.a1("public override string Name {");
+        f.a2("get {");
+        f.a3(format!("return \"{}\";", definition.name));
+        f.a2("}");
+        f.a1("}");
+
+        f.a1(format!("public {}Server() {{", definition.name));
+        for method in &definition.methods {
+            f.a2(format!("this.RegisterFunction(\"{}\");", method.name));
+        }
+        f.a1("}");
+        f.a0("");
+
+        for fnc in &definition.methods {
+            let mut args = fnc
+                .inputs
+                .iter()
+                .map(|inp| {
+                    format!(
+                        "{} {}",
+                        Self::type_to_csharp_ext(&inp.typ),
+                        Self::fix_keyword_name(&inp.name)
+                    )
+                })
+                .collect::<Vec<String>>();
+            args.push("TContext ctx".to_string());
+            let args = args.join(",");
+
+            if let Some(output) = &fnc.output {
+                if output.typ.0 == BaseType::Void {
+                    f.a1(format!("public abstract Task {}({});", fnc.name, args));
+                } else {
+                    f.a1(format!(
+                        "public abstract Task<{}> {}({});",
+                        Self::type_to_csharp_ext(&output.typ),
+                        fnc.name,
+                        args
+                    ));
+                }
+            } else {
+                f.a1(format!("public abstract void {}({});", fnc.name, args));
+            }
+        }
+
+        f.a0("");
+        f.a1("public async override Task<JsonNode?> HandleRequest(string func, JsonNode param, TContext context) {");
+        f.a2("switch(func) {");
+        for fnc in &definition.methods {
+            f.a3(format!("case \"{}\": {{", fnc.name));
+            f.a4("if(param is JsonObject) {");
+            let args_array = fnc
+                .inputs
+                .iter()
+                .map(|inp| format!("param[\"{}\"]", inp.name))
+                .collect::<Vec<String>>();
+            f.a5(format!(
+                "var ja = new JsonArray({});",
+                args_array.join(", ")
+            ));
+            f.a5("param = ja;");
+            f.a4("}");
+
+            let pref = if let Some(output) = &fnc.output {
+                if output.typ.0 == BaseType::Void {
+                    "await"
+                } else {
+                    "var result = await"
+                }
+            } else {
+                ""
+            };
+
+            let mut args_array = fnc
+                .inputs
+                .iter()
+                .map(|inp| {
+                    format!(
+                        "param[\"{}\"]!.Deserialize<{}>()",
+                        inp.name,
+                        Self::type_to_csharp_ext(&inp.typ)
+                    )
+                })
+                .collect::<Vec<String>>();
+            args_array.push("context".to_string());
+            let args_array = args_array.join(", ");
+            f.a4(format!("{} this.{}({});", pref, fnc.name, args_array));
+            if let Some(output) = &fnc.output {
+                if output.typ.0 == BaseType::Void {
+                    f.a4("return null;");
+                } else {
+                    f.a4("return JsonSerializer.SerializeToNode(result);");
+                }
+            } else {
+                f.a4("return null;");
+            };
+            f.a3("}");
+        }
+        f.a3("default: {");
+        f.a4("throw new Exception(\"Invalid Method!\");");
+        f.a3("}");
+        f.a2("}");
+        f.a1("}");
+
+        f.a0("}");
+
+        ctx.write_file(&format!("{}Server.cs", &definition.name), &f.into_content())?;
+
+        Ok(())
+    }
+
+    fn generate_service_client(
+        &mut self,
+        ctx: &mut CompileContext,
+        definition: &ServiceDefinition,
+    ) -> anyhow::Result<()> {
+        let mut f = FileGenerator::new();
+
+        f.a0("using System;");
+        f.a0("using System.Text.Json;");
+        f.a0("using System.Text.Json.Serialization;");
+        f.a0("using System.Text.Json.Nodes;");
+        f.a0("using System.Threading.Tasks;");
+        f.a0("using System.Collections.Generic;");
+
+        f.a0("");
+        f.a0(format!("namespace {};", self.namespace));
+        f.a0("");
+
+        f.a0(format!("public class {}Client {{", definition.name));
+        f.a1("private JRpcClient Client;");
+        f.a1(format!(
+            "public {}Client(JRpcClient client) {{",
+            definition.name
+        ));
+        f.a2("this.Client = client;");
+        f.a1("}");
+        f.a0("");
+        for fnc in &definition.methods {
+            let args = fnc
+                .inputs
+                .iter()
+                .map(|inp| {
+                    format!(
+                        "{} {}",
+                        Self::type_to_csharp_ext(&inp.typ),
+                        Self::fix_keyword_name(&inp.name)
+                    )
+                })
+                .collect::<Vec<String>>()
+                .join(", ");
+
+            let args_code = format!(
+                "var param = new JsonArray({});",
+                fnc.inputs
+                    .iter()
+                    .map(|inp| {
+                        format!(
+                            "JsonSerializer.SerializeToNode({})",
+                            Self::fix_keyword_name(&inp.name)
+                        )
+                    })
+                    .collect::<Vec<String>>()
+                    .join(", ")
+            );
+
+            if let Some(output) = &fnc.output {
+                if output.typ.0 == BaseType::Void {
+                    f.a1(format!("public async Task {}({}) {{", fnc.name, args));
+                    f.a2(args_code);
+                    f.a2(format!(
+                        "await Client.SendRequestRaw(\"{}.{}\", param);",
+                        definition.name, fnc.name,
+                    ));
+                    f.a1("}");
+                } else {
+                    f.a1(format!(
+                        "public async Task<{}> {}({}) {{",
+                        Self::type_to_csharp_ext(&output.typ),
+                        fnc.name,
+                        args
+                    ));
+                    f.a2(args_code);
+                    f.a2(format!(
+                        "return await Client.SendRequest<{}>(\"{}.{}\", param);",
+                        Self::type_to_csharp_ext(&output.typ),
+                        definition.name,
+                        fnc.name,
+                    ));
+                    f.a1("}");
+                }
+            } else {
+                f.a1(format!("public void {}({}) {{", fnc.name, args));
+                f.a2(args_code);
+                f.a2(format!(
+                    "Client.SendNotification(\"{}.{}\", param);",
+                    definition.name, fnc.name,
+                ));
+                f.a1("}");
+            }
+        }
+
+        f.a0("}");
+
+        ctx.write_file(&format!("{}Client.cs", &definition.name), &f.into_content())?;
+
+        Ok(())
+    }
+}
+
+impl Compile for CSharpCompiler {
+    fn new(options: &BTreeMap<String, String>) -> anyhow::Result<Self> {
+        let namespace = if let Some(namespace) = options.get("csharp_namespace") {
+            namespace.to_string()
+        } else {
+            "JRPC".to_string()
+        };
+
+        if let Some(allow_bytes) = options.get("allow_bytes") {
+            if allow_bytes == "true" {
+                anyhow::bail!("allow_bytes option is not supported for csharp compiler");
+            }
+        }
+
+        Ok(CSharpCompiler { namespace })
+    }
+
+    fn name(&self) -> String {
+        "csharp".to_string()
+    }
+
+    fn start(&mut self, ctx: &mut CompileContext) -> anyhow::Result<()> {
+        let fix_ns = |input: &str| input.replace("__NAMESPACE__", &self.namespace);
+
+        ctx.write_file(
+            &format!("{}.csproj", self.namespace),
+            &fix_ns(include_str!("../../templates/CSharp/CSharp.csproj")),
+        )?;
+
+        ctx.write_file(
+            "JRpcClient.cs",
+            &fix_ns(include_str!("../../templates/CSharp/JRpcClient.cs")),
+        )?;
+
+        ctx.write_file(
+            "JRpcServer.cs",
+            &fix_ns(include_str!("../../templates/CSharp/JRpcServer.cs")),
+        )?;
+
+        ctx.write_file(
+            "JRpcTransport.cs",
+            &fix_ns(include_str!("../../templates/CSharp/JRpcTransport.cs")),
+        )?;
+
+        Ok(())
+    }
+
+    fn generate_type(
+        &mut self,
+        ctx: &mut CompileContext,
+        definition: &TypeDefinition,
+    ) -> anyhow::Result<()> {
+        let mut f = FileGenerator::new();
+
+        f.a0("using System.Text.Json;");
+        f.a0("using System.Text.Json.Serialization;");
+        f.a0("using System.Collections.Generic;");
+        f.a0("");
+        f.a0(format!("namespace {};", self.namespace));
+        f.a0("");
+        f.a0(format!("public class {} {{", definition.name));
+
+        for field in &definition.fields {
+            f.a1(format!("[JsonPropertyName(\"{}\")]", field.name));
+
+            f.a1(format!(
+                "public {} {} {{ get; set; }}",
+                Self::type_to_csharp_ext(&field.typ),
+                Self::fix_keyword_name(&field.name)
+            ));
+        }
+
+        f.a0("}");
+
+        ctx.write_file(&format!("{}.cs", &definition.name), &f.into_content())?;
+
+        Ok(())
+    }
+
+    fn generate_enum(
+        &mut self,
+        ctx: &mut CompileContext,
+        definition: &EnumDefinition,
+    ) -> anyhow::Result<()> {
+        let mut f = FileGenerator::new();
+
+        f.a0("using System.Text.Json;");
+        f.a0("using System.Text.Json.Serialization;");
+        f.a0("");
+        f.a0(format!("namespace {};", self.namespace));
+        f.a0("");
+
+        f.a0(format!("public enum {} {{", definition.name));
+
+        for variant in &definition.values {
+            f.a1(format!("{} = {},", variant.name, variant.value));
+        }
+
+        f.a0("}");
+
+        ctx.write_file(&format!("{}.cs", &definition.name), &f.into_content())?;
+
+        Ok(())
+    }
+
+    fn generate_service(
+        &mut self,
+        ctx: &mut CompileContext,
+        definition: &ServiceDefinition,
+    ) -> anyhow::Result<()> {
+        self.generate_service_client(ctx, definition)?;
+        self.generate_service_server(ctx, definition)?;
+        Ok(())
+    }
+
+    fn finalize(&mut self, ctx: &mut CompileContext, ir: &IR) -> anyhow::Result<()> {
+        Ok(())
+    }
+}

libjrpc/src/targets/mod.rs

@@ -11,6 +11,7 @@ use crate::{
     IR,
 };
 
+pub mod csharp;
 pub mod rust;
 pub mod typescript;
 

libjrpc/src/targets/rust.rs

@@ -1,6 +1,6 @@
 use anyhow::Result;
 use log::warn;
-use std::collections::{HashMap, HashSet};
+use std::collections::{BTreeMap, BTreeSet};
 
 use crate::compile::{Compile, CompileContext, FileGenerator};
 use crate::ir::{BaseType, EnumDefinition, ServiceDefinition, Step, Type, TypeDefinition};
@@ -46,7 +46,7 @@ impl RustCompiler {
     fn add_dependencies(
         &mut self,
         file: &mut FileGenerator,
-        depends: &HashSet<BaseType>,
+        depends: &BTreeSet<BaseType>,
     ) -> Result<()> {
         for dep in depends {
             match dep {
@@ -146,8 +146,9 @@ impl RustCompiler {
 
         f.a0("#[async_trait]");
         f.a0(format!("pub trait {} {{", definition.name));
+        f.a1("type Context: Clone + Sync + Send + 'static;");
         for method in definition.methods.iter() {
-            let params = method
+            let mut params = method
                 .inputs
                 .iter()
                 .map(|arg| {
@@ -157,8 +158,9 @@ impl RustCompiler {
                         Self::type_to_rust_ext(&arg.typ)
                     )
                 })
-                .collect::<Vec<String>>()
+                .collect::<Vec<String>>();
-                .join(", ");
+            params.push("ctx: Self::Context".to_string());
+            let params = params.join(", ");
 
             let ret = method
                 .output
@@ -179,17 +181,20 @@ impl RustCompiler {
         f.a0("}");
 
         f.a0("");
-        f.a0(format!("pub struct {}Handler {{", definition.name));
+        f.a0(format!("pub struct {}Handler<Context> {{", definition.name));
         f.a1(format!(
-            "implementation: Box<dyn {} + Sync + Send + 'static>,",
+            "implementation: Box<dyn {}<Context = Context> + Sync + Send + 'static>,",
             definition.name
         ));
         f.a0("}");
         f.a0("");
 
-        f.a0(format!("impl {}Handler {{", definition.name));
+        f.a0(format!(
+            "impl<Context: Clone + Sync + Send + 'static> {}Handler<Context> {{",
+            definition.name
+        ));
         f.a1(format!(
-            "pub fn new(implementation: Box<dyn {} + Sync + Send + 'static>) -> Arc<Self> {{",
+            "pub fn new(implementation: Box<dyn {}<Context = Context> + Sync + Send + 'static>) -> Arc<Self> {{",
             definition.name,
         ));
         f.a2("Arc::from(Self { implementation })");
@@ -200,9 +205,10 @@ impl RustCompiler {
 
         f.a0("#[async_trait]");
         f.a0(format!(
-            "impl JRPCServerService for {}Handler {{",
+            "impl<Context: Clone + Sync + Send + 'static> JRPCServerService for {}Handler<Context> {{",
             definition.name
         ));
+        f.a1("type Context = Context;");
         f.a1(format!(
             "fn get_id(&self) -> String {{ \"{}\".to_owned() }} ",
             definition.name
@@ -212,7 +218,7 @@ impl RustCompiler {
 
         f.a1("#[allow(non_snake_case)]");
         f.a1(
-            "async fn handle(&self, msg: &JRPCRequest, function: &str) -> Result<(bool, Value)> {",
+            "async fn handle(&self, msg: &JRPCRequest, function: &str, ctx: Self::Context) -> Result<(bool, Value)> {",
         );
         f.a2("match function {");
 
@@ -225,7 +231,7 @@ impl RustCompiler {
             ));
             if method.inputs.len() < 1 {
                 f.a5(format!(
-                    "let res = self.implementation.{}().await?;",
+                    "let res = self.implementation.{}(ctx).await?;",
                     method.name
                 ));
                 f.a5("Ok((true, serde_json::to_value(res)?))");
@@ -249,7 +255,7 @@ impl RustCompiler {
                         ),
                     );
                 }
-                f.a5(").await?;");
+                f.a5(",ctx).await?;");
 
                 if let Some(_output) = &method.output {
                     f.a5("Ok((true, serde_json::to_value(res)?))");
@@ -277,7 +283,7 @@ impl RustCompiler {
                         ),
                     );
                 }
-                f.a5(").await?;");
+                f.a5(", ctx).await?;");
                 if let Some(_output) = &method.output {
                     f.a5("Ok((true, serde_json::to_value(res)?))");
                 } else {
@@ -403,7 +409,7 @@ impl RustCompiler {
 }
 
 impl Compile for RustCompiler {
-    fn new(options: &HashMap<String, String>) -> anyhow::Result<Self> {
+    fn new(options: &BTreeMap<String, String>) -> anyhow::Result<Self> {
         let crate_name = if let Some(crate_name) = options.get("rust_crate") {
             crate_name.to_string()
         } else {

libjrpc/src/targets/typescript.rs

@@ -1,18 +1,13 @@
-use anyhow::{anyhow, Result};
+use std::collections::{BTreeMap, BTreeSet};
+
+use anyhow::Result;
 use log::info;
-use std::collections::{HashMap, HashSet};
 
 use crate::compile::{Compile, CompileContext, FileGenerator};
 use crate::ir::{BaseType, EnumDefinition, ServiceDefinition, Step, Type, TypeDefinition};
 
 use crate::IR;
 
-// #[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
-// pub enum Flavour {
-//     ESM,
-//     Node,
-// }
-
 pub trait Flavour {
     fn ext() -> &'static str;
     fn name() -> &'static str;
@@ -115,9 +110,6 @@ impl<F: Flavour> TypeScriptCompiler<F> {
     fn type_to_typescript_ext(typ: &Type) -> String {
         let mut result = Self::type_to_typescript(&typ.0);
         let (optional, array, map) = typ.1.get_flags();
-        if optional {
-            result = format!("({} | undefined)", result);
-        }
         if array {
             result = format!("({})[]", result);
         }
@@ -128,13 +120,17 @@ impl<F: Flavour> TypeScriptCompiler<F> {
                 result
             );
         }
+        if optional {
+            // Optional should be the last modifier
+            result = format!("({} | undefined)", result);
+        }
         result
     }
 
     fn add_dependencies(
         &mut self,
         file: &mut FileGenerator,
-        depends: &HashSet<BaseType>,
+        depends: &BTreeSet<BaseType>,
     ) -> Result<()> {
         let esm = F::ext();
         file.a0(format!(
@@ -439,7 +435,7 @@ import {{ VerificationError }} from \"./ts_base{esm}\";
 }
 
 impl<F: Flavour> Compile for TypeScriptCompiler<F> {
-    fn new(options: &HashMap<String, String>) -> Result<Self> {
+    fn new(options: &BTreeMap<String, String>) -> Result<Self> {
         let flavour = options
             .get("flavour")
             .cloned()
@@ -476,9 +472,12 @@ impl<F: Flavour> Compile for TypeScriptCompiler<F> {
         for field in definition.fields.iter() {
             let typ = Self::type_to_typescript_ext(&field.typ);
 
+            let opt = if field.typ.is_optional() { "?" } else { "" };
+
             f.a1(format!(
-                "public {}: {};",
+                "public {}{}: {};",
                 Self::fix_keyword_name(&field.name),
+                opt,
                 typ
             ));
         }
@@ -541,7 +540,7 @@ impl<F: Flavour> Compile for TypeScriptCompiler<F> {
     ) -> anyhow::Result<()> {
         let mut f = FileGenerator::new();
 
-        self.add_dependencies(&mut f, &HashSet::new())?;
+        self.add_dependencies(&mut f, &BTreeSet::new())?;
 
         f.a0(format!("enum {} {{", definition.name));
         for value in &definition.values {

libjrpc/templates/CSharp/.gitignore

@@ -0,0 +1,2 @@
+bin/
+obj/

libjrpc/templates/Rust/Cargo.toml

@@ -6,10 +6,10 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-int-enum = { version = "0.5.0", features = ["serde", "convert"] }
+int-enum = { version = "0.5", features = ["serde", "convert"] }
-serde = { version = "1.0.147", features = ["derive"] }
+serde = { version = "1", features = ["derive"] }
-serde_json = "1.0.88"
+serde_json = "1"
-nanoid = "0.4.0"
+nanoid = "0.4"
-tokio = { version = "1.22.0", features = ["full"] }
+tokio = { version = "1", features = ["full"] }
-log = "0.4.17"
+log = "0.4"
-async-trait = "0.1.59"
+async-trait = "0.1"

libjrpc/templates/Rust/src/lib.rs

@@ -105,21 +105,27 @@ impl JRPCClient {
 }
 
 #[async_trait::async_trait]
-pub trait JRPCServerService: Send + Sync + 'static {
+pub trait JRPCServerService: Send + Sync {
+    type Context;
     fn get_id(&self) -> String;
-    async fn handle(&self, request: &JRPCRequest, function: &str) -> Result<(bool, Value)>;
+    async fn handle(
+        &self,
+        request: &JRPCRequest,
+        function: &str,
+        ctx: Self::Context,
+    ) -> Result<(bool, Value)>;
 }
 
-pub type JRPCServiceHandle = Arc<dyn JRPCServerService>;
+pub type JRPCServiceHandle<Context> = Arc<dyn JRPCServerService<Context = Context>>;
 
 #[derive(Clone)]
-pub struct JRPCSession {
+pub struct JRPCSession<Context> {
-    server: JRPCServer,
+    server: JRPCServer<Context>,
     message_sender: Sender<JRPCResult>,
 }
 
-impl JRPCSession {
+impl<Context: Clone + Send + Sync + 'static> JRPCSession<Context> {
-    pub fn new(server: JRPCServer, sender: Sender<JRPCResult>) -> JRPCSession {
+    pub fn new(server: JRPCServer<Context>, sender: Sender<JRPCResult>) -> Self {
         JRPCSession {
             server,
             message_sender: sender,
@@ -148,7 +154,7 @@ impl JRPCSession {
         }
     }
 
-    pub fn handle_request(&self, request: JRPCRequest) -> () {
+    pub fn handle_request(&self, request: JRPCRequest, ctx: Context) -> () {
         let session = self.clone();
         tokio::task::spawn(async move {
             info!("Received request: {}", request.method);
@@ -163,7 +169,7 @@ impl JRPCSession {
 
             let service = session.server.services.get(service);
             if let Some(service) = service {
-                let result = service.handle(&request, function).await;
+                let result = service.handle(&request, function, ctx).await;
                 match result {
                     Ok((is_send, result)) => {
                         if is_send && request.id.is_some() {
@@ -204,23 +210,23 @@ impl JRPCSession {
 }
 
 #[derive(Clone)]
-pub struct JRPCServer {
+pub struct JRPCServer<Context> {
-    services: HashMap<String, JRPCServiceHandle>,
+    services: HashMap<String, JRPCServiceHandle<Context>>,
 }
 
-impl JRPCServer {
+impl<Context: Clone + Send + Sync + 'static> JRPCServer<Context> {
-    pub fn new() -> JRPCServer {
+    pub fn new() -> Self {
         JRPCServer {
             services: HashMap::new(),
         }
     }
 
-    pub fn add_service(&mut self, service: JRPCServiceHandle) -> () {
+    pub fn add_service(&mut self, service: JRPCServiceHandle<Context>) -> () {
         let id = service.get_id();
         self.services.insert(id, service);
     }
 
-    pub fn get_session(&self, sender: Sender<JRPCResult>) -> JRPCSession {
+    pub fn get_session(&self, sender: Sender<JRPCResult>) -> JRPCSession<Context> {
         JRPCSession::new(self.clone(), sender)
     }
 }

src/main.rs

@@ -2,6 +2,7 @@ use anyhow::Result;
 use clap::{Parser, Subcommand};
 use libjrpc::{
     targets::{
+        csharp::CSharpCompiler,
         rust::RustCompiler,
         typescript::{Node, TypeScriptCompiler},
     },
@@ -67,6 +68,7 @@ pub fn main() -> Result<()> {
                     "ts-esm" => {
                         libjrpc::targets::compile::<TypeScriptCompiler<Node>>(ir, output_dir)?
                     }
+                    "csharp" => libjrpc::targets::compile::<CSharpCompiler>(ir, output_dir)?,
                     _ => {
                         println!("Unsupported target: {}", output_target);
                     }
@@ -83,6 +85,7 @@ pub fn main() -> Result<()> {
             println!("rust");
             println!("ts-node");
             println!("ts-esm");
+            println!("csharp")
         }
     }