Render composite types with the new renderer

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

@@ -207,7 +207,7 @@ 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);
+        let mut r#enum = render::datamodel::Enum::new(&dml_enum.name);
 
         if let Some(ref docs) = dml_enum.documentation {
             r#enum.documentation(docs);
@@ -222,7 +222,7 @@ fn render_datamodel(dml: &Datamodel) -> render::Datamodel<'_> {
         }
 
         for dml_variant in dml_enum.values.iter() {
-            let mut variant = render::EnumVariant::new(&dml_variant.name);
+            let mut variant = render::datamodel::EnumVariant::new(&dml_variant.name);
 
             if dml_variant.commented_out {
                 variant = variant.into_commented_out();
@@ -248,7 +248,7 @@ fn render_datamodel(dml: &Datamodel) -> render::Datamodel<'_> {
 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 +257,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/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;
 

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

@@ -1,6 +1,16 @@
-use std::fmt;
+//! Types related to the _datamodel section_ in the PSL.
+//!
+//! Includes the `model`, `enum` and `type` definitions.
+
+mod attributes;
+mod composite_type;
+mod default;
+mod enumerator;
 
-use crate::Enum;
+pub use composite_type::{CompositeType, CompositeTypeField};
+pub use default::DefaultValue;
+pub use enumerator::{Enum, EnumVariant};
+use std::fmt;
 
 /// The PSL data model declaration.
 #[derive(Default, Debug)]
@@ -38,7 +48,7 @@ impl<'a> fmt::Display for Datamodel<'a> {
 
 #[cfg(test)]
 mod tests {
-    use crate::*;
+    use super::*;
     use expect_test::expect;
 
     #[test]

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

@@ -0,0 +1,73 @@
+use std::fmt;
+
+use crate::value::{Function, FunctionParam};
+
+/// Defines a field attribute, wrapping a function.
+///
+/// ```ignore
+/// model X {
+///   field Int @map("lol")
+///             ^^^^^^^^^^^ this
+/// }
+/// ```
+#[derive(Debug)]
+pub(super) struct FieldAttribute<'a> {
+    attribute: Function<'a>,
+    prefix: Option<&'a str>,
+}
+
+impl<'a> FieldAttribute<'a> {
+    pub(super) fn new(attribute: Function<'a>) -> Self {
+        Self {
+            attribute,
+            prefix: None,
+        }
+    }
+
+    /// Adds a prefix to the field attribute. Useful for native types,
+    /// e.g. `attr.prefix("db")` for a type attribute renders as
+    /// `@db.Type`.
+    pub(super) fn prefix(&mut self, prefix: &'a str) {
+        self.prefix = Some(prefix);
+    }
+
+    /// Add a new parameter to the attribute function.
+    pub fn push_param(&mut self, param: impl Into<FunctionParam<'a>>) {
+        self.attribute.push_param(param.into());
+    }
+}
+
+impl<'a> fmt::Display for FieldAttribute<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("@")?;
+
+        if let Some(prefix) = self.prefix {
+            f.write_str(prefix)?;
+            f.write_str(".")?;
+        }
+
+        self.attribute.fmt(f)?;
+
+        Ok(())
+    }
+}
+
+/// Defines a block attribute, wrapping a function.
+///
+/// ```ignore
+/// model X {
+///   @@map("lol")
+///   ^^^^^^^^^^^^ this
+/// }
+/// ```
+#[derive(Debug)]
+pub(super) struct BlockAttribute<'a>(pub(super) Function<'a>);
+
+impl<'a> fmt::Display for BlockAttribute<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("@@")?;
+        self.0.fmt(f)?;
+
+        Ok(())
+    }
+}