feat: add default type option data from type

Author: khorshuheng

collab-database/src/entity.rs

@@ -1,7 +1,19 @@
 #![allow(clippy::upper_case_acronyms)]
 use crate::database::{gen_database_id, gen_database_view_id, gen_row_id, timestamp, DatabaseData};
 use crate::error::DatabaseError;
-use crate::fields::Field;
+use crate::fields::checkbox_type_option::CheckboxTypeOption;
+use crate::fields::checklist_type_option::ChecklistTypeOption;
+use crate::fields::date_type_option::{DateTypeOption, TimeTypeOption};
+use crate::fields::media_type_option::MediaTypeOption;
+use crate::fields::number_type_option::NumberTypeOption;
+use crate::fields::relation_type_option::RelationTypeOption;
+use crate::fields::select_type_option::{MultiSelectTypeOption, SingleSelectTypeOption};
+use crate::fields::summary_type_option::SummarizationTypeOption;
+use crate::fields::text_type_option::RichTextTypeOption;
+use crate::fields::timestamp_type_option::TimestampTypeOption;
+use crate::fields::translate_type_option::TranslateTypeOption;
+use crate::fields::url_type_option::URLTypeOption;
+use crate::fields::{Field, TypeOptionData};
 use crate::rows::CreateRowParams;
 use crate::views::{
   DatabaseLayout, FieldOrder, FieldSettingsByFieldIdMap, FieldSettingsMap, FilterMap,
@@ -323,6 +335,29 @@ impl From<i64> for FieldType {
   }
 }
 
+pub fn default_type_option_data_from_type(field_type: FieldType) -> TypeOptionData {
+  match field_type {
+    FieldType::RichText => RichTextTypeOption.into(),
+    FieldType::Number => NumberTypeOption::default().into(),
+    FieldType::DateTime => DateTypeOption::default().into(),
+    FieldType::LastEditedTime | FieldType::CreatedTime => TimestampTypeOption {
+      field_type: field_type.into(),
+      ..Default::default()
+    }
+    .into(),
+    FieldType::SingleSelect => SingleSelectTypeOption::default().into(),
+    FieldType::MultiSelect => MultiSelectTypeOption::default().into(),
+    FieldType::Checkbox => CheckboxTypeOption.into(),
+    FieldType::URL => URLTypeOption::default().into(),
+    FieldType::Time => TimeTypeOption.into(),
+    FieldType::Media => MediaTypeOption::default().into(),
+    FieldType::Checklist => ChecklistTypeOption.into(),
+    FieldType::Relation => RelationTypeOption::default().into(),
+    FieldType::Summary => SummarizationTypeOption::default().into(),
+    FieldType::Translate => TranslateTypeOption::default().into(),
+  }
+}
+
 #[derive(Debug, Clone, Default, PartialEq, Eq, Serialize_repr, Deserialize_repr)]
 #[repr(u8)]
 pub enum FileUploadType {

collab-database/src/fields/type_option/checklist_type_option.rs

@@ -0,0 +1,18 @@
+use serde::{Deserialize, Serialize};
+
+use super::{TypeOptionData, TypeOptionDataBuilder};
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct ChecklistTypeOption;
+
+impl From<TypeOptionData> for ChecklistTypeOption {
+  fn from(_data: TypeOptionData) -> Self {
+    Self
+  }
+}
+
+impl From<ChecklistTypeOption> for TypeOptionData {
+  fn from(_data: ChecklistTypeOption) -> Self {
+    TypeOptionDataBuilder::default()
+  }
+}

collab-database/src/fields/type_option/mod.rs

@@ -1,10 +1,14 @@
 pub mod checkbox_type_option;
+pub mod checklist_type_option;
 pub mod date_type_option;
 pub mod media_type_option;
 pub mod number_type_option;
+pub mod relation_type_option;
 pub mod select_type_option;
+pub mod summary_type_option;
 pub mod text_type_option;
 pub mod timestamp_type_option;
+pub mod translate_type_option;
 pub mod url_type_option;
 
 use std::collections::HashMap;

collab-database/src/fields/type_option/relation_type_option.rs

@@ -0,0 +1,22 @@
+use collab::util::AnyMapExt;
+use serde::{Deserialize, Serialize};
+
+use super::{TypeOptionData, TypeOptionDataBuilder};
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct RelationTypeOption {
+  pub database_id: String,
+}
+
+impl From<TypeOptionData> for RelationTypeOption {
+  fn from(data: TypeOptionData) -> Self {
+    let database_id: String = data.get_as("database_id").unwrap_or_default();
+    Self { database_id }
+  }
+}
+
+impl From<RelationTypeOption> for TypeOptionData {
+  fn from(data: RelationTypeOption) -> Self {
+    TypeOptionDataBuilder::from([("database_id".into(), data.database_id.into())])
+  }
+}

collab-database/src/fields/type_option/summary_type_option.rs

@@ -0,0 +1,22 @@
+use collab::util::AnyMapExt;
+use serde::{Deserialize, Serialize};
+
+use super::{TypeOptionData, TypeOptionDataBuilder};
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct SummarizationTypeOption {
+  pub auto_fill: bool,
+}
+
+impl From<TypeOptionData> for SummarizationTypeOption {
+  fn from(data: TypeOptionData) -> Self {
+    let auto_fill: bool = data.get_as("auto_fill").unwrap_or_default();
+    Self { auto_fill }
+  }
+}
+
+impl From<SummarizationTypeOption> for TypeOptionData {
+  fn from(data: SummarizationTypeOption) -> Self {
+    TypeOptionDataBuilder::from([("auto_fill".into(), data.auto_fill.into())])
+  }
+}

collab-database/src/fields/type_option/translate_type_option.rs

@@ -0,0 +1,54 @@
+use serde::{Deserialize, Serialize};
+use yrs::{encoding::serde::from_any, Any};
+
+use super::{TypeOptionData, TypeOptionDataBuilder};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TranslateTypeOption {
+  #[serde(default)]
+  pub auto_fill: bool,
+  /// Use [TranslateTypeOption::language_from_type] to get the language name
+  #[serde(default, rename = "language")]
+  pub language_type: i64,
+}
+
+impl TranslateTypeOption {
+  pub fn language_from_type(language_type: i64) -> &'static str {
+    match language_type {
+      0 => "Traditional Chinese",
+      1 => "English",
+      2 => "French",
+      3 => "German",
+      4 => "Hindi",
+      5 => "Spanish",
+      6 => "Portuguese",
+      7 => "Standard Arabic",
+      8 => "Simplified Chinese",
+      _ => "English",
+    }
+  }
+}
+
+impl Default for TranslateTypeOption {
+  fn default() -> Self {
+    Self {
+      auto_fill: false,
+      language_type: 1,
+    }
+  }
+}
+
+impl From<TypeOptionData> for TranslateTypeOption {
+  fn from(data: TypeOptionData) -> Self {
+    from_any(&Any::from(data)).unwrap()
+  }
+}
+
+impl From<TranslateTypeOption> for TypeOptionData {
+  fn from(value: TranslateTypeOption) -> Self {
+    TypeOptionDataBuilder::from([
+      ("auto_fill".into(), value.auto_fill.into()),
+      ("language".into(), Any::BigInt(value.language_type)),
+    ])
+  }
+}