can now be used as separated module

Author: lifr0m

.idea/tl.iml

@@ -4,4 +4,5 @@ members = [
     "tl-types",
     "tl-parser",
     "tl-generator",
+    "tl-example",
 ]

Cargo.lock

@@ -75,17 +75,17 @@ impl crate::Deserialize for Error {
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum Function {
-    GetUsers(crate::functions::GetUsers),
-    SendMessage(crate::functions::SendMessage),
+    GetUsers(self::functions::GetUsers),
+    SendMessage(self::functions::SendMessage),
 }
 
 impl crate::Deserialize for Function {
     fn deserialize(reader: &mut crate::Reader) -> Result<Self, crate::deserialize::Error> {
         let id = u32::deserialize(reader)?;
 
         Ok(match id {
-            1904452899_u32 => Self::GetUsers(crate::functions::GetUsers::deserialize(reader)?),
-            339054040_u32 => Self::SendMessage(crate::functions::SendMessage::deserialize(reader)?),
+            1904452899_u32 => Self::GetUsers(self::functions::GetUsers::deserialize(reader)?),
+            339054040_u32 => Self::SendMessage(self::functions::SendMessage::deserialize(reader)?),
             _ => return Err(crate::deserialize::Error::UnexpectedDefinitionId(id)),
         })
     }
@@ -209,7 +209,7 @@ pub mod functions {
     }
 
     impl crate::Call for GetUsers {
-        type Return = Vec::<crate::types::User>;
+        type Return = Vec::<super::types::User>;
     }
 
     #[derive(Debug, Clone, PartialEq)]
@@ -239,7 +239,7 @@ pub mod functions {
     }
 
     impl crate::Call for SendMessage {
-        type Return = crate::types::Message;
+        type Return = super::types::Message;
     }
 
 }
@@ -248,8 +248,9 @@ pub mod functions {
 
 ### How to use
 
-1. Clone project.
-2. Create `schema.tl` file at the root of `tl-types` crate.
-3. Specify `tl-types` crate in dependencies of your project.
-
-See `example.rs` in `tl-types/tests` folder.
+1. Clone template `tl-example` package.
+2. Create schemas in `schemas` folder.
+3. Create corresponding modules in `src/schemas` module.
+4. Specify schemas in `build.rs`.
+5. Remove `src/main.rs` / Edit `Cargo.toml` / Rename package.
+6. Specify crate in dependencies of your project.

Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "tl-example"
+version = "0.1.0"
+edition = "2024"
+description = "TL example"
+license = "MIT"
+repository = "https://github.com/lifr0m/tl"
+
+[dependencies]
+tl-types = { path = "../tl-types" }
+
+[build-dependencies]
+tl-parser = { path = "../tl-parser" }
+tl-generator = { path = "../tl-generator" }
+anyhow = "1"

README.md

@@ -0,0 +1,29 @@
+use anyhow::Context;
+use std::path::PathBuf;
+use std::{env, fs};
+
+fn main() -> anyhow::Result<()> {
+    let out_dir = PathBuf::from(env::var("OUT_DIR")?);
+
+    let name_list = ["api"];
+    let out_dir = out_dir.join("schemas");
+
+    if !out_dir.exists() {
+        fs::create_dir(&out_dir)?;
+    }
+
+    for name in name_list {
+        let out_file = out_dir.join(format!("{name}.rs"));
+
+        let schema = fs::read_to_string(format!("schemas/{name}.tl"))
+            .with_context(|| format!("failed to read schema: {name}"))?;
+        let schema = tl_parser::parse_schema(&schema)
+            .with_context(|| format!("failed to parse schema: {name}"))?;
+        let code = tl_generator::generate(&schema);
+
+        fs::write(out_file, code)
+            .with_context(|| format!("failed to write generated code for schema: {name}"))?;
+    }
+
+    Ok(())
+}

tl-example/Cargo.toml

@@ -0,0 +1,9 @@
+type Message id:int32 text:string? photos:[bytes] sent_at:time = Message
+type User id:int64 verified:bool rating:float = User
+type UserEmpty id:int64 = User
+
+error InvalidUserId user_id:int64
+error TooLongText text:string max_length:int32
+
+func get_users user_ids:[int64] = [User]
+func send_message user_id:int64 text:string? photos:[bytes] = Message

tl-example/build.rs

@@ -0,0 +1,4 @@
+mod schemas;
+
+pub use schemas::*;
+pub use tl_types::*;

tl-example/schemas/api.tl

@@ -0,0 +1,75 @@
+use tl::{Deserialize, Serialize};
+use tl_example as tl;
+
+// Located on server side.
+mod functions {
+    use tl_example as tl;
+
+    pub fn get_users(func: tl::api::functions::GetUsers) -> Result<<tl::api::functions::GetUsers as tl::Call>::Return, tl::api::Error> {
+        if func.user_ids.contains(&666) {
+            Err(tl::api::Error::InvalidUserId {
+                user_id: 666,
+            })
+        } else {
+            Ok(Vec::from_iter(
+                func.user_ids.iter()
+                    .map(|&user_id| tl::api::types::User::User {
+                        id: user_id,
+                        verified: true,
+                        rating: 0.74,
+                    })
+            ))
+        }
+    }
+}
+
+// Located on client side.
+fn call<F: Serialize + tl::Call>(func: &F) -> Result<Result<F::Return, tl::api::Error>, tl::deserialize::Error> {
+    let request = func.to_bytes();
+
+    let response = respond(&request)?;
+
+    Result::<F::Return, tl::api::Error>::from_bytes(&response)
+}
+
+// Located on server side.
+fn respond(request: &[u8]) -> Result<Vec<u8>, tl::deserialize::Error> {
+    let func = tl::api::Function::from_bytes(request)?;
+
+    Ok(match func {
+        tl::api::Function::GetUsers(func) => functions::get_users(func).to_bytes(),
+        _ => unreachable!(),
+    })
+}
+
+fn main() {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_works() -> Result<(), tl::deserialize::Error> {
+        assert_eq!(
+            call(&tl::api::functions::GetUsers {
+                user_ids: vec![1],
+            })?,
+            Ok(vec![tl::api::types::User::User {
+                id: 1,
+                verified: true,
+                rating: 0.74
+            }])
+        );
+
+        assert_eq!(
+            call(&tl::api::functions::GetUsers {
+                user_ids: vec![666],
+            })?,
+            Err(tl::api::Error::InvalidUserId {
+                user_id: 666,
+            })
+        );
+
+        Ok(())
+    }
+}

tl-example/src/lib.rs

@@ -0,0 +1 @@
+pub mod api;