feat: start work on uuid support

core/Cargo.toml

@@ -29,11 +29,11 @@ bincode = "1.3.1"
 num = { version = "0.4.0", features = [ "rand" ] }
 rand_regex = "0.15.1"
 synth-gen = { path = "../gen", features = [ "shared" ] }
-uuid = { version = "0.8.2", features = ["v4"] }
+uuid = { version = "1.2.2", features = ["v4", "serde"] }
 bimap = { version = "0.6.0", features = [ "std" ] }
 humantime-serde = "1.0.1"
 bloomfilter = "1.0.5"
 dynfmt = { version = "0.1.5", features = [ "curly" ] }
-sqlx = { version = "0.6", features = ["postgres", "mysql", "runtime-async-std-rustls", "decimal", "chrono"] }
+sqlx = { version = "0.6", features = ["postgres", "mysql", "runtime-async-std-rustls", "decimal", "chrono", "uuid"] }
 uriparse = "0.6.3"
 paste = "1.0"

core/src/compile/mod.rs

@@ -346,6 +346,15 @@ pub mod tests {
         assert!(complete(generator).unwrap().as_bool().unwrap())
     }
 
+    #[test]
+    fn compile_uuid() {
+        let generator = generator! ({
+            "type": "uuid"
+        });
+        let value = complete(generator).unwrap();
+        assert!(value.is_uuid())
+    }
+
     #[test]
     fn compile_linear() {
         let generator = generator!({

core/src/graph/json.rs

@@ -9,6 +9,7 @@ pub fn synth_val_to_json(val: Value) -> serde_json::Value {
         Value::Bool(b) => serde_json::Value::Bool(b),
         Value::Number(n) => serde_json::Value::Number(synth_num_to_json(n)),
         Value::String(s) => serde_json::Value::String(s),
+        Value::Uuid(u) => serde_json::Value::String(u.hyphenated().to_string()),
         Value::DateTime(dt) => serde_json::Value::String(dt.format_to_string()),
         Value::Object(obj) => serde_json::Value::Object(synth_obj_to_json(obj)),
         Value::Array(arr) => serde_json::Value::Array(synth_arr_to_json(arr)),

core/src/graph/mod.rs

@@ -3,6 +3,7 @@ use std::collections::BTreeMap;
 
 use anyhow::{Context, Result};
 
+use ::uuid::Uuid;
 use chrono::{DateTime, FixedOffset, NaiveDate, NaiveDateTime, NaiveTime, Utc};
 use sqlx::mysql::MySqlTypeInfo;
 use sqlx::postgres::{PgArgumentBuffer, PgTypeInfo};
@@ -23,7 +24,10 @@ pub mod null;
 pub use null::NullNode;
 
 pub mod string;
-pub use string::{Format, FormatArgs, RandFaker, RandomString, StringNode, Truncated, UuidGen};
+pub use string::{Format, FormatArgs, RandFaker, RandomString, StringNode, Truncated};
+
+pub mod uuid;
+pub use self::uuid::UuidNode;
 
 pub mod date_time;
 pub use date_time::{DateTimeNode, RandomDateTime};
@@ -161,6 +165,7 @@ derive_from! {
         Bool(bool),
         Number(Number),
         String(String),
+        Uuid(Uuid),
         DateTime(ChronoValueAndFormat),
         Object(BTreeMap<String, Value>),
         Array(Vec<Value>),
@@ -317,6 +322,7 @@ impl TryFrom<Value> for String {
             Value::String(str) => Ok(str),
             Value::Number(num) => Ok(num.to_string()),
             Value::DateTime(date) => Ok(date.format_to_string()),
+            Value::Uuid(u) => Ok(u.hyphenated().to_string()),
             otherwise => Err(failed_crate!(
                 target: Release,
                 "invalid type: expected 'String', found '{}'",
@@ -397,6 +403,7 @@ impl Value {
             Self::Object(_) => {
                 serde_json::to_string(&json::synth_val_to_json(self.clone())).unwrap()
             }
+            Self::Uuid(uid) => uid.hyphenated().to_string(),
         }
     }
 
@@ -409,6 +416,7 @@ impl Value {
         // Based on https://docs.rs/sqlx-core/0.5.9/sqlx_core/postgres/types/index.html
         while let Some(c) = current {
             let pair = match c {
+                Value::Uuid(_) => (None, "uuid"),
                 Value::Null(_) => (None, "unknown"),
                 Value::Bool(_) => (None, "bool"),
                 Value::Number(num) => match *num {
@@ -501,6 +509,7 @@ impl Encode<'_, Postgres> for Value {
                 json::synth_val_to_json(self.clone()),
                 buf,
             ),
+            Value::Uuid(u) => <Uuid as Encode<'_, Postgres>>::encode_by_ref(u, buf),
             Value::Array(_) => {
                 let s = self.to_postgres_string();
                 <String as Encode<'_, Postgres>>::encode_by_ref(&s, buf)
@@ -553,6 +562,7 @@ impl Encode<'_, MySql> for Value {
                 buf,
             ),
             Value::Array(_arr) => todo!(), //<Vec<Value> as Encode<'_, MySql>>::encode_by_ref(arr, buf), //TODO special-case for u8 arrays?
+            Value::Uuid(u) => <Uuid as Encode<'_, MySql>>::encode_by_ref(u, buf),
         }
     }
 
@@ -583,6 +593,7 @@ impl Encode<'_, MySql> for Value {
                 ChronoValue::DateTime(_) => <DateTime<Utc> as Type<MySql>>::type_info(),
             },
             Value::String(_) => <String as Type<MySql>>::type_info(),
+            Value::Uuid(_) => <Uuid as Type<MySql>>::type_info(),
             Value::Object(_) => return None, //TODO: Use JSON here?
             Value::Array(elems) => {
                 if elems.is_empty() {
@@ -623,6 +634,10 @@ impl Value {
         self.as_object().is_some()
     }
 
+    pub fn is_uuid(&self) -> bool {
+        self.as_uuid().is_some()
+    }
+
     pub fn is_array(&self) -> bool {
         self.as_array().is_some()
     }
@@ -669,6 +684,13 @@ impl Value {
         }
     }
 
+    pub fn as_uuid(&self) -> Option<&Uuid> {
+        match *self {
+            Value::Uuid(ref u) => Some(u),
+            _ => None,
+        }
+    }
+
     pub fn as_array(&self) -> Option<&Vec<Value>> {
         match *self {
             Value::Array(ref vec) => Some(vec),
@@ -714,6 +736,13 @@ impl Value {
         }
     }
 
+    pub fn as_uuid_mut(&mut self) -> Option<&mut Uuid> {
+        match *self {
+            Value::Uuid(ref mut u) => Some(u),
+            _ => None,
+        }
+    }
+
     pub fn as_array_mut(&mut self) -> Option<&mut Vec<Value>> {
         match *self {
             Value::Array(ref mut vec) => Some(vec),
@@ -777,6 +806,7 @@ derive_generator!(
         DateTime(DateTimeNode),
         Object(ObjectNode),
         Array(ArrayNode),
+        Uuid(UuidNode),
         OneOf(OneOfNode),
         Series(SeriesNode),
         Unique(UniqueNode),

core/src/graph/string/mod.rs

@@ -8,9 +8,7 @@ pub mod format;
 pub mod serialized;
 pub mod sliced;
 pub mod truncated;
-pub mod uuid;
 
-pub use self::uuid::UuidGen;
 pub use constant::Constant;
 pub use faker::{FakerArgs, Locale, RandFaker};
 pub use format::{Format, FormatArgs};
@@ -26,7 +24,6 @@ derive_generator! {
         Faker(TryOnce<RandFaker>),
         Serialized(TryOnce<Serialized>)
         Categorical(OnceInfallible<Random<String, Categorical<String>>>)
-        Uuid(OnceInfallible<UuidGen>),
         Format(Format),
         Truncated(Truncated),
         Sliced(Sliced),
@@ -58,12 +55,6 @@ impl From<Categorical<String>> for RandomString {
     }
 }
 
-impl From<UuidGen> for RandomString {
-    fn from(uuid: UuidGen) -> Self {
-        Self::Uuid(uuid.infallible().try_once())
-    }
-}
-
 impl From<Truncated> for RandomString {
     fn from(trunc: Truncated) -> Self {
         Self::Truncated(trunc)

core/src/graph/uuid.rs

@@ -0,0 +1,26 @@
+use super::prelude::*;
+use uuid::Uuid;
+
+derive_generator! {
+    yield Token,
+    return Result<Value, Error>,
+    pub struct UuidNode(Valuize<Tokenizer<RandomUuid>, Uuid>);
+}
+
+impl From<RandomUuid> for UuidNode {
+    fn from(value: RandomUuid) -> Self {
+        Self(value.into_token().map_complete(value_from_ok::<Uuid>))
+    }
+}
+
+pub struct RandomUuid {}
+
+impl Generator for RandomUuid {
+    type Yield = Token;
+    type Return = Result<Uuid, Error>;
+
+    fn next<R: Rng>(&mut self, rng: &mut R) -> GeneratorState<Self::Yield, Self::Return> {
+        let uuid = Uuid::from_u128(rng.gen());
+        GeneratorState::Complete(Ok(uuid))
+    }
+}

core/src/schema/content/mod.rs

@@ -30,7 +30,7 @@ pub use number::{number_content, NumberContent, NumberContentKind, NumberKindExt
 mod string;
 pub use string::{
     ConstantContent, FakerContent, FakerContentArgument, FormatContent, RegexContent,
-    SlicedContent, StringContent, Uuid,
+    SlicedContent, StringContent,
 };
 
 mod date_time;
@@ -44,6 +44,9 @@ pub use array::ArrayContent;
 mod object;
 pub use object::ObjectContent;
 
+mod uuid;
+pub use self::uuid::UuidContent;
+
 mod datasource;
 pub use datasource::DatasourceContent;
 
@@ -305,9 +308,10 @@ content! {
     labels: ContentLabels,
     variants: {
         Null(NullContent) => None,
+        Uuid(UuidContent) => None,
         Bool(BoolContent) => "missing a subtype. Try adding `constant`, or `frequency`",
         Number(NumberContent) => "missing a subtype. Try adding `constant`, `range`, or `id`",
-        String(StringContent) => "missing a subtype. Try adding `pattern`, `faker`, `categorical`, `serialized`, `uuid`, `truncated`, or `format`",
+        String(StringContent) => "missing a subtype. Try adding `pattern`, `faker`, `categorical`, `serialized`, `truncated`, or `format`",
         DateTime(DateTimeContent) => "missing a `format` field",
         Array(ArrayContent) => "missing a `length` and `content` field",
         Object(ObjectContent) => None,
@@ -498,6 +502,7 @@ impl Content {
 
     pub fn kind(&self) -> String {
         match self {
+            Content::Uuid(_) => "uuid".to_string(),
             Content::Null(_) => "null".to_string(),
             Content::Bool(content) => format!("bool::{}", content.kind()),
             Content::Number(content) => format!("number::{}", content.kind()),
@@ -632,6 +637,7 @@ impl Compile for Content {
             Self::Object(object_content) => object_content.compile(compiler),
             Self::Bool(bool_content) => bool_content.compile(compiler),
             Self::String(string_content) => string_content.compile(compiler),
+            Self::Uuid(uuid_content) => uuid_content.compile(compiler),
             Self::DateTime(date_time_content) => date_time_content.compile(compiler),
             Self::Number(number_content) => number_content.compile(compiler),
             Self::Array(array_content) => array_content.compile(compiler),
@@ -705,8 +711,7 @@ pub mod tests {
             "type": "object",
             "skip_when_null": true,
             "_uuid": {
-                "type": "string",
-                "uuid": {},
+                "type": "uuid",
                 "hidden": true
             },
             "user_id": {
@@ -901,7 +906,7 @@ pub mod tests {
 
     #[test]
     #[should_panic(
-        expected = "`string` generator is missing a subtype. Try adding `pattern`, `faker`, `categorical`, `serialized`, `uuid`, `truncated`, or `format`"
+        expected = "`string` generator is missing a subtype. Try adding `pattern`, `faker`, `categorical`, `serialized`, `truncated`, or `format`"
     )]
     fn string_missing_subtype() {
         let _schema: Content = schema!({

core/src/schema/content/string.rs

@@ -13,24 +13,19 @@ pub enum StringContent {
     Faker(FakerContent),
     Categorical(Categorical<String>),
     Serialized(SerializedContent),
-    Uuid(Uuid),
     Truncated(TruncatedContent),
     Sliced(SlicedContent),
     Format(FormatContent),
     Constant(ConstantContent),
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Hash)]
-pub struct Uuid;
-
 impl StringContent {
     pub fn kind(&self) -> String {
         match self {
             Self::Pattern(_) => "pattern".to_string(),
             Self::Faker(faker) => faker.kind(),
             Self::Categorical(_) => "categorical".to_string(),
             Self::Serialized(_) => "serialized".to_string(),
-            Self::Uuid(_) => "uuid".to_string(),
             Self::Truncated(_) => "truncated".to_string(),
             Self::Sliced(_) => "sliced".to_string(),
             Self::Constant(_) => "constant".to_string(),
@@ -352,7 +347,6 @@ impl Compile for StringContent {
             StringContent::Constant(ConstantContent(s)) => {
                 RandomString::from(Constant(s.into())).into()
             }
-            StringContent::Uuid(_uuid) => RandomString::from(UuidGen {}).into(),
         };
         Ok(Graph::String(string_node))
     }

core/src/schema/content/uuid.rs

@@ -0,0 +1,14 @@
+use super::prelude::*;
+use crate::graph::uuid::RandomUuid;
+
+#[derive(Default, Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Hash)]
+#[serde(rename_all = "snake_case")]
+#[serde(deny_unknown_fields)]
+pub struct UuidContent {}
+
+impl Compile for UuidContent {
+    fn compile<'a, C: Compiler<'a>>(&'a self, mut _compiler: C) -> Result<Graph> {
+        let random_uuid = RandomUuid {};
+        Ok(Graph::Uuid(random_uuid.into()))
+    }
+}

core/src/schema/inference/mod.rs

@@ -126,7 +126,6 @@ impl MergeStrategy<StringContent, String> for OptionalMergeStrategy {
             }
             StringContent::Faker(_) => Ok(()),
             StringContent::Serialized(_) => Ok(()), // we can probably do better here
-            StringContent::Uuid(_) => Ok(()),
             StringContent::Truncated(_) => Ok(()),
             StringContent::Sliced(_) => Ok(()),
             StringContent::Constant(_) => Ok(()),