graph: Create an explicit IdType for entity ids

Author: lutter

graph/src/data/store/mod.rs

@@ -172,6 +172,13 @@ impl ValueType {
     }
 }
 
+/// The types that can be used for the `id` of an entity
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
+pub enum IdType {
+    String,
+    Bytes,
+}
+
 // Note: Do not modify fields without also making a backward compatible change to the StableHash impl (below)
 /// An attribute value is represented as an enum with variants for all supported value types.
 #[derive(Clone, Deserialize, Serialize, PartialEq, Eq)]

graph/src/schema/input_schema.rs

@@ -2,7 +2,7 @@ use std::collections::{BTreeMap, HashSet};
 use std::str::FromStr;
 use std::sync::Arc;
 
-use anyhow::{anyhow, Error};
+use anyhow::{anyhow, Context, Error};
 use store::Entity;
 
 use crate::cheap_clone::CheapClone;
@@ -182,41 +182,44 @@ impl InputSchema {
         }
     }
 
-    /// Construct a value for the entity type's id attribute
-    pub fn id_value(&self, key: &EntityKey) -> Result<store::Value, Error> {
+    pub fn id_type(&self, entity_type: &EntityType) -> Result<store::IdType, Error> {
         let base_type = self
             .inner
             .schema
             .document
-            .get_object_type_definition(key.entity_type.as_str())
-            .ok_or_else(|| {
-                anyhow!(
-                    "Entity {}[{}]: unknown entity type `{}`",
-                    key.entity_type,
-                    key.entity_id,
-                    key.entity_type
-                )
-            })?
+            .get_object_type_definition(entity_type.as_str())
+            .ok_or_else(|| anyhow!("unknown entity type `{}`", entity_type))?
             .field("id")
             .unwrap()
             .field_type
             .get_base_type();
 
         match base_type {
-            "ID" | "String" => Ok(store::Value::String(key.entity_id.to_string())),
-            "Bytes" => Ok(store::Value::Bytes(scalar::Bytes::from_str(
-                &key.entity_id,
-            )?)),
+            "ID" | "String" => Ok(store::IdType::String),
+            "Bytes" => Ok(store::IdType::Bytes),
             s => {
                 return Err(anyhow!(
                     "Entity type {} uses illegal type {} for id column",
-                    key.entity_type,
+                    entity_type,
                     s
                 ))
             }
         }
     }
 
+    /// Construct a value for the entity type's id attribute
+    pub fn id_value(&self, key: &EntityKey) -> Result<store::Value, Error> {
+        let id_type = self
+            .id_type(&key.entity_type)
+            .with_context(|| format!("error determining id_type for {:?}", key))?;
+        match id_type {
+            store::IdType::String => Ok(store::Value::String(key.entity_id.to_string())),
+            store::IdType::Bytes => Ok(store::Value::Bytes(scalar::Bytes::from_str(
+                &key.entity_id,
+            )?)),
+        }
+    }
+
     pub fn is_immutable(&self, entity_type: &EntityType) -> bool {
         self.inner.immutable_types.contains(entity_type)
     }