feat(psl): add deprecation warning for the "referentialIntegrity" attribute

psl/diagnostics/src/warning.rs

@@ -27,6 +27,11 @@ impl DatamodelWarning {
         Self::new(message, span)
     }
 
+    pub fn new_referential_integrity_attr_deprecation_warning(span: Span) -> DatamodelWarning {
+        let message = "The `referentialIntegrity` attribute is deprecated. Please use `relationMode` instead. Learn more at https://pris.ly/d/relation-mode";
+        Self::new(message.to_string(), span)
+    }
+
     pub fn new_missing_index_on_emulated_relation(span: Span) -> DatamodelWarning {
         let message = indoc!(
             r#"

psl/psl-core/src/validate/datasource_loader.rs

@@ -5,6 +5,7 @@ use crate::{
     diagnostics::{DatamodelError, Diagnostics},
     Datasource,
 };
+use diagnostics::DatamodelWarning;
 use parser_database::{ast::WithDocumentation, coerce, coerce_array, coerce_opt};
 use std::{borrow::Cow, collections::HashMap};
 
@@ -185,20 +186,32 @@ fn lift_datasource(
     })
 }
 
+/// Returns the relation mode for the datasource, validating against invalid relation mode settings and
+/// the deprecated `referentialIntegrity` attribute.
 fn get_relation_mode(
     args: &mut HashMap<&str, (Span, &ast::Expression)>,
     source: &SourceConfig,
     diagnostics: &mut Diagnostics,
     connector: &'static dyn crate::datamodel_connector::Connector,
 ) -> Option<RelationMode> {
+    // check for deprecated `referentialIntegrity` attribute.
+    if let Some((span, _)) = args.get("referentialIntegrity") {
+        diagnostics.push_warning(DatamodelWarning::new_referential_integrity_attr_deprecation_warning(
+            *span,
+        ));
+    }
+
+    // figure out which attribute is used for the `relationMode` feature
     match (args.remove("relationMode"), args.remove("referentialIntegrity")) {
         (None, None) => None,
         (Some(_), Some((span, _))) => {
+            // both possible attributes are used, which is invalid
             diagnostics.push_error(DatamodelError::new_referential_integrity_and_relation_mode_cooccur_error(span));
             None
         }
         (Some((_span, rm)), None) | (None, Some((_span, rm))) => {
-            let integrity = match coerce::string(rm, diagnostics)? {
+            // either `relationMode` or `referentialIntegrity` is used, which is valid
+            let relation_mode = match coerce::string(rm, diagnostics)? {
                 "prisma" => RelationMode::Prisma,
                 "foreignKeys" => RelationMode::ForeignKeys,
                 other => {
@@ -211,21 +224,22 @@ fn get_relation_mode(
                 }
             };
 
-            if !connector.allowed_relation_mode_settings().contains(integrity) {
+            if !connector.allowed_relation_mode_settings().contains(relation_mode) {
                 let supported_values = connector
                     .allowed_relation_mode_settings()
                     .iter()
                     .map(|v| format!(r#""{}""#, v))
                     .collect::<Vec<_>>()
                     .join(", ");
 
-                let message =
-                    format!("Invalid relation mode setting: \"{integrity}\". Supported values: {supported_values}",);
+                let message = format!(
+                    "Invalid relation mode setting: \"{relation_mode}\". Supported values: {supported_values}",
+                );
                 let error = DatamodelError::new_source_validation_error(&message, "relationMode", rm.span());
                 diagnostics.push_error(error);
             }
 
-            Some(integrity)
+            Some(relation_mode)
         }
     }
 }

psl/psl/tests/config/sources.rs

@@ -641,35 +641,6 @@ fn relation_mode_default() {
     assert_eq!(config.relation_mode(), Some(RelationMode::ForeignKeys));
 }
 
-#[test]
-fn relation_mode_and_referential_integrity_cannot_cooccur() {
-    let schema = indoc! {r#"
-        datasource ps {
-          provider = "sqlite"
-          url = "sqlite"
-          relationMode = "prisma"
-          referentialIntegrity = "foreignKeys"
-        }
-        generator client {
-          provider = "prisma-client-js"
-        }
-    "#};
-
-    let config = parse_config(schema);
-    let error = config.unwrap_err();
-
-    let expectation = expect![[r#"
-        error: The `referentialIntegrity` and `relationMode` attributes cannot be used together. Please use only `relationMode` instead.
-          -->  schema.prisma:5
-           | 
-         4 |   relationMode = "prisma"
-         5 |   referentialIntegrity = "foreignKeys"
-         6 | }
-           | 
-    "#]];
-    expectation.assert_eq(&error);
-}
-
 fn load_env_var(key: &str) -> Option<String> {
     std::env::var(key).ok()
 }

psl/psl/tests/validation/attributes/relation_mode/referential_integrity_attr_is_deprecated.prisma

@@ -0,0 +1,12 @@
+datasource db {
+  provider = "sqlite"
+  url = "sqlite"
+  referentialIntegrity = "foreignKeys"
+}
+// warning: The `referentialIntegrity` attribute is deprecated. Please use `relationMode` instead. Learn more at https://pris.ly/d/relation-mode
+//   -->  schema.prisma:4
+//    | 
+//  3 |   url = "sqlite"
+//  4 |   referentialIntegrity = "foreignKeys"
+//  5 | }
+//    | 

psl/psl/tests/validation/attributes/relation_mode/relation_mode_and_referential_integrity_cannot_cooccur.prisma

@@ -0,0 +1,20 @@
+datasource db {
+  provider = "sqlite"
+  url = "sqlite"
+  relationMode = "prisma"
+  referentialIntegrity = "foreignKeys"
+}
+// warning: The `referentialIntegrity` attribute is deprecated. Please use `relationMode` instead. Learn more at https://pris.ly/d/relation-mode
+//   -->  schema.prisma:5
+//    | 
+//  4 |   relationMode = "prisma"
+//  5 |   referentialIntegrity = "foreignKeys"
+//  6 | }
+//    | 
+// error: The `referentialIntegrity` and `relationMode` attributes cannot be used together. Please use only `relationMode` instead.
+//   -->  schema.prisma:5
+//    | 
+//  4 |   relationMode = "prisma"
+//  5 |   referentialIntegrity = "foreignKeys"
+//  6 | }
+//    |