pub mod contract;
pub mod ir;
pub mod typescript;
use std::path::Path;
#[derive(Debug, Clone)]
pub struct HandlerInfo {
pub name: &'static str,
pub method: &'static str,
pub path: &'static str,
pub input_type_name: &'static str,
pub query_type_name: Option<&'static str>,
pub output_type_name: &'static str,
pub module_path: &'static str,
pub error_type_name: Option<&'static str>,
pub stream_event_type_name: Option<&'static str>,
pub path_param_types: &'static str,
}
#[derive(Debug, Clone)]
pub struct SchemaEntry {
pub type_name: &'static str,
pub ts_schema_name: String, }
#[derive(Debug, Clone)]
pub struct ErrorVariantInfo {
pub name: &'static str,
pub data_schema: Option<&'static str>,
}
#[derive(Debug, Clone)]
pub struct ErrorInfo {
pub type_name: &'static str,
pub variants: Vec<ErrorVariantInfo>,
}
pub struct ContractBuilder {
handlers: Vec<HandlerInfo>,
schemas: Vec<SchemaEntry>,
errors: Vec<ErrorInfo>,
resolved_schemas: Vec<ir::ResolvedSchema>,
}
impl ContractBuilder {
pub fn new(
handlers: Vec<HandlerInfo>,
schemas: Vec<SchemaEntry>,
resolved_schemas: Vec<ir::ResolvedSchema>,
) -> Self {
Self {
handlers,
schemas,
errors: Vec::new(),
resolved_schemas,
}
}
pub fn with_errors(mut self, errors: Vec<ErrorInfo>) -> Self {
self.errors = errors;
self
}
pub fn output(self, path: impl AsRef<Path>) -> std::io::Result<()> {
let path = path.as_ref();
let content = self.generate();
if let Some(parent) = path.parent() {
std::fs::create_dir_all(parent)?;
}
std::fs::write(path, content)
}
pub fn generate(self) -> String {
let imports = typescript::generate_imports();
let real_schema_types: std::collections::HashSet<&str> =
self.schemas.iter().map(|s| s.type_name).collect();
let real_schemas = typescript::emit_resolved_schemas(&self.resolved_schemas);
let mut rename_groups: std::collections::HashMap<String, Vec<String>> =
std::collections::HashMap::new();
for s in &self.resolved_schemas {
let default = format!("{}Schema", s.ts_type_name);
if s.ts_schema_name != default {
rename_groups
.entry(default)
.or_default()
.push(s.ts_schema_name.clone());
}
}
let unambiguous_renames: Vec<(String, String)> = rename_groups
.into_iter()
.filter_map(|(old, targets)| {
if targets.len() == 1 {
Some((old, targets.into_iter().next().unwrap()))
} else {
None
}
})
.collect();
let placeholder_schemas = generate_missing_placeholders(&self.handlers, &real_schema_types);
let mut schema_name_map: std::collections::HashMap<String, String> = self
.schemas
.iter()
.map(|s| (s.type_name.to_string(), s.ts_schema_name.clone()))
.collect();
for s in &self.resolved_schemas {
if !s.module_path.is_empty() {
schema_name_map.insert(s.module_path.to_string(), s.ts_schema_name.clone());
if let Some(without_first) =
s.module_path.find("::").map(|i| &s.module_path[i + 2..])
{
schema_name_map.insert(without_first.to_string(), s.ts_schema_name.clone());
}
}
}
let contract_raw = contract::generate_contract(
&self.handlers,
&self.errors,
&self.schemas,
&schema_name_map,
);
let contract = unambiguous_renames
.iter()
.fold(contract_raw, |text, (old, new)| {
[(")", ")"), (".", "."), (",", ","), ("\n", "\n")]
.iter()
.fold(text, |t, (suffix, new_suffix)| {
t.replace(
&format!("{}{}", old, suffix),
&format!("{}{}", new, new_suffix),
)
})
});
let schema_block = match (real_schemas.is_empty(), placeholder_schemas.is_empty()) {
(true, true) => String::new(),
(true, false) => placeholder_schemas,
(false, true) => real_schemas,
(false, false) => format!("{}\n\n{}", real_schemas, placeholder_schemas),
};
format!(
"// AUTO-GENERATED by rorpc — do not edit manually.\n// Re-generate: rorpc::generate_contract().output(path)\n\n{imports}\n\n{schema_block}\n\n{contract}"
)
}
}
fn generate_missing_placeholders(
handlers: &[HandlerInfo],
real_schema_types: &std::collections::HashSet<&str>,
) -> String {
use std::collections::{BTreeSet, HashMap};
let mut normalized_to_paths: HashMap<String, Vec<String>> = HashMap::new();
fn normalize_type_name(s: &str) -> String {
s.rsplit("::").next().unwrap_or(s).to_string()
}
for handler in handlers {
let mut type_names = vec![handler.input_type_name, handler.output_type_name];
if let Some(query_type) = handler.query_type_name {
type_names.push(query_type);
}
for type_str in type_names {
if !typescript::is_primitive_type_name(type_str) {
for full_path in extract_base_types(type_str) {
let normalized = normalize_type_name(&full_path);
normalized_to_paths
.entry(normalized)
.or_default()
.push(full_path);
}
}
}
}
let mut unique_types: BTreeSet<String> = BTreeSet::new();
let mut collision_warnings: Vec<String> = Vec::new();
for (normalized, paths) in &normalized_to_paths {
if real_schema_types.contains(normalized.as_str()) {
continue;
}
if paths.len() > 1 {
let unique_paths: BTreeSet<_> = paths.iter().collect();
if unique_paths.len() > 1 {
collision_warnings.push(format!(
"// ⚠️ WARNING: Multiple types resolve to '{normalized}Schema': {}",
unique_paths
.iter()
.map(|s| s.as_str())
.collect::<Vec<_>>()
.join(", ")
));
collision_warnings.push(
"// Add #[derive(ZodTs)] to one of them, or rename them to avoid collision."
.to_string(),
);
}
}
unique_types.insert(normalized.clone());
}
if unique_types.is_empty() {
return String::new();
}
let mut lines = vec![
"// ⚠️ Placeholder schemas — add #[derive(ZodTs)] to your types for real schemas"
.to_string(),
String::new(),
];
if !collision_warnings.is_empty() {
lines.extend(collision_warnings);
lines.push(String::new());
}
for type_name in unique_types {
let schema_name = typescript::to_schema_name(&type_name);
let base_name = typescript::base_type_name(&type_name);
lines.push(format!(
"// TODO: add #[derive(ZodTs)] to {base_name} in Rust"
));
lines.push(format!(
"export const {schema_name} = z.unknown(); // {type_name}"
));
lines.push(format!(
"export type {base_name} = z.infer<typeof {schema_name}>;"
));
lines.push(String::new());
}
lines.join("\n")
}
fn extract_base_types(type_str: &str) -> Vec<String> {
let cleaned = type_str.replace(' ', "");
if cleaned.starts_with("Sse<") {
return vec![];
}
let inner = if cleaned.starts_with("Result<") {
rorpc_parse::types::extract_first_generic_arg_string(&cleaned)
.map(|s| s.to_string())
.unwrap_or(cleaned.clone())
} else {
cleaned.clone()
};
let inner = if inner.starts_with("Json<") && inner.ends_with('>') {
inner[5..inner.len() - 1].to_string()
} else {
inner
};
let normalize_type = |s: String| -> String {
s
};
if inner.starts_with("Vec<") && inner.ends_with('>') {
let elem = &inner[4..inner.len() - 1];
if !typescript::is_primitive_type_name(elem) {
vec![normalize_type(elem.to_string())]
} else {
vec![]
}
} else if inner.starts_with("Option<") && inner.ends_with('>') {
let elem = &inner[7..inner.len() - 1];
if !typescript::is_primitive_type_name(elem) {
vec![normalize_type(elem.to_string())]
} else {
vec![]
}
} else if !typescript::is_primitive_type_name(&inner) && !inner.is_empty() && inner != "()" {
vec![normalize_type(inner)]
} else {
vec![]
}
}
#[cfg(test)]
mod tests {
use super::*;
fn make_handler(name: &'static str, method: &'static str, path: &'static str) -> HandlerInfo {
HandlerInfo {
name,
method,
path,
input_type_name: "()",
query_type_name: None,
output_type_name: "String",
module_path: "test::handlers",
error_type_name: None,
stream_event_type_name: None,
path_param_types: "",
}
}
#[test]
fn accepts_relative_paths_with_parent_dirs() {
let builder =
ContractBuilder::new(vec![make_handler("ping", "GET", "/ping")], vec![], vec![]);
let temp_dir = std::env::temp_dir();
let result = builder.output(temp_dir.join("test-output.ts"));
assert!(result.is_ok() || result.unwrap_err().kind() != std::io::ErrorKind::InvalidInput);
}
#[test]
fn accepts_multiple_parent_dirs_in_path() {
let builder =
ContractBuilder::new(vec![make_handler("test", "GET", "/test")], vec![], vec![]);
let temp_dir = std::env::temp_dir();
let test_file = temp_dir.join("rorpc-test-multiple-parents.ts");
let nested = temp_dir.join("a").join("b").join("c");
std::fs::create_dir_all(&nested).ok();
let relative_from_nested = "../../../rorpc-test-multiple-parents.ts";
let full_path = nested.join(relative_from_nested);
let result = builder.output(&full_path);
let is_valid = result
.as_ref()
.map(|_| true)
.unwrap_or_else(|e| e.kind() != std::io::ErrorKind::InvalidInput);
assert!(is_valid, "Path with multiple .. should be accepted");
if result.is_ok() {
assert!(test_file.exists(), "File should exist at resolved path");
std::fs::remove_file(test_file).ok();
}
std::fs::remove_dir_all(temp_dir.join("a")).ok();
}
#[test]
fn accepts_deep_parent_navigation() {
let builder = ContractBuilder::new(
vec![make_handler("extreme", "GET", "/extreme")],
vec![],
vec![],
);
let temp_dir = std::env::temp_dir();
let test_output = temp_dir.join("rorpc-deep-navigation-test.ts");
let deeply_nested = temp_dir
.join("level1")
.join("level2")
.join("level3")
.join("level4")
.join("level5");
std::fs::create_dir_all(&deeply_nested).ok();
let relative = "../../../../../rorpc-deep-navigation-test.ts";
let path_from_deep = deeply_nested.join(relative);
let result = builder.output(&path_from_deep);
let is_valid = result
.as_ref()
.map(|_| true)
.unwrap_or_else(|e| e.kind() != std::io::ErrorKind::InvalidInput);
assert!(
is_valid,
"Deep parent navigation (../../../../..) should be accepted"
);
if result.is_ok() && test_output.exists() {
std::fs::remove_file(test_output).ok();
}
std::fs::remove_dir_all(temp_dir.join("level1")).ok();
}
#[test]
fn generates_with_no_schemas() {
let builder =
ContractBuilder::new(vec![make_handler("ping", "GET", "/ping")], vec![], vec![]);
let output = builder.generate();
assert!(output.contains("AUTO-GENERATED"));
assert!(output.contains("ping"));
}
#[test]
fn generates_with_real_schemas() {
let builder = ContractBuilder::new(
vec![make_handler("list_planets", "POST", "/planet/list")],
vec![SchemaEntry {
type_name: "Planet",
ts_schema_name: "PlanetSchema".to_string(),
}],
vec![ir::ResolvedSchema {
ts_schema_name: "PlanetSchema".to_string(),
ts_type_name: "Planet".to_string(),
module_path: "",
def: ir::ResolvedDef::Object {
fields: vec![ir::ResolvedField {
ts_key: "id".to_string(),
zod_expr: "z.number().int()".to_string(),
}],
},
}],
);
let output = builder.generate();
assert!(output.contains("PlanetSchema"));
assert!(output.contains("z.object"));
assert!(output.contains("listPlanets"));
}
#[test]
fn test_no_duplicate_when_real_schema_exists() {
let handlers = vec![HandlerInfo {
name: "get_session",
method: "GET",
path: "/api/sessions/{id}",
input_type_name: "()",
query_type_name: None,
output_type_name: "Json<Session>",
module_path: "test",
error_type_name: None,
stream_event_type_name: None,
path_param_types: "Uuid",
}];
let schemas = vec![SchemaEntry {
type_name: "Session",
ts_schema_name: "SessionSchema".to_string(),
}];
let resolved = vec![ir::ResolvedSchema {
ts_schema_name: "SessionSchema".to_string(),
ts_type_name: "Session".to_string(),
module_path: "",
def: ir::ResolvedDef::Object {
fields: vec![ir::ResolvedField {
ts_key: "id".to_string(),
zod_expr: "z.uuid()".to_string(),
}],
},
}];
let builder = ContractBuilder::new(handlers, schemas, resolved);
let output = builder.generate();
let session_schema_count = output.matches("export const SessionSchema").count();
assert_eq!(
session_schema_count, 1,
"Should have exactly one SessionSchema definition"
);
assert!(
!output.contains("TODO: add #[derive(ZodTs)] to Session"),
"Should not have placeholder comment for Session"
);
assert!(output.contains("z.uuid()"));
}
#[test]
fn test_module_path_normalized() {
let handlers = vec![HandlerInfo {
name: "admin_list",
method: "GET",
path: "/api/admin/sessions",
input_type_name: "()",
query_type_name: None,
output_type_name: "Json<Vec<crate::types::Session>>",
module_path: "test",
error_type_name: None,
stream_event_type_name: None,
path_param_types: "",
}];
let schemas = vec![SchemaEntry {
type_name: "Session",
ts_schema_name: "SessionSchema".to_string(),
}];
let resolved = vec![ir::ResolvedSchema {
ts_schema_name: "SessionSchema".to_string(),
ts_type_name: "Session".to_string(),
module_path: "",
def: ir::ResolvedDef::Object {
fields: vec![ir::ResolvedField {
ts_key: "id".to_string(),
zod_expr: "z.uuid()".to_string(),
}],
},
}];
let builder = ContractBuilder::new(handlers, schemas, resolved);
let output = builder.generate();
let session_schema_count = output.matches("export const SessionSchema").count();
assert_eq!(
session_schema_count, 1,
"Module paths should normalize to prevent duplicates"
);
assert!(!output.contains("TODO: add #[derive(ZodTs)] to Session"));
}
#[test]
fn test_collision_warning_for_different_types() {
let handlers = vec![
HandlerInfo {
name: "get_entity_session",
method: "GET",
path: "/api/entities/sessions/{id}",
input_type_name: "()",
query_type_name: None,
output_type_name: "Json<crate::entities::Session>",
module_path: "test",
error_type_name: None,
stream_event_type_name: None,
path_param_types: "Uuid",
},
HandlerInfo {
name: "get_type_session",
method: "GET",
path: "/api/types/sessions/{id}",
input_type_name: "()",
query_type_name: None,
output_type_name: "Json<crate::types::Session>",
module_path: "test",
error_type_name: None,
stream_event_type_name: None,
path_param_types: "Uuid",
},
];
let schemas = vec![];
let builder = ContractBuilder::new(handlers, schemas, vec![]);
let output = builder.generate();
assert!(
output.contains("⚠️ WARNING: Multiple types resolve to 'SessionSchema'"),
"Should warn about collision"
);
assert!(
output.contains("crate::entities::Session") && output.contains("crate::types::Session"),
"Should list both conflicting types"
);
let session_schema_count = output.matches("export const SessionSchema").count();
assert_eq!(
session_schema_count, 1,
"Should generate one placeholder despite collision"
);
}
#[test]
fn test_collision_resolved_by_real_schema() {
let handlers = vec![
HandlerInfo {
name: "get_entity_session",
method: "GET",
path: "/api/entities/sessions/{id}",
input_type_name: "()",
query_type_name: None,
output_type_name: "Json<crate::entities::Session>",
module_path: "test",
error_type_name: None,
stream_event_type_name: None,
path_param_types: "Uuid",
},
HandlerInfo {
name: "get_type_session",
method: "GET",
path: "/api/types/sessions/{id}",
input_type_name: "()",
query_type_name: None,
output_type_name: "Json<crate::types::Session>",
module_path: "test",
error_type_name: None,
stream_event_type_name: None,
path_param_types: "Uuid",
},
];
let schemas = vec![SchemaEntry {
type_name: "Session",
ts_schema_name: "SessionSchema".to_string(),
}];
let resolved = vec![ir::ResolvedSchema {
ts_schema_name: "SessionSchema".to_string(),
ts_type_name: "Session".to_string(),
module_path: "",
def: ir::ResolvedDef::Object {
fields: vec![ir::ResolvedField {
ts_key: "id".to_string(),
zod_expr: "z.uuid()".to_string(),
}],
},
}];
let builder = ContractBuilder::new(handlers, schemas, resolved);
let output = builder.generate();
assert!(
!output.contains("⚠️ WARNING: Multiple types resolve to 'SessionSchema'"),
"Should not warn when real schema exists"
);
let session_schema_count = output.matches("export const SessionSchema").count();
assert_eq!(session_schema_count, 1);
assert!(output.contains("z.uuid()"));
assert!(!output.contains("z.unknown()"));
}
#[test]
fn test_vec_and_option_extract_inner_types() {
let handlers = vec![HandlerInfo {
name: "test",
method: "GET",
path: "/test",
input_type_name: "Json<Option<User>>",
query_type_name: None,
output_type_name: "Json<Vec<Session>>",
module_path: "test",
error_type_name: None,
stream_event_type_name: None,
path_param_types: "",
}];
let schemas = vec![];
let builder = ContractBuilder::new(handlers, schemas, vec![]);
let output = builder.generate();
assert!(output.contains("SessionSchema = z.unknown()"));
assert!(output.contains("UserSchema = z.unknown()"));
}
}