feat: field settings application domain (#3284)

* chore: default field settings if not exist

* chore: field settings listeners and services

* chore: don't need to updateFieldInfos

* chore: load default field settings if none found

* chore: update collab ref

* chore: fix remidner compile errors

* fix: fix tests

* chore: update tauri project setting

---------

Co-authored-by: nathan <nathan@appflowy.io>

frontend/rust-lib/flowy-database2/src/entities/field_settings_entities.rs

@@ -8,7 +8,7 @@ use crate::impl_into_field_visibility;
 use crate::services::field_settings::{FieldSettings, FieldSettingsChangesetParams};
 
 /// Defines the field settings for a field in a view.
-#[derive(Debug, Default, Clone, ProtoBuf)]
+#[derive(Debug, Default, Clone, ProtoBuf, Eq, PartialEq)]
 pub struct FieldSettingsPB {
   #[pb(index = 1)]
   pub field_id: String,
@@ -27,7 +27,7 @@ impl From<FieldSettings> for FieldSettingsPB {
 }
 
 #[repr(u8)]
-#[derive(Debug, Default, Clone, ProtoBuf_Enum, PartialEq)]
+#[derive(Debug, Default, Clone, ProtoBuf_Enum, Eq, PartialEq)]
 pub enum FieldVisibility {
   #[default]
   AlwaysShown = 0,
@@ -77,12 +77,18 @@ impl TryInto<(String, Vec<String>)> for FieldIdsPB {
   }
 }
 
-#[derive(Debug, Default, Clone, ProtoBuf)]
+#[derive(Debug, Default, Clone, ProtoBuf, Eq, PartialEq)]
 pub struct RepeatedFieldSettingsPB {
   #[pb(index = 1)]
   pub items: Vec<FieldSettingsPB>,
 }
 
+impl std::convert::From<Vec<FieldSettingsPB>> for RepeatedFieldSettingsPB {
+  fn from(items: Vec<FieldSettingsPB>) -> Self {
+    Self { items }
+  }
+}
+
 #[derive(Debug, Default, Clone, ProtoBuf)]
 pub struct FieldSettingsChangesetPB {
   #[pb(index = 1)]

frontend/rust-lib/flowy-database2/src/entities/setting_entities.rs

@@ -9,8 +9,9 @@ use flowy_error::ErrorCode;
 use crate::entities::parser::NotEmptyStr;
 use crate::entities::{
   CalendarLayoutSettingPB, DeleteFilterParams, DeleteFilterPayloadPB, DeleteSortParams,
-  DeleteSortPayloadPB, RepeatedFilterPB, RepeatedGroupSettingPB, RepeatedSortPB,
-  UpdateFilterParams, UpdateFilterPayloadPB, UpdateGroupPB, UpdateSortParams, UpdateSortPayloadPB,
+  DeleteSortPayloadPB, RepeatedFieldSettingsPB, RepeatedFilterPB, RepeatedGroupSettingPB,
+  RepeatedSortPB, UpdateFilterParams, UpdateFilterPayloadPB, UpdateGroupPB, UpdateSortParams,
+  UpdateSortPayloadPB,
 };
 use crate::services::setting::CalendarLayoutSetting;
 
@@ -31,6 +32,9 @@ pub struct DatabaseViewSettingPB {
 
   #[pb(index = 5)]
   pub sorts: RepeatedSortPB,
+
+  #[pb(index = 6)]
+  pub field_settings: RepeatedFieldSettingsPB,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, ProtoBuf_Enum, EnumIter)]

frontend/rust-lib/flowy-database2/src/event_handler.rs

@@ -901,12 +901,39 @@ pub(crate) async fn get_field_settings_handler(
   let manager = upgrade_manager(manager)?;
   let (view_id, field_ids) = data.into_inner().try_into()?;
   let database_editor = manager.get_database_with_view_id(&view_id).await?;
+
+  let layout_ty = database_editor.get_layout_type(view_id.as_ref()).await;
+
   let field_settings = database_editor
-    .get_field_settings(&view_id, field_ids)
+    .get_field_settings(&view_id, layout_ty, field_ids.clone())
     .await?
     .into_iter()
     .map(FieldSettingsPB::from)
-    .collect::<Vec<FieldSettingsPB>>();
+    .collect();
+
+  data_result_ok(RepeatedFieldSettingsPB {
+    items: field_settings,
+  })
+}
+
+#[tracing::instrument(level = "debug", skip_all, err)]
+pub(crate) async fn get_all_field_settings_handler(
+  data: AFPluginData<DatabaseViewIdPB>,
+  manager: AFPluginState<Weak<DatabaseManager>>,
+) -> DataResult<RepeatedFieldSettingsPB, FlowyError> {
+  let manager = upgrade_manager(manager)?;
+  let view_id = data.into_inner();
+  let database_editor = manager.get_database_with_view_id(view_id.as_ref()).await?;
+
+  let layout_ty = database_editor.get_layout_type(view_id.as_ref()).await;
+
+  let field_settings = database_editor
+    .get_all_field_settings(view_id.as_ref(), layout_ty)
+    .await?
+    .into_iter()
+    .map(FieldSettingsPB::from)
+    .collect();
+
   data_result_ok(RepeatedFieldSettingsPB {
     items: field_settings,
   })

frontend/rust-lib/flowy-database2/src/event_map.rs

@@ -77,6 +77,7 @@ pub fn init(database_manager: Weak<DatabaseManager>) -> AFPlugin {
         .event(DatabaseEvent::GetDatabaseSnapshots, get_snapshots_handler)
         // Field settings
         .event(DatabaseEvent::GetFieldSettings, get_field_settings_handler)
+        .event(DatabaseEvent::GetAllFieldSettings, get_all_field_settings_handler)
         .event(DatabaseEvent::UpdateFieldSettings, update_field_settings_handler)
 }
 
@@ -324,7 +325,10 @@ pub enum DatabaseEvent {
   #[event(input = "FieldIdsPB", output = "RepeatedFieldSettingsPB")]
   GetFieldSettings = 160,
 
+  #[event(input = "DatabaseViewIdPB", output = "RepeatedFieldSettingsPB")]
+  GetAllFieldSettings = 161,
+
   /// Updates the field settings for a field in the given view
   #[event(input = "FieldSettingsChangesetPB")]
-  UpdateFieldSettings = 161,
+  UpdateFieldSettings = 162,
 }

frontend/rust-lib/flowy-database2/src/manager.rs

@@ -25,9 +25,7 @@ use crate::entities::{
 use crate::notification::{send_notification, DatabaseNotification};
 use crate::services::database::DatabaseEditor;
 use crate::services::database_view::DatabaseLayoutDepsResolver;
-use crate::services::field_settings::{
-  default_field_settings_by_layout, default_field_settings_by_layout_map,
-};
+use crate::services::field_settings::default_field_settings_by_layout_map;
 use crate::services::share::csv::{CSVFormat, CSVImporter, ImportResult};
 
 pub trait DatabaseUser: Send + Sync {
@@ -252,18 +250,15 @@ impl DatabaseManager {
     database_view_id: String,
   ) -> FlowyResult<()> {
     let wdb = self.get_workspace_database().await?;
-    let mut params = CreateViewParams::new(
-      database_id.clone(),
-      database_view_id,
-      name,
-      layout,
-      default_field_settings_by_layout(layout),
-    );
+    let mut params = CreateViewParams::new(database_id.clone(), database_view_id, name, layout);
     if let Some(database) = wdb.get_database(&database_id).await {
       let (field, layout_setting) = DatabaseLayoutDepsResolver::new(database, layout)
         .resolve_deps_when_create_database_linked_view();
       if let Some(field) = field {
-        params = params.with_deps_fields(vec![field], default_field_settings_by_layout_map())
+        params = params.with_deps_fields(
+          vec![field.clone()],
+          vec![default_field_settings_by_layout_map()],
+        );
       }
       if let Some(layout_setting) = layout_setting {
         params = params.with_layout_setting(layout_setting);

frontend/rust-lib/flowy-database2/src/services/database/database_editor.rs

@@ -28,8 +28,7 @@ use crate::services::field::{
   SelectOptionIds, TypeOptionCellDataHandler, TypeOptionCellExt,
 };
 use crate::services::field_settings::{
-  default_field_settings_by_layout, default_field_settings_by_layout_map, FieldSettings,
-  FieldSettingsChangesetParams,
+  default_field_settings_by_layout_map, FieldSettings, FieldSettingsChangesetParams,
 };
 use crate::services::filter::Filter;
 use crate::services::group::{
@@ -109,6 +108,15 @@ impl DatabaseEditor {
 
   pub async fn close(&self) {}
 
+  pub async fn get_layout_type(&self, view_id: &str) -> DatabaseLayout {
+    let view = self.database_views.get_view_editor(view_id).await.ok();
+    if let Some(editor) = view {
+      editor.v_get_layout_type().await
+    } else {
+      DatabaseLayout::default()
+    }
+  }
+
   pub async fn update_view_layout(
     &self,
     view_id: &str,
@@ -1107,18 +1115,57 @@ impl DatabaseEditor {
   pub async fn get_field_settings(
     &self,
     view_id: &str,
+    layout_ty: DatabaseLayout,
     field_ids: Vec<String>,
-  ) -> Result<Vec<FieldSettings>, anyhow::Error> {
+  ) -> FlowyResult<Vec<FieldSettings>> {
     let view = self.database_views.get_view_editor(view_id).await?;
-    view.v_get_field_settings(field_ids).await
+    let default_field_settings = default_field_settings_by_layout_map()
+      .get(&layout_ty)
+      .unwrap()
+      .to_owned();
+
+    let found_field_settings = view.v_get_field_settings(&field_ids).await;
+
+    let field_settings = field_ids
+      .into_iter()
+      .map(|field_id| {
+        if let Some(field_settings) = found_field_settings.get(&field_id) {
+          field_settings.to_owned()
+        } else {
+          FieldSettings::try_from_anymap(field_id, default_field_settings.clone()).unwrap()
+        }
+      })
+      .collect();
+
+    Ok(field_settings)
   }
 
   pub async fn get_all_field_settings(
     &self,
     view_id: &str,
-  ) -> Result<Vec<FieldSettings>, anyhow::Error> {
+    layout_ty: DatabaseLayout,
+  ) -> FlowyResult<Vec<FieldSettings>> {
     let view = self.database_views.get_view_editor(view_id).await?;
-    view.v_get_all_field_settings().await
+    let default_field_settings = default_field_settings_by_layout_map()
+      .get(&layout_ty)
+      .unwrap()
+      .to_owned();
+    let fields = self.get_fields(view_id, None);
+
+    let found_field_settings = view.v_get_all_field_settings().await;
+
+    let field_settings = fields
+      .into_iter()
+      .map(|field| {
+        if let Some(field_settings) = found_field_settings.get(&field.id) {
+          field_settings.to_owned()
+        } else {
+          FieldSettings::try_from_anymap(field.id, default_field_settings.clone()).unwrap()
+        }
+      })
+      .collect();
+
+    Ok(field_settings)
   }
 
   pub async fn update_field_settings_with_changeset(
@@ -1352,10 +1399,6 @@ impl DatabaseViewData for DatabaseViewDataImpl {
       .insert_layout_setting(view_id, layout_ty, layout_setting);
   }
 
-  fn get_layout_type(&self, view_id: &str) -> DatabaseLayout {
-    self.database.lock().views.get_database_view_layout(view_id)
-  }
-
   fn update_layout_type(&self, view_id: &str, layout_type: &DatabaseLayout) {
     self
       .database
@@ -1379,30 +1422,40 @@ impl DatabaseViewData for DatabaseViewDataImpl {
   fn get_field_settings(
     &self,
     view_id: &str,
-    field_ids: Vec<String>,
-  ) -> Result<Vec<FieldSettings>, anyhow::Error> {
+    field_ids: &Vec<String>,
+  ) -> HashMap<String, FieldSettings> {
     let field_settings_map = self
       .database
       .lock()
-      .get_field_settings(view_id, Some(field_ids));
+      .get_field_settings(view_id, Some(&field_ids));
 
-    let field_settings: Result<Vec<FieldSettings>, anyhow::Error> = field_settings_map
+    field_settings_map
       .into_iter()
-      .map(|(field_id, field_settings)| FieldSettings::try_from_anymap(field_id, field_settings))
-      .collect();
-
-    field_settings
+      .filter_map(|(field_id, field_settings)| {
+        let field_settings = FieldSettings::try_from_anymap(field_id.clone(), field_settings);
+        if let Ok(settings) = field_settings {
+          Some((field_id, settings))
+        } else {
+          None
+        }
+      })
+      .collect()
   }
 
-  fn get_all_field_settings(&self, view_id: &str) -> Result<Vec<FieldSettings>, anyhow::Error> {
+  fn get_all_field_settings(&self, view_id: &str) -> HashMap<String, FieldSettings> {
     let field_settings_map = self.database.lock().get_field_settings(view_id, None);
 
-    let field_settings: Result<Vec<FieldSettings>, anyhow::Error> = field_settings_map
+    field_settings_map
       .into_iter()
-      .map(|(field_id, field_settings)| FieldSettings::try_from_anymap(field_id, field_settings))
-      .collect();
-
-    field_settings
+      .filter_map(|(field_id, field_settings)| {
+        let field_settings = FieldSettings::try_from_anymap(field_id.clone(), field_settings);
+        if let Ok(settings) = field_settings {
+          Some((field_id, settings))
+        } else {
+          None
+        }
+      })
+      .collect()
   }
 
   fn update_field_settings(
@@ -1411,32 +1464,34 @@ impl DatabaseViewData for DatabaseViewDataImpl {
     field_id: &str,
     visibility: Option<FieldVisibility>,
   ) {
-    let field_settings = self
-      .get_field_settings(view_id, vec![field_id.to_string()])
-      .ok();
+    let field_settings_map = self.get_field_settings(view_id, &vec![field_id.to_string()]);
 
-    let new_field_settings = match field_settings {
-      Some(field_settings) => {
-        let mut field_settings = field_settings.first().unwrap().clone();
-        field_settings.visibility = visibility.unwrap_or(field_settings.visibility);
-        field_settings
-      },
-      None => {
-        let layout_ty = self.get_layout_for_view(view_id);
-        let mut field_settings = FieldSettings::try_from_anymap(
-          field_id.to_string(),
-          default_field_settings_by_layout(layout_ty),
-        )
-        .unwrap();
-        field_settings.visibility = visibility.unwrap_or(field_settings.visibility);
-        field_settings
-      },
+    let new_field_settings = if let Some(field_settings) = field_settings_map.get(field_id) {
+      let mut field_settings = field_settings.to_owned();
+      field_settings.visibility = visibility.unwrap_or(field_settings.visibility);
+      field_settings
+    } else {
+      let layout_ty = self.get_layout_for_view(view_id);
+      let mut field_settings = FieldSettings::try_from_anymap(
+        field_id.to_string(),
+        default_field_settings_by_layout_map()
+          .get(&layout_ty)
+          .unwrap()
+          .to_owned(),
+      )
+      .unwrap();
+      field_settings.visibility = visibility.unwrap_or(field_settings.visibility);
+      field_settings
     };
 
     self.database.lock().update_field_settings(
       view_id,
       Some(vec![field_id.to_string()]),
-      new_field_settings,
-    )
+      new_field_settings.clone(),
+    );
+
+    send_notification(view_id, DatabaseNotification::DidUpdateFieldSettings)
+      .payload(FieldSettingsPB::from(new_field_settings))
+      .send()
   }
 }

frontend/rust-lib/flowy-database2/src/services/database/util.rs

@@ -2,8 +2,9 @@ use collab_database::views::DatabaseView;
 
 use crate::entities::{
   CalendarLayoutSettingPB, DatabaseLayoutPB, DatabaseLayoutSettingPB, DatabaseViewSettingPB,
-  FilterPB, GroupSettingPB, SortPB,
+  FieldSettingsPB, FilterPB, GroupSettingPB, SortPB,
 };
+use crate::services::field_settings::FieldSettings;
 use crate::services::filter::Filter;
 use crate::services::group::GroupSetting;
 use crate::services::setting::CalendarLayoutSetting;
@@ -30,6 +31,7 @@ pub(crate) fn database_view_setting_pb_from_view(view: DatabaseView) -> Database
       Err(_) => None,
     })
     .collect::<Vec<FilterPB>>();
+
   let group_settings = view
     .group_settings
     .into_iter()
@@ -48,11 +50,20 @@ pub(crate) fn database_view_setting_pb_from_view(view: DatabaseView) -> Database
     })
     .collect::<Vec<SortPB>>();
 
+  let field_settings = view
+    .field_settings
+    .into_inner()
+    .into_iter()
+    .flat_map(|(field_id, field_settings)| FieldSettings::try_from_anymap(field_id, field_settings))
+    .map(FieldSettingsPB::from)
+    .collect::<Vec<FieldSettingsPB>>();
+
   DatabaseViewSettingPB {
     layout_type,
     filters: filters.into(),
     group_settings: group_settings.into(),
     sorts: sorts.into(),
+    field_settings: field_settings.into(),
     layout_setting,
   }
 }

frontend/rust-lib/flowy-database2/src/services/database_view/view_editor.rs

@@ -75,6 +75,8 @@ pub trait DatabaseViewData: Send + Sync + 'static {
 
   fn get_cell_in_row(&self, field_id: &str, row_id: &RowId) -> Fut<Arc<RowCell>>;
 
+  /// Return the database layout type for the view with given view_id
+  /// The default layout type is [DatabaseLayout::Grid]
   fn get_layout_for_view(&self, view_id: &str) -> DatabaseLayout;
 
   fn get_group_setting(&self, view_id: &str) -> Vec<GroupSetting>;
@@ -110,10 +112,6 @@ pub trait DatabaseViewData: Send + Sync + 'static {
     layout_setting: LayoutSetting,
   );
 
-  /// Return the database layout type for the view with given view_id
-  /// The default layout type is [DatabaseLayout::Grid]
-  fn get_layout_type(&self, view_id: &str) -> DatabaseLayout;
-
   fn update_layout_type(&self, view_id: &str, layout_type: &DatabaseLayout);
 
   /// Returns a `TaskDispatcher` used to poll a `Task`
@@ -128,10 +126,10 @@ pub trait DatabaseViewData: Send + Sync + 'static {
   fn get_field_settings(
     &self,
     view_id: &str,
-    field_ids: Vec<String>,
-  ) -> Result<Vec<FieldSettings>, anyhow::Error>;
+    field_ids: &Vec<String>,
+  ) -> HashMap<String, FieldSettings>;
 
-  fn get_all_field_settings(&self, view_id: &str) -> Result<Vec<FieldSettings>, anyhow::Error>;
+  fn get_all_field_settings(&self, view_id: &str) -> HashMap<String, FieldSettings>;
 
   fn update_field_settings(
     &self,
@@ -864,6 +862,10 @@ impl DatabaseViewEditor {
     Some(events)
   }
 
+  pub async fn v_get_layout_type(&self) -> DatabaseLayout {
+    self.delegate.get_layout_for_view(&self.view_id)
+  }
+
   #[tracing::instrument(level = "trace", skip_all)]
   pub async fn v_update_layout_type(&self, new_layout_type: DatabaseLayout) -> FlowyResult<()> {
     self
@@ -910,12 +912,12 @@ impl DatabaseViewEditor {
 
   pub async fn v_get_field_settings(
     &self,
-    field_ids: Vec<String>,
-  ) -> Result<Vec<FieldSettings>, anyhow::Error> {
+    field_ids: &Vec<String>,
+  ) -> HashMap<String, FieldSettings> {
     self.delegate.get_field_settings(&self.view_id, field_ids)
   }
 
-  pub async fn v_get_all_field_settings(&self) -> Result<Vec<FieldSettings>, anyhow::Error> {
+  pub async fn v_get_all_field_settings(&self) -> HashMap<String, FieldSettings> {
     self.delegate.get_all_field_settings(&self.view_id)
   }
 

frontend/rust-lib/flowy-database2/src/services/field_settings/field_settings.rs

@@ -1,35 +0,0 @@
-use std::collections::HashMap;
-
-use strum::IntoEnumIterator;
-
-use collab_database::views::{DatabaseLayout, FieldSettingsMap, FieldSettingsMapBuilder};
-
-use crate::{entities::FieldVisibility, services::field_settings::VISIBILITY};
-
-/// Creates a map of the database layout and the default field settings for fields
-/// in a view of that database layout
-pub fn default_field_settings_by_layout_map() -> HashMap<DatabaseLayout, FieldSettingsMap> {
-  let mut template = HashMap::new();
-  for layout_ty in DatabaseLayout::iter() {
-    template.insert(layout_ty, default_field_settings_by_layout(layout_ty));
-  }
-
-  template
-}
-
-/// Returns the default FieldSettingsMap for the given database layout
-pub fn default_field_settings_by_layout(layout_ty: DatabaseLayout) -> FieldSettingsMap {
-  let visibility = default_visibility(layout_ty);
-  FieldSettingsMapBuilder::new()
-    .insert_i64_value(VISIBILITY, visibility.into())
-    .build()
-}
-
-/// Returns the default visibility of a field for the given database layout
-pub fn default_visibility(layout_ty: DatabaseLayout) -> FieldVisibility {
-  match layout_ty {
-    DatabaseLayout::Grid => FieldVisibility::AlwaysShown,
-    DatabaseLayout::Board => FieldVisibility::HideWhenEmpty,
-    DatabaseLayout::Calendar => FieldVisibility::HideWhenEmpty,
-  }
-}

frontend/rust-lib/flowy-database2/src/services/field_settings/field_settings_builder.rs

@@ -1,8 +1,16 @@
-use collab_database::views::DatabaseLayout;
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use collab_database::database::MutexDatabase;
+use collab_database::fields::Field;
+use collab_database::views::{
+  DatabaseLayout, FieldSettingsByFieldIdMap, FieldSettingsMap, FieldSettingsMapBuilder,
+};
+use strum::IntoEnumIterator;
 
 use crate::entities::FieldVisibility;
 
-use crate::services::field_settings::{default_visibility, FieldSettings};
+use crate::services::field_settings::{FieldSettings, VISIBILITY};
 
 /// Helper struct to create a new field setting
 pub struct FieldSettingsBuilder {
@@ -18,14 +26,6 @@ impl FieldSettingsBuilder {
     Self { field_settings }
   }
 
-  pub fn from_layout_type(field_id: &str, layout_ty: DatabaseLayout) -> Self {
-    let field_settings = FieldSettings {
-      field_id: field_id.to_string(),
-      visibility: default_visibility(layout_ty),
-    };
-    Self { field_settings }
-  }
-
   pub fn field_id(mut self, field_id: &str) -> Self {
     self.field_settings.field_id = field_id.to_string();
     self
@@ -40,3 +40,74 @@ impl FieldSettingsBuilder {
     self.field_settings
   }
 }
+
+pub struct DatabaseFieldSettingsMapBuilder {
+  pub fields: Vec<Field>,
+  pub database_layout: DatabaseLayout,
+}
+
+impl DatabaseFieldSettingsMapBuilder {
+  pub fn new(fields: Vec<Field>, database_layout: DatabaseLayout) -> Self {
+    Self {
+      fields,
+      database_layout,
+    }
+  }
+
+  pub fn from_database(database: Arc<MutexDatabase>, database_layout: DatabaseLayout) -> Self {
+    let fields = database.lock().get_fields(None);
+    Self {
+      fields,
+      database_layout,
+    }
+  }
+
+  pub fn build(self) -> FieldSettingsByFieldIdMap {
+    self
+      .fields
+      .into_iter()
+      .map(|field| {
+        let field_settings = field_settings_for_field(self.database_layout, &field);
+        (field.id, field_settings)
+      })
+      .collect::<HashMap<String, FieldSettingsMap>>()
+      .into()
+  }
+}
+
+pub fn field_settings_for_field(
+  database_layout: DatabaseLayout,
+  field: &Field,
+) -> FieldSettingsMap {
+  let visibility = if field.is_primary {
+    FieldVisibility::AlwaysShown
+  } else {
+    match database_layout {
+      DatabaseLayout::Grid => FieldVisibility::AlwaysShown,
+      DatabaseLayout::Board => FieldVisibility::HideWhenEmpty,
+      DatabaseLayout::Calendar => FieldVisibility::HideWhenEmpty,
+    }
+  };
+
+  FieldSettingsBuilder::new(&field.id)
+    .visibility(visibility)
+    .build()
+    .into()
+}
+
+pub fn default_field_settings_by_layout_map() -> HashMap<DatabaseLayout, FieldSettingsMap> {
+  let mut map = HashMap::new();
+  for layout_ty in DatabaseLayout::iter() {
+    let visibility = match layout_ty {
+      DatabaseLayout::Grid => FieldVisibility::AlwaysShown,
+      DatabaseLayout::Board => FieldVisibility::HideWhenEmpty,
+      DatabaseLayout::Calendar => FieldVisibility::HideWhenEmpty,
+    };
+    let field_settings = FieldSettingsMapBuilder::new()
+      .insert_i64_value(VISIBILITY, visibility.into())
+      .build();
+    map.insert(layout_ty, field_settings);
+  }
+
+  map
+}

frontend/rust-lib/flowy-database2/src/services/field_settings/mod.rs

@@ -1,8 +1,5 @@
 pub use entities::*;
-pub use field_settings::*;
 pub use field_settings_builder::*;
 
 mod entities;
-#[allow(clippy::module_inception)]
-mod field_settings;
 mod field_settings_builder;

frontend/rust-lib/flowy-database2/src/services/share/csv/import.rs

@@ -9,7 +9,7 @@ use flowy_error::{FlowyError, FlowyResult};
 
 use crate::entities::FieldType;
 use crate::services::field::{default_type_option_data_from_type, CELL_DATA};
-use crate::services::field_settings::default_field_settings_by_layout;
+use crate::services::field_settings::DatabaseFieldSettingsMapBuilder;
 use crate::services::share::csv::CSVFormat;
 
 #[derive(Default)]
@@ -97,6 +97,9 @@ fn database_from_fields_and_rows(
     })
     .collect::<Vec<Field>>();
 
+  let field_settings =
+    DatabaseFieldSettingsMapBuilder::new(fields.clone(), DatabaseLayout::Grid).build();
+
   let created_rows = rows
     .iter()
     .map(|cells| {
@@ -135,7 +138,7 @@ fn database_from_fields_and_rows(
     sorts: vec![],
     created_rows,
     fields,
-    field_settings: default_field_settings_by_layout(DatabaseLayout::Grid),
+    field_settings,
   }
 }
 

frontend/rust-lib/flowy-database2/src/template.rs

@@ -7,7 +7,7 @@ use crate::services::cell::{insert_select_option_cell, insert_text_cell};
 use crate::services::field::{
   FieldBuilder, SelectOption, SelectOptionColor, SingleSelectTypeOption,
 };
-use crate::services::field_settings::default_field_settings_by_layout;
+use crate::services::field_settings::DatabaseFieldSettingsMapBuilder;
 use crate::services::setting::CalendarLayoutSetting;
 
 pub fn make_default_grid(view_id: &str, name: &str) -> CreateDatabaseParams {
@@ -27,6 +27,11 @@ pub fn make_default_grid(view_id: &str, name: &str) -> CreateDatabaseParams {
     .visibility(true)
     .build();
 
+  let fields = vec![text_field, single_select, checkbox_field];
+
+  let field_settings =
+    DatabaseFieldSettingsMapBuilder::new(fields.clone(), DatabaseLayout::Grid).build();
+
   CreateDatabaseParams {
     database_id: gen_database_id(),
     view_id: view_id.to_string(),
@@ -41,8 +46,8 @@ pub fn make_default_grid(view_id: &str, name: &str) -> CreateDatabaseParams {
       CreateRowParams::new(gen_row_id()),
       CreateRowParams::new(gen_row_id()),
     ],
-    fields: vec![text_field, single_select, checkbox_field],
-    field_settings: default_field_settings_by_layout(DatabaseLayout::Grid),
+    fields,
+    field_settings,
   }
 }
 
@@ -83,6 +88,11 @@ pub fn make_default_board(view_id: &str, name: &str) -> CreateDatabaseParams {
     rows.push(row);
   }
 
+  let fields = vec![text_field, single_select];
+
+  let field_settings =
+    DatabaseFieldSettingsMapBuilder::new(fields.clone(), DatabaseLayout::Board).build();
+
   CreateDatabaseParams {
     database_id: gen_database_id(),
     view_id: view_id.to_string(),
@@ -93,8 +103,8 @@ pub fn make_default_board(view_id: &str, name: &str) -> CreateDatabaseParams {
     groups: vec![],
     sorts: vec![],
     created_rows: rows,
-    fields: vec![text_field, single_select],
-    field_settings: default_field_settings_by_layout(DatabaseLayout::Board),
+    fields,
+    field_settings,
   }
 }
 
@@ -119,6 +129,11 @@ pub fn make_default_calendar(view_id: &str, name: &str) -> CreateDatabaseParams
     .visibility(true)
     .build();
 
+  let fields = vec![text_field, date_field, multi_select_field];
+
+  let field_settings =
+    DatabaseFieldSettingsMapBuilder::new(fields.clone(), DatabaseLayout::Calendar).build();
+
   let mut layout_settings = LayoutSettings::default();
   layout_settings.insert(
     DatabaseLayout::Calendar,
@@ -135,7 +150,7 @@ pub fn make_default_calendar(view_id: &str, name: &str) -> CreateDatabaseParams
     groups: vec![],
     sorts: vec![],
     created_rows: vec![],
-    fields: vec![text_field, date_field, multi_select_field],
-    field_settings: default_field_settings_by_layout(DatabaseLayout::Calendar),
+    fields,
+    field_settings,
   }
 }