use super::{HandlerInfo, ir};
use std::collections::BTreeSet;
pub use rorpc_parse::codegen::{base_type_name, rust_type_to_ts_schema, to_schema_name};
pub use rorpc_parse::types::is_primitive_type_name;
pub fn generate_imports() -> String {
[
r#"import { z } from "zod";"#,
r#"import { oc } from "@orpc/contract";"#,
r#"import { openapi } from "@orpc/openapi";"#,
r#"import { asyncIteratorObject } from "@orpc/contract";"#,
]
.join("\n")
}
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
enum SchemaCategory {
Enum,
Domain,
Input,
Request,
SseEvent,
}
fn categorize_schema(schema: &ir::ResolvedSchema) -> SchemaCategory {
if matches!(schema.def, ir::ResolvedDef::Enum { .. }) {
return SchemaCategory::Enum;
}
let type_name = &schema.ts_type_name;
let lower = type_name.to_lowercase();
if lower.contains("event") || lower.contains("sse") || type_name.ends_with("Data") {
return SchemaCategory::SseEvent;
}
if type_name.ends_with("Input")
|| type_name.ends_with("Request")
|| type_name.ends_with("Query")
{
if type_name.ends_with("Request") {
return SchemaCategory::Request;
}
return SchemaCategory::Input;
}
SchemaCategory::Domain
}
fn extract_module_name(module_path: &str) -> String {
if module_path.is_empty() {
return "_ungrouped".to_string();
}
let segments: Vec<&str> = module_path.split("::").collect();
if segments.len() <= 1 {
return "_ungrouped".to_string();
}
let module_segments: Vec<&str> = segments
.iter()
.copied()
.skip_while(|&s| s == "crate")
.collect();
let module_segments = &module_segments[..module_segments.len().saturating_sub(1)];
if module_segments.is_empty() {
return "_ungrouped".to_string();
}
module_segments.join("_")
}
fn section_header(title: &str) -> String {
format!(
"// ============================================================================\n\
// {}\n\
// ============================================================================",
title
)
}
pub fn emit_resolved_schemas(schemas: &[ir::ResolvedSchema]) -> String {
use indexmap::IndexMap;
if schemas.is_empty() {
return String::new();
}
let mut enum_schemas = Vec::new();
let mut domain_by_module: IndexMap<String, Vec<&ir::ResolvedSchema>> = IndexMap::new();
let mut input_by_module: IndexMap<String, Vec<&ir::ResolvedSchema>> = IndexMap::new();
let mut request_schemas = Vec::new();
let mut sse_schemas = Vec::new();
for schema in schemas {
match categorize_schema(schema) {
SchemaCategory::Enum => enum_schemas.push(schema),
SchemaCategory::Domain => {
let module = extract_module_name(schema.module_path);
domain_by_module.entry(module).or_default().push(schema);
}
SchemaCategory::Input => {
let module = extract_module_name(schema.module_path);
input_by_module.entry(module).or_default().push(schema);
}
SchemaCategory::Request => request_schemas.push(schema),
SchemaCategory::SseEvent => sse_schemas.push(schema),
}
}
enum_schemas.sort_by_key(|s| &s.ts_schema_name);
sse_schemas.sort_by_key(|s| &s.ts_schema_name);
let mut sections = Vec::new();
if !enum_schemas.is_empty() {
let mut lines = vec![section_header("Enum Types"), String::new()];
for schema in enum_schemas {
lines.push(emit_one_resolved(schema));
}
sections.push(lines.join("\n"));
}
if !domain_by_module.is_empty() {
let mut lines = Vec::new();
for (module, schemas) in domain_by_module {
let module_title = if module == "_ungrouped" {
"Domain Types".to_string()
} else {
format!(
"Domain Types - {}",
module
.split('_')
.map(|s| {
let mut c = s.chars();
match c.next() {
None => String::new(),
Some(first) => {
first.to_uppercase().collect::<String>() + c.as_str()
}
}
})
.collect::<Vec<_>>()
.join(" ")
)
};
lines.push(section_header(&module_title));
lines.push(String::new());
for schema in schemas {
lines.push(emit_one_resolved(schema));
lines.push(String::new());
}
}
sections.push(lines.join("\n").trim_end().to_string());
}
if !input_by_module.is_empty() {
let mut lines = Vec::new();
for (module, schemas) in input_by_module {
let module_title = if module == "_ungrouped" {
"Input Types".to_string()
} else {
format!(
"Input Types - {}",
module
.split('_')
.map(|s| {
let mut c = s.chars();
match c.next() {
None => String::new(),
Some(first) => {
first.to_uppercase().collect::<String>() + c.as_str()
}
}
})
.collect::<Vec<_>>()
.join(" ")
)
};
lines.push(section_header(&module_title));
lines.push(String::new());
for schema in schemas {
lines.push(emit_one_resolved(schema));
lines.push(String::new());
}
}
sections.push(lines.join("\n").trim_end().to_string());
}
if !request_schemas.is_empty() {
let mut lines = vec![section_header("Request Types"), String::new()];
for schema in request_schemas {
lines.push(emit_one_resolved(schema));
lines.push(String::new());
}
sections.push(lines.join("\n").trim_end().to_string());
}
if !sse_schemas.is_empty() {
let mut lines = vec![section_header("SSE Event Types"), String::new()];
for schema in sse_schemas {
lines.push(emit_one_resolved(schema));
lines.push(String::new());
}
sections.push(lines.join("\n").trim_end().to_string());
}
sections.join("\n\n")
}
fn emit_one_resolved(s: &ir::ResolvedSchema) -> String {
match &s.def {
ir::ResolvedDef::Object { fields } => {
let field_lines = fields
.iter()
.map(|f| format!(" {}: {}", f.ts_key, f.zod_expr))
.collect::<Vec<_>>()
.join(",\n");
format!(
"export const {name} = z.object({{\n{fields}\n}});\n\nexport type {ty} = z.infer<typeof {name}>;",
name = s.ts_schema_name,
fields = field_lines,
ty = s.ts_type_name,
)
}
ir::ResolvedDef::Enum { repr, variants } => {
match repr {
ir::ResolvedEnumRepr::External => {
let variant_exprs = variants
.iter()
.map(|v| emit_variant_for_repr(v, repr))
.collect::<Vec<_>>()
.join(",\n ");
format!(
"export const {name} = z.union([\n {variants}\n]);\n\nexport type {ty} = z.infer<typeof {name}>;",
name = s.ts_schema_name,
variants = variant_exprs,
ty = s.ts_type_name,
)
}
ir::ResolvedEnumRepr::Untagged => {
let variant_exprs = variants
.iter()
.map(|v| emit_variant_for_repr(v, repr))
.collect::<Vec<_>>()
.join(",\n ");
format!(
"export const {name} = z.union([\n {variants}\n]);\n\nexport type {ty} = z.infer<typeof {name}>;",
name = s.ts_schema_name,
variants = variant_exprs,
ty = s.ts_type_name,
)
}
ir::ResolvedEnumRepr::Internal { tag } => {
let variant_exprs = variants
.iter()
.map(|v| emit_variant_for_repr(v, repr))
.collect::<Vec<_>>()
.join(",\n ");
format!(
"export const {name} = z.discriminatedUnion(\"{tag}\", [\n {variants}\n]);\n\nexport type {ty} = z.infer<typeof {name}>;",
name = s.ts_schema_name,
tag = escape_str(tag),
variants = variant_exprs,
ty = s.ts_type_name,
)
}
ir::ResolvedEnumRepr::Adjacent { tag, content: _ } => {
let variant_exprs = variants
.iter()
.map(|v| emit_variant_for_repr(v, repr))
.collect::<Vec<_>>()
.join(",\n ");
format!(
"export const {name} = z.discriminatedUnion(\"{tag}\", [\n {variants}\n]);\n\nexport type {ty} = z.infer<typeof {name}>;",
name = s.ts_schema_name,
tag = escape_str(tag),
variants = variant_exprs,
ty = s.ts_type_name,
)
}
}
}
}
}
fn emit_one_variant(v: &ir::ResolvedVariant) -> String {
let key = ts_object_key(&v.serialized_name);
match &v.kind {
ir::ResolvedVariantKind::Unit => {
format!("z.literal(\"{}\")", escape_str(&v.serialized_name))
}
ir::ResolvedVariantKind::Newtype { zod_expr } => {
format!("z.object({{ {}: {} }})", key, zod_expr)
}
ir::ResolvedVariantKind::Struct { fields } => {
let field_exprs = fields
.iter()
.map(|f| format!("{}: {}", f.ts_key, f.zod_expr))
.collect::<Vec<_>>()
.join(", ");
format!("z.object({{ {}: z.object({{ {} }}) }})", key, field_exprs)
}
}
}
fn emit_variant_for_repr(v: &ir::ResolvedVariant, repr: &ir::ResolvedEnumRepr) -> String {
match repr {
ir::ResolvedEnumRepr::External => {
emit_one_variant(v)
}
ir::ResolvedEnumRepr::Untagged => {
match &v.kind {
ir::ResolvedVariantKind::Unit => {
format!("z.literal(\"{}\")", escape_str(&v.serialized_name))
}
ir::ResolvedVariantKind::Newtype { zod_expr } => {
zod_expr.clone()
}
ir::ResolvedVariantKind::Struct { fields } => {
let field_exprs = fields
.iter()
.map(|f| format!("{}: {}", f.ts_key, f.zod_expr))
.collect::<Vec<_>>()
.join(", ");
format!("z.object({{ {} }})", field_exprs)
}
}
}
ir::ResolvedEnumRepr::Internal { tag } => {
let tag_key = ts_object_key(tag);
match &v.kind {
ir::ResolvedVariantKind::Unit => {
format!(
"z.object({{ {}: z.literal(\"{}\") }})",
tag_key,
escape_str(&v.serialized_name)
)
}
ir::ResolvedVariantKind::Newtype { zod_expr } => {
if let Some(field_map) = parse_zod_object_fields(zod_expr) {
let mut all_fields = vec![format!(
"{}: z.literal(\"{}\")",
tag_key,
escape_str(&v.serialized_name)
)];
for (k, v) in field_map.iter() {
all_fields.push(format!("{}: {}", k, v));
}
format!("z.object({{ {} }})", all_fields.join(", "))
} else {
format!(
"z.object({{ {}: z.literal(\"{}\") }}).and({})",
tag_key,
escape_str(&v.serialized_name),
zod_expr
)
}
}
ir::ResolvedVariantKind::Struct { fields } => {
let mut all_exprs = vec![format!(
"{}: z.literal(\"{}\")",
tag_key,
escape_str(&v.serialized_name)
)];
for f in fields {
all_exprs.push(format!("{}: {}", f.ts_key, f.zod_expr));
}
format!("z.object({{ {} }})", all_exprs.join(", "))
}
}
}
ir::ResolvedEnumRepr::Adjacent { tag, content } => {
let tag_key = ts_object_key(tag);
let content_key = ts_object_key(content);
match &v.kind {
ir::ResolvedVariantKind::Unit => {
format!(
"z.object({{ {}: z.literal(\"{}\") }})",
tag_key,
escape_str(&v.serialized_name)
)
}
ir::ResolvedVariantKind::Newtype { zod_expr } => {
format!(
"z.object({{ {}: z.literal(\"{}\"), {}: {} }})",
tag_key,
escape_str(&v.serialized_name),
content_key,
zod_expr
)
}
ir::ResolvedVariantKind::Struct { fields } => {
let field_exprs = fields
.iter()
.map(|f| format!("{}: {}", f.ts_key, f.zod_expr))
.collect::<Vec<_>>()
.join(", ");
format!(
"z.object({{ {}: z.literal(\"{}\"), {}: z.object({{ {} }}) }})",
tag_key,
escape_str(&v.serialized_name),
content_key,
field_exprs
)
}
}
}
}
}
fn ts_object_key(name: &str) -> String {
let valid = !name.is_empty()
&& name
.chars()
.next()
.is_some_and(|c| c.is_ascii_alphabetic() || c == '_' || c == '$')
&& name
.chars()
.all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '$');
if valid {
name.to_string()
} else {
format!("\"{}\"", escape_str(name))
}
}
fn escape_str(s: &str) -> String {
s.replace('\\', "\\\\").replace('"', "\\\"")
}
pub fn parse_zod_object_fields(schema: &str) -> Option<std::collections::HashMap<String, String>> {
let trimmed = schema.trim();
if !trimmed.starts_with("z.object({") || !trimmed.ends_with("})") {
return None;
}
let start = trimmed.find('{')? + 1;
let end = trimmed.rfind('}')?;
let inner = &trimmed[start..end];
let mut fields = std::collections::HashMap::new();
let mut depth = 0;
let mut current_field = String::new();
let mut current_name = String::new();
let mut in_field_name = true;
for ch in inner.chars() {
match ch {
'{' | '(' => depth += 1,
'}' | ')' => depth -= 1,
':' if depth == 0 && in_field_name => {
current_name = current_field.trim().to_string();
current_field.clear();
in_field_name = false;
continue;
}
',' if depth == 0 => {
if !current_name.is_empty() {
fields.insert(current_name.clone(), current_field.trim().to_string());
}
current_field.clear();
current_name.clear();
in_field_name = true;
continue;
}
_ => {}
}
current_field.push(ch);
}
if !current_name.is_empty() {
fields.insert(current_name, current_field.trim().to_string());
}
Some(fields)
}
pub fn generate_placeholder_schemas(handlers: &[HandlerInfo]) -> String {
let mut lines = Vec::new();
let unique_types: BTreeSet<&str> = handlers
.iter()
.flat_map(|h| [h.input_type_name, h.output_type_name])
.filter(|t| !is_primitive_type_name(t))
.collect();
if unique_types.is_empty() {
return String::new();
}
lines.push(
"// ⚠️ Placeholder schemas — add #[derive(ZodTs)] to your types for real schemas"
.to_string(),
);
lines.push(String::new());
for type_name in unique_types {
let schema_name = to_schema_name(type_name);
let base_name = 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")
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn primitive_check() {
assert!(is_primitive_type_name("String"));
assert!(is_primitive_type_name("()"));
assert!(!is_primitive_type_name("Planet"));
}
#[test]
fn json_planet() {
assert_eq!(rust_type_to_ts_schema("Json<Planet>"), "PlanetSchema");
}
#[test]
fn json_vec_planet() {
assert_eq!(
rust_type_to_ts_schema("Json<Vec<Planet>>"),
"z.array(PlanetSchema)"
);
}
#[test]
fn result_json_planet() {
assert_eq!(
rust_type_to_ts_schema("Result<Json<Planet>,StatusCode>"),
"PlanetSchema"
);
}
#[test]
fn json_string() {
assert_eq!(rust_type_to_ts_schema("Json<String>"), "z.string()");
}
#[test]
fn unit_type() {
assert_eq!(rust_type_to_ts_schema("()"), "z.void()");
}
#[test]
fn serde_json_value() {
assert_eq!(
rust_type_to_ts_schema("Json<serde_json::Value>"),
"z.record(z.string(), z.unknown())"
);
}
#[test]
fn schema_name_simple() {
assert_eq!(to_schema_name("Planet"), "PlanetSchema");
}
#[test]
fn external_unit_variant() {
let v = ir::ResolvedVariant {
serialized_name: "ping".to_string(),
kind: ir::ResolvedVariantKind::Unit,
};
let repr = ir::ResolvedEnumRepr::External;
assert_eq!(emit_variant_for_repr(&v, &repr), r#"z.literal("ping")"#);
}
#[test]
fn external_newtype_variant() {
let v = ir::ResolvedVariant {
serialized_name: "value".to_string(),
kind: ir::ResolvedVariantKind::Newtype {
zod_expr: "z.string()".to_string(),
},
};
let repr = ir::ResolvedEnumRepr::External;
assert_eq!(
emit_variant_for_repr(&v, &repr),
r#"z.object({ value: z.string() })"#
);
}
#[test]
fn external_struct_variant() {
let v = ir::ResolvedVariant {
serialized_name: "data".to_string(),
kind: ir::ResolvedVariantKind::Struct {
fields: vec![ir::ResolvedField {
ts_key: "id".to_string(),
zod_expr: "z.number()".to_string(),
}],
},
};
let repr = ir::ResolvedEnumRepr::External;
assert_eq!(
emit_variant_for_repr(&v, &repr),
r#"z.object({ data: z.object({ id: z.number() }) })"#
);
}
#[test]
fn untagged_unit_variant() {
let v = ir::ResolvedVariant {
serialized_name: "ping".to_string(),
kind: ir::ResolvedVariantKind::Unit,
};
let repr = ir::ResolvedEnumRepr::Untagged;
assert_eq!(emit_variant_for_repr(&v, &repr), r#"z.literal("ping")"#);
}
#[test]
fn untagged_newtype_variant() {
let v = ir::ResolvedVariant {
serialized_name: "value".to_string(),
kind: ir::ResolvedVariantKind::Newtype {
zod_expr: "z.string()".to_string(),
},
};
let repr = ir::ResolvedEnumRepr::Untagged;
assert_eq!(emit_variant_for_repr(&v, &repr), "z.string()");
}
#[test]
fn untagged_struct_variant() {
let v = ir::ResolvedVariant {
serialized_name: "data".to_string(),
kind: ir::ResolvedVariantKind::Struct {
fields: vec![ir::ResolvedField {
ts_key: "id".to_string(),
zod_expr: "z.number()".to_string(),
}],
},
};
let repr = ir::ResolvedEnumRepr::Untagged;
assert_eq!(
emit_variant_for_repr(&v, &repr),
r#"z.object({ id: z.number() })"#
);
}
#[test]
fn internal_unit_variant() {
let v = ir::ResolvedVariant {
serialized_name: "ping".to_string(),
kind: ir::ResolvedVariantKind::Unit,
};
let repr = ir::ResolvedEnumRepr::Internal {
tag: "type".to_string(),
};
assert_eq!(
emit_variant_for_repr(&v, &repr),
r#"z.object({ type: z.literal("ping") })"#
);
}
#[test]
fn internal_newtype_variant_with_object() {
let v = ir::ResolvedVariant {
serialized_name: "data".to_string(),
kind: ir::ResolvedVariantKind::Newtype {
zod_expr: "z.object({ id: z.number(), name: z.string() })".to_string(),
},
};
let repr = ir::ResolvedEnumRepr::Internal {
tag: "type".to_string(),
};
let result = emit_variant_for_repr(&v, &repr);
assert!(result.contains(r#"type: z.literal("data")"#));
assert!(result.contains("id: z.number()"));
assert!(result.contains("name: z.string()"));
}
#[test]
fn internal_newtype_variant_non_object() {
let v = ir::ResolvedVariant {
serialized_name: "count".to_string(),
kind: ir::ResolvedVariantKind::Newtype {
zod_expr: "z.number()".to_string(),
},
};
let repr = ir::ResolvedEnumRepr::Internal {
tag: "type".to_string(),
};
assert_eq!(
emit_variant_for_repr(&v, &repr),
r#"z.object({ type: z.literal("count") }).and(z.number())"#
);
}
#[test]
fn internal_struct_variant() {
let v = ir::ResolvedVariant {
serialized_name: "user".to_string(),
kind: ir::ResolvedVariantKind::Struct {
fields: vec![
ir::ResolvedField {
ts_key: "id".to_string(),
zod_expr: "z.number()".to_string(),
},
ir::ResolvedField {
ts_key: "name".to_string(),
zod_expr: "z.string()".to_string(),
},
],
},
};
let repr = ir::ResolvedEnumRepr::Internal {
tag: "type".to_string(),
};
let result = emit_variant_for_repr(&v, &repr);
assert!(result.contains(r#"type: z.literal("user")"#));
assert!(result.contains("id: z.number()"));
assert!(result.contains("name: z.string()"));
}
#[test]
fn adjacent_unit_variant() {
let v = ir::ResolvedVariant {
serialized_name: "ping".to_string(),
kind: ir::ResolvedVariantKind::Unit,
};
let repr = ir::ResolvedEnumRepr::Adjacent {
tag: "type".to_string(),
content: "data".to_string(),
};
assert_eq!(
emit_variant_for_repr(&v, &repr),
r#"z.object({ type: z.literal("ping") })"#
);
}
#[test]
fn adjacent_newtype_variant() {
let v = ir::ResolvedVariant {
serialized_name: "value".to_string(),
kind: ir::ResolvedVariantKind::Newtype {
zod_expr: "z.string()".to_string(),
},
};
let repr = ir::ResolvedEnumRepr::Adjacent {
tag: "type".to_string(),
content: "data".to_string(),
};
assert_eq!(
emit_variant_for_repr(&v, &repr),
r#"z.object({ type: z.literal("value"), data: z.string() })"#
);
}
#[test]
fn adjacent_struct_variant() {
let v = ir::ResolvedVariant {
serialized_name: "user".to_string(),
kind: ir::ResolvedVariantKind::Struct {
fields: vec![ir::ResolvedField {
ts_key: "id".to_string(),
zod_expr: "z.number()".to_string(),
}],
},
};
let repr = ir::ResolvedEnumRepr::Adjacent {
tag: "type".to_string(),
content: "data".to_string(),
};
assert_eq!(
emit_variant_for_repr(&v, &repr),
r#"z.object({ type: z.literal("user"), data: z.object({ id: z.number() }) })"#
);
}
#[test]
fn option_string_without_skip_generates_nullable() {
let field = ir::ResolvedField {
ts_key: "name".to_string(),
zod_expr: "z.string().nullable()".to_string(),
};
let schema = ir::ResolvedSchema {
ts_schema_name: "TestSchema".to_string(),
ts_type_name: "Test".to_string(),
module_path: "test::Test",
def: ir::ResolvedDef::Object {
fields: vec![field],
},
};
let output = emit_one_resolved(&schema);
assert!(output.contains("name: z.string().nullable()"));
}
#[test]
fn option_string_with_skip_generates_optional() {
let field = ir::ResolvedField {
ts_key: "name".to_string(),
zod_expr: "z.string().optional()".to_string(),
};
let schema = ir::ResolvedSchema {
ts_schema_name: "TestSchema".to_string(),
ts_type_name: "Test".to_string(),
module_path: "test::Test",
def: ir::ResolvedDef::Object {
fields: vec![field],
},
};
let output = emit_one_resolved(&schema);
assert!(output.contains("name: z.string().optional()"));
}
#[test]
fn option_custom_type_without_skip_generates_nullable() {
let field = ir::ResolvedField {
ts_key: "session".to_string(),
zod_expr: "SessionSchema.nullable()".to_string(),
};
let schema = ir::ResolvedSchema {
ts_schema_name: "TestSchema".to_string(),
ts_type_name: "Test".to_string(),
module_path: "test::Test",
def: ir::ResolvedDef::Object {
fields: vec![field],
},
};
let output = emit_one_resolved(&schema);
assert!(output.contains("session: SessionSchema.nullable()"));
}
#[test]
fn option_custom_type_with_skip_generates_optional() {
let field = ir::ResolvedField {
ts_key: "session".to_string(),
zod_expr: "SessionSchema.optional()".to_string(),
};
let schema = ir::ResolvedSchema {
ts_schema_name: "TestSchema".to_string(),
ts_type_name: "Test".to_string(),
module_path: "test::Test",
def: ir::ResolvedDef::Object {
fields: vec![field],
},
};
let output = emit_one_resolved(&schema);
assert!(output.contains("session: SessionSchema.optional()"));
}
#[test]
fn categorizes_enum_correctly() {
let schema = ir::ResolvedSchema {
ts_schema_name: "StatusSchema".to_string(),
ts_type_name: "Status".to_string(),
module_path: "app::Status",
def: ir::ResolvedDef::Enum {
repr: ir::ResolvedEnumRepr::External,
variants: vec![],
},
};
assert_eq!(categorize_schema(&schema), SchemaCategory::Enum);
}
#[test]
fn categorizes_input_types_correctly() {
let schema = ir::ResolvedSchema {
ts_schema_name: "CreateUserInputSchema".to_string(),
ts_type_name: "CreateUserInput".to_string(),
module_path: "app::CreateUserInput",
def: ir::ResolvedDef::Object { fields: vec![] },
};
assert_eq!(categorize_schema(&schema), SchemaCategory::Input);
let query_schema = ir::ResolvedSchema {
ts_schema_name: "SearchQuerySchema".to_string(),
ts_type_name: "SearchQuery".to_string(),
module_path: "app::SearchQuery",
def: ir::ResolvedDef::Object { fields: vec![] },
};
assert_eq!(categorize_schema(&query_schema), SchemaCategory::Input);
}
#[test]
fn categorizes_request_types_correctly() {
let schema = ir::ResolvedSchema {
ts_schema_name: "UpdateUserRequestSchema".to_string(),
ts_type_name: "UpdateUserRequest".to_string(),
module_path: "app::UpdateUserRequest",
def: ir::ResolvedDef::Object { fields: vec![] },
};
assert_eq!(categorize_schema(&schema), SchemaCategory::Request);
}
#[test]
fn categorizes_sse_event_types_correctly() {
let event_schema = ir::ResolvedSchema {
ts_schema_name: "UserEventSchema".to_string(),
ts_type_name: "UserEvent".to_string(),
module_path: "app::UserEvent",
def: ir::ResolvedDef::Object { fields: vec![] },
};
assert_eq!(categorize_schema(&event_schema), SchemaCategory::SseEvent);
let data_schema = ir::ResolvedSchema {
ts_schema_name: "StreamDataSchema".to_string(),
ts_type_name: "StreamData".to_string(),
module_path: "app::StreamData",
def: ir::ResolvedDef::Object { fields: vec![] },
};
assert_eq!(categorize_schema(&data_schema), SchemaCategory::SseEvent);
}
#[test]
fn categorizes_domain_types_by_default() {
let schema = ir::ResolvedSchema {
ts_schema_name: "UserSchema".to_string(),
ts_type_name: "User".to_string(),
module_path: "app::User",
def: ir::ResolvedDef::Object { fields: vec![] },
};
assert_eq!(categorize_schema(&schema), SchemaCategory::Domain);
}
#[test]
fn extracts_module_name_simple() {
assert_eq!(extract_module_name("crate::entities::Session"), "entities");
}
#[test]
fn extracts_module_name_nested() {
assert_eq!(
extract_module_name("crate::handlers::stream::EventData"),
"handlers_stream"
);
}
#[test]
fn extracts_module_name_ungrouped_when_empty() {
assert_eq!(extract_module_name(""), "_ungrouped");
}
#[test]
fn extracts_module_name_ungrouped_when_no_path() {
assert_eq!(extract_module_name("Session"), "_ungrouped");
}
#[test]
fn section_header_format() {
let header = section_header("Enum Types");
assert!(header.contains("// ===="));
assert!(header.contains("// Enum Types"));
assert_eq!(header.lines().count(), 3);
}
#[test]
fn emit_resolved_schemas_organizes_by_category() {
let enum_schema = ir::ResolvedSchema {
ts_schema_name: "StatusSchema".to_string(),
ts_type_name: "Status".to_string(),
module_path: "app::Status",
def: ir::ResolvedDef::Enum {
repr: ir::ResolvedEnumRepr::External,
variants: vec![ir::ResolvedVariant {
serialized_name: "active".to_string(),
kind: ir::ResolvedVariantKind::Unit,
}],
},
};
let domain_schema = ir::ResolvedSchema {
ts_schema_name: "UserSchema".to_string(),
ts_type_name: "User".to_string(),
module_path: "crate::entities::User",
def: ir::ResolvedDef::Object {
fields: vec![ir::ResolvedField {
ts_key: "id".to_string(),
zod_expr: "z.string()".to_string(),
}],
},
};
let input_schema = ir::ResolvedSchema {
ts_schema_name: "CreateUserInputSchema".to_string(),
ts_type_name: "CreateUserInput".to_string(),
module_path: "crate::handlers::CreateUserInput",
def: ir::ResolvedDef::Object {
fields: vec![ir::ResolvedField {
ts_key: "name".to_string(),
zod_expr: "z.string()".to_string(),
}],
},
};
let schemas = vec![enum_schema, domain_schema, input_schema];
let output = emit_resolved_schemas(&schemas);
let enum_pos = output.find("// Enum Types").expect("Enum Types section");
let domain_pos = output
.find("// Domain Types - Entities")
.expect("Domain Types section");
let input_pos = output
.find("// Input Types - Handlers")
.expect("Input Types section");
assert!(enum_pos < domain_pos);
assert!(domain_pos < input_pos);
assert!(output.contains("StatusSchema"));
assert!(output.contains("UserSchema"));
assert!(output.contains("CreateUserInputSchema"));
}
#[test]
fn preserves_dependency_order_within_same_module() {
let contact_schema = ir::ResolvedSchema {
ts_schema_name: "ContactSchema".to_string(),
ts_type_name: "Contact".to_string(),
module_path: "app::core_types::Contact",
def: ir::ResolvedDef::Object {
fields: vec![ir::ResolvedField {
ts_key: "id".to_string(),
zod_expr: "z.string()".to_string(),
}],
},
};
let campaign_schema = ir::ResolvedSchema {
ts_schema_name: "CampaignSchema".to_string(),
ts_type_name: "Campaign".to_string(),
module_path: "app::core_types::Campaign",
def: ir::ResolvedDef::Object {
fields: vec![
ir::ResolvedField {
ts_key: "id".to_string(),
zod_expr: "z.string()".to_string(),
},
ir::ResolvedField {
ts_key: "contacts".to_string(),
zod_expr: "z.array(ContactSchema)".to_string(), },
],
},
};
let schemas = vec![contact_schema, campaign_schema];
let output = emit_resolved_schemas(&schemas);
let contact_pos = output
.find("export const ContactSchema")
.expect("ContactSchema declaration");
let campaign_pos = output
.find("export const CampaignSchema")
.expect("CampaignSchema declaration");
assert!(
contact_pos < campaign_pos,
"ContactSchema must be declared before CampaignSchema (found at {} and {} respectively)",
contact_pos,
campaign_pos
);
assert!(
output.contains("z.array(ContactSchema)"),
"Campaign should reference ContactSchema"
);
}
}