feat(psl): add validation + warning on missing indexes for relationMode = "prisma"

psl/diagnostics/src/warning.rs

@@ -20,6 +20,11 @@ impl DatamodelWarning {
         Self::new(message, span)
     }
 
+    pub fn new_missing_index_on_emulated_relation(span: Span) -> DatamodelWarning {
+        let message = format!("The fields referenced in a `@relation` should be indexed to prevent potential performance penalties. Learn more at https://pris.ly/d/relation-mode-prisma-indexes.");
+        Self::new(message, span)
+    }
+
     /// The user-facing warning message.
     pub fn message(&self) -> &str {
         &self.message

psl/psl-core/src/validate/validation_pipeline/context.rs

@@ -2,7 +2,7 @@ use crate::{
     datamodel_connector::{Connector, RelationMode},
     Datasource, PreviewFeature,
 };
-use diagnostics::{DatamodelError, Diagnostics};
+use diagnostics::{DatamodelError, DatamodelWarning, Diagnostics};
 use enumflags2::BitFlags;
 
 /// The validation context. The lifetime parameter is _not_ the AST lifetime, but the subtype of
@@ -24,4 +24,9 @@ impl Context<'_> {
     pub(super) fn push_error(&mut self, error: DatamodelError) {
         self.diagnostics.push_error(error);
     }
+
+    /// Pure convenience method. Forwards to Diagnostics::push_warning().
+    pub(super) fn push_warning(&mut self, warning: DatamodelWarning) {
+        self.diagnostics.push_warning(warning);
+    }
 }

psl/psl-core/src/validate/validation_pipeline/validations.rs

@@ -10,6 +10,7 @@ mod indexes;
 mod models;
 mod names;
 mod relation_fields;
+mod relation_indexes;
 mod relations;
 
 use super::context::Context;
@@ -124,6 +125,10 @@ pub(super) fn validate(ctx: &mut Context<'_>) {
                 fields::validate_length_used_with_correct_types(field_attribute, attribute, ctx);
             }
         }
