qe: replace InternalDatamodelBuilder with a simple fn

query-engine/connector-test-kit-rs/query-tests-setup/src/runner/direct.rs

@@ -1,5 +1,4 @@
 use crate::{ConnectorTag, RunnerInterface, TestResult, TxResult};
-use prisma_models::InternalDataModelBuilder;
 use query_core::{executor, schema::QuerySchemaRef, schema_builder, QueryExecutor, TxId};
 use query_engine_metrics::MetricRegistry;
 use request_handlers::{GraphQlBody, GraphQlHandler, MultiQuery};
@@ -24,7 +23,7 @@ impl RunnerInterface for DirectRunner {
         let preview_features: Vec<_> = schema.configuration.preview_features().iter().collect();
         let url = data_source.load_url(|key| env::var(key).ok()).unwrap();
         let (db_name, executor) = executor::load(data_source, &preview_features, &url).await?;
-        let internal_data_model = InternalDataModelBuilder::new(&schema).build(db_name);
+        let internal_data_model = prisma_models::convert(&schema, db_name);
 
         let query_schema: QuerySchemaRef = Arc::new(schema_builder::build(
             internal_data_model,

query-engine/dmmf/src/lib.rs

@@ -4,7 +4,6 @@ mod serialization_ast;
 pub use serialization_ast::DataModelMetaFormat;
 
 use ast_builders::{schema_to_dmmf, DmmfQuerySchemaRenderer};
-use prisma_models::InternalDataModelBuilder;
 use schema::{QuerySchemaRef, QuerySchemaRenderer};
 use std::sync::Arc;
 
@@ -22,7 +21,7 @@ pub fn dmmf_from_schema(schema: &str) -> DataModelMetaFormat {
     // We only support one data source at the moment, so take the first one (default not exposed yet).
     let data_source = config.datasources.first().unwrap();
     let preview_features: Vec<_> = config.preview_features().iter().collect();
-    let internal_data_model = InternalDataModelBuilder::from(&dml).build("dummy".to_owned());
+    let internal_data_model = prisma_models::convert(&schema, "dummy".to_owned());
 
     // Construct query schema
     let query_schema = Arc::new(schema_builder::build(

query-engine/prisma-models/src/builders/internal_dm_builder.rs

@@ -1,84 +1,19 @@
 use super::{
-    build_composites, field_builders::RelationFieldBuilder, relation_builder::RelationBuilder, CompositeTypeBuilder,
-    FieldBuilder, IndexBuilder, ModelBuilder, PrimaryKeyBuilder,
+    field_builders::RelationFieldBuilder, relation_builder::RelationBuilder, CompositeTypeBuilder, FieldBuilder,
+    IndexBuilder, ModelBuilder, PrimaryKeyBuilder,
 };
 use crate::{
     builders::{CompositeFieldBuilder, ScalarFieldBuilder},
     extensions::*,
-    IndexType, InlineRelation, InternalDataModel, InternalDataModelRef, InternalEnum, InternalEnumValue,
-    RelationLinkManifestation, RelationSide, RelationTable, TypeIdentifier,
+    IndexType, InlineRelation, InternalEnum, InternalEnumValue, RelationLinkManifestation, RelationSide, RelationTable,
+    TypeIdentifier,
 };
-use once_cell::sync::OnceCell;
 use psl::dml::{self, CompositeTypeFieldType, Datamodel, Ignorable, WithDatabaseName};
-use std::sync::Arc;
-
-#[derive(Debug, Default)]
-pub struct InternalDataModelBuilder {
-    pub models: Vec<ModelBuilder>,
-    pub relations: Vec<RelationBuilder>,
-    pub enums: Vec<InternalEnum>,
-    pub composite_types: Vec<CompositeTypeBuilder>,
-}
-
-impl InternalDataModelBuilder {
-    pub fn new(datamodel: &psl::ValidatedSchema) -> Self {
-        let datamodel = psl::lift(datamodel);
-
-        Self::from(&datamodel)
-    }
-
-    pub fn build(self, db_name: String) -> InternalDataModelRef {
-        let internal_data_model = Arc::new(InternalDataModel {
-            models: OnceCell::new(),
-            composite_types: OnceCell::new(),
-            relations: OnceCell::new(),
-            relation_fields: OnceCell::new(),
-            db_name,
-            enums: self.enums.into_iter().map(Arc::new).collect(),
-        });
-
-        let composite_types = build_composites(self.composite_types, Arc::downgrade(&internal_data_model));
-        internal_data_model.composite_types.set(composite_types).unwrap();
-
-        let models = self
-            .models
-            .into_iter()
-            .map(|mt| {
-                mt.build(
-                    Arc::downgrade(&internal_data_model),
-                    internal_data_model.composite_types.get().unwrap(),
-                )
-            })
-            .collect();
-
-        internal_data_model.models.set(models).unwrap();
-
-        let relations = self
-            .relations
-            .into_iter()
-            .map(|rt| rt.build(Arc::downgrade(&internal_data_model)))
-            .collect();
-
-        internal_data_model.relations.set(relations).unwrap();
-        internal_data_model.finalize();
-        internal_data_model
-    }
-}
 
-impl From<&dml::Datamodel> for InternalDataModelBuilder {
-    fn from(datamodel: &dml::Datamodel) -> Self {
-        let relation_placeholders = relation_placeholders(datamodel);
-
-        Self {
-            models: model_builders(datamodel, &relation_placeholders),
-            relations: relation_builders(&relation_placeholders),
-            enums: convert_enums(datamodel),
-            composite_types: composite_type_builders(datamodel),
-        }
-    }
-}
-
-fn model_builders(datamodel: &Datamodel, relation_placeholders: &[RelationPlaceholder]) -> Vec<ModelBuilder> {
+pub(crate) fn model_builders(
+    datamodel: &Datamodel,
+    relation_placeholders: &[RelationPlaceholder],
+) -> Vec<ModelBuilder> {
     datamodel
         .models()
         .filter(|model| !model.is_ignored())
@@ -201,7 +136,7 @@ fn composite_field_builders(datamodel: &Datamodel, composite: &dml::CompositeTyp
         .collect()
 }
 
-fn relation_builders(placeholders: &[RelationPlaceholder]) -> Vec<RelationBuilder> {
+pub(crate) fn relation_builders(placeholders: &[RelationPlaceholder]) -> Vec<RelationBuilder> {
     placeholders
         .iter()
         .filter(|r| r.model_a.is_relation_supported(&r.field_a) && r.model_b.is_relation_supported(&r.field_b))
@@ -245,7 +180,7 @@ fn pk_builder(model: &dml::Model) -> Option<PrimaryKeyBuilder> {
     })
 }
 
-fn composite_type_builders(datamodel: &Datamodel) -> Vec<CompositeTypeBuilder> {
+pub(crate) fn composite_type_builders(datamodel: &Datamodel) -> Vec<CompositeTypeBuilder> {
     datamodel
         .composite_types
         .iter()
@@ -256,7 +191,7 @@ fn composite_type_builders(datamodel: &Datamodel) -> Vec<CompositeTypeBuilder> {
         .collect()
 }
 
-fn convert_enums(datamodel: &Datamodel) -> Vec<InternalEnum> {
+pub(crate) fn convert_enums(datamodel: &Datamodel) -> Vec<InternalEnum> {
     datamodel
         .enums()
         .map(|e| InternalEnum {
@@ -276,7 +211,7 @@ fn convert_enum_values(enm: &dml::Enum) -> Vec<InternalEnumValue> {
 }
 
 /// Calculates placeholders that are used to compute builders dependent on some relation information being present already.
-fn relation_placeholders(datamodel: &dml::Datamodel) -> Vec<RelationPlaceholder> {
+pub(crate) fn relation_placeholders(datamodel: &dml::Datamodel) -> Vec<RelationPlaceholder> {
     let mut result = Vec::new();
 
     for model in datamodel.models().filter(|model| !model.is_ignored) {

query-engine/prisma-models/src/convert.rs

@@ -0,0 +1,45 @@
+use crate::{builders, InternalDataModel, InternalDataModelRef};
+use once_cell::sync::OnceCell;
+use std::sync::Arc;
+
+pub fn convert(schema: &psl::ValidatedSchema, db_name: String) -> InternalDataModelRef {
+    let datamodel = psl::lift(schema);
+
+    let relation_placeholders = builders::relation_placeholders(&datamodel);
+    let models = builders::model_builders(&datamodel, &relation_placeholders);
+    let relations = builders::relation_builders(&relation_placeholders);
+    let enums = builders::convert_enums(&datamodel);
+    let composite_types = builders::composite_type_builders(&datamodel);
+    let internal_data_model = Arc::new(InternalDataModel {
+        models: OnceCell::new(),
+        composite_types: OnceCell::new(),
+        relations: OnceCell::new(),
+        relation_fields: OnceCell::new(),
+        db_name,
+        enums: enums.into_iter().map(Arc::new).collect(),
+    });
+
+    let composite_types = builders::build_composites(composite_types, Arc::downgrade(&internal_data_model));
+    internal_data_model.composite_types.set(composite_types).unwrap();
+
+    let models = models
+        .into_iter()
+        .map(|mt| {
+            mt.build(
+                Arc::downgrade(&internal_data_model),
+                internal_data_model.composite_types.get().unwrap(),
+            )
+        })
+        .collect();
+
+    internal_data_model.models.set(models).unwrap();
+
+    let relations = relations
+        .into_iter()
+        .map(|rt| rt.build(Arc::downgrade(&internal_data_model)))
+        .collect();
+
+    internal_data_model.relations.set(relations).unwrap();
+    internal_data_model.finalize();
+    internal_data_model
+}

query-engine/prisma-models/src/lib.rs

@@ -5,6 +5,7 @@
 
 mod builders;
 mod composite_type;
+mod convert;
 mod error;
 mod extensions;
 mod field;
@@ -25,8 +26,8 @@ mod selection_result;
 pub mod pk;
 pub mod prelude;
 
-pub use builders::InternalDataModelBuilder;
 pub use composite_type::*;
+pub use convert::convert;
 pub use error::*;
 pub use field::*;
 pub use field_selection::*;

query-engine/prisma-models/tests/datamodel_converter_tests.rs

@@ -469,7 +469,7 @@ fn duplicate_relation_name() {
         "#;
 
     let dml = psl::parse_schema_parserdb(schema).unwrap();
-    InternalDataModelBuilder::from(&psl::lift(&dml)).build(String::new());
+    prisma_models::convert(&dml, String::new());
 }
 
 #[test]
@@ -492,8 +492,7 @@ fn implicit_many_to_many_relation() {
 
 fn convert(datamodel: &str) -> Arc<InternalDataModel> {
     let schema = psl::parse_schema_parserdb(datamodel).unwrap();
-    let builder = InternalDataModelBuilder::new(&schema);
-    builder.build("not_important".to_string())
+    prisma_models::convert(&schema, "not_important".to_string())
 }
 
 trait DatamodelAssertions {

query-engine/query-engine-node-api/src/engine.rs

@@ -1,6 +1,5 @@
 use crate::{error::ApiError, log_callback::LogCallback, logger::Logger};
 use futures::FutureExt;
-use prisma_models::InternalDataModelBuilder;
 use psl::{common::preview_features::PreviewFeature, dml::Datamodel};
 use query_core::{
     executor,
@@ -45,6 +44,7 @@ enum Inner {
 /// Holding the information to reconnect the engine if needed.
 #[derive(Debug, Clone)]
 struct EngineDatamodel {
+    #[allow(unused)]
     ast: Datamodel,
     raw: String,
 }
@@ -246,7 +246,8 @@ impl QueryEngine {
                 connector.get_connection().await?;
 
                 // Build internal data model
-                let internal_data_model = InternalDataModelBuilder::from(&builder.datamodel.ast).build(db_name);
+                let schema = psl::parse_schema_parserdb(&*builder.datamodel.raw).unwrap();
+                let internal_data_model = prisma_models::convert(&schema, db_name);
 
                 let query_schema = schema_builder::build(
                     internal_data_model,

query-engine/query-engine-node-api/src/functions.rs

@@ -1,7 +1,6 @@
 use crate::error::ApiError;
 use napi::{bindgen_prelude::*, JsUnknown};
 use napi_derive::napi;
-use prisma_models::InternalDataModelBuilder;
 use query_core::{schema::QuerySchemaRef, schema_builder};
 use request_handlers::dmmf;
 use std::{
@@ -42,7 +41,7 @@ pub fn dmmf(datamodel_string: String) -> napi::Result<String> {
 
     let referential_integrity = datasource.map(|ds| ds.referential_integrity()).unwrap_or_default();
 
-    let internal_data_model = InternalDataModelBuilder::from(&datamodel).build("".into());
+    let internal_data_model = prisma_models::convert(&schema, "".into());
 
     let query_schema: QuerySchemaRef = Arc::new(schema_builder::build(
         internal_data_model,

query-engine/query-engine/src/cli.rs

@@ -3,21 +3,20 @@ use crate::{
     opt::{CliOpt, PrismaOpt, Subcommand},
     PrismaResult,
 };
-use prisma_models::InternalDataModelBuilder;
-use psl::{dml::Datamodel, Configuration};
+use psl::Configuration;
 use query_core::{schema::QuerySchemaRef, schema_builder};
 use request_handlers::{dmmf, GraphQlHandler};
 use std::{env, sync::Arc};
 
 pub struct ExecuteRequest {
     query: String,
-    datamodel: Datamodel,
+    datamodel: psl::ValidatedSchema,
     config: Configuration,
     enable_raw_queries: bool,
 }
 
 pub struct DmmfRequest {
-    datamodel: Datamodel,
+    datamodel: psl::ValidatedSchema,
     enable_raw_queries: bool,
     config: Configuration,
 }
@@ -94,7 +93,7 @@ impl CliCommand {
         let referential_integrity = datasource.map(|ds| ds.referential_integrity()).unwrap_or_default();
 
         // temporary code duplication
-        let internal_data_model = InternalDataModelBuilder::from(&request.datamodel).build("".into());
+        let internal_data_model = prisma_models::convert(&request.datamodel, "".into());
         let query_schema: QuerySchemaRef = Arc::new(schema_builder::build(
             internal_data_model,
             request.enable_raw_queries,
@@ -103,7 +102,7 @@ impl CliCommand {
             referential_integrity,
         ));
 
-        let dmmf = dmmf::render_dmmf(&request.datamodel, query_schema);
+        let dmmf = dmmf::render_dmmf(&psl::lift(&request.datamodel), query_schema);
         let serialized = serde_json::to_string_pretty(&dmmf)?;
 
         println!("{}", serialized);
@@ -132,7 +131,7 @@ impl CliCommand {
 
         request.config.validate_that_one_datasource_is_provided()?;
 
-        let cx = PrismaContext::builder(request.config, request.datamodel)
+        let cx = PrismaContext::builder(request.datamodel)
             .enable_raw_queries(request.enable_raw_queries)
             .build()
             .await?;