Replace type issue

Author: owjs3901

.changepacks/changepack_log_VL8xtXZ0Ty1P8XW4hfaso.json

@@ -0,0 +1 @@
+{"changes":{"crates/vespera_core/Cargo.toml":"Patch","crates/vespera/Cargo.toml":"Patch","crates/vespera_macro/Cargo.toml":"Patch"},"note":"Support serde flatten, tagged, untagged","date":"2026-02-05T12:30:36.574038700Z"}

crates/vespera_macro/src/schema_macro/inline_types.rs

@@ -9,7 +9,7 @@ use quote::quote;
 use super::{
     circular::detect_circular_fields,
     file_lookup::find_model_from_schema_path,
-    seaorm::RelationFieldInfo,
+    seaorm::{RelationFieldInfo, convert_type_with_chrono},
     type_utils::{capitalize_first, is_seaorm_relation_type},
 };
 use crate::parser::{extract_rename_all, extract_skip};
@@ -123,10 +123,12 @@ pub fn generate_inline_relation_type_from_def(
                 .cloned()
                 .collect();
 
-            let field_ty = &field.ty;
+            // Convert SeaORM datetime types to chrono equivalents
+            // This prevents users from needing to import sea_orm::prelude::DateTimeWithTimeZone
+            let converted_ty = convert_type_with_chrono(&field.ty, source_module_path);
             fields.push(InlineField {
                 name: field_ident.clone(),
-                ty: quote!(#field_ty),
+                ty: converted_ty,
                 attrs: kept_attrs,
             });
         }
@@ -150,6 +152,7 @@ pub fn generate_inline_relation_type_from_def(
 pub fn generate_inline_relation_type_no_relations(
     parent_type_name: &syn::Ident,
     rel_info: &RelationFieldInfo,
+    source_module_path: &[String],
     schema_name_override: Option<&str>,
 ) -> Option<InlineRelationType> {
     // Find the target model definition
@@ -160,6 +163,7 @@ pub fn generate_inline_relation_type_no_relations(
     generate_inline_relation_type_no_relations_from_def(
         parent_type_name,
         rel_info,
+        source_module_path,
         schema_name_override,
         model_def,
     )
@@ -169,6 +173,7 @@ pub fn generate_inline_relation_type_no_relations(
 pub fn generate_inline_relation_type_no_relations_from_def(
     parent_type_name: &syn::Ident,
     rel_info: &RelationFieldInfo,
+    source_module_path: &[String],
     schema_name_override: Option<&str>,
     model_def: &str,
 ) -> Option<InlineRelationType> {
@@ -214,10 +219,12 @@ pub fn generate_inline_relation_type_no_relations_from_def(
                 .cloned()
                 .collect();
 
-            let field_ty = &field.ty;
+            // Convert SeaORM datetime types to chrono equivalents
+            // This prevents users from needing to import sea_orm::prelude::DateTimeWithTimeZone
+            let converted_ty = convert_type_with_chrono(&field.ty, source_module_path);
             fields.push(InlineField {
                 name: field_ident.clone(),
-                ty: quote!(#field_ty),
+                ty: converted_ty,
                 attrs: kept_attrs,
             });
         }
@@ -584,6 +591,7 @@ mod tests {
         let result = generate_inline_relation_type_no_relations_from_def(
             &parent_type_name,
             &rel_info,
+            &[],
             None,
             model_def,
         );
@@ -626,6 +634,7 @@ mod tests {
         let result = generate_inline_relation_type_no_relations_from_def(
             &parent_type_name,
             &rel_info,
+            &[],
             None,
             model_def,
         );
@@ -786,6 +795,7 @@ mod tests {
         let result = generate_inline_relation_type_no_relations_from_def(
             &parent_type_name,
             &rel_info,
+            &[],
             Some("UserSchema"),
             model_def,
         );
@@ -906,7 +916,17 @@ pub struct Model {
             inline_type_info: None,
         };
 
-        let result = generate_inline_relation_type_no_relations(&parent_type_name, &rel_info, None);
+        let source_module_path = vec![
+            "crate".to_string(),
+            "models".to_string(),
+            "user".to_string(),
+        ];
+        let result = generate_inline_relation_type_no_relations(
+            &parent_type_name,
+            &rel_info,
+            &source_module_path,
+            None,
+        );
 
         // Restore original CARGO_MANIFEST_DIR
         // SAFETY: This is a test that runs single-threaded
@@ -1001,7 +1021,8 @@ pub struct Model {
             inline_type_info: None,
         };
 
-        let result = generate_inline_relation_type_no_relations(&parent_type_name, &rel_info, None);
+        let result =
+            generate_inline_relation_type_no_relations(&parent_type_name, &rel_info, &[], None);
 
         // Restore original CARGO_MANIFEST_DIR
         // SAFETY: This is a test that runs single-threaded
@@ -1016,4 +1037,128 @@ pub struct Model {
         // Should return None when file not found
         assert!(result.is_none());
     }
+
+    #[test]
+    fn test_generate_inline_relation_type_converts_datetime_types() {
+        // Test that DateTimeWithTimeZone is converted to vespera::chrono::DateTime<FixedOffset>
+        let parent_type_name = syn::Ident::new("MemoSchema", proc_macro2::Span::call_site());
+        let rel_info = RelationFieldInfo {
+            field_name: syn::Ident::new("user", proc_macro2::Span::call_site()),
+            relation_type: "BelongsTo".to_string(),
+            schema_path: quote!(super::user::Schema),
+            is_optional: false,
+            inline_type_info: None,
+        };
+        let source_module_path = vec![
+            "crate".to_string(),
+            "models".to_string(),
+            "memo".to_string(),
+        ];
+
+        // Model with DateTimeWithTimeZone field AND circular reference
+        let model_def = r#"pub struct Model {
+            pub id: i32,
+            pub name: String,
+            pub created_at: DateTimeWithTimeZone,
+            pub memo: BelongsTo<memo::Entity>
+        }"#;
+
+        let result = generate_inline_relation_type_from_def(
+            &parent_type_name,
+            &rel_info,
+            &source_module_path,
+            None,
+            model_def,
+        );
+        assert!(result.is_some());
+
+        let inline_type = result.unwrap();
+        assert_eq!(inline_type.type_name.to_string(), "MemoSchema_User");
+
+        // Find created_at field and check its type was converted
+        let created_at_field = inline_type
+            .fields
+            .iter()
+            .find(|f| f.name == "created_at")
+            .expect("created_at field should exist");
+
+        let ty_str = created_at_field.ty.to_string();
+        // Should be converted to vespera::chrono::DateTime<FixedOffset>
+        assert!(
+            ty_str.contains("vespera :: chrono :: DateTime"),
+            "DateTimeWithTimeZone should be converted to vespera::chrono::DateTime, got: {}",
+            ty_str
+        );
+        assert!(
+            ty_str.contains("FixedOffset"),
+            "Should contain FixedOffset, got: {}",
+            ty_str
+        );
+    }
+
+    #[test]
+    fn test_generate_inline_relation_type_no_relations_converts_datetime_types() {
+        // Test that DateTimeWithTimeZone is converted in no_relations variant too
+        let parent_type_name = syn::Ident::new("UserSchema", proc_macro2::Span::call_site());
+        let rel_info = RelationFieldInfo {
+            field_name: syn::Ident::new("memos", proc_macro2::Span::call_site()),
+            relation_type: "HasMany".to_string(),
+            schema_path: quote!(super::memo::Schema),
+            is_optional: false,
+            inline_type_info: None,
+        };
+
+        // Model with DateTimeWithTimeZone field
+        let model_def = r#"pub struct Model {
+            pub id: i32,
+            pub title: String,
+            pub created_at: DateTimeWithTimeZone,
+            pub updated_at: Option<DateTimeWithTimeZone>,
+            pub user: BelongsTo<user::Entity>
+        }"#;
+
+        let result = generate_inline_relation_type_no_relations_from_def(
+            &parent_type_name,
+            &rel_info,
+            &[],
+            None,
+            model_def,
+        );
+        assert!(result.is_some());
+
+        let inline_type = result.unwrap();
+
+        // Find created_at field and check its type was converted
+        let created_at_field = inline_type
+            .fields
+            .iter()
+            .find(|f| f.name == "created_at")
+            .expect("created_at field should exist");
+
+        let ty_str = created_at_field.ty.to_string();
+        assert!(
+            ty_str.contains("vespera :: chrono :: DateTime"),
+            "DateTimeWithTimeZone should be converted, got: {}",
+            ty_str
+        );
+
+        // Also check Option<DateTimeWithTimeZone>
+        let updated_at_field = inline_type
+            .fields
+            .iter()
+            .find(|f| f.name == "updated_at")
+            .expect("updated_at field should exist");
+
+        let updated_ty_str = updated_at_field.ty.to_string();
+        assert!(
+            updated_ty_str.contains("Option"),
+            "Should be Option type, got: {}",
+            updated_ty_str
+        );
+        assert!(
+            updated_ty_str.contains("vespera :: chrono :: DateTime"),
+            "Option<DateTimeWithTimeZone> should be converted, got: {}",
+            updated_ty_str
+        );
+    }
 }

crates/vespera_macro/src/schema_macro/mod.rs

@@ -279,6 +279,7 @@ pub fn generate_schema_type_code(
                             if let Some(inline_type) = generate_inline_relation_type_no_relations(
                                 new_type_name,
                                 &rel_info,
+                                &source_module_path,
                                 input.schema_name.as_deref(),
                             ) {
                                 let inline_type_def = generate_inline_type_definition(&inline_type);

examples/axum-example/src/routes/memos.rs

@@ -10,7 +10,6 @@
 use std::sync::Arc;
 
 // Import types used by the source model that we want to include in generated structs
-use sea_orm::entity::prelude::DateTimeWithTimeZone;
 use vespera::{
     axum::{
         Json,
@@ -71,14 +70,16 @@ pub async fn update_memo(Json(req): Json<UpdateMemoRequest>) -> Json<UpdateMemoR
 pub async fn get_memo(Path(id): Path<i32>) -> Json<MemoResponse> {
     // In real app, this would be a DB query returning Model
     // schema_type! generates From<Model> for MemoResponse, so .into() works
+    // Create a default datetime using vespera's chrono re-export
+    let now: vespera::chrono::DateTime<vespera::chrono::FixedOffset> = vespera::chrono::Utc::now().fixed_offset();
     let model = crate::models::memo::Model {
         id,
         user_id: 1, // Example user ID
         title: "Test Memo".to_string(),
         content: "This is test content".to_string(),
         status: crate::models::memo::MemoStatus::Published,
-        created_at: DateTimeWithTimeZone::default(),
-        updated_at: DateTimeWithTimeZone::default(),
+        created_at: now,
+        updated_at: now,
     };
     Json(model.into())
 }
@@ -90,14 +91,15 @@ pub async fn get_memo_rel(
 ) -> Json<MemoResponseRel> {
     // In real app, this would be a DB query returning Model
     // schema_type! generates From<Model> for MemoResponse, so .into() works
+    let now: vespera::chrono::DateTime<vespera::chrono::FixedOffset> = vespera::chrono::Utc::now().fixed_offset();
     let model = crate::models::memo::Model {
         id,
         user_id: 1, // Example user ID
         title: "Test Memo".to_string(),
         content: "This is test content".to_string(),
         status: crate::models::memo::MemoStatus::Published,
-        created_at: DateTimeWithTimeZone::default(),
-        updated_at: DateTimeWithTimeZone::default(),
+        created_at: now,
+        updated_at: now,
     };
     Json(
         MemoResponseRel::from_model(model, app_state.db.as_ref())