Fix required issue

Author: owjs3901

Cargo.lock

@@ -656,24 +656,8 @@ fn generate_sea_orm_default_attrs(
     };
 
     // SQL functions like NOW(), CURRENT_TIMESTAMP(), gen_random_uuid()
-    // can't be expressed as concrete JSON defaults, but we can make the field
-    // not-required by generating serde(default) with a dummy default value.
+    // can't be expressed as concrete JSON defaults — skip entirely.
     if is_sql_function_default(&default_value) {
-        let has_existing_serde_default = extract_default(original_attrs).is_some();
-        if !has_existing_serde_default
-            && let Some(default_body) = sql_function_default_body(original_ty)
-        {
-            let fn_name = format!("default_{struct_name}_{field_name}");
-            let fn_ident = syn::Ident::new(&fn_name, proc_macro2::Span::call_site());
-            default_functions.push(quote! {
-                #[allow(non_snake_case)]
-                fn #fn_ident() -> #field_ty {
-                    #default_body
-                }
-            });
-            let serde_default_attr = quote! { #[serde(default = #fn_name)] };
-            return (serde_default_attr, quote! {});
-        }
         return (quote! {}, quote! {});
     }
 
@@ -708,52 +692,6 @@ fn generate_sea_orm_default_attrs(
     (serde_default_attr, schema_default_attr)
 }
 
-/// Generate a dummy default expression for types with SQL function defaults
-/// (e.g., `gen_random_uuid()`, `NOW()`).
-///
-/// Returns `Some(TokenStream)` with the default expression for supported types,
-/// `None` for types where a dummy default cannot be generated.
-///
-/// These defaults exist solely to satisfy `serde(default)` so the field becomes
-/// not-required in OpenAPI. The actual value is irrelevant since the database
-/// provides the real default.
-fn sql_function_default_body(original_ty: &syn::Type) -> Option<TokenStream> {
-    let syn::Type::Path(type_path) = original_ty else {
-        return None;
-    };
-    let segment = type_path.path.segments.last()?;
-    let type_name = segment.ident.to_string();
-
-    match type_name.as_str() {
-        // Types implementing Default (returns zero/empty values)
-        "i8" | "i16" | "i32" | "i64" | "i128" | "isize" | "u8" | "u16" | "u32" | "u64" | "u128"
-        | "usize" | "f32" | "f64" | "bool" | "String" | "Decimal" | "Uuid" => {
-            Some(quote! { Default::default() })
-        }
-        // SeaORM datetime types → chrono epoch
-        "DateTimeWithTimeZone" => Some(quote! {
-            vespera::chrono::DateTime::<vespera::chrono::Utc>::UNIX_EPOCH.fixed_offset()
-        }),
-        "DateTimeUtc" => Some(quote! {
-            vespera::chrono::DateTime::<vespera::chrono::Utc>::UNIX_EPOCH
-        }),
-        "DateTimeLocal" => Some(quote! {
-            vespera::chrono::DateTime::<vespera::chrono::Utc>::UNIX_EPOCH
-                .with_timezone(&vespera::chrono::Local)
-        }),
-        "DateTime" | "NaiveDateTime" => Some(quote! {
-            vespera::chrono::NaiveDateTime::UNIX_EPOCH
-        }),
-        "NaiveDate" | "Date" => Some(quote! {
-            vespera::chrono::NaiveDate::from_ymd_opt(1970, 1, 1).unwrap()
-        }),
-        "NaiveTime" | "Time" => Some(quote! {
-            vespera::chrono::NaiveTime::from_hms_opt(0, 0, 0).unwrap()
-        }),
-        _ => None,
-    }
-}
-
 /// Check if a type is known to implement `FromStr` and can use `.parse().unwrap()`.
 ///
 /// Returns true for primitive types, String, and Decimal.

crates/vespera_macro/src/schema_macro/mod.rs

@@ -311,7 +311,7 @@ fn test_sea_orm_default_attrs_no_default_value() {
 }
 
 #[test]
