Something went wrong. Try again.
A human-friendly DSL for ATProto Lexicons
Something went wrong. Try again.
7.1 kB · 182 lines
Rust
at commit afee6ed9
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183use mlf_codegen::{CodeGenerator, GeneratorContext, register_generator};use mlf_lang::ast::*;use std::fmt::Write;
pub struct TypeScriptGenerator;
impl TypeScriptGenerator { pub const NAME: &'static str = "typescript";
fn generate_type(&self, ty: &Type, ctx: &GeneratorContext) -> Result<String, String> { match ty { Type::Primitive { kind, .. } => Ok(match kind { PrimitiveType::Null => "null".to_string(), PrimitiveType::Boolean => "boolean".to_string(), PrimitiveType::Integer => "number".to_string(), PrimitiveType::String => "string".to_string(), PrimitiveType::Bytes => "Uint8Array".to_string(), PrimitiveType::Blob => "Blob".to_string(), // Annotation idea: @tsType("CustomBlobType") }), Type::Reference { path, .. } => { // Check if it's from the standard library let path_str = path.to_string();
// Map standard library types to TypeScript types Ok(match path_str.as_str() { "Datetime" => "string".to_string(), // ISO 8601 "Did" | "AtUri" | "Cid" | "AtIdentifier" | "Handle" | "Nsid" | "Tid" | "RecordKey" | "Uri" | "Language" => "string".to_string(), _ => { // Local or cross-file reference path.segments.last().unwrap().name.clone() } }) } Type::Array { inner, .. } => { let inner_type = self.generate_type(inner, ctx)?; Ok(format!("{}[]", inner_type)) } Type::Union { types, .. } => { let type_strings: Result<Vec<_>, _> = types.iter().map(|t| self.generate_type(t, ctx)).collect(); Ok(type_strings?.join(" | ")) } Type::Object { fields, .. } => { let mut obj = String::from("{\n"); for field in fields { if !field.docs.is_empty() { obj.push_str(" /** "); obj.push_str(&field.docs[0].text); obj.push_str(" */\n"); } obj.push_str(" "); obj.push_str(&field.name.name); if field.optional { obj.push('?'); } obj.push_str(": "); obj.push_str(&self.generate_type(&field.ty, ctx)?); obj.push_str(";\n"); } obj.push('}'); Ok(obj) } Type::Parenthesized { inner, .. } => { let inner_type = self.generate_type(inner, ctx)?; Ok(format!("({})", inner_type)) } Type::Constrained { base, .. } => { // For constrained types, just use the base type // Annotations like @min, @max could be added for runtime validation libraries self.generate_type(base, ctx) } Type::Unknown { .. } => Ok("unknown".to_string()), } }
fn generate_doc_comment(&self, docs: &[DocComment]) -> String { if docs.is_empty() { return String::new(); }
let mut result = String::from("/**\n"); for doc in docs { result.push_str(" * "); result.push_str(&doc.text); result.push('\n'); } result.push_str(" */\n"); result }}
impl CodeGenerator for TypeScriptGenerator { fn name(&self) -> &'static str { Self::NAME }
fn description(&self) -> &'static str { "Generate TypeScript type definitions and client code" }
fn file_extension(&self) -> &'static str { ".ts" }
fn generate(&self, ctx: &GeneratorContext) -> Result<String, String> { let mut output = String::new();
// Header comment writeln!(output, "/**").unwrap(); writeln!(output, " * Generated from {}", ctx.namespace).unwrap(); writeln!(output, " * Do not edit manually").unwrap(); writeln!(output, " */").unwrap(); writeln!(output).unwrap();
// Generate code for each item for item in &ctx.lexicon.items { match item { Item::Record(record) => { output.push_str(&self.generate_doc_comment(&record.docs)); writeln!(output, "export interface {} {{", record.name.name).unwrap();
for field in &record.fields { if !field.docs.is_empty() { write!(output, " /** {} */\n", field.docs[0].text).unwrap(); } write!(output, " {}", field.name.name).unwrap(); if field.optional { write!(output, "?").unwrap(); } writeln!(output, ": {};", self.generate_type(&field.ty, ctx)?).unwrap(); }
writeln!(output, "}}\n").unwrap(); } Item::DefType(def) => { output.push_str(&self.generate_doc_comment(&def.docs)); writeln!( output, "export type {} = {};\n", def.name.name, self.generate_type(&def.ty, ctx)? ) .unwrap(); } Item::InlineType(inline) => { output.push_str(&self.generate_doc_comment(&inline.docs)); writeln!( output, "export type {} = {};\n", inline.name.name, self.generate_type(&inline.ty, ctx)? ) .unwrap(); } Item::Token(token) => { output.push_str(&self.generate_doc_comment(&token.docs)); writeln!( output, "export const {} = Symbol('{}');\n", token.name.name, token.name.name ) .unwrap(); } Item::Query(_) | Item::Procedure(_) | Item::Subscription(_) => { // TODO: Generate client methods for these // Annotation idea: @clientMethod for custom generation } Item::Use(_) | Item::SelfItem(_) => { // Skip `use` statements and the `self { }` item — both // are lexicon-level metadata, not types to emit. } } }
Ok(output) }}
// Register the TypeScript generatorpub static TYPESCRIPT_GENERATOR: TypeScriptGenerator = TypeScriptGenerator;register_generator!(TYPESCRIPT_GENERATOR);