feat: add simple AsFormField impl for ForeignKeys

cot/src/form/fields.rs

@@ -12,9 +12,7 @@ pub use files::{FileField, FileFieldOptions, InMemoryUploadedFile};
 use crate::auth::PasswordHash;
 use crate::common_types::{Email, Password};
 #[cfg(feature = "db")]
-use crate::db::Auto;
-#[cfg(feature = "db")]
-use crate::db::LimitedString;
+use crate::db::{Auto, ForeignKey, LimitedString, Model};
 use crate::form::{
     AsFormField, FormField, FormFieldOptions, FormFieldValidationError, FormFieldValue,
     FormFieldValueError,
@@ -592,6 +590,40 @@ impl<T: AsFormField> AsFormField for Auto<T> {
     }
 }
 
+#[cfg(feature = "db")]
+impl<T> AsFormField for ForeignKey<T>
+where
+    T: Model,
+    <T as Model>::PrimaryKey: AsFormField,
+{
+    type Type = <<T as Model>::PrimaryKey as AsFormField>::Type;
+
+    fn new_field(
+        options: FormFieldOptions,
+        custom_options: <Self::Type as FormField>::CustomOptions,
+    ) -> Self::Type {
+        Self::Type::with_options(options, custom_options)
+    }
+
+    fn clean_value(field: &Self::Type) -> Result<Self, FormFieldValidationError>
+    where
+        Self: Sized,
+    {
+        let value = <T as Model>::PrimaryKey::clean_value(field);
+        match value {
+            Ok(value) => Ok(ForeignKey::PrimaryKey(value)),
+            Err(error) => Err(error),
+        }
+    }
+
+    fn to_field_value(&self) -> String {
+        match self {
+            ForeignKey::PrimaryKey(primary_key) => primary_key.to_field_value(),
+            ForeignKey::Model(model) => model.primary_key().to_field_value(),
+        }
+    }
+}
+
 fn check_required<T: FormField>(field: &T) -> Result<&str, FormFieldValidationError> {
     if let Some(value) = field.value() {
         if value.is_empty() {

cot/tests/form.rs

@@ -1,7 +1,10 @@
+use cot::db::{Auto, ForeignKey};
 use cot::form::{
-    Form, FormContext, FormErrorTarget, FormField, FormFieldValidationError, FormResult,
+    AsFormField, Form, FormContext, FormErrorTarget, FormField, FormFieldValidationError,
+    FormResult,
 };
 use cot::test::TestRequestBuilder;
+use cot_macros::model;
 
 #[derive(Debug, Form)]
 struct MyForm {
@@ -88,3 +91,70 @@ async fn values_persist_on_form_errors() {
         _ => panic!("Expected a validation error"),
     }
 }
+
+#[cot::test]
+async fn foreign_key_field() {
+    #[model]
+    struct TestModel {
+        #[model(primary_key)]
+        name: String,
+    }
+
+    #[derive(Form)]
+    struct TestModelForm {
+        test_field: ForeignKey<TestModel>,
+    }
+
+    // test field rendering
+    let context = TestModelForm::build_context(&mut TestRequestBuilder::get("/").build())
+        .await
+        .unwrap();
+    let form_rendered = context.to_string();
+    assert!(form_rendered.contains("test_field"));
+    assert!(form_rendered.contains("type=\"text\""));
+
+    // test form data
+    let mut request = TestRequestBuilder::post("/")
+        .form_data(&[("test_field", "Alice")])
+        .build();
+    let form = TestModelForm::from_request(&mut request).await;
+    match form {
+        Ok(FormResult::Ok(instance)) => {
+            assert_eq!(instance.test_field.primary_key(), "Alice");
+        }
+        _ => panic!("Expected a valid form"),
+    }
+
+    // test re-raising validation errors
+    let mut request = TestRequestBuilder::post("/")
+        .form_data(&[("test_field", "")])
+        .build();
+    let form = TestModelForm::from_request(&mut request).await;
+    match form {
+        Ok(FormResult::ValidationError(context)) => {
+            assert_eq!(
+                context.errors_for(FormErrorTarget::Field("test_field")),
+                &[FormFieldValidationError::Required]
+            );
+        }
+        _ => panic!("Expected a validation error"),
+    }
+}
+
+#[cot::test]
+async fn foreign_key_field_to_field_value() {
+    #[model]
+    struct TestModel {
+        #[model(primary_key)]
+        id: Auto<i32>,
+    }
+
+    let field_value = ForeignKey::<TestModel>::Model(Box::new(TestModel {
+        id: Auto::fixed(123),
+    }))
+    .to_field_value();
+    assert_eq!(field_value, "123");
+
+    let field_value = ForeignKey::<TestModel>::PrimaryKey(Auto::fixed(456)).to_field_value();
+    assert_eq!(field_value, "456");
+}