Separate Introspection warnings to its own module (#3633)

introspection-engine/connectors/mongodb-introspection-connector/src/lib.rs

@@ -41,7 +41,7 @@ impl MongoDbIntrospectionConnector {
 
             ConnectorError {
                 user_facing_error: Some(known),
-                kind: introspection_connector::ErrorKind::InvalidDatabaseUrl(format!("{} in database URL", err)),
+                kind: introspection_connector::ErrorKind::InvalidDatabaseUrl(format!("{err} in database URL")),
             }
         };
 

introspection-engine/connectors/mongodb-introspection-connector/src/sampler/field_type.rs

@@ -115,8 +115,8 @@ impl fmt::Display for FieldType {
             FieldType::Int64 => f.write_str("BigInt"),
             FieldType::Json => f.write_str("Json"),
             FieldType::Document(s) => f.write_str(s),
-            FieldType::Array(r#type) => write!(f, "Array({})", r#type),
-            FieldType::Unsupported(r#type) => write!(f, "{}", r#type),
+            FieldType::Array(r#type) => write!(f, "Array({type})"),
+            FieldType::Unsupported(r#type) => write!(f, "{type}"),
         }
     }
 }

introspection-engine/connectors/mongodb-introspection-connector/src/sampler/statistics.rs

@@ -56,15 +56,12 @@ impl<'a> Statistics<'a> {
     /// - if model is foo and field is bar, the type is FooBar
     /// - if a model already exists with the name, we'll use FooBar_
     fn composite_type_name(&self, model: &str, field: &str) -> Name {
-        let combined: String = format!("{}_{}", model, field)
-            .chars()
-            .filter(|c| c.is_ascii())
-            .collect();
+        let combined: String = format!("{model}_{field}").chars().filter(|c| c.is_ascii()).collect();
 
         let name = Name::Model(combined.to_case(Case::Pascal));
 
         let name = if self.models.contains_key(&name) {
-            format!("{}_", name)
+            format!("{name}_")
         } else {
             name.take()
         };
@@ -568,7 +565,7 @@ impl fmt::Display for FieldPercentages {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         for (i, (k, v)) in self.data.iter().enumerate() {
             let p = (*v * 1000.0).round() / 10.0;
-            write!(f, "{}: {}%", k, p)?;
+            write!(f, "{k}: {p}%")?;
 
             if i < self.data.keys().count() - 1 {
                 write!(f, ", ")?;

introspection-engine/connectors/mongodb-introspection-connector/tests/test_api/mod.rs

@@ -90,7 +90,7 @@ where
 
     let features = preview_features
         .iter()
-        .map(|f| format!("\"{}\"", f))
+        .map(|f| format!("\"{f}\""))
         .collect::<Vec<_>>()
         .join(", ");
 

introspection-engine/connectors/sql-introspection-connector/src/datamodel_calculator.rs

@@ -2,45 +2,24 @@
 
 mod context;
 
-use crate::{rendering, warnings, SqlFamilyTrait, SqlIntrospectionResult};
-pub(crate) use context::{InputContext, OutputContext};
+use crate::{rendering, warnings, SqlIntrospectionResult};
+pub(crate) use context::DatamodelCalculatorContext;
 use introspection_connector::{IntrospectionContext, IntrospectionResult, Version};
 
 use sql_schema_describer as sql;
 
 /// Calculate a data model from a database schema.
 pub fn calculate(schema: &sql::SqlSchema, ctx: &IntrospectionContext) -> SqlIntrospectionResult<IntrospectionResult> {
-    let introspection_map = Default::default();
+    let ctx = DatamodelCalculatorContext::new(ctx, schema);
 
-    let mut input = InputContext {
-        version: Version::NonPrisma,
-        config: ctx.configuration(),
-        render_config: ctx.render_config,
-        schema,
-        sql_family: ctx.sql_family(),
-        previous_schema: ctx.previous_schema(),
-        introspection_map: &introspection_map,
-        force_namespaces: ctx.namespaces(),
-    };
-
-    let introspection_map = crate::introspection_map::IntrospectionMap::new(input);
-    input.introspection_map = &introspection_map;
-
-    let mut output = OutputContext {
-        rendered_schema: datamodel_renderer::Datamodel::default(),
-        warnings: warnings::Warnings::new(),
-    };
-
-    input.version = crate::version_checker::check_prisma_version(&input);
-
-    let (schema_string, is_empty) = rendering::to_psl_string(input, &mut output)?;
-    let warnings = output.finalize_warnings();
+    let (schema_string, is_empty) = rendering::to_psl_string(&ctx)?;
+    let warnings = warnings::generate(&ctx);
 
     // Warning codes 5 and 6 are for Prisma 1 default reintrospection.
     let version = if warnings.iter().any(|w| ![5, 6].contains(&w.code)) {
         Version::NonPrisma
     } else {
-        input.version
+        ctx.version
     };
 
     Ok(IntrospectionResult {