Temp

Author: BrynCooke

crates/apollo-smith/src/next/ast/mod.rs

@@ -1,4 +1,6 @@
-use apollo_compiler::ast::{FieldDefinition, InterfaceTypeDefinition, ObjectTypeDefinition};
+use apollo_compiler::ast::{
+    Definition, FieldDefinition, InterfaceTypeDefinition, ObjectTypeDefinition,
+};
 use apollo_compiler::Node;
 
 pub(crate) mod definition;
@@ -69,12 +71,12 @@ macro_rules! field_access {
 field_access!(ObjectTypeDefinition);
 field_access!(InterfaceTypeDefinition);
 
-pub(crate) trait HasFields {
+pub(crate) trait DefinitionHasFields {
     fn fields(&self) -> &Vec<Node<FieldDefinition>>;
     fn fields_mut(&mut self) -> &mut Vec<Node<FieldDefinition>>;
 }
 
-impl HasFields for ObjectTypeDefinition {
+impl DefinitionHasFields for ObjectTypeDefinition {
     fn fields(&self) -> &Vec<Node<FieldDefinition>> {
         &self.fields
     }
@@ -84,7 +86,7 @@ impl HasFields for ObjectTypeDefinition {
     }
 }
 
-impl HasFields for InterfaceTypeDefinition {
+impl DefinitionHasFields for InterfaceTypeDefinition {
     fn fields(&self) -> &Vec<Node<FieldDefinition>> {
         &self.fields
     }
@@ -93,3 +95,22 @@ impl HasFields for InterfaceTypeDefinition {
         &mut self.fields
     }
 }
+
+impl DefinitionHasFields for Definition {
+    fn fields(&self) -> &Vec<Node<FieldDefinition>> {
+        static EMPTY: Vec<Node<FieldDefinition>> = Vec::new();
+        match self {
+            Definition::ObjectTypeDefinition(d) => &d.fields,
+            Definition::InterfaceTypeDefinition(d) => &d.fields,
+            _ => &EMPTY,
+        }
+    }
+
+    fn fields_mut(&mut self) -> &mut Vec<Node<FieldDefinition>> {
+        match self {
+            Definition::ObjectTypeDefinition(d) => &mut d.fields,
+            Definition::InterfaceTypeDefinition(d) => &mut d.fields,
+            _ => panic!("fields_mut cannot be called on a definition that has no fields"),
+        }
+    }
+}

crates/apollo-smith/src/next/schema/mod.rs

@@ -1,5 +1,7 @@
-use crate::next::ast::HasFields;
-use apollo_compiler::schema::{Component, InterfaceType, ObjectType};
+use apollo_compiler::ast::{FieldDefinition, Name};
+use apollo_compiler::schema::{Component, ExtendedType, InterfaceType, ObjectType};
+use apollo_compiler::Node;
+use indexmap::IndexMap;
 
 pub(crate) mod extended_type;
 
@@ -68,24 +70,34 @@ macro_rules! field_access {
 field_access!(ObjectType);
 field_access!(InterfaceType);
 
-impl HasFields for Component<ObjectType> {
-    fn fields(
-        &self,
-    ) -> &std::collections::HashMap<
-        String,
-        apollo_compiler::schema::Component<apollo_compiler::ast::FieldDefinition>,
-    > {
+pub(crate) trait TypeHasFields {
+    fn fields(&self) -> &IndexMap<Name, Component<FieldDefinition>>;
+    fn random_field(&self, u:) -> Option<&Node<FieldDefinition>> {
+        let mut fields = self.fields().values().collect::<Vec<_>>();
+        fields.c()
+    }
+
+}
+
+impl TypeHasFields for ObjectType {
+    fn fields(&self) -> &IndexMap<Name, Component<FieldDefinition>> {
         &self.fields
     }
 }
 
-impl HasFields for InterfaceType {
-    fn fields(
-        &self,
-    ) -> &std::collections::HashMap<
-        String,
-        apollo_compiler::schema::Component<apollo_compiler::ast::FieldDefinition>,
-    > {
+impl TypeHasFields for InterfaceType {
+    fn fields(&self) -> &IndexMap<Name, Component<FieldDefinition>> {
         &self.fields
     }
 }
+
+impl TypeHasFields for ExtendedType {
+    fn fields(&self) -> &IndexMap<Name, Component<FieldDefinition>> {
+        static EMPTY: IndexMap<Name, Component<FieldDefinition>> = IndexMap::new();
+        match self {
+            ExtendedType::Object(t) => t.fields(),
+            ExtendedType::Interface(t) => t.fields(),
+            _ => &EMPTY,
+        }
+    }
+}

crates/apollo-smith/src/next/unstructured.rs

@@ -13,7 +13,7 @@ use apollo_compiler::schema::{ExtendedType, InterfaceType, ObjectType};
 use apollo_compiler::{Node, NodeStr, Schema};
 
 use crate::next::ast::directive_definition::DirectiveDefinitionIterExt;
-use crate::next::ast::HasFields;
+use crate::next::ast::DefinitionHasFields;
 use crate::next::schema::extended_type::{ExtendedTypeExt, ExtendedTypeKind};
 use crate::next::schema::object_type::ObjectTypeExt;
 use crate::next::schema::schema::SchemaExt;
@@ -463,7 +463,7 @@ impl Unstructured<'_> {
             name: self.unique_name(),
             ty: Node::new(ty),
             default_value: self
-                .arbitrary_optional(|u| Ok(Node::new(u.arbitrary_value(&ty, schema)?)))?,
+                .arbitrary_optional(|u| Ok(Node::new(u.arbitrary_value(schema, &ty)?)))?,
             directives: schema
                 .sample_directives(self)?
                 .into_iter()
@@ -503,7 +503,7 @@ impl Unstructured<'_> {
     fn arbitrary_selection(
         &mut self,
         schema: &Schema,
-        object_type: &dyn HasFields,
+        object_type: &dyn super::schema::TypeHasFields,
     ) -> Result<Selection> {
         if let Some(field) = object_type.random_field(self)? {
             match self.choose_index(3) {