@typokit/transform-native 0.1.4

package/src/test_stub_generator.rs

@@ -0,0 +1,318 @@
+use crate::route_compiler::{RouteEntry, RouteTypeInfo, RouteObjectProp};
+
+/// Generate contract test scaffolding from route entries.
+///
+/// Produces TypeScript test code using describe/it blocks that test:
+/// - Valid request payloads return success
+/// - Missing required fields return 400
+/// - Invalid types return 400
+pub fn generate_test_stubs(routes: &[RouteEntry]) -> String {
+    let mut output = String::new();
+
+    output.push_str("// AUTO-GENERATED by @typokit/transform-native — DO NOT EDIT\n");
+    output.push_str("// Contract tests generated from route definitions\n");
+    output.push_str("import { describe, it, expect } from \"@rstest/core\";\n");
+    output.push_str("import { createTestClient } from \"@typokit/testing\";\n\n");
+    output.push_str("const client = createTestClient();\n\n");
+
+    for entry in routes {
+        generate_route_test(&mut output, entry);
+    }
+
+    output
+}
+
+fn generate_route_test(output: &mut String, entry: &RouteEntry) {
+    let label = format!("{} {}", entry.method, entry.path);
+    output.push_str(&format!("describe(\"{}\", () => {{\n", label));
+
+    // Test 1: Valid request
+    generate_valid_request_test(output, entry);
+
+    // Test 2: If body has required fields, test missing fields
+    if has_required_fields(&entry.body_type) {
+        generate_missing_fields_test(output, entry);
+    }
+
+    // Test 3: If params exist, test with valid params
+    if !matches!(entry.params_type, RouteTypeInfo::Void) {
+        generate_params_test(output, entry);
+    }
+
+    output.push_str("});\n\n");
+}
+
+fn generate_valid_request_test(output: &mut String, entry: &RouteEntry) {
+    let method_lower = entry.method.to_lowercase();
+    output.push_str("  it(\"accepts valid request\", async () => {\n");
+
+    let path = convert_path_params(&entry.path);
+    let has_body = !matches!(entry.body_type, RouteTypeInfo::Void);
+    let has_query = !matches!(entry.query_type, RouteTypeInfo::Void);
+
+    if has_body || has_query {
+        output.push_str(&format!("    const res = await client.{}(\"{}\", {{\n", method_lower, path));
+        if has_body {
+            output.push_str("      body: ");
+            output.push_str(&generate_sample_value(&entry.body_type, 3));
+            output.push_str(",\n");
+        }
+        if has_query {
+            output.push_str("      query: ");
+            output.push_str(&generate_sample_value(&entry.query_type, 3));
+            output.push_str(",\n");
+        }
+        output.push_str("    });\n");
+    } else {
+        output.push_str(&format!("    const res = await client.{}(\"{}\");\n", method_lower, path));
+    }
+
+    output.push_str("    expect(res.status).toBe(200);\n");
+    output.push_str("  });\n\n");
+}
+
+fn generate_missing_fields_test(output: &mut String, entry: &RouteEntry) {
+    let method_lower = entry.method.to_lowercase();
+    let path = convert_path_params(&entry.path);
+
+    output.push_str("  it(\"rejects missing required fields\", async () => {\n");
+    output.push_str(&format!(
+        "    const res = await client.{}(\"{}\", {{\n      body: {{}},\n    }});\n",
+        method_lower, path
+    ));
+    output.push_str("    expect(res.status).toBe(400);\n");
+    output.push_str("  });\n\n");
+}
+
+fn generate_params_test(output: &mut String, entry: &RouteEntry) {
+    let method_lower = entry.method.to_lowercase();
+    let path = convert_path_params(&entry.path);
+
+    output.push_str("  it(\"handles path parameters\", async () => {\n");
+    output.push_str(&format!(
+        "    const res = await client.{}(\"{}\");\n",
+        method_lower, path
+    ));
+    output.push_str("    expect(res.status).toBeDefined();\n");
+    output.push_str("  });\n\n");
+}
+
+/// Convert route path params (`:id`) to sample values for test URLs
+fn convert_path_params(path: &str) -> String {
+    let mut result = String::new();
+    for segment in path.split('/') {
+        if segment.is_empty() {
+            continue;
+        }
+        result.push('/');
+        if segment.starts_with(':') {
+            result.push_str("test-id");
+        } else if segment.starts_with('*') {
+            result.push_str("test/wildcard/path");
+        } else {
+            result.push_str(segment);
+        }
+    }
+    if result.is_empty() {
+        result.push('/');
+    }
+    result
+}
+
+/// Check if a type has required (non-optional) fields
+fn has_required_fields(type_info: &RouteTypeInfo) -> bool {
+    match type_info {
+        RouteTypeInfo::ObjectLiteral(props) => props.iter().any(|p| !p.optional),
+        RouteTypeInfo::Named(_) => true, // Assume named types have required fields
+        _ => false,
+    }
+}
+
+/// Generate a sample value string for a given type
+fn generate_sample_value(type_info: &RouteTypeInfo, indent: usize) -> String {
+    match type_info {
+        RouteTypeInfo::Void => "undefined".to_string(),
+        RouteTypeInfo::Primitive(p) => match p.as_str() {
+            "string" => "\"test-value\"".to_string(),
+            "number" => "42".to_string(),
+            "boolean" => "true".to_string(),
+            _ => "null".to_string(),
+        },
+        RouteTypeInfo::Named(name) => format!("{{}} as unknown as {}", name),
+        RouteTypeInfo::ObjectLiteral(props) => {
+            generate_object_sample(props, indent)
+        }
+        RouteTypeInfo::Array(inner) => {
+            format!("[{}]", generate_sample_value(inner, indent))
+        }
+        RouteTypeInfo::StringLiteral(s) => format!("\"{}\"", s),
+        RouteTypeInfo::NumberLiteral(n) => format!("{}", n),
+        RouteTypeInfo::BooleanLiteral(b) => format!("{}", b),
+        RouteTypeInfo::Union(variants) => {
+            // Use first variant as sample
+            if let Some(first) = variants.first() {
+                generate_sample_value(first, indent)
+            } else {
+                "null".to_string()
+            }
+        }
+        RouteTypeInfo::Generic(name, _args) => {
+            format!("{{}} as unknown as {}", name)
+        }
+    }
+}
+
+fn generate_object_sample(props: &[RouteObjectProp], indent: usize) -> String {
+    if props.is_empty() {
+        return "{}".to_string();
+    }
+
+    let indent_str = "  ".repeat(indent);
+    let inner_indent = "  ".repeat(indent + 1);
+    let mut parts = Vec::new();
+
+    for prop in props {
+        if !prop.optional {
+            parts.push(format!(
+                "{}{}: {}",
+                inner_indent,
+                prop.name,
+                generate_sample_value(&prop.type_info, indent + 1)
+            ));
+        }
+    }
+
+    if parts.is_empty() {
+        "{}".to_string()
+    } else {
+        format!("{{\n{},\n{}}}", parts.join(",\n"), indent_str)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::route_compiler::{parse_path_segments, RouteEntry, RouteTypeInfo, RouteObjectProp};
+
+    fn make_route(method: &str, path: &str, body: RouteTypeInfo) -> RouteEntry {
+        RouteEntry {
+            method: method.to_string(),
+            path: path.to_string(),
+            segments: parse_path_segments(path),
+            handler_ref: format!("Test#{} {}", method, path),
+            params_type: if path.contains(':') {
+                RouteTypeInfo::ObjectLiteral(vec![RouteObjectProp {
+                    name: "id".to_string(),
+                    type_info: RouteTypeInfo::Primitive("string".into()),
+                    optional: false,
+                }])
+            } else {
+                RouteTypeInfo::Void
+            },
+            query_type: RouteTypeInfo::Void,
+            body_type: body,
+            response_type: RouteTypeInfo::Void,
+        }
+    }
+
+    #[test]
+    fn test_generate_stubs_basic() {
+        let routes = vec![
+            make_route("GET", "/users", RouteTypeInfo::Void),
+        ];
+
+        let output = generate_test_stubs(&routes);
+
+        assert!(output.contains("AUTO-GENERATED"));
+        assert!(output.contains("describe(\"GET /users\""));
+        assert!(output.contains("accepts valid request"));
+        assert!(output.contains("client.get(\"/users\")"));
+    }
+
+    #[test]
+    fn test_generate_stubs_with_body() {
+        let body = RouteTypeInfo::ObjectLiteral(vec![
+            RouteObjectProp {
+                name: "email".to_string(),
+                type_info: RouteTypeInfo::Primitive("string".into()),
+                optional: false,
+            },
+            RouteObjectProp {
+                name: "name".to_string(),
+                type_info: RouteTypeInfo::Primitive("string".into()),
+                optional: false,
+            },
+        ]);
+        let routes = vec![
+            make_route("POST", "/users", body),
+        ];
+
+        let output = generate_test_stubs(&routes);
+
+        assert!(output.contains("client.post(\"/users\""));
+        assert!(output.contains("body:"));
+        assert!(output.contains("email:"));
+        assert!(output.contains("rejects missing required fields"));
+        assert!(output.contains("body: {}"));
+    }
+
+    #[test]
+    fn test_generate_stubs_with_params() {
+        let routes = vec![
+            make_route("GET", "/users/:id", RouteTypeInfo::Void),
+        ];
+
+        let output = generate_test_stubs(&routes);
+
+        assert!(output.contains("GET /users/:id"));
+        assert!(output.contains("test-id"));
+        assert!(output.contains("handles path parameters"));
+    }
+
+    #[test]
+    fn test_generate_stubs_multiple_routes() {
+        let routes = vec![
+            make_route("GET", "/users", RouteTypeInfo::Void),
+            make_route("POST", "/users", RouteTypeInfo::ObjectLiteral(vec![
+                RouteObjectProp {
+                    name: "email".to_string(),
+                    type_info: RouteTypeInfo::Primitive("string".into()),
+                    optional: false,
+                },
+            ])),
+            make_route("DELETE", "/users/:id", RouteTypeInfo::Void),
+        ];
+
+        let output = generate_test_stubs(&routes);
+
+        assert!(output.contains("GET /users"));
+        assert!(output.contains("POST /users"));
+        assert!(output.contains("DELETE /users/:id"));
+    }
+
+    #[test]
+    fn test_convert_path_params() {
+        assert_eq!(convert_path_params("/users"), "/users");
+        assert_eq!(convert_path_params("/users/:id"), "/users/test-id");
+        assert_eq!(convert_path_params("/users/:userId/posts/:postId"), "/users/test-id/posts/test-id");
+        assert_eq!(convert_path_params("/files/*path"), "/files/test/wildcard/path");
+    }
+
+    #[test]
+    fn test_generate_sample_value_primitives() {
+        assert_eq!(generate_sample_value(&RouteTypeInfo::Primitive("string".into()), 0), "\"test-value\"");
+        assert_eq!(generate_sample_value(&RouteTypeInfo::Primitive("number".into()), 0), "42");
+        assert_eq!(generate_sample_value(&RouteTypeInfo::Primitive("boolean".into()), 0), "true");
+        assert_eq!(generate_sample_value(&RouteTypeInfo::Void, 0), "undefined");
+    }
+
+    #[test]
+    fn test_generate_imports() {
+        let routes = vec![make_route("GET", "/health", RouteTypeInfo::Void)];
+        let output = generate_test_stubs(&routes);
+
+        assert!(output.contains("import { describe, it, expect }"));
+        assert!(output.contains("import { createTestClient }"));
+        assert!(output.contains("const client = createTestClient()"));
+    }
+}

package/src/type_extractor.rs

@@ -0,0 +1,370 @@
+use std::collections::HashMap;
+use serde::{Deserialize, Serialize};
+use swc_common::comments::{Comment, CommentKind, SingleThreadedComments, Comments};
+use swc_common::Spanned;
+use swc_ecma_ast::*;
+
+/// Metadata about a single property in a type
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PropertyMetadata {
+    #[serde(rename = "type")]
+    pub type_str: String,
+    pub optional: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub jsdoc: Option<HashMap<String, String>>,
+}
+
+/// Metadata about a single extracted type (matches @typokit/types TypeMetadata)
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TypeMetadata {
+    pub name: String,
+    pub properties: HashMap<String, PropertyMetadata>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub jsdoc: Option<HashMap<String, String>>,
+}
+
+/// Extract all JSDoc tags from a comment block
+fn parse_jsdoc_tags(comment: &str) -> HashMap<String, String> {
+    let mut tags: HashMap<String, String> = HashMap::new();
+
+    for line in comment.lines() {
+        let trimmed = line.trim().trim_start_matches('*').trim();
+        // Find all @tag occurrences on this line
+        let mut rest = trimmed;
+        while let Some(at_pos) = rest.find('@') {
+            rest = &rest[at_pos + 1..];
+            let parts: Vec<&str> = rest.splitn(2, char::is_whitespace).collect();
+            let tag_name = parts[0].to_string();
+            let tag_value_str = parts.get(1).map(|s| s.trim()).unwrap_or("");
+            // The tag value is everything up to the next @tag or end of line
+            let value = if let Some(next_at) = tag_value_str.find('@') {
+                tag_value_str[..next_at].trim().to_string()
+            } else {
+                tag_value_str.to_string()
+            };
+            tags.insert(tag_name, value);
+            // Advance rest past this tag's value to find next @
+            rest = parts.get(1).map(|s| *s).unwrap_or("");
+        }
+    }
+
+    tags
+}
+
+/// Get leading comments for a span position
+fn get_leading_comments(comments: &SingleThreadedComments, span: &dyn Spanned) -> Vec<Comment> {
+    let lo = span.span().lo;
+    comments.get_leading(lo).unwrap_or_default()
+}
+
+/// Convert a TypeScript type annotation to a string representation
+fn ts_type_to_string(ts_type: &TsType) -> String {
+    match ts_type {
+        TsType::TsKeywordType(kw) => match kw.kind {
+            TsKeywordTypeKind::TsStringKeyword => "string".to_string(),
+            TsKeywordTypeKind::TsNumberKeyword => "number".to_string(),
+            TsKeywordTypeKind::TsBooleanKeyword => "boolean".to_string(),
+            TsKeywordTypeKind::TsVoidKeyword => "void".to_string(),
+            TsKeywordTypeKind::TsNullKeyword => "null".to_string(),
+            TsKeywordTypeKind::TsUndefinedKeyword => "undefined".to_string(),
+            TsKeywordTypeKind::TsAnyKeyword => "any".to_string(),
+            TsKeywordTypeKind::TsUnknownKeyword => "unknown".to_string(),
+            TsKeywordTypeKind::TsNeverKeyword => "never".to_string(),
+            TsKeywordTypeKind::TsBigIntKeyword => "bigint".to_string(),
+            TsKeywordTypeKind::TsSymbolKeyword => "symbol".to_string(),
+            TsKeywordTypeKind::TsObjectKeyword => "object".to_string(),
+            _ => "unknown".to_string(),
+        },
+        TsType::TsTypeRef(type_ref) => {
+            let name = match &type_ref.type_name {
+                TsEntityName::Ident(ident) => ident.sym.to_string(),
+                TsEntityName::TsQualifiedName(qn) => format!("{}.{}", ts_entity_name_to_string(&TsEntityName::TsQualifiedName(qn.clone())), ""),
+            };
+            if let Some(type_params) = &type_ref.type_params {
+                let params: Vec<String> = type_params.params.iter().map(|p| ts_type_to_string(p)).collect();
+                format!("{}<{}>", name, params.join(", "))
+            } else {
+                name
+            }
+        }
+        TsType::TsArrayType(arr) => format!("{}[]", ts_type_to_string(&arr.elem_type)),
+        TsType::TsUnionOrIntersectionType(u) => match u {
+            TsUnionOrIntersectionType::TsUnionType(union) => {
+                let types: Vec<String> = union.types.iter().map(|t| ts_type_to_string(t)).collect();
+                types.join(" | ")
+            }
+            TsUnionOrIntersectionType::TsIntersectionType(inter) => {
+                let types: Vec<String> = inter.types.iter().map(|t| ts_type_to_string(t)).collect();
+                types.join(" & ")
+            }
+        },
+        TsType::TsLitType(lit) => match &lit.lit {
+            TsLit::Str(s) => format!("\"{}\"", s.value.to_string_lossy()),
+            TsLit::Number(n) => n.value.to_string(),
+            TsLit::Bool(b) => b.value.to_string(),
+            _ => "unknown".to_string(),
+        },
+        TsType::TsParenthesizedType(paren) => format!("({})", ts_type_to_string(&paren.type_ann)),
+        TsType::TsOptionalType(opt) => format!("{}?", ts_type_to_string(&opt.type_ann)),
+        TsType::TsTupleType(tuple) => {
+            let elems: Vec<String> = tuple.elem_types.iter().map(|e| ts_type_to_string(&e.ty)).collect();
+            format!("[{}]", elems.join(", "))
+        }
+        TsType::TsFnOrConstructorType(_) => "Function".to_string(),
+        TsType::TsTypeLit(_) => "object".to_string(),
+        _ => "unknown".to_string(),
+    }
+}
+
+/// Helper to convert TsEntityName to string
+fn ts_entity_name_to_string(name: &TsEntityName) -> String {
+    match name {
+        TsEntityName::Ident(ident) => ident.sym.to_string(),
+        TsEntityName::TsQualifiedName(qn) => {
+            format!("{}.{}", ts_entity_name_to_string(&qn.left), qn.right.sym)
+        }
+    }
+}
+
+/// Extract type metadata from all interfaces in a module
+pub fn extract_types(module: &Module, comments: &SingleThreadedComments) -> HashMap<String, TypeMetadata> {
+    let mut types: HashMap<String, TypeMetadata> = HashMap::new();
+
+    for item in &module.body {
+        match item {
+            ModuleItem::Stmt(Stmt::Decl(Decl::TsInterface(iface))) => {
+                let metadata = extract_interface(iface, comments);
+                types.insert(metadata.name.clone(), metadata);
+            }
+            ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(export)) => {
+                if let Decl::TsInterface(iface) = &export.decl {
+                    let metadata = extract_interface(iface, comments);
+                    types.insert(metadata.name.clone(), metadata);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    types
+}
+
+/// Extract metadata from a single interface declaration
+fn extract_interface(iface: &TsInterfaceDecl, comments: &SingleThreadedComments) -> TypeMetadata {
+    let name = iface.id.sym.to_string();
+
+    // Extract interface-level JSDoc tags
+    let leading = get_leading_comments(comments, iface);
+    let iface_jsdoc = extract_jsdoc_from_comments(&leading);
+
+    let mut properties: HashMap<String, PropertyMetadata> = HashMap::new();
+
+    for member in &iface.body.body {
+        if let TsTypeElement::TsPropertySignature(prop) = member {
+            let prop_name = match &*prop.key {
+                Expr::Ident(ident) => ident.sym.to_string(),
+                _ => continue,
+            };
+
+            let type_str = prop
+                .type_ann
+                .as_ref()
+                .map(|ann| ts_type_to_string(&ann.type_ann))
+                .unwrap_or_else(|| "unknown".to_string());
+
+            let optional = prop.optional;
+
+            // Extract property-level JSDoc tags
+            let prop_leading = get_leading_comments(comments, prop);
+            let prop_jsdoc = extract_jsdoc_from_comments(&prop_leading);
+
+            properties.insert(
+                prop_name,
+                PropertyMetadata {
+                    type_str,
+                    optional,
+                    jsdoc: if prop_jsdoc.is_empty() { None } else { Some(prop_jsdoc) },
+                },
+            );
+        }
+    }
+
+    TypeMetadata {
+        name,
+        properties,
+        jsdoc: if iface_jsdoc.is_empty() { None } else { Some(iface_jsdoc) },
+    }
+}
+
+/// Extract JSDoc tags from comment list
+fn extract_jsdoc_from_comments(comments: &[Comment]) -> HashMap<String, String> {
+    let mut tags = HashMap::new();
+    for comment in comments {
+        if comment.kind == CommentKind::Block {
+            let parsed = parse_jsdoc_tags(&comment.text);
+            tags.extend(parsed);
+        }
+    }
+    tags
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::parser::parse_typescript;
+
+    #[test]
+    fn test_extract_simple_interface() {
+        let source = r#"
+interface User {
+    id: string;
+    name: string;
+    age: number;
+    active: boolean;
+}
+"#;
+        let parsed = parse_typescript("test.ts", source).unwrap();
+        let types = extract_types(&parsed.module, &parsed.comments);
+
+        assert!(types.contains_key("User"));
+        let user = &types["User"];
+        assert_eq!(user.name, "User");
+        assert_eq!(user.properties.len(), 4);
+        assert_eq!(user.properties["id"].type_str, "string");
+        assert_eq!(user.properties["age"].type_str, "number");
+        assert_eq!(user.properties["active"].type_str, "boolean");
+        assert!(!user.properties["id"].optional);
+    }
+
+    #[test]
+    fn test_extract_optional_properties() {
+        let source = r#"
+interface Profile {
+    bio?: string;
+    avatar?: string;
+    required: number;
+}
+"#;
+        let parsed = parse_typescript("test.ts", source).unwrap();
+        let types = extract_types(&parsed.module, &parsed.comments);
+
+        let profile = &types["Profile"];
+        assert!(profile.properties["bio"].optional);
+        assert!(profile.properties["avatar"].optional);
+        assert!(!profile.properties["required"].optional);
+    }
+
+    #[test]
+    fn test_extract_jsdoc_table_tag() {
+        let source = r#"
+/**
+ * @table users
+ */
+interface User {
+    /** @id */
+    id: string;
+    name: string;
+}
+"#;
+        let parsed = parse_typescript("test.ts", source).unwrap();
+        let types = extract_types(&parsed.module, &parsed.comments);
+
+        let user = &types["User"];
+        let jsdoc = user.jsdoc.as_ref().unwrap();
+        assert_eq!(jsdoc["table"], "users");
+
+        let id_jsdoc = user.properties["id"].jsdoc.as_ref().unwrap();
+        assert!(id_jsdoc.contains_key("id"));
+    }
+
+    #[test]
+    fn test_extract_all_jsdoc_tags() {
+        let source = r#"
+/**
+ * @table users
+ */
+interface User {
+    /** @id @generated */
+    id: string;
+    /** @format email @unique */
+    email: string;
+    /** @minLength 2 @maxLength 100 */
+    name: string;
+    /** @default now() @onUpdate now() */
+    updatedAt: string;
+}
+"#;
+        let parsed = parse_typescript("test.ts", source).unwrap();
+        let types = extract_types(&parsed.module, &parsed.comments);
+
+        let user = &types["User"];
+        let id_jsdoc = user.properties["id"].jsdoc.as_ref().unwrap();
+        assert!(id_jsdoc.contains_key("id"));
+        assert!(id_jsdoc.contains_key("generated"));
+
+        let email_jsdoc = user.properties["email"].jsdoc.as_ref().unwrap();
+        assert_eq!(email_jsdoc["format"], "email");
+        assert!(email_jsdoc.contains_key("unique"));
+
+        let name_jsdoc = user.properties["name"].jsdoc.as_ref().unwrap();
+        assert_eq!(name_jsdoc["minLength"], "2");
+        assert_eq!(name_jsdoc["maxLength"], "100");
+
+        let updated_jsdoc = user.properties["updatedAt"].jsdoc.as_ref().unwrap();
+        assert_eq!(updated_jsdoc["default"], "now()");
+        assert_eq!(updated_jsdoc["onUpdate"], "now()");
+    }
+
+    #[test]
+    fn test_extract_exported_interface() {
+        let source = r#"
+export interface Post {
+    id: string;
+    title: string;
+}
+"#;
+        let parsed = parse_typescript("test.ts", source).unwrap();
+        let types = extract_types(&parsed.module, &parsed.comments);
+
+        assert!(types.contains_key("Post"));
+        assert_eq!(types["Post"].properties.len(), 2);
+    }
+
+    #[test]
+    fn test_extract_complex_types() {
+        let source = r#"
+interface Complex {
+    tags: string[];
+    metadata: Record<string, unknown>;
+    status: "active" | "inactive";
+    nested?: Array<string>;
+}
+"#;
+        let parsed = parse_typescript("test.ts", source).unwrap();
+        let types = extract_types(&parsed.module, &parsed.comments);
+
+        let complex = &types["Complex"];
+        assert_eq!(complex.properties["tags"].type_str, "string[]");
+        assert_eq!(complex.properties["metadata"].type_str, "Record<string, unknown>");
+        assert_eq!(complex.properties["status"].type_str, "\"active\" | \"inactive\"");
+    }
+
+    #[test]
+    fn test_extract_multiple_interfaces() {
+        let source = r#"
+interface User {
+    id: string;
+}
+interface Post {
+    id: string;
+    authorId: string;
+}
+"#;
+        let parsed = parse_typescript("test.ts", source).unwrap();
+        let types = extract_types(&parsed.module, &parsed.comments);
+
+        assert_eq!(types.len(), 2);
+        assert!(types.contains_key("User"));
+        assert!(types.contains_key("Post"));
+    }
+}