-fn test_sea_orm_default_attrs_sql_function_supported_type() {
+fn test_sea_orm_default_attrs_sql_function_skips() {
     let attrs: Vec<syn::Attribute> = vec![syn::parse_quote!(#[sea_orm(default_value = "NOW()")])];
     let struct_name = syn::Ident::new("Test", proc_macro2::Span::call_site());
     let ty: syn::Type = syn::parse_str("String").unwrap();
@@ -325,42 +325,8 @@ fn test_sea_orm_default_attrs_sql_function_supported_type() {
         false,
         &mut fns,
     );
-    // Supported type with SQL function → generates serde(default) to mark field not-required
-    let serde_str = serde.to_string();
-    assert!(
-        serde_str.contains("serde"),
-        "should have serde default attr: {serde_str}"
-    );
-    assert!(
-        serde_str.contains("default_Test_created_at"),
-        "should reference generated default fn: {serde_str}"
-    );
-    // No JSON default for SQL functions (value is DB-side only)
-    assert!(schema.is_empty());
-    // Default function was generated
-    assert_eq!(fns.len(), 1, "should generate one default function");
-}
-
-#[test]
-fn test_sea_orm_default_attrs_sql_function_unsupported_type_skips() {
-    let attrs: Vec<syn::Attribute> =
-        vec![syn::parse_quote!(#[sea_orm(default_value = "MY_FUNC()")])];
-    let struct_name = syn::Ident::new("Test", proc_macro2::Span::call_site());
-    let ty: syn::Type = syn::parse_str("MyCustomType").unwrap();
-    let mut fns = Vec::new();
-    let (serde, schema) = generate_sea_orm_default_attrs(
-        &attrs,
-        &struct_name,
-        "custom_field",
-        &ty,
-        &ty,
-        false,
-        &mut fns,
-    );
-    // Unsupported type with SQL function → still skips entirely
     assert!(serde.is_empty());
     assert!(schema.is_empty());
-    assert!(fns.is_empty());
 }
 
 #[test]
@@ -477,156 +443,6 @@ fn test_generate_schema_type_code_with_partial_fields() {
     );
 }
 
-// --- Coverage: sql_function_default_body branches ---
-
-#[test]
-fn test_sql_function_default_non_path_type_skips() {
-    // Reference type (&str) is Type::Reference, not Type::Path → sql_function_default_body returns None
-    let attrs: Vec<syn::Attribute> = vec![syn::parse_quote!(#[sea_orm(default_value = "GEN()")])];
-    let struct_name = syn::Ident::new("Test", proc_macro2::Span::call_site());
-    let ty: syn::Type = syn::parse_str("&str").unwrap();
-    let mut fns = Vec::new();
-    let (serde, schema) =
-        generate_sea_orm_default_attrs(&attrs, &struct_name, "val", &ty, &ty, false, &mut fns);
-    assert!(serde.is_empty());
-    assert!(schema.is_empty());
-    assert!(fns.is_empty());
-}
-
-#[test]
-fn test_sql_function_default_datetime_with_timezone() {
-    let attrs: Vec<syn::Attribute> = vec![syn::parse_quote!(#[sea_orm(default_value = "NOW()")])];
-    let struct_name = syn::Ident::new("Test", proc_macro2::Span::call_site());
-    let ty: syn::Type = syn::parse_str("DateTimeWithTimeZone").unwrap();
-    let mut fns = Vec::new();
-    let (serde, schema) =
-        generate_sea_orm_default_attrs(&attrs, &struct_name, "ts", &ty, &ty, false, &mut fns);
-    let serde_str = serde.to_string();
-    assert!(
-        serde_str.contains("serde"),
-        "should have serde attr: {serde_str}"
-    );
-    assert!(schema.is_empty());
-    assert_eq!(fns.len(), 1);
-    let fn_str = fns[0].to_string();
-    assert!(
-        fn_str.contains("UNIX_EPOCH"),
-        "should use epoch default: {fn_str}"
-    );
-}
-
-#[test]
-fn test_sql_function_default_datetime_utc() {
-    let attrs: Vec<syn::Attribute> = vec![syn::parse_quote!(#[sea_orm(default_value = "NOW()")])];
-    let struct_name = syn::Ident::new("Test", proc_macro2::Span::call_site());
-    let ty: syn::Type = syn::parse_str("DateTimeUtc").unwrap();
-    let mut fns = Vec::new();
-    let (serde, schema) =
-        generate_sea_orm_default_attrs(&attrs, &struct_name, "ts", &ty, &ty, false, &mut fns);
-    let serde_str = serde.to_string();
-    assert!(
-        serde_str.contains("serde"),
-        "should have serde attr: {serde_str}"
-    );
-    assert!(schema.is_empty());
-    assert_eq!(fns.len(), 1);
-    let fn_str = fns[0].to_string();
-    assert!(
-        fn_str.contains("UNIX_EPOCH"),
-        "should use epoch default: {fn_str}"
-    );
-}
-
-#[test]
-fn test_sql_function_default_datetime_local() {
-    let attrs: Vec<syn::Attribute> = vec![syn::parse_quote!(#[sea_orm(default_value = "NOW()")])];
-    let struct_name = syn::Ident::new("Test", proc_macro2::Span::call_site());
-    let ty: syn::Type = syn::parse_str("DateTimeLocal").unwrap();
-    let mut fns = Vec::new();
-    let (serde, schema) =
-        generate_sea_orm_default_attrs(&attrs, &struct_name, "ts", &ty, &ty, false, &mut fns);
-    let serde_str = serde.to_string();
-    assert!(
-        serde_str.contains("serde"),
-        "should have serde attr: {serde_str}"
-    );
-    assert!(schema.is_empty());
-    assert_eq!(fns.len(), 1);
-    let fn_str = fns[0].to_string();
-    assert!(
-        fn_str.contains("UNIX_EPOCH"),
-        "should use epoch default: {fn_str}"
-    );
-}
-
-#[test]
-fn test_sql_function_default_naive_datetime() {
-    let attrs: Vec<syn::Attribute> = vec![syn::parse_quote!(#[sea_orm(default_value = "NOW()")])];
-    let struct_name = syn::Ident::new("Test", proc_macro2::Span::call_site());
-    let ty: syn::Type = syn::parse_str("NaiveDateTime").unwrap();
-    let mut fns = Vec::new();
-    let (serde, schema) =
-        generate_sea_orm_default_attrs(&attrs, &struct_name, "ts", &ty, &ty, false, &mut fns);
-    let serde_str = serde.to_string();
-    assert!(
-        serde_str.contains("serde"),
-        "should have serde attr: {serde_str}"
-    );
-    assert!(schema.is_empty());
-    assert_eq!(fns.len(), 1);
-    let fn_str = fns[0].to_string();
-    assert!(
-        fn_str.contains("UNIX_EPOCH"),
-        "should use epoch default: {fn_str}"
-    );
-}
-
-#[test]
-fn test_sql_function_default_naive_date() {
-    let attrs: Vec<syn::Attribute> =
-        vec![syn::parse_quote!(#[sea_orm(default_value = "CURDATE()")])];
-    let struct_name = syn::Ident::new("Test", proc_macro2::Span::call_site());
-    let ty: syn::Type = syn::parse_str("NaiveDate").unwrap();
-    let mut fns = Vec::new();
-    let (serde, schema) =
-        generate_sea_orm_default_attrs(&attrs, &struct_name, "d", &ty, &ty, false, &mut fns);
-    let serde_str = serde.to_string();
-    assert!(
-        serde_str.contains("serde"),
-        "should have serde attr: {serde_str}"
-    );
-    assert!(schema.is_empty());
-    assert_eq!(fns.len(), 1);
-    let fn_str = fns[0].to_string();
-    assert!(
-        fn_str.contains("from_ymd_opt"),
-        "should use ymd default: {fn_str}"
-    );
-}
-
-#[test]
-fn test_sql_function_default_naive_time() {
-    let attrs: Vec<syn::Attribute> =
-        vec![syn::parse_quote!(#[sea_orm(default_value = "CURTIME()")])];
-    let struct_name = syn::Ident::new("Test", proc_macro2::Span::call_site());
-    let ty: syn::Type = syn::parse_str("NaiveTime").unwrap();
-    let mut fns = Vec::new();
-    let (serde, schema) =
-        generate_sea_orm_default_attrs(&attrs, &struct_name, "t", &ty, &ty, false, &mut fns);
-    let serde_str = serde.to_string();
-    assert!(
-        serde_str.contains("serde"),
-        "should have serde attr: {serde_str}"
-    );
-    assert!(schema.is_empty());
-    assert_eq!(fns.len(), 1);
-    let fn_str = fns[0].to_string();
-    assert!(
-        fn_str.contains("from_hms_opt"),
-        "should use hms default: {fn_str}"
-    );
-}
-
 // --- Coverage: is_parseable_type empty segments ---
 
 #[test]

crates/vespera_macro/src/schema_macro/tests.rs

@@ -3045,6 +3045,8 @@
           "userId",
           "memoId",
           "content",
+          "createdAt",
+          "updatedAt",
           "user",
           "memo"
         ]
@@ -3079,7 +3081,8 @@
           "userId",
           "title",
           "content",
-          "status"
+          "status",
+          "createdAt"
         ]
       },
       "MemoResponseComments": {
@@ -3166,6 +3169,7 @@
           "title",
           "content",
           "status",
+          "createdAt",
           "user"
         ]
       },
@@ -3207,6 +3211,8 @@
           "title",
           "content",
           "status",
+          "createdAt",
+          "updatedAt",
           "user"
         ]
       },
@@ -3228,7 +3234,8 @@
         },
         "required": [
           "id",
-          "user_id"
+          "user_id",
+          "created_at"
         ]
       },
       "MemoStatus": {
@@ -3919,7 +3926,9 @@
         "required": [
           "id",
           "email",
-          "name"
+          "name",
+          "createdAt",
+          "updatedAt"
         ]
       },
       "UserSummary": {
@@ -3986,7 +3995,9 @@
           }
         },
         "required": [
-          "name"
+          "id",
+          "name",
+          "createdAt"
         ]
       }
     }