diff --git a/Cargo.lock b/Cargo.lock
index 988f77092ad0..8d19d108e9e6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -662,7 +662,6 @@ dependencies = [
  "chrono",
  "datamodel-connector",
  "diagnostics",
- "dml",
  "either",
  "enumflags2",
  "indoc",
@@ -670,6 +669,7 @@ dependencies = [
  "mongodb-datamodel-connector",
  "once_cell",
  "parser-database",
+ "prisma-value",
  "regex",
  "schema-ast",
  "serde",
@@ -746,10 +746,13 @@ version = "0.1.0"
 dependencies = [
  "chrono",
  "cuid",
+ "datamodel",
+ "either",
  "enumflags2",
  "indoc",
  "native-types",
  "prisma-value",
+ "schema-ast",
  "serde",
  "serde_json",
  "uuid 1.1.2",
@@ -3068,6 +3071,7 @@ version = "0.1.0"
 dependencies = [
  "datamodel",
  "dissimilar",
+ "dml",
  "expect-test",
  "indoc",
  "native-types",
@@ -3543,14 +3547,13 @@ version = "0.1.0"
 dependencies = [
  "bigdecimal",
  "connection-string",
- "datamodel",
- "datamodel-connector",
  "dmmf",
  "futures",
  "graphql-parser",
  "indexmap",
  "itertools",
  "prisma-models",
+ "psl",
  "query-core",
  "serde",
  "serde_json",
diff --git a/libs/datamodel/connectors/dml/Cargo.toml b/libs/datamodel/connectors/dml/Cargo.toml
index 237cfd9cffb5..5b40e0f0a1a4 100644
--- a/libs/datamodel/connectors/dml/Cargo.toml
+++ b/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
diff --git a/libs/datamodel/connectors/dml/src/lib.rs b/libs/datamodel/connectors/dml/src/lib.rs
index 1917fc3b4ab0..ab199c5a586d 100644
--- a/libs/datamodel/connectors/dml/src/lib.rs
+++ b/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,6 +23,8 @@ 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
@@ -28,3 +32,27 @@ pub fn find_model_by_db_name<'a>(datamodel: &'a Datamodel, db_name: &str) -> Opt
         .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;
diff --git a/libs/datamodel/core/src/lift.rs b/libs/datamodel/connectors/dml/src/lift.rs
similarity index 96%
rename from libs/datamodel/core/src/lift.rs
rename to libs/datamodel/connectors/dml/src/lift.rs
index edf885020922..cc604ab61636 100644
--- a/libs/datamodel/core/src/lift.rs
+++ b/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, _) => {
diff --git a/libs/datamodel/core/src/render.rs b/libs/datamodel/connectors/dml/src/render.rs
similarity index 100%
rename from libs/datamodel/core/src/render.rs
rename to libs/datamodel/connectors/dml/src/render.rs
diff --git a/libs/datamodel/core/src/render/render_configuration.rs b/libs/datamodel/connectors/dml/src/render/render_configuration.rs
similarity index 97%
rename from libs/datamodel/core/src/render/render_configuration.rs
rename to libs/datamodel/connectors/dml/src/render/render_configuration.rs
index 815ab0b4accf..3b7ed9b4d903 100644
--- a/libs/datamodel/core/src/render/render_configuration.rs
+++ b/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 _};
 
diff --git a/libs/datamodel/core/src/render/render_datamodel.rs b/libs/datamodel/connectors/dml/src/render/render_datamodel.rs
similarity index 93%
rename from libs/datamodel/core/src/render/render_datamodel.rs
rename to libs/datamodel/connectors/dml/src/render/render_datamodel.rs
index 5cc1e4f8eb35..3010c2919615 100644
--- a/libs/datamodel/core/src/render/render_datamodel.rs
+++ b/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,7 +479,7 @@ 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('?'),
@@ -486,24 +487,24 @@ fn render_field_arity(arity: &dml::FieldArity, out: &mut String) {
     }
 }
 
-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();
diff --git a/libs/datamodel/core/Cargo.toml b/libs/datamodel/core/Cargo.toml
index 27ee9f5d19d2..25c7eccc5999 100644
--- a/libs/datamodel/core/Cargo.toml
+++ b/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"]
diff --git a/libs/datamodel/core/src/lib.rs b/libs/datamodel/core/src/lib.rs
index a6c1764646ee..f18006e0af7b 100644
--- a/libs/datamodel/core/src/lib.rs
+++ b/libs/datamodel/core/src/lib.rs
@@ -8,9 +8,7 @@ pub mod common;
 pub mod mcf;
 
 mod configuration;
-mod lift;
 mod reformat;
-mod render;
 mod validate;
 
 pub use crate::{
@@ -19,7 +17,6 @@ pub use crate::{
 };
 pub use datamodel_connector;
 pub use diagnostics;
-pub use dml;
 pub use parser_database::{self, is_reserved_type_name};
 
 use self::{
@@ -27,12 +24,14 @@ use self::{
     validate::{DatasourceLoader, GeneratorLoader},
 };
 use diagnostics::Diagnostics;
-use enumflags2::BitFlags;
 use parser_database::{ast, ParserDatabase, SourceFile};
 
 pub mod builtin_connectors {
     pub use mongodb_datamodel_connector::*;
     pub use sql_datamodel_connector::*;
+
+    pub(crate) type ConnectorRegistry = &'static [&'static dyn datamodel_connector::Connector];
+    pub(crate) const BUILTIN_CONNECTORS: ConnectorRegistry = &[POSTGRES, MYSQL, SQLITE, MSSQL, COCKROACH, MONGODB];
 }
 
 pub struct ValidatedSchema {
@@ -63,7 +62,7 @@ pub fn parse_schema_parserdb(file: impl Into<SourceFile>) -> Result<ValidatedSch
 pub fn validate(file: SourceFile) -> ValidatedSchema {
     let mut diagnostics = Diagnostics::new();
     let db = ParserDatabase::new(file, &mut diagnostics);
-    let configuration = validate_configuration(db.ast(), &mut diagnostics);
+    let configuration = validate_configuration(db.ast(), &mut diagnostics, builtin_connectors::BUILTIN_CONNECTORS);
     let datasources = &configuration.datasources;
     let out = validate::validate(db, datasources, configuration.preview_features(), diagnostics);
 
@@ -80,14 +79,18 @@ pub fn validate(file: SourceFile) -> ValidatedSchema {
 pub fn parse_configuration(schema: &str) -> Result<Configuration, diagnostics::Diagnostics> {
     let mut diagnostics = Diagnostics::default();
     let ast = schema_ast::parse_schema(schema, &mut diagnostics);
-    let out = validate_configuration(&ast, &mut diagnostics);
+    let out = validate_configuration(&ast, &mut diagnostics, builtin_connectors::BUILTIN_CONNECTORS);
     diagnostics.to_result().map(|_| out)
 }
 
-fn validate_configuration(schema_ast: &ast::SchemaAst, diagnostics: &mut Diagnostics) -> Configuration {
+fn validate_configuration(
+    schema_ast: &ast::SchemaAst,
+    diagnostics: &mut Diagnostics,
+    connectors: builtin_connectors::ConnectorRegistry,
+) -> Configuration {
     let generators = GeneratorLoader::load_generators_from_ast(schema_ast, diagnostics);
-    let preview_features = preview_features(&generators);
-    let datasources = DatasourceLoader.load_datasources_from_ast(schema_ast, preview_features, diagnostics);
+    let preview_features = generators.iter().filter_map(|gen| gen.preview_features).collect();
+    let datasources = DatasourceLoader.load_datasources_from_ast(schema_ast, preview_features, diagnostics, connectors);
 
     Configuration {
         generators,
@@ -95,38 +98,3 @@ fn validate_configuration(schema_ast: &ast::SchemaAst, diagnostics: &mut Diagnos
         warnings: diagnostics.warnings().to_owned(),
     }
 }
-
-//
-//  ************** RENDERING FUNCTIONS **************
-//
-
-/// Renders the datamodel _without configuration blocks_.
-pub fn render_datamodel_to_string(datamodel: &dml::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: &dml::Datamodel,
-    config: &configuration::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")
-}
-
-/// Validated schema -> dml::Datamodel.
-pub fn lift(schema: &ValidatedSchema) -> dml::Datamodel {
-    lift::LiftAstToDml::new(&schema.db, schema.connector, schema.referential_integrity()).lift()
-}
-
-fn preview_features(generators: &[Generator]) -> BitFlags<PreviewFeature> {
-    generators.iter().filter_map(|gen| gen.preview_features).collect()
-}
-
-const DEFAULT_INDENT_WIDTH: usize = 2;
diff --git a/libs/datamodel/core/src/validate/datasource_loader.rs b/libs/datamodel/core/src/validate/datasource_loader.rs
index 108f384c27ef..bcce12a1e8ae 100644
--- a/libs/datamodel/core/src/validate/datasource_loader.rs
+++ b/libs/datamodel/core/src/validate/datasource_loader.rs
@@ -7,9 +7,7 @@ use crate::{
 };
 use datamodel_connector::ReferentialIntegrity;
 use enumflags2::BitFlags;
-use mongodb_datamodel_connector::*;
 use parser_database::{ast::WithDocumentation, coerce, coerce_array, coerce_opt};
-use sql_datamodel_connector::*;
 use std::{borrow::Cow, collections::HashMap};
 
 const PREVIEW_FEATURES_KEY: &str = "previewFeatures";
@@ -29,11 +27,12 @@ impl DatasourceLoader {
         ast_schema: &ast::SchemaAst,
         preview_features: BitFlags<PreviewFeature>,
         diagnostics: &mut Diagnostics,
+        connectors: crate::builtin_connectors::ConnectorRegistry,
     ) -> Vec<Datasource> {
         let mut sources = Vec::new();
 
         for src in ast_schema.sources() {
-            if let Some(source) = self.lift_datasource(src, preview_features, diagnostics) {
+            if let Some(source) = self.lift_datasource(src, preview_features, diagnostics, connectors) {
                 sources.push(source)
             }
         }
@@ -56,6 +55,7 @@ impl DatasourceLoader {
         ast_source: &ast::SourceConfig,
         preview_features: BitFlags<PreviewFeature>,
         diagnostics: &mut Diagnostics,
+        connectors: crate::builtin_connectors::ConnectorRegistry,
     ) -> Option<Datasource> {
         let source_name = &ast_source.name.name;
         let mut args: HashMap<_, _> = ast_source
@@ -134,23 +134,18 @@ impl DatasourceLoader {
         let documentation = ast_source.documentation().map(String::from);
         let referential_integrity = get_referential_integrity(&args, preview_features, ast_source, diagnostics);
 
-        let active_connector: &'static dyn datamodel_connector::Connector = match provider {
-            p if MYSQL.is_provider(p) => MYSQL,
-            p if POSTGRES.is_provider(p) => POSTGRES,
-            p if SQLITE.is_provider(p) => SQLITE,
-            p if MSSQL.is_provider(p) => MSSQL,
-            p if MONGODB.is_provider(p) => MONGODB,
-            p if COCKROACH.is_provider(p) => COCKROACH,
-
-            _ => {
-                diagnostics.push_error(DatamodelError::new_datasource_provider_not_known_error(
-                    provider,
-                    provider_arg.span(),
-                ));
+        let active_connector: &'static dyn datamodel_connector::Connector =
+            match connectors.iter().find(|c| c.is_provider(provider)) {
+                Some(c) => *c,
+                None => {
+                    diagnostics.push_error(DatamodelError::new_datasource_provider_not_known_error(
+                        provider,
+                        provider_arg.span(),
+                    ));
 
-                return None;
-            }
-        };
+                    return None;
+                }
+            };
 
         if let Some(integrity) = referential_integrity {
             if !active_connector
diff --git a/libs/datamodel/core/src/validate/validation_pipeline/validations/default_value.rs b/libs/datamodel/core/src/validate/validation_pipeline/validations/default_value.rs
index 4acfb6be6fc5..c13edfdbbddf 100644
--- a/libs/datamodel/core/src/validate/validation_pipeline/validations/default_value.rs
+++ b/libs/datamodel/core/src/validate/validation_pipeline/validations/default_value.rs
@@ -69,7 +69,7 @@ pub(super) fn validate_default_value(
             ));
         }
         (ScalarType::Bytes, ast::Expression::StringValue(value, span)) => {
-            let details = match dml::prisma_value::decode_bytes(value) {
+            let details = match prisma_value::decode_bytes(value) {
                 Ok(_) => return,
                 Err(details) => details,
             };
diff --git a/psl/psl/Cargo.toml b/psl/psl/Cargo.toml
index 6147627bb98d..ac20f9c6e6f0 100644
--- a/psl/psl/Cargo.toml
+++ b/psl/psl/Cargo.toml
@@ -4,6 +4,7 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+dml = { path = "../../libs/datamodel/connectors/dml" }
 psl-core = { path = "../../libs/datamodel/core", package = "datamodel", default-features = false }
 
 [dev-dependencies]
@@ -13,4 +14,4 @@ indoc = "1"
 native-types = { path = "../../libs/native-types" }
 
 [features]
-default_generators = ["psl-core/default_generators"]
+default_generators = ["dml/default_generators"]
diff --git a/psl/psl/src/lib.rs b/psl/psl/src/lib.rs
index 8c0141b4ddf2..165d2929eaf9 100644
--- a/psl/psl/src/lib.rs
+++ b/psl/psl/src/lib.rs
@@ -1,4 +1,5 @@
 #![doc = include_str!("../README.md")]
 #![deny(rust_2018_idioms, unsafe_code, missing_docs)]
 
+pub use dml::{self, lift, render_datamodel_and_config_to_string, render_datamodel_to_string};
 pub use psl_core::*;
diff --git a/query-engine/request-handlers/Cargo.toml b/query-engine/request-handlers/Cargo.toml
index 3e307970012b..507ecab9f846 100644
--- a/query-engine/request-handlers/Cargo.toml
+++ b/query-engine/request-handlers/Cargo.toml
@@ -7,7 +7,7 @@ edition = "2021"
 [dependencies]
 query-core = { path = "../core" }
 user-facing-errors = { path = "../../libs/user-facing-errors" }
-datamodel = { path = "../../libs/datamodel/core" }
+psl = { path = "../../psl/psl" }
 dmmf_crate = { path = "../dmmf", package = "dmmf" }
 itertools = "0.10"
 graphql-parser = { git = "https://github.com/prisma/graphql-parser" }
@@ -24,5 +24,4 @@ connection-string = "0.1"
 [dev-dependencies]
 test-setup = { path = "../../libs/test-setup" }
 serial_test = "*"
-datamodel-connector = { path = "../../libs/datamodel/connectors/datamodel-connector" }
 prisma-models = { path = "../prisma-models" }
diff --git a/query-engine/request-handlers/src/dmmf/mod.rs b/query-engine/request-handlers/src/dmmf/mod.rs
index 28dcd1af5742..3f275b68224c 100644
--- a/query-engine/request-handlers/src/dmmf/mod.rs
+++ b/query-engine/request-handlers/src/dmmf/mod.rs
@@ -1,6 +1,6 @@
 use dmmf_crate::DataModelMetaFormat;
 use query_core::schema::QuerySchemaRef;
 
-pub fn render_dmmf(dml: &datamodel::dml::Datamodel, query_schema: QuerySchemaRef) -> DataModelMetaFormat {
+pub fn render_dmmf(dml: &psl::dml::Datamodel, query_schema: QuerySchemaRef) -> DataModelMetaFormat {
     dmmf_crate::from_precomputed_parts(dml, query_schema)
 }