store: Abstract to_entity as deserialize_with_layout

Author: leoyvens

store/postgres/src/relational.rs

@@ -496,7 +496,7 @@ impl Layout {
         FindQuery::new(table.as_ref(), id, block)
             .get_result::<EntityData>(conn)
             .optional()?
-            .map(|entity_data| entity_data.to_entity(self))
+            .map(|entity_data| entity_data.deserialize_with_layout(self))
             .transpose()
     }
 
@@ -521,7 +521,7 @@ impl Layout {
             entities_for_type
                 .entry(data.entity_type())
                 .or_default()
-                .push(data.to_entity(self)?);
+                .push(data.deserialize_with_layout(self)?);
         }
         Ok(entities_for_type)
     }
@@ -619,7 +619,11 @@ impl Layout {
         log_query_timing(logger, &query_clone, start.elapsed(), values.len());
         values
             .into_iter()
-            .map(|entity_data| entity_data.to_entity(self).map_err(|e| e.into()))
+            .map(|entity_data| {
+                entity_data
+                    .deserialize_with_layout(self)
+                    .map_err(|e| e.into())
+            })
             .collect()
     }
 

store/postgres/src/relational_queries.rs

@@ -171,14 +171,40 @@ impl ForeignKeyClauses for Column {
     }
 }
 
-trait FromColumnValue: Sized {
+pub trait FromEntityData: Default {
+    type Value: FromColumnValue;
+
+    fn insert_entity_data(&mut self, key: String, v: Self::Value);
+}
+
+impl FromEntityData for Entity {
+    type Value = graph::prelude::Value;
+
+    fn insert_entity_data(&mut self, key: String, v: Self::Value) {
+        self.insert(key, v);
+    }
+}
+
+pub trait FromColumnValue: Sized {
+    fn is_null(&self) -> bool;
+
+    fn from_string(s: String) -> Self;
+
     fn from_column_value(
         column_type: &ColumnType,
         json: serde_json::Value,
     ) -> Result<Self, StoreError>;
 }
 
 impl FromColumnValue for graph::prelude::Value {
+    fn is_null(&self) -> bool {
+        self == &Value::Null
+    }
+
+    fn from_string(s: String) -> Self {
+        Value::String(s)
+    }
+
     fn from_column_value(
         column_type: &ColumnType,
         json: serde_json::Value,
@@ -276,36 +302,33 @@ impl EntityData {
         self.entity.clone()
     }
 
-    /// Map the `EntityData` to an entity using the schema information
-    /// in `Layout`
-    pub fn to_entity(self, layout: &Layout) -> Result<Entity, StoreError> {
+    /// Map the `EntityData` using the schema information in `Layout`
+    pub fn deserialize_with_layout<T: FromEntityData>(
+        self,
+        layout: &Layout,
+    ) -> Result<T, StoreError> {
         let table = layout.table_for_entity(&self.entity)?;
 
         use serde_json::Value as j;
         match self.data {
             j::Object(map) => {
-                let mut entity = Entity::new();
-                entity.insert(
-                    "__typename".to_owned(),
-                    graph::prelude::Value::from(self.entity),
-                );
+                let mut out = T::default();
+                out.insert_entity_data("__typename".to_owned(), T::Value::from_string(self.entity));
                 for (key, json) in map {
                     // Simply ignore keys that do not have an underlying table
                     // column; those will be things like the block_range that
                     // is used internally for versioning
                     if key == "g$parent_id" {
-                        let value =
-                            graph::prelude::Value::from_column_value(&ColumnType::String, json)?;
-                        entity.insert("g$parent_id".to_owned(), value);
+                        let value = T::Value::from_column_value(&ColumnType::String, json)?;
+                        out.insert_entity_data("g$parent_id".to_owned(), value);
                     } else if let Some(column) = table.column(&SqlName::verbatim(key)) {
-                        let value =
-                            graph::prelude::Value::from_column_value(&column.column_type, json)?;
-                        if value != Value::Null {
-                            entity.insert(column.field.clone(), value);
+                        let value = T::Value::from_column_value(&column.column_type, json)?;
+                        if !value.is_null() {
+                            out.insert_entity_data(column.field.clone(), value);
                         }
                     }
                 }
-                Ok(entity)
+                Ok(out)
             }
             _ => unreachable!(
                 "we use `to_json` in our queries, and will therefore always get an object back"