feat(psl): Recommend type in error message if schema validation fails…

… because of case (#4137) * feat(psl): error for ignore case validation * feat(psl): fix formatting * feat(psl): ignore Source & Generator when recommending type in error * feat(psl): enclose recommended type in quotes Closes #15174 --------- Co-authored-by: Sophie <[email protected]>
prisma · Apr 5, 2024 · e66d30d · e66d30d
1 parent 3d92748
commit e66d30d
Show file tree

Hide file tree

Showing 4 changed files with 134 additions and 18 deletions.
diff --git a/psl/diagnostics/src/error.rs b/psl/diagnostics/src/error.rs
@@ -293,6 +293,13 @@ impl DatamodelError {
         Self::new(msg, span)
     }
 
+    pub fn new_type_for_case_not_found_error(type_name: &str, suggestion: &str, span: Span) -> DatamodelError {
+        let msg = format!(
+            "Type \"{type_name}\" is neither a built-in type, nor refers to another model, custom type, or enum. Did you mean \"{suggestion}\"?"
+        );
+        Self::new(msg, span)
+    }
+
     pub fn new_scalar_type_not_found_error(type_name: &str, span: Span) -> DatamodelError {
         Self::new(format!("Type \"{type_name}\" is not a built-in type."), span)
     }

diff --git a/psl/parser-database/src/names.rs b/psl/parser-database/src/names.rs
@@ -159,7 +159,7 @@ fn duplicate_top_error(existing: &ast::Top, duplicate: &ast::Top) -> DatamodelEr
 }
 
 fn assert_is_not_a_reserved_scalar_type(ident: &ast::Identifier, ctx: &mut Context<'_>) {
-    if ScalarType::try_from_str(&ident.name).is_some() {
+    if ScalarType::try_from_str(&ident.name, false).is_some() {
         ctx.push_error(DatamodelError::new_reserved_scalar_type_error(&ident.name, ident.span));
     }
 }

diff --git a/psl/parser-database/src/types.rs b/psl/parser-database/src/types.rs
@@ -648,10 +648,41 @@ fn visit_model<'db>(model_id: ast::ModelId, ast_model: &'db ast::Model, ctx: &mu
                     native_type: None,
                 });
             }
-            Err(supported) => ctx.push_error(DatamodelError::new_type_not_found_error(
-                supported,
-                ast_field.field_type.span(),
-            )),
+            Err(supported) => {
+                let top_names: Vec<_> = ctx
+                    .ast
+                    .iter_tops()
+                    .filter_map(|(_, top)| match top {
+                        ast::Top::Source(_) | ast::Top::Generator(_) => None,
+                        _ => Some(&top.identifier().name),
+                    })
+                    .collect();
+
+                match top_names.iter().find(|&name| name.to_lowercase() == supported) {
+                    Some(ignore_case_match) => {
+                        ctx.push_error(DatamodelError::new_type_for_case_not_found_error(
+                            supported,
+                            ignore_case_match.as_str(),
+                            ast_field.field_type.span(),
+                        ));
+                    }
+                    None => match ScalarType::try_from_str(supported, true) {
+                        Some(ignore_case_match) => {
+                            ctx.push_error(DatamodelError::new_type_for_case_not_found_error(
+                                supported,
+                                ignore_case_match.as_str(),
+                                ast_field.field_type.span(),
+                            ));
+                        }
+                        None => {
+                            ctx.push_error(DatamodelError::new_type_not_found_error(
+                                supported,
+                                ast_field.field_type.span(),
+                            ));
+                        }
+                    },
+                }
+            }
         }
     }
 }
@@ -699,7 +730,7 @@ fn field_type<'db>(field: &'db ast::Field, ctx: &mut Context<'db>) -> Result<Fie
     };
     let supported_string_id = ctx.interner.intern(supported);
 
