intro: Simplify field creation (#3462)

prisma · Dec 2, 2022 · a35ef59 · a35ef59
1 parent 8f4ecb5
commit a35ef59
Show file tree

Hide file tree

Showing 11 changed files with 190 additions and 235 deletions.
diff --git a/...ction-engine/connectors/sql-introspection-connector/src/introspection/inline_relations.rs b/...ction-engine/connectors/sql-introspection-connector/src/introspection/inline_relations.rs
@@ -61,10 +61,11 @@ fn calculate_relation_field<'a>(
     let referenced_model_name = input.table_prisma_name(foreign_key.referenced_table().id).prisma_name();
 
     let mut relation = render::Relation::new();
-    let mut field = if foreign_key.constrained_columns().any(|c| !c.arity().is_required()) {
-        render::ModelField::new_optional(field_name, referenced_model_name)
-    } else {
-        render::ModelField::new_required(field_name, referenced_model_name)
+
+    let mut field = render::ModelField::new(field_name, referenced_model_name);
+
+    if foreign_key.constrained_columns().any(|c| !c.arity().is_required()) {
+        field.optional();
     };
 
     let any_field_required = foreign_key.constrained_columns().any(|c| c.arity().is_required());
@@ -153,11 +154,13 @@ fn calculate_backrelation_field<'a>(
         });
 
     let model_a_name = input.table_prisma_name(fk.table().id).prisma_name();
