Render composite types with the new renderer

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

@@ -53,12 +53,18 @@ pub(super) async fn sample(
     let is_empty = data_model.is_empty();
 
     let data_model = if ctx.render_config {
-        let config = render::Configuration::from_psl(ctx.configuration());
-        let datamodel = psl::render_datamodel_to_string(&data_model, Some(ctx.configuration()));
-
-        format!("{}\n{}", config, datamodel)
+        format!(
+            "{}\n{}\n{}",
+            render::Configuration::from_psl(ctx.configuration()),
+            render::Datamodel::from_dml(ctx.datasource(), &data_model),
+            psl::render_datamodel_to_string(&data_model, Some(ctx.configuration())),
+        )
     } else {
-        psl::render_datamodel_to_string(&data_model, Some(ctx.configuration()))
+        format!(
+            "{}\n{}",
+            render::Datamodel::from_dml(ctx.datasource(), &data_model),
+            psl::render_datamodel_to_string(&data_model, Some(ctx.configuration())),
+        )
     };
 
     Ok(IntrospectionResult {

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

@@ -90,7 +90,7 @@ fn remapping_composite_fields_with_numbers() {
 
     let expected = expect![[r#"
         type OuterInner {
-          // This field was commented out because of an invalid name. Please provide a valid one that matches [a-zA-Z][a-zA-Z0-9_]*
+          /// This field was commented out because of an invalid name. Please provide a valid one that matches [a-zA-Z][a-zA-Z0-9_]*
           // 1 Int @map("1")
         }
 

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

@@ -195,60 +195,16 @@ pub(crate) fn introspect(ctx: &Context, warnings: &mut Vec<Warning>) -> Result<(
         "{}\n{}\n{}",
         config,
         psl::render_datamodel_to_string(&datamodel, Some(ctx.config)),
-        render_datamodel(&datamodel),
+        render::Datamodel::from_dml(&ctx.config.datasources[0], &datamodel),
     );
 
     Ok((version, psl::reformat(&rendered, 2).unwrap(), datamodel.is_empty()))
 }
 
-/// Render all of the data model. For now, just enums. More will be
-/// added in the upcoming days.
-fn render_datamodel(dml: &Datamodel) -> render::Datamodel<'_> {
-    let mut data_model = render::Datamodel::new();
-
-    for dml_enum in dml.enums() {
-        let mut r#enum = render::Enum::new(&dml_enum.name);
-
-        if let Some(ref docs) = dml_enum.documentation {
-            r#enum.documentation(docs);
-        }
-
-        if let Some(ref schema) = dml_enum.schema {
-            r#enum.schema(schema);
-        }
-
-        if let Some(ref map) = dml_enum.database_name {
-            r#enum.map(map);
-        }
-
-        for dml_variant in dml_enum.values.iter() {
-            let mut variant = render::EnumVariant::new(&dml_variant.name);
-
-            if dml_variant.commented_out {
-                variant = variant.into_commented_out();
-            }
-
-            if let Some(ref map) = dml_variant.database_name {
-                variant.map(map);
-            }
-
-            if let Some(ref docs) = dml_variant.documentation {
-                variant.documentation(docs);
-            }
-
-            r#enum.push_variant(variant);
-        }
-
-        data_model.push_enum(r#enum);
-    }
-
-    data_model
-}
-
 fn render_configuration<'a>(config: &'a Configuration, schema: &'a SqlSchema) -> render::Configuration<'a> {
     let mut output = render::Configuration::default();
     let prev_ds = config.datasources.first().unwrap();
-    let mut datasource = render::Datasource::from_psl(prev_ds);
+    let mut datasource = render::configuration::Datasource::from_psl(prev_ds);
 
     if prev_ds.active_connector.is_provider("postgres") {
         postgres::add_extensions(&mut datasource, schema, config);
@@ -257,7 +213,7 @@ fn render_configuration<'a>(config: &'a Configuration, schema: &'a SqlSchema) ->
     output.push_datasource(datasource);
 
     for prev in config.generators.iter() {
-        output.push_generator(render::Generator::from_psl(prev));
+        output.push_generator(render::configuration::Generator::from_psl(prev));
     }
 
     output

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

@@ -5,7 +5,7 @@ use sql_schema_describer::{postgres::PostgresSchemaExt, SqlSchema};
 const EXTENSION_ALLOW_LIST: &[&str] = &["citext", "postgis", "pg_crypto", "uuid-ossp"];
 
 pub(super) fn add_extensions<'a>(
-    datasource: &mut render::Datasource<'a>,
+    datasource: &mut render::configuration::Datasource<'a>,
     schema: &'a SqlSchema,
     config: &'a Configuration,
 ) {
@@ -21,37 +21,37 @@ pub(super) fn add_extensions<'a>(
         .downcast_ref::<PostgresDatasourceProperties>();
 
     let previous_extensions = connector_data.and_then(|p| p.extensions());
-    let mut next_extensions = render::Array::new();
+    let mut next_extensions = render::value::Array::new();
 
     for ext in pg_schema_ext.extension_walkers() {
-        let mut next_extension = render::Function::new(ext.name());
+        let mut next_extension = render::value::Function::new(ext.name());
 
         match previous_extensions.and_then(|e| e.find_by_name(ext.name())) {
             Some(prev) => {
                 match prev.version() {
                     Some(previous_version) if previous_version != ext.version() => {
-                        next_extension.push_param(("version", render::Text(ext.version())));
+                        next_extension.push_param(("version", render::value::Text(ext.version())));
                     }
                     Some(previous_version) => {
-                        next_extension.push_param(("version", render::Text(previous_version)));
+                        next_extension.push_param(("version", render::value::Text(previous_version)));
                     }
                     None => (),
                 };
 
                 match prev.schema() {
                     Some(previous_schema) if previous_schema != ext.schema() => {
-                        next_extension.push_param(("schema", render::Text(ext.schema())));
+                        next_extension.push_param(("schema", render::value::Text(ext.schema())));
                     }
                     Some(previous_schema) => {
-                        next_extension.push_param(("schema", render::Text(previous_schema)));
+                        next_extension.push_param(("schema", render::value::Text(previous_schema)));
                     }
                     None => (),
                 }
 
                 next_extensions.push(next_extension);
             }
             None if EXTENSION_ALLOW_LIST.contains(&ext.name()) => {
-                next_extension.push_param(("schema", render::Text(ext.schema())));
+                next_extension.push_param(("schema", render::value::Text(ext.schema())));
                 next_extensions.push(next_extension);
             }
             None => (),

introspection-engine/datamodel-renderer/Cargo.toml

@@ -9,6 +9,7 @@ edition = "2021"
 once_cell = "1.15.0"
 psl.workspace = true
 regex = "1.6.0"
+base64 = "0.13.1"
 
 [dev-dependencies]
 expect-test = "1.4.0"

introspection-engine/datamodel-renderer/src/configuration.rs

@@ -1,6 +1,14 @@
-use std::fmt;
+//! Types related to the _configuration section_ in the PSL.
+//!
+//! Includes the `datasource` and `generator` definitions.
+
+mod datasource;
+mod generator;
 
-use crate::{Datasource, Generator};
+pub use datasource::Datasource;
+pub use generator::Generator;
+
+use std::fmt;
 
 /// The configuration part of a data model. First the generators, then
 /// the datasources.
@@ -53,7 +61,7 @@ impl<'a> fmt::Display for Configuration<'a> {
 
 #[cfg(test)]
 mod tests {
-    use crate::*;
+    use crate::{configuration::*, value::*};
     use expect_test::expect;
 
     #[test]

introspection-engine/datamodel-renderer/src/datasource.rs → introspection-engine/datamodel-renderer/src/configuration/datasource.rs

@@ -1,9 +1,7 @@
+use crate::value::{Array, Documentation, Env, Text, Value};
 use core::fmt;
-use std::default::Default;
-
 use psl::datamodel_connector::RelationMode;
-
-use crate::{Array, Documentation, Env, Text, Value};
+use std::default::Default;
 
 /// The datasource block in a PSL file.
 #[derive(Debug)]
@@ -157,7 +155,7 @@ impl<'a> fmt::Display for Datasource<'a> {
 
 #[cfg(test)]
 mod tests {
-    use crate::*;
+    use crate::{configuration::*, value::*};
     use expect_test::expect;
     use psl::datamodel_connector::RelationMode;
 

introspection-engine/datamodel-renderer/src/generator.rs → introspection-engine/datamodel-renderer/src/configuration/generator.rs

@@ -1,8 +1,6 @@
-use std::fmt;
-
+use crate::value::{Array, Documentation, Env, Text};
 use psl::PreviewFeature;
-
-use crate::{Array, Documentation, Env, Text};
+use std::fmt;
 
 /// The generator block of the datasource.
 #[derive(Debug)]
@@ -162,7 +160,7 @@ impl<'a> fmt::Display for Generator<'a> {
 
 #[cfg(test)]
 mod tests {
-    use crate::*;
+    use crate::{configuration::*, value::*};
     use expect_test::expect;
     use psl::PreviewFeature;