Remove special case for type parameter

Author: benwebber

crates/protosearch-plugin/src/mapping.rs

@@ -2,7 +2,9 @@ use std::collections::BTreeMap;
 use std::fmt;
 
 use protobuf::MessageDyn;
-use protobuf::reflect::{ReflectFieldRef, ReflectValueRef, RuntimeType};
+use protobuf::reflect::{
+    FieldDescriptor, ReflectFieldRef, ReflectValueRef, RuntimeFieldType, RuntimeType,
+};
 use serde::Serialize;
 use serde_json::{Map, Value, json};
 
@@ -19,17 +21,10 @@ pub struct Mapping {
 #[serde(untagged)]
 pub enum Property {
     /// A simple, scalar property.
-    Leaf {
-        #[serde(rename = "type")]
-        typ: String,
-        #[serde(default, flatten)]
-        parameters: BTreeMap<String, Value>,
-    },
+    Leaf(BTreeMap<String, Value>),
     /// A sub-document mapping, i.e., an `object` or `nested` field.
     Mapping {
-        #[serde(rename = "type")]
-        typ: String,
-        #[serde(default, flatten)]
+        #[serde(flatten)]
         parameters: BTreeMap<String, Value>,
         #[serde(flatten)]
         properties: Mapping,
@@ -49,14 +44,13 @@ pub enum InferredType {
     Object,
 }
 
-impl Property {
-    pub fn from_options(options: &FieldMapping, typ: String) -> Self {
-        let mut params = other_to_json(options as &dyn MessageDyn);
-        params.remove("type");
-        Self::Leaf {
-            typ,
-            parameters: params.into_iter().collect(),
-        }
+impl From<&FieldMapping> for Property {
+    fn from(options: &FieldMapping) -> Self {
+        Self::Leaf(
+            other_to_json(options as &dyn MessageDyn)
+                .into_iter()
+                .collect(),
+        )
     }
 }
 
@@ -94,6 +88,15 @@ impl From<RuntimeType> for InferredType {
     }
 }
 
+impl From<&FieldDescriptor> for InferredType {
+    fn from(field: &FieldDescriptor) -> Self {
+        match field.runtime_field_type() {
+            RuntimeFieldType::Singular(t) | RuntimeFieldType::Repeated(t) => Self::from(t),
+            RuntimeFieldType::Map(_, _) => Self::Object,
+        }
+    }
+}
+
 fn to_json(message: &dyn MessageDyn) -> Value {
     match message.descriptor_dyn().full_name() {
         "google.protobuf.Struct" => struct_to_json(message),

crates/protosearch-plugin/src/plugin.rs

@@ -65,25 +65,19 @@ fn compile_field(ctx: &Context, field: &FieldDescriptor) -> Result<Option<(Strin
                     field: field.name().to_string(),
                     source: e,
                 })?;
-            let Value::Object(mut params) = json else {
+            let Value::Object(params) = json else {
                 return Err(Error::InvalidJsonObject(field.name().into()));
             };
-            let typ = params
-                .remove("type")
-                .and_then(|v| v.as_str().map(str::to_string))
-                .unwrap_or_default();
-            Property::Leaf {
-                typ,
-                parameters: params.into_iter().collect(),
-            }
+            Property::Leaf(params.into_iter().collect())
         }
         None => {
-            let typ = if !options.field.type_().is_empty() {
-                options.field.type_().to_string()
-            } else {
-                infer_type(field).to_string()
-            };
-            Property::from_options(&options.field, typ)
+            let mut property = Property::from(&*options.field);
+            if let Property::Leaf(ref mut parameters) = property {
+                parameters
+                    .entry("type".into())
+                    .or_insert_with(|| Value::String(InferredType::from(field).to_string()));
+            }
+            property
         }
     };
     // A mapping type, as in an object or nested field.
@@ -96,8 +90,7 @@ fn compile_field(ctx: &Context, field: &FieldDescriptor) -> Result<Option<(Strin
     .transpose()?
     .unwrap_or_default();
     let property = match (mapping.properties.is_empty(), property) {
-        (false, Property::Leaf { typ, parameters }) => Property::Mapping {
-            typ,
+        (false, Property::Leaf(parameters)) => Property::Mapping {
             parameters,
             properties: mapping,
         },
@@ -133,11 +126,3 @@ fn get_mapping_options(field: &FieldDescriptor) -> Result<Option<proto::Mapping>
     }
     Ok(if found { Some(mapping) } else { None })
 }
-
-fn infer_type(field: &FieldDescriptor) -> InferredType {
-    let rt = match field.runtime_field_type() {
-        RuntimeFieldType::Singular(t) | RuntimeFieldType::Repeated(t) => t,
-        RuntimeFieldType::Map(_, _) => return InferredType::Object,
-    };
-    InferredType::from(rt)
-}