+
+        for field in model.relation_fields() {
+            relation_indexes::validate_missing_relation_indexes(model, field, ctx);
+        }
     }
 
     if ctx.connector.supports_enums() {

psl/psl-core/src/validate/validation_pipeline/validations/relation_indexes.rs

@@ -0,0 +1,86 @@
+use diagnostics::DatamodelWarning;
+use parser_database::{
+    ast::ModelId,
+    walkers::{RelationFieldWalker, Walker},
+};
+
+use crate::{datamodel_connector::RelationMode, validate::validation_pipeline::context::Context};
+
+// { x_1, x_2, ..., x_n } is left-wise included in { y_1, y_2, ..., y_m } if and only if
+// n <= m and x_i = y_i for all i in [1, n].
+fn is_left_wise_included<T>(item: &Vec<T>, group: &Vec<T>) -> bool
+where
+    T: PartialEq,
+{
+    group.iter().take(item.len()).eq(item.iter())
+}
+
+pub(super) fn validate_missing_relation_indexes(
+    _model: Walker<'_, ModelId>,
+    relation_field: RelationFieldWalker<'_>,
+    ctx: &mut Context<'_>,
+) {
+    dbg!("Inspecting: {:?}", relation_field.name());
+
+    let is_provider_mongodb = ctx
+        .datasource
+        .map(|datasource| datasource.active_provider == "mongodb")
+        .unwrap_or(false);
+
+    if is_provider_mongodb || ctx.relation_mode != RelationMode::Prisma {
+        return;
+    }
+
+    if let Some(fields) = relation_field.referenced_fields() {
+        // vector of ids of the fields that should be part of an index in the given model, w.r.t. to left-wise inclusion.
+        let relation_fields = fields.map(|field| field.field_id()).collect::<Vec<_>>();
+
+        // for index_walker in model.indexes() {
+        //     dbg!("exploring index: {:?}", index_walker.name());
+        //     index_walker.fields().for_each(|index| {
+        //         dbg!("  index: {:?}", index);
+        //     });
+        // }
+
+        // vector of all @unique/@@unique attributes in the given model
+        // TODO: figure out how to retrieve these attributes
+        let unique_sets: Vec<Vec<_>> = vec![];
+
+        // vector of all @@index attributes in the given model
+        // TODO: figure out how to retrieve these attributes
+        let index_sets: Vec<Vec<_>> = vec![];
+
+        let relation_fields_appear_in_unique = unique_sets
+            .iter()
+            .any(|unique_set| is_left_wise_included(&relation_fields, unique_set));
+
+        let relation_fields_appear_in_index = index_sets
+            .iter()
+            .any(|index_set| is_left_wise_included(&relation_fields, index_set));
+
+        if !(relation_fields_appear_in_unique || relation_fields_appear_in_index) {
+            let span = relation_field.ast_field().field_type.span();
+            ctx.push_warning(DatamodelWarning::new_missing_index_on_emulated_relation(span));
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::is_left_wise_included;
+
+    #[test]
+    fn test_is_left_wise_included() {
+        let item = vec![1, 2];
+        let group = vec![1, 2, 3, 4];
+        assert_eq!(is_left_wise_included(&item, &group), true);
+
+        let item = vec![1, 2, 3, 4];
+        let group = vec![1, 2];
+        assert_eq!(is_left_wise_included(&item, &group), false);
+
+        let item = vec![2, 3];
+        let group = vec![1, 2, 3, 4];
+        assert_eq!(is_left_wise_included(&item, &group), false);
+    }
+}

psl/psl/tests/validation/attributes/index/missing_index_warning/mongodb.prisma

@@ -0,0 +1,17 @@
+// no missing relation index validation on mongodb.
+
+datasource db {
+    provider = "mongodb"
+    url = env("TEST_DATABASE_URL")
+}
+
+model SomeUser {
+    id String @id @map("_id") @default(auto()) @db.ObjectId
+    posts Post[]
+}
+
+model Post {
+    id String @id @map("_id") @default(auto()) @db.ObjectId
+    userId String
+    user SomeUser @relation(fields: [userId], references: [id])
+}

psl/psl/tests/validation/attributes/index/missing_index_warning/relation_mode_foreign_keys.prisma

@@ -0,0 +1,22 @@
+// no missing relation index validation on relationMode = "foreignKeys".
+
+generator client {
+    provider        = "prisma-client-js"
+    previewFeatures = ["referentialIntegrity"]
+}
+
+datasource db {
+    provider = "mysql"
+    url = env("TEST_DATABASE_URL")
+}
+
+model SomeUser {
+    id Int @id
+    posts Post[]
+}
+
+model Post {
+    id Int @id
+    userId Int
+    user SomeUser @relation(fields: [userId], references: [id])
+}

psl/psl/tests/validation/attributes/index/missing_index_warning/relation_mode_prisma/one_field_at_at_unique.prisma

@@ -0,0 +1,25 @@
+// no relation index validation warning on relationMode = "prisma" when a referenced field is already in @@unique.
+
+generator client {
+    provider        = "prisma-client-js"
+    previewFeatures = ["referentialIntegrity"]
+}
+
+datasource db {
+    provider = "mysql"
+    url = env("TEST_DATABASE_URL")
+    relationMode = "prisma"
+}
+
+model SomeUser {
+    id Int @id
+    profile Profile?
+}
+
+model Profile {
+    id Int @id
+    userId Int
+    user SomeUser? @relation(fields: [userId], references: [id])
+
+    @@unique([userId])
+}

psl/psl/tests/validation/attributes/index/missing_index_warning/relation_mode_prisma/one_field_at_unique.prisma

@@ -0,0 +1,23 @@
+// no relation index validation warning on relationMode = "prisma" when a referenced field is already @unique.
+
+generator client {
+    provider        = "prisma-client-js"
+    previewFeatures = ["referentialIntegrity"]
+}
+
+datasource db {
+    provider = "mysql"
+    url = env("TEST_DATABASE_URL")
+    relationMode = "prisma"
+}
+
+model SomeUser {
+    id Int @id
+    profile Profile?
+}
+
+model Profile {
+    id Int @id
+    userId Int @unique
+    user SomeUser? @relation(fields: [userId], references: [id])
+}

psl/psl/tests/validation/attributes/index/missing_index_warning/relation_mode_prisma/one_field_no_index.prisma

@@ -0,0 +1,23 @@
+// add missing relation index validation warning on relationMode = "prisma".
+
+generator client {
+    provider        = "prisma-client-js"
+    previewFeatures = ["referentialIntegrity"]
+}
+
+datasource db {
+    provider = "mysql"
+    url = env("TEST_DATABASE_URL")
+    relationMode = "prisma"
+}
+
+model SomeUser {
+    id Int @id
+    posts Post[]
+}
+
+model Post {
+    id Int @id
+    userId Int
+    user SomeUser @relation(fields: [userId], references: [id])
+}

psl/psl/tests/validation/attributes/index/missing_index_warning/relation_mode_prisma/three_fields_index_leftmost.prisma

@@ -0,0 +1,31 @@
+// add missing relation index validation warning on relationMode = "prisma".
+
+generator client {
+    provider        = "prisma-client-js"
+    previewFeatures = ["referentialIntegrity"]
+}
+
+datasource db {
+    provider = "mysql"
+    url = env("TEST_DATABASE_URL")
+    relationMode = "prisma"
+}
+
+model SomeUser {
+    idA Int
+    idB Int
+    idC Int
+    posts Post[]
+
+    @@id([idA, idB, idC])
+}
+
+model Post {
+    id Int @id
+    userIdA Int
+    userIdB Int
+    userIdC Int
+    user SomeUser @relation(fields: [userIdA, userIdB, userIdC], references: [idA, idB, idC])
+
+    @@index([userIdA, userIdB])
+}

psl/psl/tests/validation/attributes/index/missing_index_warning/relation_mode_prisma/three_fields_index_rightmost.prisma

@@ -0,0 +1,31 @@
+// add missing relation index validation warning on relationMode = "prisma".
+
+generator client {
+    provider        = "prisma-client-js"
+    previewFeatures = ["referentialIntegrity"]
+}
+
+datasource db {
+    provider = "mysql"
+    url = env("TEST_DATABASE_URL")
+    relationMode = "prisma"
+}
+
+model SomeUser {
+    idA Int
+    idB Int
+    idC Int
+    posts Post[]
+
+    @@id([idA, idB, idC])
+}
+
+model Post {
+    id Int @id
+    userIdA Int
+    userIdB Int
+    userIdC Int
+    user SomeUser @relation(fields: [userIdA, userIdB, userIdC], references: [idA, idB, idC])
+
+    @@index([userIdB, userIdC])
+}

psl/psl/tests/validation/attributes/index/missing_index_warning/relation_mode_prisma/three_fields_mixed_unique.prisma

@@ -0,0 +1,31 @@
+// add missing relation index validation warning on relationMode = "prisma".
+
+generator client {
+    provider        = "prisma-client-js"
+    previewFeatures = ["referentialIntegrity"]
+}
+
+datasource db {
+    provider = "mysql"
+    url = env("TEST_DATABASE_URL")
+    relationMode = "prisma"
+}
+
+model SomeUser {
+    idA Int
+    idB Int
+    idC Int
+    posts Post[]
+
+    @@id([idA, idB, idC])
+}
+
+model Post {
+    id Int @id
+    userIdA Int @unique
+    userIdB Int
+    userIdC Int @unique
+    user SomeUser @relation(fields: [userIdA, userIdB, userIdC], references: [idA, idB, idC])
+
+    @@unique([userIdA, userIdB])
+}

psl/psl/tests/validation/attributes/index/missing_index_warning/relation_mode_prisma/three_fields_no_index.prisma

@@ -0,0 +1,29 @@
+// add missing relation index validation warning on relationMode = "prisma".
+
+generator client {
+    provider        = "prisma-client-js"
+    previewFeatures = ["referentialIntegrity"]
+}
+
+datasource db {
+    provider = "mysql"
+    url = env("TEST_DATABASE_URL")
+    relationMode = "prisma"
+}
+
+model SomeUser {
+    idA Int
+    idB Int
+    idC Int
+    posts Post[]
+
+    @@id([idA, idB, idC])
+}
+
+model Post {
+    id Int @id
+    userIdA Int
+    userIdB Int
+    userIdC Int
+    user SomeUser @relation(fields: [userIdA, userIdB, userIdC], references: [idA, idB, idC])
+}