[PM-23646] Add support for CustomFieldsCredential (#412)

Adds support for mapping CustomFieldsCredential to custom fields.

Author: Hinton

crates/bitwarden-exporters/src/cxf/api_key.rs

@@ -5,24 +5,30 @@ use crate::{cxf::editable_field::create_field, Field};
 /// Convert API key credentials to custom fields
 pub(super) fn api_key_to_fields(api_key: &ApiKeyCredential) -> Vec<Field> {
     [
-        api_key.key.as_ref().map(|key| create_field("API Key", key)),
+        api_key
+            .key
+            .as_ref()
+            .map(|key| create_field(key, Some("API Key"))),
         api_key
             .username
             .as_ref()
-            .map(|username| create_field("Username", username)),
+            .map(|username| create_field(username, Some("Username"))),
         api_key
             .key_type
             .as_ref()
-            .map(|key_type| create_field("Key Type", key_type)),
-        api_key.url.as_ref().map(|url| create_field("URL", url)),
+            .map(|key_type| create_field(key_type, Some("Key Type"))),
+        api_key
+            .url
+            .as_ref()
+            .map(|url| create_field(url, Some("URL"))),
         api_key
             .valid_from
             .as_ref()
-            .map(|valid_from| create_field("Valid From", valid_from)),
+            .map(|valid_from| create_field(valid_from, Some("Valid From"))),
         api_key
             .expiry_date
             .as_ref()
-            .map(|expiry_date| create_field("Expiry Date", expiry_date)),
+            .map(|expiry_date| create_field(expiry_date, Some("Expiry Date"))),
     ]
     .into_iter()
     .flatten()

crates/bitwarden-exporters/src/cxf/card.rs

@@ -61,11 +61,14 @@ pub(super) fn to_card(credential: &CreditCardCredential) -> (Card, Vec<Field>) {
     let card = credential.into();
 
     let fields = [
-        credential.pin.as_ref().map(|v| create_field("PIN", v)),
+        credential
+            .pin
+            .as_ref()
+            .map(|v| create_field(v, Some("PIN"))),
         credential
             .valid_from
             .as_ref()
-            .map(|v| create_field("Valid From", v)),
+            .map(|v| create_field(v, Some("Valid From"))),
     ]
     .into_iter()
     .flatten()

crates/bitwarden-exporters/src/cxf/editable_field.rs

@@ -8,82 +8,105 @@ use credential_exchange_format::{
 use crate::Field;
 
 /// Helper function to create a Field from any EditableField type
-pub(super) fn create_field<T>(name: impl Into<String>, field: &T) -> Field
+pub(super) fn create_field<T>(field: &T, overridden_name: Option<impl Into<String>>) -> Field
 where
     T: EditableFieldToField,
 {
+    let field_name = overridden_name
+        .map(Into::into)
+        .or_else(|| field.label().clone());
+
     Field {
-        name: Some(name.into()),
+        name: field_name,
         value: Some(field.field_value()),
         r#type: T::FIELD_TYPE as u8,
         linked_id: None,
     }
 }
 
-/// Trait to convert CXP EditableField types to Bitwarden Field values and types
-pub(super) trait EditableFieldToField {
+/// Trait to define field type and value conversion for inner field types
+pub(super) trait InnerFieldType {
     const FIELD_TYPE: FieldType;
 
-    fn field_value(&self) -> String;
+    fn to_field_value(&self) -> String;
 }
 
-impl EditableFieldToField for EditableField<EditableFieldString> {
+impl InnerFieldType for EditableFieldString {
     const FIELD_TYPE: FieldType = FieldType::Text;
 
-    fn field_value(&self) -> String {
-        self.value.0.clone()
+    fn to_field_value(&self) -> String {
+        self.0.clone()
     }
 }
 
-impl EditableFieldToField for EditableField<EditableFieldConcealedString> {
+impl InnerFieldType for EditableFieldConcealedString {
     const FIELD_TYPE: FieldType = FieldType::Hidden;
 
-    fn field_value(&self) -> String {
-        self.value.0.clone()
+    fn to_field_value(&self) -> String {
+        self.0.clone()
     }
 }
 
-impl EditableFieldToField for EditableField<EditableFieldBoolean> {
+impl InnerFieldType for EditableFieldBoolean {
     const FIELD_TYPE: FieldType = FieldType::Boolean;
 
-    fn field_value(&self) -> String {
-        self.value.0.to_string()
+    fn to_field_value(&self) -> String {
+        self.0.to_string()
     }
 }
 
-impl EditableFieldToField for EditableField<EditableFieldWifiNetworkSecurityType> {
+impl InnerFieldType for EditableFieldWifiNetworkSecurityType {
     const FIELD_TYPE: FieldType = FieldType::Text;
 
-    fn field_value(&self) -> String {
-        security_type_to_string(&self.value).to_string()
+    fn to_field_value(&self) -> String {
+        security_type_to_string(self).to_string()
     }
 }
 
-impl EditableFieldToField for EditableField<EditableFieldCountryCode> {
+impl InnerFieldType for EditableFieldCountryCode {
     const FIELD_TYPE: FieldType = FieldType::Text;
 
-    fn field_value(&self) -> String {
-        self.value.0.clone()
+    fn to_field_value(&self) -> String {
+        self.0.clone()
     }
 }
 
-impl EditableFieldToField for EditableField<EditableFieldDate> {
+impl InnerFieldType for EditableFieldDate {
     const FIELD_TYPE: FieldType = FieldType::Text;
 
-    fn field_value(&self) -> String {
-        self.value.0.to_string()
+    fn to_field_value(&self) -> String {
+        self.0.to_string()
     }
 }
 
-impl EditableFieldToField for EditableField<EditableFieldYearMonth> {
+impl InnerFieldType for EditableFieldYearMonth {
     const FIELD_TYPE: FieldType = FieldType::Text;
 
+    fn to_field_value(&self) -> String {
+        format!("{:04}-{:02}", self.year, self.month.number_from_month())
+    }
+}
+
+/// Trait to convert CXP EditableField types to Bitwarden Field values and types
+pub(super) trait EditableFieldToField {
+    const FIELD_TYPE: FieldType;
+
+    fn field_value(&self) -> String;
+    fn label(&self) -> &Option<String>;
+}
+
+impl<T> EditableFieldToField for EditableField<T>
+where
+    T: InnerFieldType,
+{
+    const FIELD_TYPE: FieldType = T::FIELD_TYPE;
+
     fn field_value(&self) -> String {
-        format!(
-            "{:04}-{:02}",
-            self.value.year,
-            self.value.month.number_from_month()
-        )
+        self.value.to_field_value()
+    }
+
+    fn label(&self) -> &Option<String> {
+        &self.label
     }
 }
 
@@ -114,7 +137,7 @@ mod tests {
             extensions: None,
         };
 
-        let field = create_field("Test Name", &editable_field);
+        let field = create_field(&editable_field, Some("Test Name"));
 
         assert_eq!(
             field,
@@ -136,7 +159,7 @@ mod tests {
             extensions: None,
         };
 
-        let field = create_field("Password", &editable_field);
+        let field = create_field(&editable_field, Some("Password"));
 
         assert_eq!(
             field,
@@ -158,7 +181,7 @@ mod tests {
             extensions: None,
         };
 
-        let field = create_field("Is Enabled", &editable_field);
+        let field = create_field(&editable_field, Some("Is Enabled"));
 
         assert_eq!(
             field,
@@ -180,7 +203,7 @@ mod tests {
             extensions: None,
         };
 
-        let field = create_field("Is Hidden", &editable_field);
+        let field = create_field(&editable_field, Some("Is Hidden"));
 
         assert_eq!(
             field,
@@ -202,7 +225,7 @@ mod tests {
             extensions: None,
         };
 
-        let field = create_field("WiFi Security", &editable_field);
+        let field = create_field(&editable_field, Some("WiFi Security"));
 
         assert_eq!(
             field,
@@ -258,7 +281,7 @@ mod tests {
             extensions: None,
         };
 
-        let field = create_field("Expiry Date".to_string(), &editable_field);
+        let field = create_field(&editable_field, Some("Expiry Date".to_string()));
 
         assert_eq!(
             field,
@@ -285,7 +308,7 @@ mod tests {
             extensions: None,
         };
 
-        let field = create_field("Card Expiry", &editable_field);
+        let field = create_field(&editable_field, Some("Card Expiry"));
 
         assert_eq!(
             field,
@@ -297,4 +320,48 @@ mod tests {
             }
         );
     }
+
+    #[test]
+    fn test_create_field_with_none_name_uses_label() {
+        let editable_field = EditableField {
+            id: None,
+            label: Some("Label From Field".to_string()),
+            value: EditableFieldString("Test Value".to_string()),
+            extensions: None,
+        };
+
+        let field = create_field(&editable_field, None::<String>);
+
+        assert_eq!(
+            field,
+            Field {
+                name: Some("Label From Field".to_string()),
+                value: Some("Test Value".to_string()),
+                r#type: FieldType::Text as u8,
+                linked_id: None,
+            }
+        );
+    }
+
+    #[test]
+    fn test_create_field_with_none_name_and_none_label() {
+        let editable_field = EditableField {
+            id: None,
+            label: None,
+            value: EditableFieldString("Test Value".to_string()),
+            extensions: None,
+        };
+
+        let field = create_field(&editable_field, None::<String>);
+
+        assert_eq!(
+            field,
+            Field {
+                name: None,
+                value: Some("Test Value".to_string()),
+                r#type: FieldType::Text as u8,
+                linked_id: None,
+            }
+        );
+    }
 }