Fix default issue

Author: owjs3901

crates/vespera_macro/src/parser/schema/struct_schema.rs

@@ -10,9 +10,8 @@ use vespera_core::schema::{Schema, SchemaRef, SchemaType};
 
 use super::{
     serde_attrs::{
-        extract_default, extract_doc_comment, extract_field_rename, extract_flatten,
-        extract_rename_all, extract_skip, extract_skip_serializing_if, rename_field,
-        strip_raw_prefix,
+        extract_doc_comment, extract_field_rename, extract_flatten, extract_rename_all,
+        extract_skip, rename_field, strip_raw_prefix,
     },
     type_schema::parse_type_to_schema_ref,
 };
@@ -104,36 +103,21 @@ pub fn parse_struct_to_schema(
                     }
                 }
 
-                // Check for default attribute
-                let has_default = extract_default(&field.attrs).is_some();
-
-                // Check for skip_serializing_if attribute
-                let has_skip_serializing_if = extract_skip_serializing_if(&field.attrs);
+                // Required is determined solely by nullability (Option<T>).
+                // Fields with #[serde(default)] still have defaults applied in
+                // openapi_generator, but that does NOT affect required status.
+                let is_optional = matches!(
+                    field_type,
+                    Type::Path(type_path)
+                        if type_path
+                            .path
+                            .segments
+                            .first()
+                            .is_some_and(|s| s.ident == "Option")
+                );
 
