psl: invert the dependency between dml and core

libs/datamodel/connectors/dml/Cargo.toml

@@ -5,6 +5,8 @@ edition = "2021"
 
 [dependencies]
 prisma-value = { path = "../../../prisma-value" }
+datamodel = { path = "../../core" }
+schema-ast = { path = "../../schema-ast" }
 
 uuid = { version = "1", features = ["serde", "v4"], optional = true }
 cuid = { git = "https://github.com/prisma/cuid-rust", optional = true }
@@ -14,6 +16,7 @@ serde_json = { version = "1.0", features = ["float_roundtrip"] }
 native-types = { path = "../../../native-types" }
 enumflags2 = "0.7"
 indoc = "1"
+either = "1.6"
 
 [features]
 # Support for generating default UUID and CUID default values. This implies

libs/datamodel/connectors/dml/src/lib.rs

@@ -4,6 +4,8 @@
 #![allow(clippy::derive_partial_eq_without_eq)]
 
 mod datamodel;
+mod lift;
+mod render;
 
 pub mod composite_type;
 pub mod default_value;
@@ -21,10 +23,36 @@ pub use self::{
 };
 pub use prisma_value::{self, PrismaValue};
 
+use ::datamodel::{reformat, Configuration, ValidatedSchema};
+
 /// Find the model mapping to the passed in database name.
 pub fn find_model_by_db_name<'a>(datamodel: &'a Datamodel, db_name: &str) -> Option<&'a Model> {
     datamodel
         .models
         .iter()
         .find(|model| model.database_name() == Some(db_name) || model.name == db_name)
 }
+
+/// Validated schema -> dml::Datamodel.
+pub fn lift(schema: &ValidatedSchema) -> crate::Datamodel {
+    lift::LiftAstToDml::new(&schema.db, schema.connector, schema.referential_integrity()).lift()
+}
+
+/// Renders the datamodel _without configuration blocks_.
+pub fn render_datamodel_to_string(datamodel: &crate::Datamodel, configuration: Option<&Configuration>) -> String {
+    let datasource = configuration.and_then(|c| c.datasources.first());
+    let mut out = String::new();
+    render::render_datamodel(render::RenderParams { datasource, datamodel }, &mut out);
+    reformat(&out, DEFAULT_INDENT_WIDTH).expect("Internal error: failed to reformat introspected schema")
+}
+
+/// Renders a datamodel, sources and generators.
+pub fn render_datamodel_and_config_to_string(datamodel: &crate::Datamodel, config: &Configuration) -> String {
+    let mut out = String::new();
+    let datasource = config.datasources.first();
+    render::render_configuration(config, &mut out);
+    render::render_datamodel(render::RenderParams { datasource, datamodel }, &mut out);
+    reformat(&out, DEFAULT_INDENT_WIDTH).expect("Internal error: failed to reformat introspected schema")
+}
+
+const DEFAULT_INDENT_WIDTH: usize = 2;

libs/datamodel/core/src/lift.rs → libs/datamodel/connectors/dml/src/lift.rs

@@ -1,11 +1,11 @@
-use crate::parser_database::{
+use crate::{self as dml, *};
+use ::datamodel::datamodel_connector::{walker_ext_traits::*, Connector, ReferentialIntegrity, ScalarType};
+use ::datamodel::parser_database::{
     self as db,
     ast::{self, WithDocumentation, WithName, WithSpan},
     walkers::*,
     IndexAlgorithm,
 };
-use datamodel_connector::{walker_ext_traits::*, Connector, ReferentialIntegrity, ScalarType};
-use dml::*;
 use either::Either;
 use std::collections::HashMap;
 
@@ -97,8 +97,7 @@ impl<'a> LiftAstToDml<'a> {
             field.documentation = ast_field.documentation().map(String::from);
             field.is_ignored = relation_field.is_ignored();
             field.supports_restrict_action(
-                active_connector
-                    .supports_referential_action(&referential_integrity, parser_database::ReferentialAction::Restrict),
+                active_connector.supports_referential_action(&referential_integrity, db::ReferentialAction::Restrict),
             );
             field.emulates_referential_actions(referential_integrity.is_prisma());
         };
@@ -527,31 +526,29 @@ impl<'a> LiftAstToDml<'a> {
     }
 }
 