-    let mut field = if forward_relation_field_is_unique {
+    let mut field = render::ModelField::new(field_name, model_a_name);
+
+    if forward_relation_field_is_unique {
         // 1:1 relation
-        render::ModelField::new_optional(field_name, model_a_name)
+        field.optional();
     } else {
-        render::ModelField::new_array(field_name, model_a_name)
+        field.array();
     };
 
     if !relation_name.is_empty() {

diff --git a/...spection-engine/connectors/sql-introspection-connector/src/introspection/m2m_relations.rs b/...spection-engine/connectors/sql-introspection-connector/src/introspection/m2m_relations.rs
@@ -58,7 +58,8 @@ fn calculate_many_to_many_field<'a>(
 ) {
     let opposite_model_name = input.table_prisma_name(other_fk.referenced_table().id).prisma_name();
 
-    let mut field = datamodel_renderer::datamodel::ModelField::new_array(field_name, opposite_model_name);
+    let mut field = datamodel_renderer::datamodel::ModelField::new(field_name, opposite_model_name);
+    field.array();
 
     if !relation_name.is_empty() {
         let mut relation = datamodel_renderer::datamodel::Relation::new();

diff --git a/...n-engine/connectors/sql-introspection-connector/src/introspection/prisma_relation_mode.rs b/...n-engine/connectors/sql-introspection-connector/src/introspection/prisma_relation_mode.rs
@@ -37,10 +37,12 @@ pub(super) fn render<'a>(input: InputContext<'a>, output: &mut OutputContext<'a>
         }
 
         for rf in fields {
-            let mut field = match rf.ast_field().arity {
-                ast::FieldArity::Required => render::ModelField::new_required(rf.name(), rf.related_model().name()),
-                ast::FieldArity::Optional => render::ModelField::new_optional(rf.name(), rf.related_model().name()),
-                ast::FieldArity::List => render::ModelField::new_array(rf.name(), rf.related_model().name()),
+            let mut field = render::ModelField::new(rf.name(), rf.related_model().name());
+
+            match rf.ast_field().arity {
+                ast::FieldArity::Required => (),
+                ast::FieldArity::Optional => field.optional(),
+                ast::FieldArity::List => field.array(),
             };
 
             if rf.relation_attribute().is_some() {

diff --git a/...ospection-engine/connectors/sql-introspection-connector/src/introspection/scalar_field.rs b/...ospection-engine/connectors/sql-introspection-connector/src/introspection/scalar_field.rs
@@ -3,20 +3,17 @@ use datamodel_renderer::datamodel as renderer;
 use sql_schema_describer::ColumnArity;
 
 pub(crate) fn render<'a>(field: ScalarFieldPair<'a>, output: &mut OutputContext<'a>) -> renderer::ModelField<'a> {
-    let mut rendered = match field.arity() {
-        ColumnArity::Required if field.is_unsupported() => {
-            renderer::ModelField::new_required_unsupported(field.name(), field.prisma_type())
-        }
-        ColumnArity::Nullable if field.is_unsupported() => {
-            renderer::ModelField::new_optional_unsupported(field.name(), field.prisma_type())
-        }
-        ColumnArity::List if field.is_unsupported() => {
-            renderer::ModelField::new_array_unsupported(field.name(), field.prisma_type())
-        }
-        ColumnArity::Required => renderer::ModelField::new_required(field.name(), field.prisma_type()),
-        ColumnArity::Nullable => renderer::ModelField::new_optional(field.name(), field.prisma_type()),
-        ColumnArity::List => renderer::ModelField::new_array(field.name(), field.prisma_type()),
-    };
+    let mut rendered = renderer::ModelField::new(field.name(), field.prisma_type());
+
+    match field.arity() {
+        ColumnArity::Nullable => rendered.optional(),
+        ColumnArity::List => rendered.array(),
+        ColumnArity::Required => (),
+    }
+
+    if field.is_unsupported() {
+        rendered.unsupported();
+    }
 
     if let Some(map) = field.mapped_name() {
         rendered.map(map);

diff --git a/introspection-engine/datamodel-renderer/src/datamodel.rs b/introspection-engine/datamodel-renderer/src/datamodel.rs
@@ -121,14 +121,14 @@ mod tests {
         let mut data_model = Datamodel::new();
 
         let mut composite = CompositeType::new("Address");
-        let field = CompositeTypeField::new_required("street", "String");
+        let field = CompositeTypeField::new("street", "String");
         composite.push_field(field);
 
         data_model.push_composite_type(composite);
 
         let mut model = Model::new("User");
 
-        let mut field = ModelField::new_required("id", "Int");
+        let mut field = ModelField::new("id", "Int");
         field.id(IdFieldDefinition::default());
 
         let dv = DefaultValue::function(Function::new("autoincrement"));

diff --git a/introspection-engine/datamodel-renderer/src/datamodel/composite_type.rs b/introspection-engine/datamodel-renderer/src/datamodel/composite_type.rs
@@ -99,27 +99,29 @@ mod tests {
         let mut composite_type = CompositeType::new("Address");
         composite_type.documentation("...so many tears 🎵");
 
-        let mut field = CompositeTypeField::new_required("Street", "String");
+        let mut field = CompositeTypeField::new("Street", "String");
         field.native_type("db", "VarChar", vec!["255".into()]);
         field.default(DefaultValue::text("Prenzlauer Allee 193"));
         field.map("Shield");
         composite_type.push_field(field);
 
-        let field = CompositeTypeField::new_required("Number", "Int");
+        let field = CompositeTypeField::new("Number", "Int");
         composite_type.push_field(field);
 
-        let mut field = CompositeTypeField::new_optional("City", "String");
+        let mut field = CompositeTypeField::new("City", "String");
+        field.optional();
         field.documentation("...soooooooo many tears 🎵");
         composite_type.push_field(field);
 
-        let field = CompositeTypeField::new_array("Other", "String");
+        let mut field = CompositeTypeField::new("Other", "String");
+        field.array();
         composite_type.push_field(field);
 
-        let mut field = CompositeTypeField::new_required("Invalid", "Float");
+        let mut field = CompositeTypeField::new("Invalid", "Float");
         field.map("1Invalid");
         composite_type.push_field(field);
 
-        let mut field = CompositeTypeField::new_required("11111", "Float");
+        let mut field = CompositeTypeField::new("11111", "Float");
         field.commented_out();
         field.map("11111");
         composite_type.push_field(field);

diff --git a/introspection-engine/datamodel-renderer/src/datamodel/composite_type/field.rs b/introspection-engine/datamodel-renderer/src/datamodel/composite_type/field.rs
@@ -29,73 +29,54 @@ impl<'a> CompositeTypeField<'a> {
     /// //^^^^^^ name
     /// }
     /// ```
-    pub fn new_required(name: impl Into<Cow<'a, str>>, type_name: impl Into<Cow<'a, str>>) -> Self {
-        Self::new(name.into(), FieldType::required(type_name))
+    pub fn new(name: impl Into<Cow<'a, str>>, type_name: impl Into<Cow<'a, str>>) -> Self {
+        let (name, map, commented_out) = (Constant::new_no_validate(name.into()), None, false);
+
+        Self {
+            name,
+            r#type: FieldType::required(type_name),
+            map,
+            default: None,
+            native_type: None,
+            documentation: None,
+            commented_out,
+        }
     }
 
-    /// Create a new optional composite field declaration.
+    /// Sets the field as optional.
     ///
     /// ```ignore
     /// type Address {
     ///   street String?
-    /// //       ^^^^^^ type_name
-    /// //^^^^^^ name
+    /// //             ^ this
     /// }
     /// ```
-    pub fn new_optional(name: impl Into<Cow<'a, str>>, type_name: impl Into<Cow<'a, str>>) -> Self {
-        Self::new(name.into(), FieldType::optional(type_name))
+    pub fn optional(&mut self) {
+        self.r#type.into_optional();
     }
 
-    /// Create a new array composite field declaration.
+    /// Sets the field to be an array.
     ///
     /// ```ignore
     /// type Address {
     ///   street String[]
-    /// //       ^^^^^^ type_name
-    /// //^^^^^^ name
+    /// //             ^^ this
     /// }
     /// ```
-    pub fn new_array(name: impl Into<Cow<'a, str>>, type_name: impl Into<Cow<'a, str>>) -> Self {
-        Self::new(name.into(), FieldType::array(type_name))
+    pub fn array(&mut self) {
+        self.r#type.into_array();
     }
 
-    /// Create a new required unsupported composite field declaration.
+    /// Sets the field to be unsupported.
     ///
     /// ```ignore
     /// type Address {
     ///   street Unsupported("foo")
-    /// //                    ^^^ type_name
-    /// //^^^^^^ name
-    /// }
-    /// ```
-    pub fn new_required_unsupported(name: impl Into<Cow<'a, str>>, type_name: impl Into<Cow<'a, str>>) -> Self {
-        Self::new(name.into(), FieldType::required_unsupported(type_name.into()))
-    }
-
-    /// Create a new optional unsupported composite field declaration.
-    ///
-    /// ```ignore
-    /// type Address {
-    ///   street Unsupported("foo")?
-    /// //                    ^^^ type_name
-    /// //^^^^^^ name
+    /// //       ^^^^^^^^^^^^^^^^^^ this
     /// }
     /// ```
-    pub fn new_optional_unsupported(name: impl Into<Cow<'a, str>>, type_name: impl Into<Cow<'a, str>>) -> Self {
-        Self::new(name.into(), FieldType::optional_unsupported(type_name))
-    }
-
-    /// Create a new array unsupported composite field declaration.
-    ///
-    /// ```ignore
-    /// type Address {
-    ///   street Unsupported("foo")[]
-    /// //                    ^^^ type_name
-    /// //^^^^^^ name
-    /// }
-    /// ```
-    pub fn new_array_unsupported(name: impl Into<Cow<'a, str>>, type_name: impl Into<Cow<'a, str>>) -> Self {
-        Self::new(name.into(), FieldType::array_unsupported(type_name))
+    pub fn unsupported(&mut self) {
+        self.r#type.into_unsupported();
     }
 
     /// Sets the field map attribute.
@@ -180,20 +161,17 @@ impl<'a> CompositeTypeField<'a> {
         };
         let field_name = dml_field.name.clone();
 
-        let mut field = match dml_field.arity {
-            dml::FieldArity::Required if dml_field.r#type.is_unsupported() => {
-                CompositeTypeField::new_required_unsupported(field_name, r#type)
-            }
-            dml::FieldArity::Optional if dml_field.r#type.is_unsupported() => {
-                CompositeTypeField::new_optional_unsupported(field_name, r#type)
-            }
-            dml::FieldArity::List if dml_field.r#type.is_unsupported() => {
-                CompositeTypeField::new_array_unsupported(field_name, r#type)
-            }
-            dml::FieldArity::Required => CompositeTypeField::new_required(field_name, r#type),
-            dml::FieldArity::Optional => CompositeTypeField::new_optional(field_name, r#type),
-            dml::FieldArity::List => CompositeTypeField::new_array(field_name, r#type),
-        };
+        let mut field = CompositeTypeField::new(field_name, r#type);
+
+        match dml_field.arity {
+            dml::FieldArity::Optional => field.optional(),
+            dml::FieldArity::List => field.array(),
+            dml::FieldArity::Required => (),
+        }
+
+        if dml_field.r#type.is_unsupported() {
+            field.unsupported();
+        }
 
         if let Some(ref docs) = dml_field.documentation {
             field.documentation(docs.clone());
@@ -217,20 +195,6 @@ impl<'a> CompositeTypeField<'a> {
 
         field
     }
-
-    fn new(name: Cow<'a, str>, r#type: FieldType<'a>) -> Self {
-        let (name, map, commented_out) = (Constant::new_no_validate(name), None, false);
-
-        Self {
-            name,
-            r#type,
-            map,
-            default: None,
-            native_type: None,
-            documentation: None,
-            commented_out,
-        }
-    }
 }
 
 impl<'a> fmt::Display for CompositeTypeField<'a> {