-                // If default or skip_serializing_if is present, mark field as optional (not required)
-                // and set default value if it's a simple default (not a function)
-                if has_default || has_skip_serializing_if {
-                    // For default = "function_name", we'll handle it in openapi_generator
-                    // For now, just mark as optional
-                    if let SchemaRef::Inline(ref mut _schema) = schema_ref {
-                        // Default will be set later in openapi_generator if it's a function
-                        // For simple default, we could set it here, but serde handles it
-                    }
-                } else {
-                    // Check if field is Option<T>
-                    let is_optional = matches!(
-                        field_type,
-                        Type::Path(type_path)
-                            if type_path
-                                .path
-                                .segments
-                                .first()
-                                .is_some_and(|s| s.ident == "Option")
-                    );
-
-                    if !is_optional {
-                        required.push(field_name.clone());
-                    }
+                if !is_optional {
+                    required.push(field_name.clone());
                 }
 
                 properties.insert(field_name, schema_ref);
@@ -212,20 +196,16 @@ mod tests {
         let props = schema.properties.as_ref().unwrap();
         assert!(props.contains_key("id"));
         assert!(props.contains_key("name"));
-        assert!(
-            schema
-                .required
-                .as_ref()
-                .unwrap()
-                .contains(&"id".to_string())
-        );
-        assert!(
-            !schema
-                .required
-                .as_ref()
-                .unwrap()
-                .contains(&"name".to_string())
-        );
+        assert!(schema
+            .required
+            .as_ref()
+            .unwrap()
+            .contains(&"id".to_string()));
+        assert!(!schema
+            .required
+            .as_ref()
+            .unwrap()
+            .contains(&"name".to_string()));
     }
 
     #[test]
@@ -283,14 +263,15 @@ mod tests {
     }
 
     // Test struct with default and skip_serializing_if
+    // Required is determined solely by nullability (Option<T>), not by defaults.
     #[test]
     fn test_parse_struct_to_schema_with_default_fields() {
         let struct_item: syn::ItemStruct = syn::parse_str(
             r#"
             struct Config {
                 required_field: i32,
                 #[serde(default)]
-                optional_with_default: String,
+                with_default: String,
                 #[serde(skip_serializing_if = "Option::is_none")]
                 maybe_skip: Option<i32>,
             }
@@ -300,14 +281,14 @@ mod tests {
         let schema = parse_struct_to_schema(&struct_item, &HashSet::new(), &HashMap::new());
         let props = schema.properties.as_ref().unwrap();
         assert!(props.contains_key("required_field"));
-        assert!(props.contains_key("optional_with_default"));
+        assert!(props.contains_key("with_default"));
         assert!(props.contains_key("maybe_skip"));
 
         let required = schema.required.as_ref().unwrap();
         assert!(required.contains(&"required_field".to_string()));
-        // Fields with default should NOT be required
-        assert!(!required.contains(&"optional_with_default".to_string()));
-        // Fields with skip_serializing_if should NOT be required
+        // Non-nullable fields are always required, even with #[serde(default)]
+        assert!(required.contains(&"with_default".to_string()));
+        // Option<T> fields are not required (nullable)
         assert!(!required.contains(&"maybe_skip".to_string()));
     }
 

crates/vespera_macro/src/schema_macro/mod.rs

@@ -29,7 +29,7 @@ use proc_macro2::TokenStream;
 use quote::quote;
 use seaorm::{
     RelationFieldInfo, convert_relation_type_to_schema_with_info, convert_type_with_chrono,
-    extract_sea_orm_default_value, is_sql_function_default,
+    extract_sea_orm_default_value, has_sea_orm_primary_key, is_sql_function_default,
 };
 use transformation::{
     build_omit_set, build_partial_config, build_pick_set, build_rename_map, determine_rename_all,
@@ -408,8 +408,8 @@ pub fn generate_schema_type_code(
                 // that may have ORM-specific attributes we don't want in the generated struct
                 let serde_field_attrs = extract_field_serde_attrs(&field.attrs);
 
-                // Generate serde default + schema(default) from sea_orm(default_value)
-                // Only for non-partial, non-Option fields with literal (non-SQL-function) defaults
+                // Generate serde default + schema(default) from sea_orm(default_value) or primary_key
+                // Handles literal defaults, SQL function defaults, and implicit auto-increment
                 let (serde_default_attr, schema_default_attr) = generate_sea_orm_default_attrs(
                     &field.attrs,
                     new_type_name,
@@ -622,20 +622,26 @@ pub fn generate_schema_type_code(
 }
 
 /// Generate `#[serde(default = "...")]` and `#[schema(default = "...")]` attributes
-/// from `#[sea_orm(default_value = ...)]` on source fields.
+/// from `#[sea_orm(default_value = ...)]` or `#[sea_orm(primary_key)]` on source fields.
 ///
 /// Returns `(serde_default_attr, schema_default_attr)` as `TokenStream`s.
 /// - `serde_default_attr`: `#[serde(default = "default_structname_field")]` for deserialization
 /// - `schema_default_attr`: `#[schema(default = "value")]` for OpenAPI default value
 ///
 /// Also generates a companion default function and appends it to `default_functions`.
 ///
+/// Handles three categories of defaults:
+/// 1. **Literal defaults** (`default_value = "42"`, `"draft"`, `0.7`):
+///    Generates parse-based default function + schema default.
+/// 2. **SQL function defaults** (`default_value = "NOW()"`, `"gen_random_uuid()"`):
+///    Generates type-specific default function + schema default with type's zero value.
+/// 3. **Primary key** (implicit auto-increment):
+///    Treated as having an implicit default — generates type-specific default.
+///
 /// Skips serde default generation when:
-/// - The field type doesn't implement `FromStr` (enums, custom types)
-/// - The field already has `#[serde(default)]`
 /// - The field is wrapped in `Option` (partial mode or already optional)
-///
-/// Always generates `#[schema(default)]` for OpenAPI when a literal default exists.
+/// - The field already has `#[serde(default)]`
+/// - For literal defaults: the field type doesn't implement `FromStr`
 fn generate_sea_orm_default_attrs(
     original_attrs: &[syn::Attribute],
     struct_name: &syn::Ident,
@@ -650,46 +656,129 @@ fn generate_sea_orm_default_attrs(
         return (quote! {}, quote! {});
     }
 
-    // Check for sea_orm(default_value)
-    let Some(default_value) = extract_sea_orm_default_value(original_attrs) else {
-        return (quote! {}, quote! {});
-    };
+    // Check for sea_orm(default_value) and sea_orm(primary_key)
+    let default_value = extract_sea_orm_default_value(original_attrs);
+    let has_pk = has_sea_orm_primary_key(original_attrs);
 
-    // SQL functions like NOW(), CURRENT_TIMESTAMP(), gen_random_uuid()
-    // can't be expressed as concrete JSON defaults — skip entirely.
-    if is_sql_function_default(&default_value) {
+    // No default source found
+    if default_value.is_none() && !has_pk {
         return (quote! {}, quote! {});
     }
 
-    // Generate #[schema(default = "value")] for OpenAPI (always, regardless of type support)
-    let schema_default_attr = quote! { #[schema(default = #default_value)] };
-
-    // Check if field already has serde(default)
     let has_existing_serde_default = extract_default(original_attrs).is_some();
-    if has_existing_serde_default {
-        return (quote! {}, schema_default_attr);
-    }
 
-    // Only generate serde default function for types known to implement FromStr
-    if !is_parseable_type(original_ty) {
-        return (quote! {}, schema_default_attr);
-    }
+    match &default_value {
+        // Literal default (e.g., "42", "draft", "0.7")
+        Some(value) if !is_sql_function_default(value) => {
+            let schema_default_attr = quote! { #[schema(default = #value)] };
+
+            if has_existing_serde_default {
+                return (quote! {}, schema_default_attr);
+            }
 
-    // Generate default function with struct-specific name to avoid collisions:
-    // fn default_{StructName}_{field_name}() -> Type { "value".parse().unwrap() }
-    let fn_name = format!("default_{struct_name}_{field_name}");
-    let fn_ident = syn::Ident::new(&fn_name, proc_macro2::Span::call_site());
+            if !is_parseable_type(original_ty) {
+                return (quote! {}, schema_default_attr);
+            }
+
+            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 {
+                    #value.parse().unwrap()
+                }
+            });
 
-    default_functions.push(quote! {
-        #[allow(non_snake_case)]
-        fn #fn_ident() -> #field_ty {
-            #default_value.parse().unwrap()
+            let serde_default_attr = quote! { #[serde(default = #fn_name)] };
+            (serde_default_attr, schema_default_attr)
         }
-    });
+        // SQL function default (NOW(), gen_random_uuid(), etc.) or primary_key auto-increment
+        _ => {
+            let Some((default_expr, schema_default_str)) =
+                sql_function_default_for_type(original_ty)
+            else {
+                return (quote! {}, quote! {});
+            };
+
+            let schema_default_attr = quote! { #[schema(default = #schema_default_str)] };
+
+            if has_existing_serde_default {
+                return (quote! {}, schema_default_attr);
+            }
+
+            let fn_name = format!("default_{struct_name}_{field_name}");
+            let fn_ident = syn::Ident::new(&fn_name, proc_macro2::Span::call_site());
 
-    let serde_default_attr = quote! { #[serde(default = #fn_name)] };
+            default_functions.push(quote! {
+                #[allow(non_snake_case)]
+                fn #fn_ident() -> #field_ty {
+                    #default_expr
+                }
+            });
+
+            let serde_default_attr = quote! { #[serde(default = #fn_name)] };
+            (serde_default_attr, schema_default_attr)
+        }
+    }
+}
 
-    (serde_default_attr, schema_default_attr)
+/// Return a type-appropriate (Rust default expression, OpenAPI default string) pair
+/// for fields with SQL function defaults or implicit auto-increment.
+///
+/// The Rust expression is used in the generated `#[serde(default = "fn")]` function body.
+/// The OpenAPI string is used in `#[schema(default = "value")]`.
+fn sql_function_default_for_type(original_ty: &syn::Type) -> Option<(TokenStream, String)> {
+    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() {
+        "DateTimeWithTimeZone" | "DateTimeUtc" => {
+            let expr = quote! {
+                vespera::chrono::DateTime::<vespera::chrono::Utc>::UNIX_EPOCH.fixed_offset()
+            };
+            Some((expr, "1970-01-01T00:00:00+00:00".to_string()))
+        }
+        "DateTime" => {
+            // Could be chrono::DateTime<Tz> — use UTC epoch
+            let expr = quote! {
+                vespera::chrono::DateTime::<vespera::chrono::Utc>::UNIX_EPOCH.fixed_offset()
+            };
+            Some((expr, "1970-01-01T00:00:00+00:00".to_string()))
+        }
+        "NaiveDateTime" => {
+            let expr = quote! {
+                vespera::chrono::NaiveDateTime::UNIX_EPOCH
+            };
+            Some((expr, "1970-01-01T00:00:00".to_string()))
+        }
+        "NaiveDate" => {
+            let expr = quote! {
+                vespera::chrono::NaiveDate::default()
+            };
+            Some((expr, "1970-01-01".to_string()))
+        }
+        "NaiveTime" | "Time" => {
+            let expr = quote! {
+                vespera::chrono::NaiveTime::from_hms_opt(0, 0, 0).unwrap()
+            };
+            Some((expr, "00:00:00".to_string()))
+        }
+        "Uuid" => Some((
+            quote! { Default::default() },
+            "00000000-0000-0000-0000-000000000000".to_string(),
+        )),
+        "i8" | "i16" | "i32" | "i64" | "i128" | "isize" | "u8" | "u16" | "u32" | "u64"
+        | "u128" | "usize" | "f32" | "f64" | "Decimal" => {
+            Some((quote! { Default::default() }, "0".to_string()))
+        }
+        "bool" => Some((quote! { Default::default() }, "false".to_string())),
+        "String" => Some((quote! { Default::default() }, String::new())),
+        _ => None,
+    }
 }
 
 /// Check if a type is known to implement `FromStr` and can use `.parse().unwrap()`.