-    if let Some(tpe) = ScalarType::try_from_str(supported) {
+    if let Some(tpe) = ScalarType::try_from_str(supported, false) {
         return Ok(FieldType::Scalar(ScalarFieldType::BuiltInScalar(tpe)));
     }
 
@@ -1423,18 +1454,32 @@ impl ScalarType {
         matches!(self, ScalarType::Bytes)
     }
 
-    pub(crate) fn try_from_str(s: &str) -> Option<ScalarType> {
-        match s {
-            "Int" => Some(ScalarType::Int),
-            "BigInt" => Some(ScalarType::BigInt),
-            "Float" => Some(ScalarType::Float),
-            "Boolean" => Some(ScalarType::Boolean),
-            "String" => Some(ScalarType::String),
-            "DateTime" => Some(ScalarType::DateTime),
-            "Json" => Some(ScalarType::Json),
-            "Bytes" => Some(ScalarType::Bytes),
-            "Decimal" => Some(ScalarType::Decimal),
-            _ => None,
+    pub(crate) fn try_from_str(s: &str, ignore_case: bool) -> Option<ScalarType> {
+        match ignore_case {
+            true => match s.to_lowercase().as_str() {
+                "int" => Some(ScalarType::Int),
+                "bigint" => Some(ScalarType::BigInt),
+                "float" => Some(ScalarType::Float),
+                "boolean" => Some(ScalarType::Boolean),
+                "string" => Some(ScalarType::String),
+                "datetime" => Some(ScalarType::DateTime),
+                "json" => Some(ScalarType::Json),
+                "bytes" => Some(ScalarType::Bytes),
+                "decimal" => Some(ScalarType::Decimal),
+                _ => None,
+            },
+            _ => match s {
+                "Int" => Some(ScalarType::Int),
+                "BigInt" => Some(ScalarType::BigInt),
+                "Float" => Some(ScalarType::Float),
+                "Boolean" => Some(ScalarType::Boolean),
+                "String" => Some(ScalarType::String),
+                "DateTime" => Some(ScalarType::DateTime),
+                "Json" => Some(ScalarType::Json),
+                "Bytes" => Some(ScalarType::Bytes),
+                "Decimal" => Some(ScalarType::Decimal),
+                _ => None,
+            },
         }
     }
 }

diff --git a/psl/psl/tests/base/basic.rs b/psl/psl/tests/base/basic.rs
@@ -239,3 +239,67 @@ fn type_aliases_must_error() {
 
     expectation.assert_eq(&error);
 }
+
+#[test]
+fn must_return_good_error_message_for_type_match() {
+    let dml = indoc! {r#"
+        model User {
+          firstName String
+        }
+        model B {
+          a  datetime
+          b  footime
+          c user
+          d DB
+          e JS
+        }
+
+        datasource db {
+          provider   = "postgresql"
+          url        = env("TEST_DATABASE_URL")
+          extensions = [citext, pg_trgm]
+        }
+
+        generator js {
+          provider        = "prisma-client-js"
+          previewFeatures = ["postgresqlExtensions"]
+        }
+    "#};
+
+    let error = parse_unwrap_err(dml);
+
+    let expected = expect![[r#"
+        [1;91merror[0m: [1mType "datetime" is neither a built-in type, nor refers to another model, custom type, or enum. Did you mean "DateTime"?[0m
+          [1;94m-->[0m  [4mschema.prisma:5[0m
+        [1;94m   | [0m
+        [1;94m 4 | [0mmodel B {
+        [1;94m 5 | [0m  a  [1;91mdatetime[0m
+        [1;94m   | [0m
+        [1;91merror[0m: [1mType "footime" is neither a built-in type, nor refers to another model, custom type, or enum.[0m
+          [1;94m-->[0m  [4mschema.prisma:6[0m
+        [1;94m   | [0m
+        [1;94m 5 | [0m  a  datetime
+        [1;94m 6 | [0m  b  [1;91mfootime[0m
+        [1;94m   | [0m
+        [1;91merror[0m: [1mType "user" is neither a built-in type, nor refers to another model, custom type, or enum. Did you mean "User"?[0m
+          [1;94m-->[0m  [4mschema.prisma:7[0m
+        [1;94m   | [0m
+        [1;94m 6 | [0m  b  footime
+        [1;94m 7 | [0m  c [1;91muser[0m
+        [1;94m   | [0m
+        [1;91merror[0m: [1mType "DB" is neither a built-in type, nor refers to another model, custom type, or enum.[0m
+          [1;94m-->[0m  [4mschema.prisma:8[0m
+        [1;94m   | [0m
+        [1;94m 7 | [0m  c user
+        [1;94m 8 | [0m  d [1;91mDB[0m
+        [1;94m   | [0m
+        [1;91merror[0m: [1mType "JS" is neither a built-in type, nor refers to another model, custom type, or enum.[0m
+          [1;94m-->[0m  [4mschema.prisma:9[0m
+        [1;94m   | [0m
+        [1;94m 8 | [0m  d DB
+        [1;94m 9 | [0m  e [1;91mJS[0m
+        [1;94m   | [0m
+    "#]];
+
+    expected.assert_eq(&error);
+}