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,
@@ -13,6 +25,7 @@ use collab_entity::CollabType;
 use serde::{Deserialize, Serialize};
 use serde_repr::{Deserialize_repr, Serialize_repr};
 use std::collections::HashMap;
+use std::fmt::{Display, Formatter};
 use tracing::error;
 use yrs::{Any, Out};
 
@@ -254,7 +267,7 @@ impl CreateDatabaseParams {
   }
 }
 
-#[derive(Clone, Debug, Hash, Eq, PartialEq, Serialize_repr, Deserialize_repr)]
+#[derive(Clone, Copy, Debug, Hash, Eq, PartialEq, Serialize_repr, Deserialize_repr)]
 #[repr(u8)]
 pub enum FieldType {
   RichText = 0,
@@ -297,6 +310,120 @@ impl TryFrom<yrs::Out> for FieldType {
   }
 }
 
+impl Display for FieldType {
+  fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+    let value: i64 = (*self).into();
+    f.write_fmt(format_args!("{}", value))
+  }
+}
+
+impl AsRef<FieldType> for FieldType {
+  fn as_ref(&self) -> &FieldType {
+    self
+  }
+}
+
+impl From<&FieldType> for FieldType {
+  fn from(field_type: &FieldType) -> Self {
+    *field_type
+  }
+}
+
+impl FieldType {
+  pub fn value(&self) -> i64 {
+    (*self).into()
+  }
+
+  pub fn default_name(&self) -> String {
+    let s = match self {
+      FieldType::RichText => "Text",
+      FieldType::Number => "Number",
+      FieldType::DateTime => "Date",
+      FieldType::SingleSelect => "Single Select",
+      FieldType::MultiSelect => "Multi Select",
+      FieldType::Checkbox => "Checkbox",
+      FieldType::URL => "URL",
+      FieldType::Checklist => "Checklist",
+      FieldType::LastEditedTime => "Last modified",
+      FieldType::CreatedTime => "Created time",
+      FieldType::Relation => "Relation",
+      FieldType::Summary => "Summarize",
+      FieldType::Translate => "Translate",
+      FieldType::Time => "Time",
+      FieldType::Media => "Media",
+    };
+    s.to_string()
+  }
+
+  pub fn is_ai_field(&self) -> bool {
+    matches!(self, FieldType::Summary | FieldType::Translate)
+  }
+
+  pub fn is_number(&self) -> bool {
+    matches!(self, FieldType::Number)
+  }
+
+  pub fn is_text(&self) -> bool {
+    matches!(self, FieldType::RichText)
+  }
+
+  pub fn is_checkbox(&self) -> bool {
+    matches!(self, FieldType::Checkbox)
+  }
+
+  pub fn is_date(&self) -> bool {
+    matches!(self, FieldType::DateTime)
+  }
+
+  pub fn is_single_select(&self) -> bool {
+    matches!(self, FieldType::SingleSelect)
+  }
+
+  pub fn is_multi_select(&self) -> bool {
+    matches!(self, FieldType::MultiSelect)
+  }
+
+  pub fn is_last_edited_time(&self) -> bool {
+    matches!(self, FieldType::LastEditedTime)
+  }
+
+  pub fn is_created_time(&self) -> bool {
+    matches!(self, FieldType::CreatedTime)
+  }
+
+  pub fn is_url(&self) -> bool {
+    matches!(self, FieldType::URL)
+  }
+
+  pub fn is_select_option(&self) -> bool {
+    self.is_single_select() || self.is_multi_select()
+  }
+
+  pub fn is_checklist(&self) -> bool {
+    matches!(self, FieldType::Checklist)
+  }
+
+  pub fn is_relation(&self) -> bool {
+    matches!(self, FieldType::Relation)
+  }
+
+  pub fn is_time(&self) -> bool {
+    matches!(self, FieldType::Time)
+  }
+
+  pub fn is_media(&self) -> bool {
+    matches!(self, FieldType::Media)
+  }
+
+  pub fn can_be_group(&self) -> bool {
+    self.is_select_option() || self.is_checkbox() || self.is_url()
+  }
+
+  pub fn is_auto_update(&self) -> bool {
+    self.is_last_edited_time()
+  }
+}
+
 impl From<i64> for FieldType {
   fn from(index: i64) -> Self {
     match index {
@@ -323,6 +450,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/field.rs

@@ -2,6 +2,8 @@ use serde::{Deserialize, Serialize};
 
 use collab::preclude::{Any, Map, MapExt, MapRef, ReadTxn, TransactionMut, YrsValue};
 
+use crate::database::gen_field_id;
+use crate::entity::{default_type_option_data_from_type, FieldType};
 use crate::fields::{TypeOptionData, TypeOptions, TypeOptionsUpdate};
 use crate::{impl_bool_update, impl_i64_update, impl_str_update};
 
@@ -37,6 +39,17 @@ impl Field {
     self
   }
 
+  pub fn from_field_type(name: &str, field_type: FieldType, is_primary: bool) -> Self {
+    let new_field = Self {
+      id: gen_field_id(),
+      name: name.to_string(),
+      field_type: field_type.into(),
+      is_primary,
+      ..Default::default()
+    };
+    new_field.with_type_option_data(field_type, default_type_option_data_from_type(field_type))
+  }
+
   pub fn get_type_option<T: From<TypeOptionData>>(&self, type_id: impl ToString) -> Option<T> {
     let type_option_data = self.type_options.get(&type_id.to_string())?.clone();
     Some(T::from(type_option_data))

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)),
+    ])
+  }
+}