-fn parser_database_sort_order_to_dml_sort_order(sort_order: parser_database::SortOrder) -> dml::SortOrder {
+fn parser_database_sort_order_to_dml_sort_order(sort_order: db::SortOrder) -> dml::SortOrder {
     match sort_order {
-        parser_database::SortOrder::Asc => dml::SortOrder::Asc,
-        parser_database::SortOrder::Desc => dml::SortOrder::Desc,
+        db::SortOrder::Asc => dml::SortOrder::Asc,
+        db::SortOrder::Desc => dml::SortOrder::Desc,
     }
 }
 
-fn parser_database_referential_action_to_dml_referential_action(
-    ra: parser_database::ReferentialAction,
-) -> dml::ReferentialAction {
+fn parser_database_referential_action_to_dml_referential_action(ra: db::ReferentialAction) -> dml::ReferentialAction {
     match ra {
-        parser_database::ReferentialAction::Cascade => dml::ReferentialAction::Cascade,
-        parser_database::ReferentialAction::SetNull => dml::ReferentialAction::SetNull,
-        parser_database::ReferentialAction::SetDefault => dml::ReferentialAction::SetDefault,
-        parser_database::ReferentialAction::Restrict => dml::ReferentialAction::Restrict,
-        parser_database::ReferentialAction::NoAction => dml::ReferentialAction::NoAction,
+        db::ReferentialAction::Cascade => dml::ReferentialAction::Cascade,
+        db::ReferentialAction::SetNull => dml::ReferentialAction::SetNull,
+        db::ReferentialAction::SetDefault => dml::ReferentialAction::SetDefault,
+        db::ReferentialAction::Restrict => dml::ReferentialAction::Restrict,
+        db::ReferentialAction::NoAction => dml::ReferentialAction::NoAction,
     }
 }
 
-fn parser_database_scalar_type_to_dml_scalar_type(st: parser_database::ScalarType) -> dml::ScalarType {
+fn parser_database_scalar_type_to_dml_scalar_type(st: db::ScalarType) -> dml::ScalarType {
     st.as_str().parse().unwrap()
 }
 
 fn datamodel_connector_native_type_to_dml_native_type(
-    instance: datamodel_connector::NativeTypeInstance,
+    instance: ::datamodel::datamodel_connector::NativeTypeInstance,
 ) -> dml::NativeTypeInstance {
     dml::NativeTypeInstance {
         name: instance.name,
@@ -607,9 +604,7 @@ fn dml_default_kind(default_value: &ast::Expression, scalar_type: Option<ScalarT
             Some(ScalarType::String) => DefaultKind::Single(PrismaValue::String(v.parse().unwrap())),
             Some(ScalarType::Json) => DefaultKind::Single(PrismaValue::Json(v.parse().unwrap())),
             Some(ScalarType::Decimal) => DefaultKind::Single(PrismaValue::Float(v.parse().unwrap())),
-            Some(ScalarType::Bytes) => {
-                DefaultKind::Single(PrismaValue::Bytes(::dml::prisma_value::decode_bytes(v).unwrap()))
-            }
+            Some(ScalarType::Bytes) => DefaultKind::Single(PrismaValue::Bytes(prisma_value::decode_bytes(v).unwrap())),
             other => unreachable!("{:?}", other),
         },
         ast::Expression::Array(values, _) => {

libs/datamodel/core/src/render/render_configuration.rs → libs/datamodel/connectors/dml/src/render/render_configuration.rs

@@ -1,4 +1,4 @@
-use crate::{configuration::StringFromEnvVar, Configuration, Datasource, Generator};
+use ::datamodel::{Configuration, Datasource, Generator, StringFromEnvVar};
 use schema_ast::string_literal;
 use std::fmt::{self, Write as _};
 

libs/datamodel/core/src/render/render_datamodel.rs → libs/datamodel/connectors/dml/src/render/render_datamodel.rs

@@ -1,12 +1,13 @@
-use crate::{common::RelationNames, dml::*, Datasource};
-use datamodel_connector::{constraint_names::ConstraintNames, Connector, EmptyDatamodelConnector};
+use crate::*;
+use ::datamodel::datamodel_connector::{constraint_names::ConstraintNames, Connector, EmptyDatamodelConnector};
+use ::datamodel::{common::RelationNames, parser_database as db, Datasource};
 use schema_ast::string_literal;
 use std::fmt::Write;
 
 #[derive(Debug, Clone, Copy)]
 pub(crate) struct RenderParams<'a> {
     pub datasource: Option<&'a Datasource>,
-    pub datamodel: &'a dml::Datamodel,
+    pub datamodel: &'a Datamodel,
 }
 
 impl RenderParams<'_> {
@@ -410,7 +411,7 @@ fn render_composite_field_type(field_type: &CompositeTypeFieldType, out: &mut St
     }
 }
 
-fn render_field_type(field_type: &dml::FieldType, out: &mut String) {
+fn render_field_type(field_type: &crate::FieldType, out: &mut String) {
     match field_type {
         FieldType::CompositeType(name) | FieldType::Enum(name) => out.push_str(name),
         FieldType::Unsupported(name) => {
@@ -423,7 +424,7 @@ fn render_field_type(field_type: &dml::FieldType, out: &mut String) {
     }
 }
 
-fn render_model_attributes(model: &dml::Model, params: RenderParams<'_>, out: &mut String) {
+fn render_model_attributes(model: &crate::Model, params: RenderParams<'_>, out: &mut String) {
     // @@id
     if let Some(pk) = &model.primary_key {
         if !pk.defined_on_field {
@@ -478,32 +479,32 @@ fn render_model_attributes(model: &dml::Model, params: RenderParams<'_>, out: &m
     }
 }
 
-fn render_field_arity(arity: &dml::FieldArity, out: &mut String) {
+fn render_field_arity(arity: &crate::FieldArity, out: &mut String) {
     match arity {
         FieldArity::Required => (),
         FieldArity::Optional => out.push('?'),
         FieldArity::List => out.push_str("[]"),
     }
 }
 
-fn dml_scalar_type_to_parser_database_scalar_type(st: dml::ScalarType) -> parser_database::ScalarType {
+fn dml_scalar_type_to_parser_database_scalar_type(st: crate::ScalarType) -> db::ScalarType {
     match st {
-        dml::ScalarType::Int => parser_database::ScalarType::Int,
-        dml::ScalarType::BigInt => parser_database::ScalarType::BigInt,
-        dml::ScalarType::Float => parser_database::ScalarType::Float,
-        dml::ScalarType::Boolean => parser_database::ScalarType::Boolean,
-        dml::ScalarType::String => parser_database::ScalarType::String,
-        dml::ScalarType::DateTime => parser_database::ScalarType::DateTime,
-        dml::ScalarType::Json => parser_database::ScalarType::Json,
-        dml::ScalarType::Bytes => parser_database::ScalarType::Bytes,
-        dml::ScalarType::Decimal => parser_database::ScalarType::Decimal,
+        crate::ScalarType::Int => db::ScalarType::Int,
+        crate::ScalarType::BigInt => db::ScalarType::BigInt,
+        crate::ScalarType::Float => db::ScalarType::Float,
+        crate::ScalarType::Boolean => db::ScalarType::Boolean,
+        crate::ScalarType::String => db::ScalarType::String,
+        crate::ScalarType::DateTime => db::ScalarType::DateTime,
+        crate::ScalarType::Json => db::ScalarType::Json,
+        crate::ScalarType::Bytes => db::ScalarType::Bytes,
+        crate::ScalarType::Decimal => db::ScalarType::Decimal,
     }
 }
 
-fn render_default_value(dv: &dml::DefaultValue, out: &mut String) {
+fn render_default_value(dv: &crate::DefaultValue, out: &mut String) {
     match dv.kind() {
-        dml::DefaultKind::Single(v) => render_prisma_value(v, out),
-        dml::DefaultKind::Expression(e) => {
+        crate::DefaultKind::Single(v) => render_prisma_value(v, out),
+        crate::DefaultKind::Expression(e) => {
             out.push_str(e.name());
             out.push('(');
             let mut args = e.args().iter().peekable();

libs/datamodel/core/Cargo.toml

@@ -5,12 +5,12 @@ version = "0.1.0"
 
 [dependencies]
 datamodel-connector = { path = "../connectors/datamodel-connector" }
-dml = { path = "../connectors/dml" }
+diagnostics = { path = "../diagnostics" }
 mongodb-datamodel-connector = { path = "../connectors/mongodb-datamodel-connector" }
+parser-database = { path = "../parser-database" }
+prisma-value = { path = "../../prisma-value" }
 schema-ast = { path = "../schema-ast" }
 sql-datamodel-connector = { path = "../connectors/sql-datamodel-connector" }
-diagnostics = { path = "../diagnostics" }
-parser-database = { path = "../parser-database" }
 
 bigdecimal = "0.3"
 chrono = { version = "0.4.6", default_features = false }
@@ -23,5 +23,3 @@ enumflags2 = "0.7"
 indoc = "1"
 either = "1.6"
 
-[features]
-default_generators = ["dml/default_generators"]